@supalive/core 1.8.1 → 1.10.0

package/dist/procedure-CRkrxHvn.js

@@ -0,0 +1,187 @@
+//#region src/router/procedure.ts
+/**
+* Mark a Zod schema as a **partial codegen hint** for the procedure's return
+* type. Only the fields you specify are used; everything else is inferred from
+* the handler's TypeScript return type.
+*
+* Purely for codegen — the returned schema is the same Zod type you passed in.
+*
+* @example
+* returns: partial(z.object({
+*   value: z.array(genModelName("StoreCardItem")(z.object({
+*     balanceCents: z.number().int(),
+*   }))),
+* })),
+*/
+function partial(schema) {
+	return schema.meta({ __partial: true });
+}
+/**
+* Attach a custom model name to a Zod schema via `.meta({ __genType: name })`.
+* The codegen uses this name instead of auto-generating one from the TS type.
+*
+* Purely for codegen — the returned schema is the same Zod type you passed in.
+*
+* @example
+* z.array(genModelName("StoreCardItem")(z.object({ ... })))
+*/
+function genModelName(name) {
+	return (schema) => schema.meta({ __genType: name });
+}
+/**
+* Create a query builder with a pre-defined context type.
+* This allows you to define the context type once and have it inferred
+* automatically in all your query handlers.
+* 
+* @example
+* // Define your server context
+* interface ServerContext {
+*   auth: { userId: string };
+*   requestId: string;
+* }
+* 
+* // Create a typed query builder
+* const query = createQueryBuilder<ServerContext>();
+* 
+* // Use it - context type is automatically inferred!
+* const getUser = query({
+*   args: z.object({ id: z.string() }),
+*   handler: async (ctx, { id }) => {
+*     // ctx.db for database queries
+*     const user = await ctx.db.query(UsersSchema).find(id);
+*     // ctx.context for server context
+*     console.log(ctx.context.requestId);
+*     return user;
+*   }
+* });
+*/
+function createQueryBuilder() {
+	return function query(config) {
+		return {
+			_type: "procedure",
+			procedureType: "query",
+			inputSchema: config.args,
+			outputSchema: config.returns,
+			fn: config.handler,
+			internal: config.internal ?? false,
+			queryIdentity: config.queryIdentity
+		};
+	};
+}
+/**
+* Create a mutation builder with a pre-defined context type.
+* This allows you to define the context type once and have it inferred
+* automatically in all your mutation handlers.
+* 
+* @example
+* // Define your server context
+* interface ServerContext {
+*   auth: { userId: string };
+*   requestId: string;
+* }
+* 
+* // Create a typed mutation builder
+* const mutation = createMutationBuilder<ServerContext>();
+* 
+* // Use it - context type is automatically inferred!
+* const createUser = mutation({
+*   args: z.object({ name: z.string() }),
+*   handler: async (ctx, { name }) => {
+*     // ctx.db for mutations
+*     await ctx.db.insert(UsersSchema, id, { name });
+*     // ctx.context for server context
+*     console.log(ctx.context.requestId);
+*     return { success: true };
+*   }
+* });
+*/
+function createMutationBuilder() {
+	return function mutation(config) {
+		return {
+			_type: "procedure",
+			procedureType: "mutation",
+			inputSchema: config.args,
+			outputSchema: config.returns,
+			fn: config.handler,
+			internal: config.internal ?? false
+		};
+	};
+}
+/**
+* Create an action builder with a pre-defined context type.
+* Actions have access to the full SupaliveDb for both queries and mutations.
+*
+* @example
+* // Define your server context
+* interface ServerContext {
+*   auth: { userId: string };
+*   requestId: string;
+* }
+*
+* // Create a typed action builder
+* const action = createActionBuilder<ServerContext>();
+*
+* // Use it - context type is automatically inferred!
+* const processOrder = action({
+*   args: z.object({ orderId: z.string() }),
+*   handler: async (ctx, { orderId }) => {
+*     // ctx.db for full database access
+*     const order = await ctx.db.query(async (db) => {
+*       return db.query(OrdersSchema).find(orderId);
+*     });
+*     await ctx.db.mutation(async (db) => {
+*       await db.update(OrdersSchema, orderId, { status: "processed" });
+*     });
+*     // ctx.context for server context
+*     console.log(ctx.context.requestId);
+*     return { success: true };
+*   }
+* });
+*/
+function createActionBuilder() {
+	return function action(config) {
+		return {
+			_type: "procedure",
+			procedureType: "action",
+			inputSchema: config.args,
+			outputSchema: config.returns,
+			fn: config.handler,
+			internal: config.internal ?? false
+		};
+	};
+}
+/**
+* Create a job builder with a pre-defined context type. A job is a
+* server-only procedure invoked by the scheduler over HTTP — either on its
+* declared `cron` schedule or as a precise one-shot enqueued via the
+* server's job API. Jobs run like actions (full db, non-transactional) and
+* are always internal, so they are never reachable from a client.
+*
+* @example
+* const job = createJobBuilder<ServerContext>();
+*
+* export const cleanupOtps = job({
+*   cron: "0 * * * *", // hourly
+*   args: z.object({}),
+*   handler: async (ctx) => {
+*     await ctx.db.mutation(async (db) => { ... });
+*     return { ok: true };
+*   },
+* });
+*/
+function createJobBuilder() {
+	return function job(config) {
+		return {
+			_type: "procedure",
+			procedureType: "job",
+			inputSchema: config.args,
+			fn: config.handler,
+			internal: true,
+			cron: config.cron
+		};
+	};
+}
+//#endregion
+export { genModelName as a, createQueryBuilder as i, createJobBuilder as n, partial as o, createMutationBuilder as r, createActionBuilder as t };
+
+//# sourceMappingURL=procedure-CRkrxHvn.js.map

