@supalive/core 1.8.1 → 1.10.0

package/dist/procedure-DPgXC2Cm.js

@@ -0,0 +1,221 @@
+import { z as z$2 } from "zod";
+//#region src/router/procedure.ts
+/**
+* Patch all Zod schema types on the given `z` namespace with `.modelName(name)`.
+* Must be called with the same `z` instance the consumer uses so the prototypes
+* match. Runs once per unique `z` instance (tracked via a WeakSet).
+*/
+function patchZod(zInstance) {
+	const key = "__supalivePatchedZodInstances";
+	const patchedInstances = globalThis[key] ??= /* @__PURE__ */ new Set();
+	if (patchedInstances.has(zInstance)) return;
+	patchedInstances.add(zInstance);
+	const patched = /* @__PURE__ */ new Set();
+	const samples = [
+		zInstance.string(),
+		zInstance.number(),
+		zInstance.boolean(),
+		zInstance.bigint(),
+		zInstance.date(),
+		zInstance.object({}),
+		zInstance.array(zInstance.string()),
+		zInstance.enum(["_"]),
+		zInstance.literal("_"),
+		zInstance.null(),
+		zInstance.undefined(),
+		zInstance.any(),
+		zInstance.unknown(),
+		zInstance.void(),
+		zInstance.never(),
+		zInstance.nan(),
+		zInstance.record(zInstance.string(), zInstance.string()),
+		zInstance.union([zInstance.string(), zInstance.number()]),
+		zInstance.intersection(zInstance.string(), zInstance.string()),
+		zInstance.tuple([zInstance.string()]),
+		zInstance.promise(zInstance.string()),
+		zInstance.custom(),
+		zInstance.coerce.string(),
+		zInstance.coerce.number(),
+		zInstance.coerce.boolean(),
+		zInstance.coerce.bigint(),
+		zInstance.coerce.date(),
+		zInstance.string().optional(),
+		zInstance.string().nullable(),
+		zInstance.string().default(""),
+		zInstance.string().pipe(zInstance.string()),
+		zInstance.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
+		});
+	}
+}
+patchZod(z$2);
+/**
+* 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 { patchZod as a, createQueryBuilder as i, createJobBuilder as n, z$2 as o, createMutationBuilder as r, createActionBuilder as t };
+
+//# sourceMappingURL=procedure-DPgXC2Cm.js.map

package/dist/procedure-DPgXC2Cm.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"procedure-DPgXC2Cm.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\nexport { z };\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.\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.\n\n/**\n * Patch all Zod schema types on the given `z` namespace with `.modelName(name)`.\n * Must be called with the same `z` instance the consumer uses so the prototypes\n * match. Runs once per unique `z` instance (tracked via a WeakSet).\n */\nexport function patchZod(zInstance: typeof z): void {\n  const key = \"__supalivePatchedZodInstances\";\n  const patchedInstances: Set<object> = (globalThis as any)[key] ??= new Set();\n  if (patchedInstances.has(zInstance)) return;\n  patchedInstances.add(zInstance);\n\n  const patched = new Set<object>();\n  const samples: ZodType[] = [\n    zInstance.string(), zInstance.number(), zInstance.boolean(), zInstance.bigint(), zInstance.date(),\n    zInstance.object({}), zInstance.array(zInstance.string()), zInstance.enum([\"_\"]),\n    zInstance.literal(\"_\"), zInstance.null(), zInstance.undefined(), zInstance.any(), zInstance.unknown(),\n    zInstance.void(), zInstance.never(), zInstance.nan(), zInstance.record(zInstance.string(), zInstance.string()),\n    zInstance.union([zInstance.string(), zInstance.number()]), zInstance.intersection(zInstance.string(), zInstance.string()),\n    zInstance.tuple([zInstance.string()]), zInstance.promise(zInstance.string()), zInstance.custom(),\n    zInstance.coerce.string(), zInstance.coerce.number(), zInstance.coerce.boolean(),\n    zInstance.coerce.bigint(), zInstance.coerce.date(),\n    zInstance.string().optional(), zInstance.string().nullable(), zInstance.string().default(\"\"),\n    zInstance.string().pipe(zInstance.string()), zInstance.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}\n\n// Auto-patch this module's own z instance so the re-exported z already has .modelName()\npatchZod(z);\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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"}

