API Reference

// Exampleinterface MyModel {  id: Key<string>; // Marks 'id' as a primary key of type string}

// Exampletype UserJWT = JWT<{ userId: string, role: string }>;

interface ApiUtil {  client: MooseClient;  // Client for interacting with the database  sql: typeof sql;      // SQL template tag function  jwt: JWTPayload | undefined;  // Current JWT if available}

class MooseClient {  query: QueryClient;      // For database queries  workflow: WorkflowClient; // For workflow operations}

interface BaseOlapConfig<T> {  // Optional database name (defaults to moose.config.toml clickhouse_config.db_name)  database?: string;   // Optional array of field names to order by  orderByFields?: (keyof T & string)[];   // Optional SQL expression for ORDER BY clause (alternative to orderByFields)  orderByExpression?: string;   // Optional table engine (defaults to MergeTree)  engine?: ClickHouseEngines;   // Optional settings for table configuration  settings?: { [key: string]: string };   // Optional lifecycle mode (defaults to MOOSE_MANAGED)  lifeCycle?: LifeCycle;   // Additional engine-specific fields (ver, isDeleted, keeperPath, etc.)  // depend on the engine type}

// Basic usage with MergeTree (default)export const myTable = new OlapTable<UserProfile>("user_profiles"); // With sorting configuration (fields)export const myConfiguredTable = new OlapTable<UserProfile>("user_profiles", {  orderByFields: ["id", "timestamp"]}); // With sorting configuration (expression)export const myConfiguredTableExpr = new OlapTable<UserProfile>("user_profiles_expr", {  // Equivalent to orderByFields: ["id", "timestamp"]  orderByExpression: "(id, timestamp)"}); // Disable sorting entirelyexport const myUnsortedTable = new OlapTable<UserProfile>("user_profiles_unsorted", {  orderByExpression: "tuple()"}); // For deduplication, explicitly set the ReplacingMergeTree engineexport const dedupTable = new OlapTable<UserProfile>("user_profiles", {  engine: ClickHouseEngines.ReplacingMergeTree,  orderByFields: ["id", "timestamp"],  ver: "updated_at",  // Optional: version column for keeping latest  isDeleted: "deleted"  // Optional: soft delete marker (requires ver)});

// Basic usageexport const myStream = new Stream<UserEvent>("user_events"); // With configurationexport const myConfiguredStream = new Stream<UserEvent>("user_events", {  parallelism: 3,  retentionPeriod: 86400 // 1 day in seconds}); // Adding transformationsmyConfiguredStream.addTransform(  destinationStream,  (record) => transformFunction(record));

// Basic usage with destination streamexport const myIngestApi = new IngestApi<UserEvent>("user_events", {  destination: myUserEventStream});

// Basic usageexport const myApi = new Api<UserQuery, UserProfile[]>(  "getUserProfiles",  async (params, { client, sql }) => {    const result = await client.query.execute(      sql`SELECT * FROM user_profiles WHERE age > ${params.minAge} LIMIT 10`    );    return result;  });

// Basic usageexport const pipeline = new IngestPipeline<UserEvent>("user_pipeline", {  ingestApi: true,  stream: true,  table: true}); // With advanced configurationexport const advancedPipeline = new IngestPipeline<UserEvent>("advanced_pipeline", {  ingestApi: true,  stream: { parallelism: 3 },  table: {     orderByFields: ["id", "timestamp"]  }});

// Basic usageexport const view = new MaterializedView<UserStatistics>({  selectStatement: "SELECT user_id, COUNT(*) as event_count FROM user_events GROUP BY user_id",  tableName: "user_events",  materializedViewName: "user_statistics",  orderByFields: ["user_id"]});

// Basic usageexport const activeUserEvents = new View(  "active_user_events",  sql`    SELECT      ${events.columns.id}    AS event_id,      ${users.columns.id}     AS user_id,      ${users.columns.name}   AS user_name,      ${events.columns.ts}    AS ts    FROM ${events}    JOIN ${users} ON ${events.columns.user_id} = ${users.columns.id}    WHERE ${users.columns.active} = 1  `,  [events, users]);

// Basic usageconst query = sql`SELECT * FROM users WHERE id = ${userId}`; // With multiple parametersconst query = sql`  SELECT * FROM users   WHERE age > ${minAge}   AND country = ${country}  LIMIT ${limit}`;

enum ClickHouseEngines {  MergeTree = "MergeTree",  ReplacingMergeTree = "ReplacingMergeTree",  AggregatingMergeTree = "AggregatingMergeTree",  SummingMergeTree = "SummingMergeTree",  ReplicatedMergeTree = "ReplicatedMergeTree",  ReplicatedReplacingMergeTree = "ReplicatedReplacingMergeTree",  ReplicatedAggregatingMergeTree = "ReplicatedAggregatingMergeTree",  ReplicatedSummingMergeTree = "ReplicatedSummingMergeTree",  S3Queue = "S3Queue"}

type ReplacingMergeTreeConfig<T> = {  engine: ClickHouseEngines.ReplacingMergeTree;  orderByFields?: (keyof T & string)[];  ver?: keyof T & string;  // Optional: version column for keeping latest  isDeleted?: keyof T & string;  // Optional: soft delete marker (requires ver)  settings?: { [key: string]: string };}

// ReplicatedMergeTreetype ReplicatedMergeTreeConfig<T> = {  engine: ClickHouseEngines.ReplicatedMergeTree;  keeperPath?: string;  // Optional: ZooKeeper/Keeper path (omit for Cloud)  replicaName?: string; // Optional: replica name (omit for Cloud)  orderByFields?: (keyof T & string)[];  settings?: { [key: string]: string };} // ReplicatedReplacingMergeTreetype ReplicatedReplacingMergeTreeConfig<T> = {  engine: ClickHouseEngines.ReplicatedReplacingMergeTree;  keeperPath?: string;  // Optional: ZooKeeper/Keeper path (omit for Cloud)  replicaName?: string; // Optional: replica name (omit for Cloud)  ver?: keyof T & string;  // Optional: version column  isDeleted?: keyof T & string;  // Optional: soft delete marker  orderByFields?: (keyof T & string)[];  settings?: { [key: string]: string };} // ReplicatedAggregatingMergeTreetype ReplicatedAggregatingMergeTreeConfig<T> = {  engine: ClickHouseEngines.ReplicatedAggregatingMergeTree;  keeperPath?: string;  // Optional: ZooKeeper/Keeper path (omit for Cloud)  replicaName?: string; // Optional: replica name (omit for Cloud)  orderByFields?: (keyof T & string)[];  settings?: { [key: string]: string };} // ReplicatedSummingMergeTreetype ReplicatedSummingMergeTreeConfig<T> = {  engine: ClickHouseEngines.ReplicatedSummingMergeTree;  keeperPath?: string;  // Optional: ZooKeeper/Keeper path (omit for Cloud)  replicaName?: string; // Optional: replica name (omit for Cloud)  columns?: string[];   // Optional: columns to sum  orderByFields?: (keyof T & string)[];  settings?: { [key: string]: string };}

// No input, no outputexport const task1 = new Task<null, void>("task1", {  run: async () => {    console.log("No input/output");  },  retries: 3,  timeout: "30s"}); // With input and outputexport const task2 = new Task<InputType, OutputType>("task2", {  run: async (ctx) => {    return process(ctx.input);  },  onComplete: [nextTask]});

interface TaskConfig<T, R> {  // The main function that executes the task logic  run: (context: TaskContext<T>) => Promise<R>;    // Optional array of tasks to execute after this task completes  onComplete?: (Task<R extends void ? null : R, any> | Task<R extends void ? null : R, void>)[];   // Optional function that is called when the task is cancelled.  onCancel?: (context: TaskContext<T>) => Promise<void>;    // Optional timeout duration (e.g., "30s", "5m", "never")  timeout?: string;    // Optional number of retry attempts  retries?: number;}

const myWorkflow = new Workflow("getData", {  startingTask: callAPI,  schedule: "@every 5s", // Run every 5 seconds  timeout: "1h",  retries: 3});

interface WorkflowConfig {  // The initial task that begins the workflow execution  startingTask: Task<null, any> | Task<null, void> | Task<any, any> | Task<any, void>;    // Optional number of retry attempts  retries?: number;    // Optional timeout duration (e.g., "10m", "1h", "never")  timeout?: string;    // Optional cron-style schedule string  schedule?: string;}