package/dist/procedure-CRkrxHvn.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"procedure-CRkrxHvn.js","names":[],"sources":["../src/router/procedure.ts"],"sourcesContent":["import type { ZodType } from \"zod\";\nimport type { DbReader, DbWriter } from \"../db/context\";\nimport type { SupaliveDb } from \"../db/realtime_db\";\nimport type { ObjectStorage } from \"../storage\";\nimport type { JobClient } from \"../jobs/scheduler\";\n\n// ─── Context Types ───────────────────────────────────────────────────────────\n\n/**\n * Query context passed to query handlers.\n * Contains database reader and user-defined server context.\n */\nexport interface QueryCtx<TContext = unknown> {\n  /** Database reader for queries */\n  db: DbReader;\n  /** User-defined server context (auth, requestId, etc.) */\n  serverCtx?: TContext;\n}\n\n/**\n * Mutation context passed to mutation handlers.\n * Contains database writer and user-defined server context.\n */\nexport interface MutationCtx<TContext = unknown> {\n  /** Database writer for mutations (includes insert/update/delete) */\n  db: DbWriter;\n  /** User-defined server context (auth, requestId, etc.) */\n  serverCtx?: TContext;\n}\n\n/**\n * Action context passed to action handlers.\n *\n * Actions are the \"external I/O\" tier: they hold the full {@link SupaliveDb}\n * (queries + mutations) and are the ONLY context that also carries side-effect\n * services — {@link ObjectStorage} for uploads/downloads and a {@link JobClient}\n * for scheduling precise one-shots. Queries/mutations stay pure (db only) so\n * they remain cacheable and transaction-scoped.\n */\nexport interface ActionCtx<TContext = unknown> {\n  /** Full database interface for queries and mutations */\n  db: SupaliveDb;\n   /** Object storage, when the server was configured with one (see\n   * `SupaliveServerConfig.storage`); `undefined` otherwise. The usual home\n   * for upload/download presigning. */\n  storage: ObjectStorage;\n  /** Job scheduler client for enqueueing precise one-shots, when the server\n   * was configured with a `scheduler`; `undefined` otherwise. Scheduling is\n   * network I/O, so it belongs in actions, never inside a DB transaction. */\n  scheduler: JobClient;\n  /** User-defined server context (auth, requestId, etc.) */\n  serverCtx?: TContext;\n}\n\n/**\n * Job context passed to job handlers. Structurally identical to\n * {@link ActionCtx}: a job is a server-only procedure that runs\n * non-transactionally against the full {@link SupaliveDb} and may perform\n * external work, but it is triggered by the scheduler over HTTP (a cron tick\n * or a precise one-shot) rather than by a connected client. `serverCtx` is\n * the system context built by the server's `jobContext` factory.\n */\nexport interface JobCtx<TContext = unknown> {\n  /** Full database interface for queries and mutations */\n  db: SupaliveDb;\n  /** System server context built by the server for scheduler-triggered runs */\n  serverCtx?: TContext;\n}\n\n/**\n * Context handed to `caller.<proc>.runQuery` / `.runMutation` when invoking one\n * procedure from inside another. Pass the caller handler's own `ctx` — its `db`\n * carries the parent's live transaction (a {@link DbReader}/{@link DbWriter}) or,\n * inside an action, the full {@link SupaliveDb}. The caller uses this to decide\n * whether the nested call joins the parent's snapshot (queries) or runs as an\n * independent sub-transaction (mutations).\n */\nexport interface ParentCtx<TContext = unknown> {\n    db: DbReader | DbWriter | SupaliveDb;\n    serverCtx?: TContext | undefined;\n}\n\n// ─── Procedure Types ─────────────────────────────────────────────────────────\n\nexport type QueryFn<TInput, TResult, TContext = unknown> = (\n  ctx: QueryCtx<TContext>,\n  input: TInput,\n) => Promise<TResult>;\n\nexport type MutationFn<TInput, TResult, TContext = unknown> = (\n  ctx: MutationCtx<TContext>,\n  input: TInput,\n) => Promise<TResult>;\n\nexport type ActionFn<TInput, TResult, TContext = unknown> = (\n  ctx: ActionCtx<TContext>,\n  input: TInput,\n) => Promise<TResult>;\n\nexport type JobFn<TInput, TResult, TContext = unknown> = (\n  ctx: JobCtx<TContext>,\n  input: TInput,\n) => Promise<TResult>;\n\n/**\n * Per-procedure override for the cache/subscription segmentation key.\n *\n *   omitted | undefined  → fall back to `config.getUserId(serverCtx)` (default)\n *   false               → no identity in hash; cache/sub shared across all users\n *   string              → a static identity literal (e.g. \"public\" or a tenant id)\n *   function            → compute from serverCtx + input (sync)\n *\n * When the result of a query is identical regardless of who calls it, set\n * this to a literal (or `false`) so a single cache entry serves everyone.\n *\n * The function form intentionally takes `serverCtx` (not the full `QueryCtx`)\n * because identity is resolved before any DB read is issued.\n */\nexport type QueryIdentitySpec<TInput, TContext> =\n  | false\n  | string\n  | ((serverCtx: TContext, input: TInput) => string | null | undefined);\n\nexport interface BaseProcedure<\n  TInput, TResult,\n  TType extends \"query\" | \"mutation\" | \"action\" | \"job\",\n  TContext = unknown,\n  TInternal extends boolean = boolean\n> {\n  readonly _type: \"procedure\";\n  readonly procedureType: TType;\n  readonly inputSchema: ZodType<TInput>;\n  readonly outputSchema?: ZodType<any>;\n  readonly fn: QueryFn<TInput, TResult, TContext> | MutationFn<TInput, TResult, TContext> | ActionFn<TInput, TResult, TContext> | JobFn<TInput, TResult, TContext>;\n  readonly internal: TInternal;\n}\n\nexport interface QueryProcedure<\n  TInput, TResult,\n  TContext = unknown,\n  TInternal extends boolean = boolean\n> extends BaseProcedure<TInput, TResult, \"query\", TContext, TInternal> {\n  readonly procedureType: \"query\";\n  readonly fn: QueryFn<TInput, TResult, TContext>;\n  readonly queryIdentity?: QueryIdentitySpec<TInput, TContext>;\n}\n\nexport interface MutationProcedure<\n  TInput, TResult,\n  TContext = unknown,\n  TInternal extends boolean = boolean\n> extends BaseProcedure<TInput, TResult, \"mutation\", TContext, TInternal> {\n  readonly procedureType: \"mutation\";\n  readonly fn: MutationFn<TInput, TResult, TContext>;\n}\n\nexport interface ActionProcedure<\n  TInput, TResult,\n  TContext = unknown,\n  TInternal extends boolean = boolean\n> extends BaseProcedure<TInput, TResult, \"action\", TContext, TInternal> {\n  readonly procedureType: \"action\";\n  readonly fn: ActionFn<TInput, TResult, TContext>;\n}\n\n/**\n * A scheduler-triggered, server-only procedure. Runs like an action (full\n * db, non-transactional, may do external work) but is dispatched by the\n * server's HTTP job endpoint on a cron tick or a precise one-shot rather\n * than over the client WebSocket. Always {@link internal}: true, so it is\n * never reachable via `call`/`subscribe`.\n */\nexport interface JobProcedure<\n  TInput, TResult,\n  TContext = unknown,\n> extends BaseProcedure<TInput, TResult, \"job\", TContext, true> {\n  readonly procedureType: \"job\";\n  readonly fn: JobFn<TInput, TResult, TContext>;\n  /**\n   * Cron expression for a recurring job (e.g. `\"0 3 * * *\"`). Declared crons\n   * are synced to the scheduler at server startup. Omit for a job that is\n   * only ever invoked as a precise one-shot via the scheduler API.\n   */\n  readonly cron?: string;\n}\n\nexport type AnyProcedure<TContext = unknown> =\n  | QueryProcedure<any, any, TContext>\n  | MutationProcedure<any, any, TContext>\n  | ActionProcedure<any, any, TContext>\n  | JobProcedure<any, any, TContext>;\n\n// ─── Codegen Return Type Helpers ─────────────────────────────────────────────\n\n/**\n * Mark a Zod schema as a **partial codegen hint** for the procedure's return\n * type. Only the fields you specify are used; everything else is inferred from\n * the handler's TypeScript return type.\n *\n * Purely for codegen — the returned schema is the same Zod type you passed in.\n *\n * @example\n * returns: partial(z.object({\n *   value: z.array(genModelName(\"StoreCardItem\")(z.object({\n *     balanceCents: z.number().int(),\n *   }))),\n * })),\n */\nexport function partial<T extends ZodType<any>>(schema: T): T {\n  return schema.meta({ __partial: true }) as T;\n}\n\n/**\n * Attach a custom model name to a Zod schema via `.meta({ __genType: name })`.\n * The codegen uses this name instead of auto-generating one from the TS type.\n *\n * Purely for codegen — the returned schema is the same Zod type you passed in.\n *\n * @example\n * z.array(genModelName(\"StoreCardItem\")(z.object({ ... })))\n */\nexport function genModelName<T extends ZodType<any>>(name: string) {\n  return (schema: T): T => schema.meta({ __genType: name }) as T;\n}\n\n// ─── Procedure Configuration Types ───────────────────────────────────────────\n\nexport interface QueryConfig<TInput, TResult, TContext = unknown> {\n  /** Zod schema for input validation */\n  args: ZodType<TInput>;\n  /** The query handler function */\n  handler: QueryFn<TInput, TResult, TContext>;\n  /** Mark as internal (server-only). Default: false */\n  internal?: boolean;\n  /**\n   * Partial Zod schema describing return-type overrides for codegen.\n   * Only the fields you specify are used; everything else is inferred\n   * from the handler's TypeScript return type. Wrap with `partial()`\n   * for explicit partial semantics and `genModelName()` for model naming.\n   */\n  returns?: ZodType<any>;\n  /**\n   * Override the cache/subscription segmentation key for this procedure.\n   * See {@link QueryIdentitySpec}. Omit to keep the default (per-user) behavior.\n   */\n  queryIdentity?: QueryIdentitySpec<TInput, TContext>;\n}\n\nexport interface MutationConfig<TInput, TResult, TContext = unknown> {\n  /** Zod schema for input validation */\n  args: ZodType<TInput>;\n  /** The mutation handler function */\n  handler: MutationFn<TInput, TResult, TContext>;\n  /** Mark as internal (server-only). Default: false */\n  internal?: boolean;\n  /**\n   * Partial Zod schema describing return-type overrides for codegen.\n   * Only the fields you specify are used; everything else is inferred\n   * from the handler's TypeScript return type.\n   */\n  returns?: ZodType<any>;\n}\n\nexport interface ActionConfig<TInput, TResult, TContext = unknown> {\n  /** Zod schema for input validation */\n  args: ZodType<TInput>;\n  /** The action handler function */\n  handler: ActionFn<TInput, TResult, TContext>;\n  /** Mark as internal (server-only). Default: false */\n  internal?: boolean;\n  /**\n   * Partial Zod schema describing return-type overrides for codegen.\n   * Only the fields you specify are used; everything else is inferred\n   * from the handler's TypeScript return type.\n   */\n  returns?: ZodType<any>;\n}\n\nexport interface JobConfig<TInput, TResult, TContext = unknown> {\n  /** Zod schema for the job payload */\n  args: ZodType<TInput>;\n  /** The job handler function */\n  handler: JobFn<TInput, TResult, TContext>;\n  /**\n   * Cron expression for a recurring schedule (e.g. `\"0 3 * * *\"`). Omit for a\n   * job that is only invoked as a precise one-shot.\n   */\n  cron?: string;\n}\n\n/** Extract input type from a procedure */\nexport type InputOf<T> = T extends BaseProcedure<infer I, any, any, any> ? I : never;\n\n/** Extract output type from a procedure */\nexport type OutputOf<T> = T extends BaseProcedure<any, infer O, any, any> ? O : never;\n\n/** Extract procedure type (query/mutation) */\nexport type TypeOf<T> = T extends BaseProcedure<any, any, infer Type, any> ? Type : never;\n\n/** Extract server context type from a procedure */\nexport type ContextOf<T> = T extends BaseProcedure<any, any, any, infer C> ? C : never;\n\n/**\n * Create a query builder with a pre-defined context type.\n * This allows you to define the context type once and have it inferred\n * automatically in all your query handlers.\n * \n * @example\n * // Define your server context\n * interface ServerContext {\n *   auth: { userId: string };\n *   requestId: string;\n * }\n * \n * // Create a typed query builder\n * const query = createQueryBuilder<ServerContext>();\n * \n * // Use it - context type is automatically inferred!\n * const getUser = query({\n *   args: z.object({ id: z.string() }),\n *   handler: async (ctx, { id }) => {\n *     // ctx.db for database queries\n *     const user = await ctx.db.query(UsersSchema).find(id);\n *     // ctx.context for server context\n *     console.log(ctx.context.requestId);\n *     return user;\n *   }\n * });\n */\nexport function createQueryBuilder<TContext = unknown>() {\n  return function query<TInput, TResult, const TInternal extends boolean = false>(\n    config: QueryConfig<TInput, TResult, TContext> & { internal?: TInternal }\n  ): QueryProcedure<TInput, TResult, TContext, TInternal> {\n    return {\n      _type: \"procedure\",\n      procedureType: \"query\",\n      inputSchema: config.args,\n      outputSchema: config.returns,\n      fn: config.handler,\n      internal: (config.internal ?? false) as TInternal,\n      queryIdentity: config.queryIdentity,\n    };\n  };\n}\n\n// ─── Mutation Builder Factory ────────────────────────────────────────────────\n\n/**\n * Create a mutation builder with a pre-defined context type.\n * This allows you to define the context type once and have it inferred\n * automatically in all your mutation handlers.\n * \n * @example\n * // Define your server context\n * interface ServerContext {\n *   auth: { userId: string };\n *   requestId: string;\n * }\n * \n * // Create a typed mutation builder\n * const mutation = createMutationBuilder<ServerContext>();\n * \n * // Use it - context type is automatically inferred!\n * const createUser = mutation({\n *   args: z.object({ name: z.string() }),\n *   handler: async (ctx, { name }) => {\n *     // ctx.db for mutations\n *     await ctx.db.insert(UsersSchema, id, { name });\n *     // ctx.context for server context\n *     console.log(ctx.context.requestId);\n *     return { success: true };\n *   }\n * });\n */\nexport function createMutationBuilder<TContext = unknown>() {\n  return function mutation<TInput, TResult, const TInternal extends boolean = false>(\n    config: MutationConfig<TInput, TResult, TContext> & { internal?: TInternal }\n  ): MutationProcedure<TInput, TResult, TContext, TInternal> {\n    return {\n      _type: \"procedure\",\n      procedureType: \"mutation\",\n      inputSchema: config.args,\n      outputSchema: config.returns,\n      fn: config.handler,\n      internal: (config.internal ?? false) as TInternal,\n    };\n  };\n}\n\n// ─── Action Builder Factory ──────────────────────────────────────────────────\n\n/**\n * Create an action builder with a pre-defined context type.\n * Actions have access to the full SupaliveDb for both queries and mutations.\n *\n * @example\n * // Define your server context\n * interface ServerContext {\n *   auth: { userId: string };\n *   requestId: string;\n * }\n *\n * // Create a typed action builder\n * const action = createActionBuilder<ServerContext>();\n *\n * // Use it - context type is automatically inferred!\n * const processOrder = action({\n *   args: z.object({ orderId: z.string() }),\n *   handler: async (ctx, { orderId }) => {\n *     // ctx.db for full database access\n *     const order = await ctx.db.query(async (db) => {\n *       return db.query(OrdersSchema).find(orderId);\n *     });\n *     await ctx.db.mutation(async (db) => {\n *       await db.update(OrdersSchema, orderId, { status: \"processed\" });\n *     });\n *     // ctx.context for server context\n *     console.log(ctx.context.requestId);\n *     return { success: true };\n *   }\n * });\n */\nexport function createActionBuilder<TContext = unknown>() {\n  return function action<TInput, TResult, const TInternal extends boolean = false>(\n    config: ActionConfig<TInput, TResult, TContext> & { internal?: TInternal }\n  ): ActionProcedure<TInput, TResult, TContext, TInternal> {\n    return {\n      _type: \"procedure\",\n      procedureType: \"action\",\n      inputSchema: config.args,\n      outputSchema: config.returns,\n      fn: config.handler,\n      internal: (config.internal ?? false) as TInternal,\n    };\n  };\n}\n\n// ─── Job Builder Factory ─────────────────────────────────────────────────────\n\n/**\n * Create a job builder with a pre-defined context type. A job is a\n * server-only procedure invoked by the scheduler over HTTP — either on its\n * declared `cron` schedule or as a precise one-shot enqueued via the\n * server's job API. Jobs run like actions (full db, non-transactional) and\n * are always internal, so they are never reachable from a client.\n *\n * @example\n * const job = createJobBuilder<ServerContext>();\n *\n * export const cleanupOtps = job({\n *   cron: \"0 * * * *\", // hourly\n *   args: z.object({}),\n *   handler: async (ctx) => {\n *     await ctx.db.mutation(async (db) => { ... });\n *     return { ok: true };\n *   },\n * });\n */\nexport function createJobBuilder<TContext = unknown>() {\n  return function job<TInput, TResult>(\n    config: JobConfig<TInput, TResult, TContext>\n  ): JobProcedure<TInput, TResult, TContext> {\n    return {\n      _type: \"procedure\",\n      procedureType: \"job\",\n      inputSchema: config.args,\n      fn: config.handler,\n      internal: true,\n      cron: config.cron,\n    };\n  };\n}"],"mappings":";;;;;;;;;;;;;;;AAgNA,SAAgB,QAAgC,QAAc;CAC5D,OAAO,OAAO,KAAK,EAAE,WAAW,KAAK,CAAC;AACxC;;;;;;;;;;AAWA,SAAgB,aAAqC,MAAc;CACjE,QAAQ,WAAiB,OAAO,KAAK,EAAE,WAAW,KAAK,CAAC;AAC1D;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA0GA,SAAgB,qBAAyC;CACvD,OAAO,SAAS,MACd,QACsD;EACtD,OAAO;GACL,OAAO;GACP,eAAe;GACf,aAAa,OAAO;GACpB,cAAc,OAAO;GACrB,IAAI,OAAO;GACX,UAAW,OAAO,YAAY;GAC9B,eAAe,OAAO;EACxB;CACF;AACF;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+BA,SAAgB,wBAA4C;CAC1D,OAAO,SAAS,SACd,QACyD;EACzD,OAAO;GACL,OAAO;GACP,eAAe;GACf,aAAa,OAAO;GACpB,cAAc,OAAO;GACrB,IAAI,OAAO;GACX,UAAW,OAAO,YAAY;EAChC;CACF;AACF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAmCA,SAAgB,sBAA0C;CACxD,OAAO,SAAS,OACd,QACuD;EACvD,OAAO;GACL,OAAO;GACP,eAAe;GACf,aAAa,OAAO;GACpB,cAAc,OAAO;GACrB,IAAI,OAAO;GACX,UAAW,OAAO,YAAY;EAChC;CACF;AACF;;;;;;;;;;;;;;;;;;;;AAuBA,SAAgB,mBAAuC;CACrD,OAAO,SAAS,IACd,QACyC;EACzC,OAAO;GACL,OAAO;GACP,eAAe;GACf,aAAa,OAAO;GACpB,IAAI,OAAO;GACX,UAAU;GACV,MAAM,OAAO;EACf;CACF;AACF"}