package/dist/procedure-xUVIUm5W.js

@@ -0,0 +1,213 @@
+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;
+	globalThis.__supalivePatchedCount = patched.size;
+}
+/**
+* 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-xUVIUm5W.js.map

package/dist/procedure-xUVIUm5W.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"procedure-xUVIUm5W.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  (globalThis as any).__supalivePatchedCount = patched.size;\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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"}

package/dist/src/client/index.d.ts

@@ -1,2 +1,2 @@
-import { $ as ProcedureNames, $r as WriteOp, Ar as OrPredicateSchema, Br as RangeRead, Bt as SupaliveDb, Cr as LeafPredicateSchema, Ct as QueryFn, Dr as OccAbortError, Er as NO_RETRY, Et as createActionBuilder, Fn as defineSchema, Fr as QueryCacheEntry, G as RPCError, Gn as PooledClient, Gr as RawRangeReadSchema, Gt as QueryDefinition, Hn as DbQueryResult, Hr as RawPointRead, Ht as AnyQueryDef, Ir as QueryCacheEntrySchema, J as ActionProcedures, Jr as ReadEntry, Jt as defineQuery, K as WSClientOptions, Kr as RawReadEntry, Kt as ResultOf, Lr as QueryCacheMetadata, Mn as SchemaDefinition, Mr as PointReadSchema, Nr as Predicate, Or as OccConflictError, Ot as createMutationBuilder, Pn as defineComputedField, Pr as PredicateSchema, Q as MutationProcedures, Qr as WriteEntrySchema, Rr as QueryCacheMetadataSchema, Sn as Model, Sr as LeafPredicate, St as QueryCtx, Tr as MutationResult, Tt as TypeOf, U as ClientPublicState, Ur as RawPointReadSchema, Ut as DefsToMap, Vn as Database, Vr as RangeReadSchema, Vt as sleep, W as HeartbeatOptions, Wr as RawRangeRead, Wt as ParamsOf, Xr as RetryConfig, Xt as DbWriter, Y as AppRouter, Yr as ReadEntrySchema, Yt as DbReader, Zr as WriteEntry, Zt as TxContext, _r as CommitLogEntry, _t as MutationCtx, a as CallOptions, at as router, bn as InferSchema, br as CompareOperatorSchema, bt as OutputOf, c as LiveQueryHandle, ct as ActionFn, d as WSClientMethods, dt as ContextOf, ei as WriteOpSchema, et as PublicProcedures, f as createClient, fn as ColumnCodec, fr as AndPredicate, gn as ComputedFieldConfig, gr as CachedPgMetadataSchema, gt as MutationConfig, hr as CachedPgMetadata, i as createCaller, jn as SchemaColumnsOptions, jr as PointRead, kn as SchemaCodecs, kr as OrPredicate, kt as createQueryBuilder, l as LiveQueryState, lt as ActionProcedure, mr as BigIntSchema, n as CallerFromRouter, ni as normalizeIdToBytes, nt as RegisteredProcedure, o as ClientFromProcedures, ot as ActionConfig, pr as AndPredicateSchema, q as WsClientManager, qn as RawClient, qr as RawReadEntrySchema, qt as _resetGlobalDefs, r as CallerOptions, ri as normalizeToBytes, rt as Router, s as ClientOptions, st as ActionCtx, t as CallerFromProcedures, ti as bytesFromJson, tt as QueryProcedures, u as LiveQueryStatus, un as matchesPredicate, ut as AnyProcedure, vr as CommitTs, vt as MutationFn, wr as LiveResult, wt as QueryProcedure, xn as InsertData, xr as DEFAULT_RETRY, xt as QueryConfig, yr as CompareOperator, yt as MutationProcedure, zr as QuerySpec } from "../../index-DgZeS3JK.js";
+import { $ as ProcedureNames, $r as WriteEntry, $t as TxContext, Ar as OccConflictError, Br as QueryCacheMetadataSchema, Cn as InsertData, Cr as DEFAULT_RETRY, Ct as QueryFn, Dr as MutationResult, Er as LiveResult, Et as createActionBuilder, Fr as Predicate, G as RPCError, Gr as RawPointReadSchema, Gt as DefsToMap, Hr as RangeRead, Ht as SupaliveDb, In as defineComputedField, Ir as PredicateSchema, J as ActionProcedures, Jr as RawReadEntry, Jt as ResultOf, K as WSClientOptions, Kr as RawRangeRead, Kt as ParamsOf, Ln as defineSchema, Lr as QueryCacheEntry, Mr as OrPredicateSchema, Nn as SchemaColumnsOptions, Nr as PointRead, Or as NO_RETRY, Ot as createMutationBuilder, Pn as SchemaDefinition, Pr as PointReadSchema, Q as MutationProcedures, Qr as RetryConfig, Qt as DbWriter, Rr as QueryCacheEntrySchema, Sn as InferSchema, Sr as CompareOperatorSchema, St as QueryCtx, Tr as LeafPredicateSchema, Tt as TypeOf, U as ClientPublicState, Un as Database, Ur as RangeReadSchema, Ut as sleep, Vr as QuerySpec, W as HeartbeatOptions, Wn as DbQueryResult, Wr as RawPointRead, Wt as AnyQueryDef, Xr as ReadEntry, Xt as defineQuery, Y as AppRouter, Yn as RawClient, Yr as RawReadEntrySchema, Yt as _resetGlobalDefs, Zr as ReadEntrySchema, Zt as DbReader, _r as CachedPgMetadata, _t as MutationCtx, a as CallOptions, ai as normalizeToBytes, at as router, br as CommitTs, bt as OutputOf, c as LiveQueryHandle, ct as ActionFn, d as WSClientMethods, dt as ContextOf, ei as WriteEntrySchema, et as PublicProcedures, f as createClient, fn as matchesPredicate, gr as BigIntSchema, gt as MutationConfig, hr as AndPredicateSchema, i as createCaller, ii as normalizeIdToBytes, jn as SchemaCodecs, jr as OrPredicate, kr as OccAbortError, kt as createQueryBuilder, l as LiveQueryState, lt as ActionProcedure, mn as ColumnCodec, mr as AndPredicate, n as CallerFromRouter, ni as WriteOpSchema, nt as RegisteredProcedure, o as ClientFromProcedures, ot as ActionConfig, q as WsClientManager, qn as PooledClient, qr as RawRangeReadSchema, qt as QueryDefinition, r as CallerOptions, ri as bytesFromJson, rt as Router, s as ClientOptions, st as ActionCtx, t as CallerFromProcedures, ti as WriteOp, tt as QueryProcedures, u as LiveQueryStatus, ut as AnyProcedure, vn as ComputedFieldConfig, vr as CachedPgMetadataSchema, vt as MutationFn, wn as Model, wr as LeafPredicate, wt as QueryProcedure, xr as CompareOperator, xt as QueryConfig, yr as CommitLogEntry, yt as MutationProcedure, zr as QueryCacheMetadata } from "../../index-BQRlJY_1.js";
 export { type ActionConfig, type ActionCtx, type ActionFn, type ActionProcedure, type ActionProcedures, AndPredicate, AndPredicateSchema, type AnyProcedure, type AnyQueryDef, type AppRouter, BigIntSchema, CachedPgMetadata, CachedPgMetadataSchema, type CallOptions, CallerFromProcedures, CallerFromRouter, CallerOptions, type ClientFromProcedures, type ClientOptions, type ClientPublicState, type ColumnCodec, CommitLogEntry, CommitTs, CompareOperator, CompareOperatorSchema, type ComputedFieldConfig, type ContextOf, DEFAULT_RETRY, type Database, type DbQueryResult, DbReader, DbReader as ReadContext, DbWriter, DbWriter as WritableContext, type DefsToMap, type HeartbeatOptions, type InferSchema, type InsertData, LeafPredicate, LeafPredicateSchema, type LiveQueryHandle, type LiveQueryState, type LiveQueryStatus, LiveResult, type Model, type MutationConfig, type MutationCtx, type MutationFn, type MutationProcedure, type MutationProcedures, MutationResult, NO_RETRY, OccAbortError, OccConflictError, OrPredicate, OrPredicateSchema, type OutputOf, type ParamsOf, PointRead, PointReadSchema, type PooledClient, Predicate, PredicateSchema, type ProcedureNames, type PublicProcedures, QueryCacheEntry, QueryCacheEntrySchema, QueryCacheMetadata, QueryCacheMetadataSchema, type QueryConfig, type QueryCtx, type QueryDefinition, type QueryFn, type QueryProcedure, type QueryProcedures, QuerySpec, RPCError, RangeRead, RangeReadSchema, type RawClient, RawPointRead, RawPointReadSchema, RawRangeRead, RawRangeReadSchema, RawReadEntry, RawReadEntrySchema, ReadEntry, ReadEntrySchema, type RegisteredProcedure, type ResultOf, RetryConfig, type Router, type SchemaCodecs, type SchemaColumnsOptions, type SchemaDefinition, SupaliveDb, TxContext, type TypeOf, type WSClientMethods, type WSClientOptions, WriteEntry, WriteEntrySchema, WriteOp, WriteOpSchema, WsClientManager, _resetGlobalDefs, bytesFromJson, createActionBuilder, createCaller, createClient, createMutationBuilder, createQueryBuilder, defineComputedField, defineQuery, defineSchema, matchesPredicate, normalizeIdToBytes, normalizeToBytes, router, sleep };

package/dist/src/client/index.js

@@ -1,4 +1,4 @@
-import { i as createQueryBuilder, r as createMutationBuilder, t as createActionBuilder } from "../../procedure-Ze1GE-N9.js";
+import { i as createQueryBuilder, r as createMutationBuilder, t as createActionBuilder } from "../../procedure-DPgXC2Cm.js";
 import { n as getContextRegistry, r as router } from "../../router-CiWYeWUR.js";
 import { o as matchesPredicate } from "../../query-ur-jCtVr.js";
 import { n as defineSchema, t as defineComputedField } from "../../schema-Dd7u0A1L.js";

package/dist/src/exports/mysql.d.ts

@@ -1,2 +1,2 @@
-import { t as MySqlDatabase } from "../../mysql-9euRTU3L.js";
+import { t as MySqlDatabase } from "../../mysql-CBSuONm5.js";
 export { MySqlDatabase };

package/dist/src/exports/postgres.d.ts

@@ -1,2 +1,2 @@
-import { t as PgDatabase } from "../../postgres-B-OZJdD9.js";
+import { t as PgDatabase } from "../../postgres-BKGLPrKt.js";
 export { PgDatabase };

package/dist/src/exports/procedure.d.ts

@@ -1,3 +1,18 @@
-import { $ as ProcedureNames, $t as JsonContainsOptions, An as SchemaColumnMapping, Cn as MutationArgs, Ct as QueryFn, Dn as ReturnLiveQuery, Dt as createJobBuilder, En as QueryArgs, Et as createActionBuilder, Fn as defineSchema, In as schemaRegistry, J as ActionProcedures, Ln as shouldTrackSchema, Mn as SchemaDefinition, Nn as StoredSchemaColumnsOptions, On as ReturnQuery, Ot as createMutationBuilder, Pn as defineComputedField, Q as MutationProcedures, Qt as IdAndCommitTs, Rn as tableNameToId, Sn as Model, St as QueryCtx, Tn as Prettify, Tt as TypeOf, X as ContextRegistry, Y as AppRouter, Z as JobProcedures, _n as DeclarativeIndex, _t as MutationCtx, an as QueryBuilder, at as router, bn as InferSchema, bt as OutputOf, cn as jsonPathExists, ct as ActionFn, dn as ActionArgs, dt as ContextOf, en as JsonHasKeyMultiOptions, et as PublicProcedures, fn as ColumnCodec, ft as JobConfig, gn as ComputedFieldConfig, gt as MutationConfig, hn as ComputedField, ht as JobProcedure, in as PaginationClause, it as getContextRegistry, jn as SchemaColumnsOptions, kn as SchemaCodecs, kt as createQueryBuilder, ln as jsonPathExtract, lt as ActionProcedure, mn as ComputedDataType, mt as JobFn, nn as OrderByOptions, nt as RegisteredProcedure, on as buildPredicateSql, ot as ActionConfig, pn as ComputedCodec, pt as JobCtx, rn as OrderDirection, rt as Router, sn as jsonContains, st as ActionCtx, tn as JsonOpOptions, tt as QueryProcedures, un as matchesPredicate, ut as AnyProcedure, vn as DefineSchemaConfig, vt as MutationFn, wn as OverrideField, wt as QueryProcedure, xn as InsertData, xt as QueryConfig, yn as IndexDefinition, yt as MutationProcedure, zn as trackSchema } from "../../index-DgZeS3JK.js";
+import { $ as ProcedureNames, An as ReturnQuery, At as patchZod$1, Bn as tableNameToId, Cn as InsertData, Ct as QueryFn, Dn as Prettify, Dt as createJobBuilder, En as OverrideField, Et as createActionBuilder, Fn as StoredSchemaColumnsOptions, In as defineComputedField, J as ActionProcedures, Ln as defineSchema, Mn as SchemaColumnMapping, Nn as SchemaColumnsOptions, On as QueryArgs, Ot as createMutationBuilder, Pn as SchemaDefinition, Q as MutationProcedures, Rn as schemaRegistry, Sn as InferSchema, St as QueryCtx, Tn as MutationArgs, Tt as TypeOf, Vn as trackSchema, X as ContextRegistry, Y as AppRouter, Z as JobProcedures, _n as ComputedField, _t as MutationCtx, an as OrderDirection, at as router, bn as DefineSchemaConfig, bt as OutputOf, cn as buildPredicateSql, ct as ActionFn, dn as jsonPathExtract, dt as ContextOf, en as IdAndCommitTs, et as PublicProcedures, fn as matchesPredicate, ft as JobConfig, gn as ComputedDataType, gt as MutationConfig, hn as ComputedCodec, ht as JobProcedure, in as OrderByOptions, it as getContextRegistry, jn as SchemaCodecs, jt as z$1, kn as ReturnLiveQuery, kt as createQueryBuilder, ln as jsonContains, lt as ActionProcedure, mn as ColumnCodec, mt as JobFn, nn as JsonHasKeyMultiOptions, nt as RegisteredProcedure, on as PaginationClause, ot as ActionConfig, pn as ActionArgs, pt as JobCtx, rn as JsonOpOptions, rt as Router, sn as QueryBuilder, st as ActionCtx, tn as JsonContainsOptions, tt as QueryProcedures, un as jsonPathExists, ut as AnyProcedure, vn as ComputedFieldConfig, vt as MutationFn, wn as Model, wt as QueryProcedure, xn as IndexDefinition, xt as QueryConfig, yn as DeclarativeIndex, yt as MutationProcedure, zn as shouldTrackSchema } from "../../index-BQRlJY_1.js";
 import { n as stableStringify, r as supaliveStringify, t as groupByToMap } from "../../helper-CiacMqje.js";
-export { ActionArgs, type ActionConfig, type ActionCtx, type ActionFn, type ActionProcedure, type ActionProcedures, type AnyProcedure, type AppRouter, ColumnCodec, ComputedCodec, ComputedDataType, ComputedField, ComputedFieldConfig, type ContextOf, ContextRegistry, DeclarativeIndex, DefineSchemaConfig, IdAndCommitTs, IndexDefinition, InferSchema, InsertData, type JobConfig, type JobCtx, type JobFn, type JobProcedure, type JobProcedures, JsonContainsOptions, JsonHasKeyMultiOptions, JsonOpOptions, Model, MutationArgs, type MutationConfig, type MutationCtx, type MutationFn, type MutationProcedure, type MutationProcedures, OrderByOptions, OrderDirection, type OutputOf, OverrideField, PaginationClause, Prettify, type ProcedureNames, type PublicProcedures, QueryArgs, QueryBuilder, type QueryConfig, type QueryCtx, type QueryFn, type QueryProcedure, type QueryProcedures, type RegisteredProcedure, ReturnLiveQuery, ReturnQuery, type Router, SchemaCodecs, SchemaColumnMapping, SchemaColumnsOptions, SchemaDefinition, StoredSchemaColumnsOptions, type TypeOf, buildPredicateSql, createActionBuilder, createJobBuilder, createMutationBuilder, createQueryBuilder, defineComputedField, defineSchema, getContextRegistry, groupByToMap, jsonContains, jsonPathExists, jsonPathExtract, matchesPredicate, router, schemaRegistry, shouldTrackSchema, stableStringify, supaliveStringify, tableNameToId, trackSchema };
+
+//#region src/exports/procedure.d.ts
+declare const z: typeof z$1;
+declare const patchZod: typeof patchZod$1;
+declare module "zod" {
+  interface ZodType<Output, Input, Internals> {
+    /**
+     * Rename the generated model class in @supalive codegen output.
+     * Purely metadata — has no runtime effect beyond setting `.meta({ __genType: name })`.
+     */
+    modelName(name: string): this;
+  }
+} //# sourceMappingURL=procedure.d.ts.map
+//#endregion
+export { ActionArgs, type ActionConfig, type ActionCtx, type ActionFn, type ActionProcedure, type ActionProcedures, type AnyProcedure, type AppRouter, ColumnCodec, ComputedCodec, ComputedDataType, ComputedField, ComputedFieldConfig, type ContextOf, ContextRegistry, DeclarativeIndex, DefineSchemaConfig, IdAndCommitTs, IndexDefinition, InferSchema, InsertData, type JobConfig, type JobCtx, type JobFn, type JobProcedure, type JobProcedures, JsonContainsOptions, JsonHasKeyMultiOptions, JsonOpOptions, Model, MutationArgs, type MutationConfig, type MutationCtx, type MutationFn, type MutationProcedure, type MutationProcedures, OrderByOptions, OrderDirection, type OutputOf, OverrideField, PaginationClause, Prettify, type ProcedureNames, type PublicProcedures, QueryArgs, QueryBuilder, type QueryConfig, type QueryCtx, type QueryFn, type QueryProcedure, type QueryProcedures, type RegisteredProcedure, ReturnLiveQuery, ReturnQuery, type Router, SchemaCodecs, SchemaColumnMapping, SchemaColumnsOptions, SchemaDefinition, StoredSchemaColumnsOptions, type TypeOf, buildPredicateSql, createActionBuilder, createJobBuilder, createMutationBuilder, createQueryBuilder, defineComputedField, defineSchema, getContextRegistry, groupByToMap, jsonContains, jsonPathExists, jsonPathExtract, matchesPredicate, patchZod, router, schemaRegistry, shouldTrackSchema, stableStringify, supaliveStringify, tableNameToId, trackSchema, z };
+//# sourceMappingURL=procedure.d.ts.map