package/dist/procedure-Ck4v3__H.js

@@ -0,0 +1,212 @@
+import { z as z$1 } from "zod";
+//#region src/router/procedure.ts
+if (!globalThis.__supaliveModelNamePatched) {
+	const patched = /* @__PURE__ */ new Set();
+	const samples = [
+		z$1.string(),
+		z$1.number(),
+		z$1.boolean(),
+		z$1.bigint(),
+		z$1.date(),
+		z$1.object({}),
+		z$1.array(z$1.string()),
+		z$1.enum(["_"]),
+		z$1.literal("_"),
+		z$1.null(),
+		z$1.undefined(),
+		z$1.any(),
+		z$1.unknown(),
+		z$1.void(),
+		z$1.never(),
+		z$1.nan(),
+		z$1.record(z$1.string(), z$1.string()),
+		z$1.union([z$1.string(), z$1.number()]),
+		z$1.intersection(z$1.string(), z$1.string()),
+		z$1.tuple([z$1.string()]),
+		z$1.promise(z$1.string()),
+		z$1.custom(),
+		z$1.coerce.string(),
+		z$1.coerce.number(),
+		z$1.coerce.boolean(),
+		z$1.coerce.bigint(),
+		z$1.coerce.date(),
+		z$1.string().optional(),
+		z$1.string().nullable(),
+		z$1.string().default(""),
+		z$1.string().pipe(z$1.string()),
+		z$1.string().transform(() => "")
+	];
+	for (const inst of samples) {
+		const proto = Object.getPrototypeOf(inst);
+		if (patched.has(proto)) continue;
+		patched.add(proto);
+		const metaDesc = Object.getOwnPropertyDescriptor(proto, "meta");
+		if (!metaDesc || !metaDesc.get) continue;
+		if (proto.modelName) continue;
+		Object.defineProperty(proto, "modelName", {
+			value: function modelName(name) {
+				return this.meta({ __genType: name });
+			},
+			writable: true,
+			configurable: true
+		});
+	}
+	globalThis.__supaliveModelNamePatched = true;
+}
+/**
+* Create a query builder with a pre-defined context type.
+* This allows you to define the context type once and have it inferred
+* automatically in all your query handlers.
+* 
+* @example
+* // Define your server context
+* interface ServerContext {
+*   auth: { userId: string };
+*   requestId: string;
+* }
+* 
+* // Create a typed query builder
+* const query = createQueryBuilder<ServerContext>();
+* 
+* // Use it - context type is automatically inferred!
+* const getUser = query({
+*   args: z.object({ id: z.string() }),
+*   handler: async (ctx, { id }) => {
+*     // ctx.db for database queries
+*     const user = await ctx.db.query(UsersSchema).find(id);
+*     // ctx.context for server context
+*     console.log(ctx.context.requestId);
+*     return user;
+*   }
+* });
+*/
+function createQueryBuilder() {
+	return function query(config) {
+		return {
+			_type: "procedure",
+			procedureType: "query",
+			inputSchema: config.args,
+			outputSchema: config.returns,
+			fn: config.handler,
+			internal: config.internal ?? false,
+			queryIdentity: config.queryIdentity
+		};
+	};
+}
+/**
+* Create a mutation builder with a pre-defined context type.
+* This allows you to define the context type once and have it inferred
+* automatically in all your mutation handlers.
+* 
+* @example
+* // Define your server context
+* interface ServerContext {
+*   auth: { userId: string };
+*   requestId: string;
+* }
+* 
+* // Create a typed mutation builder
+* const mutation = createMutationBuilder<ServerContext>();
+* 
+* // Use it - context type is automatically inferred!
+* const createUser = mutation({
+*   args: z.object({ name: z.string() }),
+*   handler: async (ctx, { name }) => {
+*     // ctx.db for mutations
+*     await ctx.db.insert(UsersSchema, id, { name });
+*     // ctx.context for server context
+*     console.log(ctx.context.requestId);
+*     return { success: true };
+*   }
+* });
+*/
+function createMutationBuilder() {
+	return function mutation(config) {
+		return {
+			_type: "procedure",
+			procedureType: "mutation",
+			inputSchema: config.args,
+			outputSchema: config.returns,
+			fn: config.handler,
+			internal: config.internal ?? false
+		};
+	};
+}
+/**
+* Create an action builder with a pre-defined context type.
+* Actions have access to the full SupaliveDb for both queries and mutations.
+*
+* @example
+* // Define your server context
+* interface ServerContext {
+*   auth: { userId: string };
+*   requestId: string;
+* }
+*
+* // Create a typed action builder
+* const action = createActionBuilder<ServerContext>();
+*
+* // Use it - context type is automatically inferred!
+* const processOrder = action({
+*   args: z.object({ orderId: z.string() }),
+*   handler: async (ctx, { orderId }) => {
+*     // ctx.db for full database access
+*     const order = await ctx.db.query(async (db) => {
+*       return db.query(OrdersSchema).find(orderId);
+*     });
+*     await ctx.db.mutation(async (db) => {
+*       await db.update(OrdersSchema, orderId, { status: "processed" });
+*     });
+*     // ctx.context for server context
+*     console.log(ctx.context.requestId);
+*     return { success: true };
+*   }
+* });
+*/
+function createActionBuilder() {
+	return function action(config) {
+		return {
+			_type: "procedure",
+			procedureType: "action",
+			inputSchema: config.args,
+			outputSchema: config.returns,
+			fn: config.handler,
+			internal: config.internal ?? false
+		};
+	};
+}
+/**
+* Create a job builder with a pre-defined context type. A job is a
+* server-only procedure invoked by the scheduler over HTTP — either on its
+* declared `cron` schedule or as a precise one-shot enqueued via the
+* server's job API. Jobs run like actions (full db, non-transactional) and
+* are always internal, so they are never reachable from a client.
+*
+* @example
+* const job = createJobBuilder<ServerContext>();
+*
+* export const cleanupOtps = job({
+*   cron: "0 * * * *", // hourly
+*   args: z.object({}),
+*   handler: async (ctx) => {
+*     await ctx.db.mutation(async (db) => { ... });
+*     return { ok: true };
+*   },
+* });
+*/
+function createJobBuilder() {
+	return function job(config) {
+		return {
+			_type: "procedure",
+			procedureType: "job",
+			inputSchema: config.args,
+			fn: config.handler,
+			internal: true,
+			cron: config.cron
+		};
+	};
+}
+//#endregion
+export { createQueryBuilder as i, createJobBuilder as n, createMutationBuilder as r, createActionBuilder as t };
+
+//# sourceMappingURL=procedure-Ck4v3__H.js.map