package/dist/src/exports/procedure.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"procedure.d.ts","names":[],"sources":["../../../src/exports/procedure.ts"],"mappings":";;;;cAOa,CAAA,SAAC,GAAK;AAAA,cACN,QAAA,SAAQ,UAAY;AAAA;EAAA,UAIrB,OAAA;IAJC;;;;IAST,SAAA,CAAU,IAAA;EAAA;AAAA"}

package/dist/src/exports/procedure.js

@@ -1,6 +1,12 @@
-import { i as createQueryBuilder, n as createJobBuilder, r as createMutationBuilder, t as createActionBuilder } from "../../procedure-Ze1GE-N9.js";
+import { a as patchZod$1, i as createQueryBuilder, n as createJobBuilder, o as z$1, r as createMutationBuilder, t as createActionBuilder } from "../../procedure-DPgXC2Cm.js";
 import { n as getContextRegistry, r as router, t as ContextRegistry } from "../../router-CiWYeWUR.js";
 import { a as jsonPathExtract, i as jsonPathExists, n as buildPredicateSql, o as matchesPredicate, r as jsonContains, t as QueryBuilder } from "../../query-ur-jCtVr.js";
 import { a as tableNameToId, i as shouldTrackSchema, n as defineSchema, o as trackSchema, r as schemaRegistry, t as defineComputedField } from "../../schema-Dd7u0A1L.js";
 import { n as stableStringify, r as supaliveStringify, t as groupByToMap } from "../../helper-wGbzz6zo.js";
-export { ContextRegistry, QueryBuilder, buildPredicateSql, createActionBuilder, createJobBuilder, createMutationBuilder, createQueryBuilder, defineComputedField, defineSchema, getContextRegistry, groupByToMap, jsonContains, jsonPathExists, jsonPathExtract, matchesPredicate, router, schemaRegistry, shouldTrackSchema, stableStringify, supaliveStringify, tableNameToId, trackSchema };
+//#region src/exports/procedure.ts
+const z = z$1;
+const patchZod = patchZod$1;
+//#endregion
+export { ContextRegistry, QueryBuilder, buildPredicateSql, createActionBuilder, createJobBuilder, createMutationBuilder, createQueryBuilder, defineComputedField, defineSchema, getContextRegistry, groupByToMap, jsonContains, jsonPathExists, jsonPathExtract, matchesPredicate, patchZod, router, schemaRegistry, shouldTrackSchema, stableStringify, supaliveStringify, tableNameToId, trackSchema, z };
+
+//# sourceMappingURL=procedure.js.map

package/dist/src/exports/procedure.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"procedure.js","names":["_z","_patchZod"],"sources":["../../../src/exports/procedure.ts"],"sourcesContent":["export * from \"../router/index\";\nexport * from \"../db/query\";\nexport * from \"../db/schema\";\nexport * from \"../helper\";\n\n// Re-export z (with .modelName() already patched at import time)\nimport { z as _z, patchZod as _patchZod } from \"../router/procedure\";\nexport const z = _z;\nexport const patchZod = _patchZod;\n\n// eslint-disable-next-line @typescript-eslint/no-namespace\ndeclare module \"zod\" {\n  interface ZodType<Output, Input, Internals> {\n    /**\n     * Rename the generated model class in @supalive codegen output.\n     * Purely metadata — has no runtime effect beyond setting `.meta({ __genType: name })`.\n     */\n    modelName(name: string): this;\n  }\n}"],"mappings":";;;;;;AAOA,MAAa,IAAIA;AACjB,MAAa,WAAWC"}

package/dist/src/exports/schema-sql.d.ts

@@ -1,4 +1,4 @@
-import { In as schemaRegistry, Mn as SchemaDefinition, zn as trackSchema } from "../../index-DgZeS3JK.js";
+import { Pn as SchemaDefinition, Rn as schemaRegistry, Vn as trackSchema } from "../../index-BQRlJY_1.js";
 
 //#region src/db/schema-sql.d.ts
 type SqlDialect = "postgres" | "mysql";