package/dist/procedure-Ck4v3__H.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"procedure-Ck4v3__H.js","names":["z"],"sources":["../src/router/procedure.ts"],"sourcesContent":["import type { ZodType } from \"zod\";\nimport { z } from \"zod\";\nimport type { DbReader, DbWriter } from \"../db/context\";\nimport type { SupaliveDb } from \"../db/realtime_db\";\nimport type { ObjectStorage } from \"../storage\";\nimport type { JobClient } from \"../jobs/scheduler\";\n\n// ─── Zod .modelName() extension ─────────────────────────────────────────────\n// Patches every Zod schema type with a `.modelName(\"Name\")` method that sets\n// `__genType` metadata for codegen model renaming. Runs once at import time.\n//\n// Zod v4: `z.string` is a factory — `z.string.prototype` is NOT the real class\n// prototype. We collect the actual prototypes by creating one instance per type,\n// then patch each unique prototype once.\nif (!(globalThis as any).__supaliveModelNamePatched) {\n  const patched = new Set<object>();\n  // Create one instance of each core type to capture real class prototypes.\n  const samples: ZodType[] = [\n    z.string(), z.number(), z.boolean(), z.bigint(), z.date(),\n    z.object({}), z.array(z.string()), z.enum([\"_\"]),\n    z.literal(\"_\"), z.null(), z.undefined(), z.any(), z.unknown(),\n    z.void(), z.never(), z.nan(), z.record(z.string(), z.string()),\n    z.union([z.string(), z.number()]), z.intersection(z.string(), z.string()),\n    z.tuple([z.string()]), z.promise(z.string()), z.custom(),\n    z.coerce.string(), z.coerce.number(), z.coerce.boolean(),\n    z.coerce.bigint(), z.coerce.date(),\n    z.string().optional(), z.string().nullable(), z.string().default(\"\"),\n    z.string().pipe(z.string()), z.string().transform(() => \"\"),\n  ];\n  for (const inst of samples) {\n    const proto = Object.getPrototypeOf(inst);\n    if (patched.has(proto)) continue;\n    patched.add(proto);\n    const metaDesc = Object.getOwnPropertyDescriptor(proto, \"meta\");\n    if (!metaDesc || !metaDesc.get) continue;\n    if ((proto as any).modelName) continue;\n    Object.defineProperty(proto, \"modelName\", {\n      value: function modelName(name: string) {\n        return this.meta({ __genType: name });\n      },\n      writable: true,\n      configurable: true,\n    });\n  }\n  (globalThis as any).__supaliveModelNamePatched = true;\n}\n\n// ─── Context Types ───────────────────────────────────────────────────────────\n\n/**\n * Query context passed to query handlers.\n * Contains database reader and user-defined server context.\n */\nexport interface QueryCtx<TContext = unknown> {\n  /** Database reader for queries */\n  db: DbReader;\n  /** User-defined server context (auth, requestId, etc.) */\n  serverCtx?: TContext;\n}\n\n/**\n * Mutation context passed to mutation handlers.\n * Contains database writer and user-defined server context.\n */\nexport interface MutationCtx<TContext = unknown> {\n  /** Database writer for mutations (includes insert/update/delete) */\n  db: DbWriter;\n  /** User-defined server context (auth, requestId, etc.) */\n  serverCtx?: TContext;\n}\n\n/**\n * Action context passed to action handlers.\n *\n * Actions are the \"external I/O\" tier: they hold the full {@link SupaliveDb}\n * (queries + mutations) and are the ONLY context that also carries side-effect\n * services — {@link ObjectStorage} for uploads/downloads and a {@link JobClient}\n * for scheduling precise one-shots. Queries/mutations stay pure (db only) so\n * they remain cacheable and transaction-scoped.\n */\nexport interface ActionCtx<TContext = unknown> {\n  /** Full database interface for queries and mutations */\n  db: SupaliveDb;\n   /** Object storage, when the server was configured with one (see\n   * `SupaliveServerConfig.storage`); `undefined` otherwise. The usual home\n   * for upload/download presigning. */\n  storage: ObjectStorage;\n  /** Job scheduler client for enqueueing precise one-shots, when the server\n   * was configured with a `scheduler`; `undefined` otherwise. Scheduling is\n   * network I/O, so it belongs in actions, never inside a DB transaction. */\n  scheduler: JobClient;\n  /** User-defined server context (auth, requestId, etc.) */\n  serverCtx?: TContext;\n}\n\n/**\n * Job context passed to job handlers. Structurally identical to\n * {@link ActionCtx}: a job is a server-only procedure that runs\n * non-transactionally against the full {@link SupaliveDb} and may perform\n * external work, but it is triggered by the scheduler over HTTP (a cron tick\n * or a precise one-shot) rather than by a connected client. `serverCtx` is\n * the system context built by the server's `jobContext` factory.\n */\nexport interface JobCtx<TContext = unknown> {\n  /** Full database interface for queries and mutations */\n  db: SupaliveDb;\n  /** System server context built by the server for scheduler-triggered runs */\n  serverCtx?: TContext;\n}\n\n/**\n * Context handed to `caller.<proc>.runQuery` / `.runMutation` when invoking one\n * procedure from inside another. Pass the caller handler's own `ctx` — its `db`\n * carries the parent's live transaction (a {@link DbReader}/{@link DbWriter}) or,\n * inside an action, the full {@link SupaliveDb}. The caller uses this to decide\n * whether the nested call joins the parent's snapshot (queries) or runs as an\n * independent sub-transaction (mutations).\n */\nexport interface ParentCtx<TContext = unknown> {\n    db: DbReader | DbWriter | SupaliveDb;\n    serverCtx?: TContext | undefined;\n}\n\n// ─── Procedure Types ─────────────────────────────────────────────────────────\n\nexport type QueryFn<TInput, TResult, TContext = unknown> = (\n  ctx: QueryCtx<TContext>,\n  input: TInput,\n) => Promise<TResult>;\n\nexport type MutationFn<TInput, TResult, TContext = unknown> = (\n  ctx: MutationCtx<TContext>,\n  input: TInput,\n) => Promise<TResult>;\n\nexport type ActionFn<TInput, TResult, TContext = unknown> = (\n  ctx: ActionCtx<TContext>,\n  input: TInput,\n) => Promise<TResult>;\n\nexport type JobFn<TInput, TResult, TContext = unknown> = (\n  ctx: JobCtx<TContext>,\n  input: TInput,\n) => Promise<TResult>;\n\n/**\n * Per-procedure override for the cache/subscription segmentation key.\n *\n *   omitted | undefined  → fall back to `config.getUserId(serverCtx)` (default)\n *   false               → no identity in hash; cache/sub shared across all users\n *   string              → a static identity literal (e.g. \"public\" or a tenant id)\n *   function            → compute from serverCtx + input (sync)\n *\n * When the result of a query is identical regardless of who calls it, set\n * this to a literal (or `false`) so a single cache entry serves everyone.\n *\n * The function form intentionally takes `serverCtx` (not the full `QueryCtx`)\n * because identity is resolved before any DB read is issued.\n */\nexport type QueryIdentitySpec<TInput, TContext> =\n  | false\n  | string\n  | ((serverCtx: TContext, input: TInput) => string | null | undefined);\n\nexport interface BaseProcedure<\n  TInput, TResult,\n  TType extends \"query\" | \"mutation\" | \"action\" | \"job\",\n  TContext = unknown,\n  TInternal extends boolean = boolean\n> {\n  readonly _type: \"procedure\";\n  readonly procedureType: TType;\n  readonly inputSchema: ZodType<TInput>;\n  readonly outputSchema?: ZodType<any>;\n  readonly fn: QueryFn<TInput, TResult, TContext> | MutationFn<TInput, TResult, TContext> | ActionFn<TInput, TResult, TContext> | JobFn<TInput, TResult, TContext>;\n  readonly internal: TInternal;\n}\n\nexport interface QueryProcedure<\n  TInput, TResult,\n  TContext = unknown,\n  TInternal extends boolean = boolean\n> extends BaseProcedure<TInput, TResult, \"query\", TContext, TInternal> {\n  readonly procedureType: \"query\";\n  readonly fn: QueryFn<TInput, TResult, TContext>;\n  readonly queryIdentity?: QueryIdentitySpec<TInput, TContext>;\n}\n\nexport interface MutationProcedure<\n  TInput, TResult,\n  TContext = unknown,\n  TInternal extends boolean = boolean\n> extends BaseProcedure<TInput, TResult, \"mutation\", TContext, TInternal> {\n  readonly procedureType: \"mutation\";\n  readonly fn: MutationFn<TInput, TResult, TContext>;\n}\n\nexport interface ActionProcedure<\n  TInput, TResult,\n  TContext = unknown,\n  TInternal extends boolean = boolean\n> extends BaseProcedure<TInput, TResult, \"action\", TContext, TInternal> {\n  readonly procedureType: \"action\";\n  readonly fn: ActionFn<TInput, TResult, TContext>;\n}\n\n/**\n * A scheduler-triggered, server-only procedure. Runs like an action (full\n * db, non-transactional, may do external work) but is dispatched by the\n * server's HTTP job endpoint on a cron tick or a precise one-shot rather\n * than over the client WebSocket. Always {@link internal}: true, so it is\n * never reachable via `call`/`subscribe`.\n */\nexport interface JobProcedure<\n  TInput, TResult,\n  TContext = unknown,\n> extends BaseProcedure<TInput, TResult, \"job\", TContext, true> {\n  readonly procedureType: \"job\";\n  readonly fn: JobFn<TInput, TResult, TContext>;\n  /**\n   * Cron expression for a recurring job (e.g. `\"0 3 * * *\"`). Declared crons\n   * are synced to the scheduler at server startup. Omit for a job that is\n   * only ever invoked as a precise one-shot via the scheduler API.\n   */\n  readonly cron?: string;\n}\n\nexport type AnyProcedure<TContext = unknown> =\n  | QueryProcedure<any, any, TContext>\n  | MutationProcedure<any, any, TContext>\n  | ActionProcedure<any, any, TContext>\n  | JobProcedure<any, any, TContext>;\n\n// ─── Procedure Configuration Types ───────────────────────────────────────────\n\nexport interface QueryConfig<TInput, TResult, TContext = unknown> {\n  /** Zod schema for input validation */\n  args: ZodType<TInput>;\n  /** The query handler function */\n  handler: QueryFn<TInput, TResult, TContext>;\n  /** Mark as internal (server-only). Default: false */\n  internal?: boolean;\n  /**\n   * Optional Zod schema describing return-type overrides for codegen.\n   * Only the fields you specify are overridden; everything else is inferred\n   * from the handler's TypeScript return type. Use `.modelName(\"Name\")`\n   * on a Zod object to rename the generated model class.\n   */\n  returns?: ZodType<any>;\n  /**\n   * Override the cache/subscription segmentation key for this procedure.\n   * See {@link QueryIdentitySpec}. Omit to keep the default (per-user) behavior.\n   */\n  queryIdentity?: QueryIdentitySpec<TInput, TContext>;\n}\n\nexport interface MutationConfig<TInput, TResult, TContext = unknown> {\n  /** Zod schema for input validation */\n  args: ZodType<TInput>;\n  /** The mutation handler function */\n  handler: MutationFn<TInput, TResult, TContext>;\n  /** Mark as internal (server-only). Default: false */\n  internal?: boolean;\n  /**\n   * Optional Zod schema describing return-type overrides for codegen.\n   * Only the fields you specify are overridden; everything else is inferred\n   * from the handler's TypeScript return type.\n   */\n  returns?: ZodType<any>;\n}\n\nexport interface ActionConfig<TInput, TResult, TContext = unknown> {\n  /** Zod schema for input validation */\n  args: ZodType<TInput>;\n  /** The action handler function */\n  handler: ActionFn<TInput, TResult, TContext>;\n  /** Mark as internal (server-only). Default: false */\n  internal?: boolean;\n  /**\n   * Optional Zod schema describing return-type overrides for codegen.\n   * Only the fields you specify are overridden; everything else is inferred\n   * from the handler's TypeScript return type.\n   */\n  returns?: ZodType<any>;\n}\n\nexport interface JobConfig<TInput, TResult, TContext = unknown> {\n  /** Zod schema for the job payload */\n  args: ZodType<TInput>;\n  /** The job handler function */\n  handler: JobFn<TInput, TResult, TContext>;\n  /**\n   * Cron expression for a recurring schedule (e.g. `\"0 3 * * *\"`). Omit for a\n   * job that is only invoked as a precise one-shot.\n   */\n  cron?: string;\n}\n\n/** Extract input type from a procedure */\nexport type InputOf<T> = T extends BaseProcedure<infer I, any, any, any> ? I : never;\n\n/** Extract output type from a procedure */\nexport type OutputOf<T> = T extends BaseProcedure<any, infer O, any, any> ? O : never;\n\n/** Extract procedure type (query/mutation) */\nexport type TypeOf<T> = T extends BaseProcedure<any, any, infer Type, any> ? Type : never;\n\n/** Extract server context type from a procedure */\nexport type ContextOf<T> = T extends BaseProcedure<any, any, any, infer C> ? C : never;\n\n/**\n * Create a query builder with a pre-defined context type.\n * This allows you to define the context type once and have it inferred\n * automatically in all your query handlers.\n * \n * @example\n * // Define your server context\n * interface ServerContext {\n *   auth: { userId: string };\n *   requestId: string;\n * }\n * \n * // Create a typed query builder\n * const query = createQueryBuilder<ServerContext>();\n * \n * // Use it - context type is automatically inferred!\n * const getUser = query({\n *   args: z.object({ id: z.string() }),\n *   handler: async (ctx, { id }) => {\n *     // ctx.db for database queries\n *     const user = await ctx.db.query(UsersSchema).find(id);\n *     // ctx.context for server context\n *     console.log(ctx.context.requestId);\n *     return user;\n *   }\n * });\n */\nexport function createQueryBuilder<TContext = unknown>() {\n  return function query<TInput, TResult, const TInternal extends boolean = false>(\n    config: QueryConfig<TInput, TResult, TContext> & { internal?: TInternal }\n  ): QueryProcedure<TInput, TResult, TContext, TInternal> {\n    return {\n      _type: \"procedure\",\n      procedureType: \"query\",\n      inputSchema: config.args,\n      outputSchema: config.returns,\n      fn: config.handler,\n      internal: (config.internal ?? false) as TInternal,\n      queryIdentity: config.queryIdentity,\n    };\n  };\n}\n\n// ─── Mutation Builder Factory ────────────────────────────────────────────────\n\n/**\n * Create a mutation builder with a pre-defined context type.\n * This allows you to define the context type once and have it inferred\n * automatically in all your mutation handlers.\n * \n * @example\n * // Define your server context\n * interface ServerContext {\n *   auth: { userId: string };\n *   requestId: string;\n * }\n * \n * // Create a typed mutation builder\n * const mutation = createMutationBuilder<ServerContext>();\n * \n * // Use it - context type is automatically inferred!\n * const createUser = mutation({\n *   args: z.object({ name: z.string() }),\n *   handler: async (ctx, { name }) => {\n *     // ctx.db for mutations\n *     await ctx.db.insert(UsersSchema, id, { name });\n *     // ctx.context for server context\n *     console.log(ctx.context.requestId);\n *     return { success: true };\n *   }\n * });\n */\nexport function createMutationBuilder<TContext = unknown>() {\n  return function mutation<TInput, TResult, const TInternal extends boolean = false>(\n    config: MutationConfig<TInput, TResult, TContext> & { internal?: TInternal }\n  ): MutationProcedure<TInput, TResult, TContext, TInternal> {\n    return {\n      _type: \"procedure\",\n      procedureType: \"mutation\",\n      inputSchema: config.args,\n      outputSchema: config.returns,\n      fn: config.handler,\n      internal: (config.internal ?? false) as TInternal,\n    };\n  };\n}\n\n// ─── Action Builder Factory ──────────────────────────────────────────────────\n\n/**\n * Create an action builder with a pre-defined context type.\n * Actions have access to the full SupaliveDb for both queries and mutations.\n *\n * @example\n * // Define your server context\n * interface ServerContext {\n *   auth: { userId: string };\n *   requestId: string;\n * }\n *\n * // Create a typed action builder\n * const action = createActionBuilder<ServerContext>();\n *\n * // Use it - context type is automatically inferred!\n * const processOrder = action({\n *   args: z.object({ orderId: z.string() }),\n *   handler: async (ctx, { orderId }) => {\n *     // ctx.db for full database access\n *     const order = await ctx.db.query(async (db) => {\n *       return db.query(OrdersSchema).find(orderId);\n *     });\n *     await ctx.db.mutation(async (db) => {\n *       await db.update(OrdersSchema, orderId, { status: \"processed\" });\n *     });\n *     // ctx.context for server context\n *     console.log(ctx.context.requestId);\n *     return { success: true };\n *   }\n * });\n */\nexport function createActionBuilder<TContext = unknown>() {\n  return function action<TInput, TResult, const TInternal extends boolean = false>(\n    config: ActionConfig<TInput, TResult, TContext> & { internal?: TInternal }\n  ): ActionProcedure<TInput, TResult, TContext, TInternal> {\n    return {\n      _type: \"procedure\",\n      procedureType: \"action\",\n      inputSchema: config.args,\n      outputSchema: config.returns,\n      fn: config.handler,\n      internal: (config.internal ?? false) as TInternal,\n    };\n  };\n}\n\n// ─── Job Builder Factory ─────────────────────────────────────────────────────\n\n/**\n * Create a job builder with a pre-defined context type. A job is a\n * server-only procedure invoked by the scheduler over HTTP — either on its\n * declared `cron` schedule or as a precise one-shot enqueued via the\n * server's job API. Jobs run like actions (full db, non-transactional) and\n * are always internal, so they are never reachable from a client.\n *\n * @example\n * const job = createJobBuilder<ServerContext>();\n *\n * export const cleanupOtps = job({\n *   cron: \"0 * * * *\", // hourly\n *   args: z.object({}),\n *   handler: async (ctx) => {\n *     await ctx.db.mutation(async (db) => { ... });\n *     return { ok: true };\n *   },\n * });\n */\nexport function createJobBuilder<TContext = unknown>() {\n  return function job<TInput, TResult>(\n    config: JobConfig<TInput, TResult, TContext>\n  ): JobProcedure<TInput, TResult, TContext> {\n    return {\n      _type: \"procedure\",\n      procedureType: \"job\",\n      inputSchema: config.args,\n      fn: config.handler,\n      internal: true,\n      cron: config.cron,\n    };\n  };\n}"],"mappings":"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"}