@supalive/core 0.1.4 → 0.1.5

package/dist/schema-SKcIWHfo.js

@@ -0,0 +1,167 @@
+import { s as commitTsCodec } from "./query-CbQLjeME.js";
+import { o as utf8Encode } from "./helper-zdJT5FUc.js";
+import { z as z$1 } from "zod";
+//#region src/router/procedure.ts
+/**
+* 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,
+			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,
+			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,
+			fn: config.handler,
+			internal: config.internal ?? false
+		};
+	};
+}
+//#endregion
+//#region src/db/schema.ts
+function defineComputedField(config) {
+	return config;
+}
+function defineSchema(config) {
+	const columns = {};
+	if (config.columns) Object.assign(columns, {
+		"id": "id",
+		"commitTs": "commit_ts",
+		...config.columns
+	});
+	else {
+		for (const key of Object.keys(config.schema)) columns[key] = key;
+		columns["id"] = "id";
+		columns["commitTs"] = "commit_ts";
+	}
+	const augmentedShape = {
+		...config.schema,
+		id: z$1.string(),
+		commitTs: z$1.coerce.bigint()
+	};
+	const mergedCodecs = {
+		...config.options?.codecs ?? {},
+		commitTs: commitTsCodec
+	};
+	return {
+		tableId: tableNameToId(config.name),
+		table: config.name,
+		schema: z$1.object(augmentedShape),
+		columnsOptions: {
+			...config.options,
+			codecs: mergedCodecs
+		},
+		columns
+	};
+}
+function tableNameToId(tableName) {
+	return utf8Encode(tableName);
+}
+//#endregion
+export { createMutationBuilder as a, createActionBuilder as i, defineSchema as n, createQueryBuilder as o, tableNameToId as r, defineComputedField as t };
+
+//# sourceMappingURL=schema-SKcIWHfo.js.map

package/dist/schema-SKcIWHfo.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema-SKcIWHfo.js","names":["z"],"sources":["../src/router/procedure.ts","../src/db/schema.ts"],"sourcesContent":["import type { ZodType } from \"zod\";\nimport type { DbReader, DbWriter } from \"../db/context\";\nimport type { SupaliveDb } from \"../db/realtime_db\";\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 * Contains the full SupaliveDb for both queries and mutations, plus user-defined server context.\n */\nexport interface ActionCtx<TContext = unknown> {\n  /** Full database interface for queries and mutations */\n  db: SupaliveDb;\n  /** User-defined server context (auth, requestId, etc.) */\n  serverCtx: TContext;\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\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\",\n  TContext = unknown,\n  TInternal extends boolean = boolean\n> {\n  readonly _type: \"procedure\";\n  readonly procedureType: TType;\n  readonly inputSchema: ZodType<TInput>;\n  readonly fn: QueryFn<TInput, TResult, TContext> | MutationFn<TInput, TResult, TContext> | ActionFn<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\nexport type AnyProcedure<TContext = unknown> =\n  | QueryProcedure<any, any, TContext>\n  | MutationProcedure<any, any, TContext>\n  | ActionProcedure<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   * 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\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\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      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      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      fn: config.handler,\n      internal: (config.internal ?? false) as TInternal,\n    };\n  };\n}","import { z, ZodRawShape } from \"zod\";\nimport { commitTsCodec } from \"./codec\";\nimport { LiveQueryHandle } from \"../client\";\nimport { utf8Encode } from \"./bytes\";\n\nexport interface ColumnCodec<TData = unknown, TDriver = unknown> {\n    encode?: (value: TData) => TDriver;\n    decode?: (value: TDriver) => TData;\n}\n\n// Constrain a codec's decoded type to match the schema field's inferred type.\n// Without this, `decode` could return any value (e.g. a string outside an enum)\n// and silently override the schema's declared type at the type level.\ntype SchemaCodecField<TSchema extends ZodRawShape, K extends PropertyKey> =\n    K extends keyof TSchema\n    ? TSchema[K] extends z.ZodTypeAny ? z.infer<TSchema[K]> : unknown\n    : K extends keyof BaseSchema\n    ? BaseSchema[K] extends z.ZodTypeAny ? z.infer<BaseSchema[K]> : unknown\n    : unknown;\n\nexport type SchemaCodecs<TSchema extends ZodRawShape> = Partial<{\n    [K in keyof (TSchema & BaseSchema)]: ColumnCodec<SchemaCodecField<TSchema, K>, any>;\n}>;\n\nexport interface SchemaColumnsOptions<TSchema extends ZodRawShape = ZodRawShape> {\n    codecs?: SchemaCodecs<TSchema>;\n}\n\nexport interface SchemaColumnMapping {\n    [key: string]: string;\n}\n\nexport interface DefineSchemaConfig<TSchema extends ZodRawShape> {\n    name: string;\n    schema: TSchema;\n    options?: SchemaColumnsOptions<TSchema>;\n    columns?: SchemaColumnMapping;\n}\n\n// Tuple-wrap the `undefined` checks so they don't fall through to the\n// object-shape conditionals when consumers compile under `strict: false`\n// (without `strictNullChecks`, `undefined` is assignable to object types and\n// would otherwise match `{ decode: ... }` / `ColumnCodec<...>` with all\n// `infer`s collapsing to `unknown`).\ntype CodecDataType<TCodec, TFallback> =\n    [TCodec] extends [undefined] ? TFallback\n    : TCodec extends { decode: (...args: any[]) => infer TDecoded } ? TDecoded\n    : TCodec extends ColumnCodec<infer TData, unknown> ? TData\n    : TFallback;\n\ntype ZodOutput<TZod> =\n    [TZod] extends [undefined] ? unknown\n    : TZod extends z.ZodTypeAny ? z.infer<TZod>\n    : unknown;\nexport type ComputedDataType<TCodec, TZod> = CodecDataType<TCodec, ZodOutput<TZod>>;\nexport type ComputedCodec<TData, TDriver> = ColumnCodec<TData, TDriver>;\nexport type OverrideField<TObj, TKey extends PropertyKey, TValue> = Omit<TObj, TKey> & { [K in TKey]: TValue };\nexport interface ComputedFieldConfig<\n    TField extends string,\n    TDecoded = unknown,\n    TDriver = unknown,\n    TZodType extends z.ZodTypeAny | undefined = undefined,\n> {\n    field: TField;\n    sql: string;\n    alias?: string;\n    type?: TZodType;\n    codec?: {\n        decode: (value: TDriver) => TDecoded;\n        encode?: (value: TDecoded) => TDriver;\n    };\n}\n\nexport type ComputedField = {\n    field: string;\n    sql: string;\n    alias: string;\n    codec?: ColumnCodec<any, any>;\n};\n\nexport function defineComputedField<\n    TField extends string,\n    TDecoded = unknown,\n    TDriver = unknown,\n    TZodType extends z.ZodTypeAny | undefined = undefined,\n>(\n    config: ComputedFieldConfig<TField, TDecoded, TDriver, TZodType>\n): ComputedFieldConfig<TField, TDecoded, TDriver, TZodType> {\n    return config;\n}\n\nexport type Prettify<T> = { [K in keyof T]: T[K] } & {};\n\ntype ApplySchemaCodecs<TBase, TCodecs> = {\n    [K in keyof TBase]: K extends keyof TCodecs ? CodecDataType<TCodecs[K], TBase[K]> : TBase[K];\n};\n\n// Only apply codecs when `options.codecs` is explicitly provided. Without this\n// guard, the default constraint (`SchemaColumnsOptions<TSchema>`) makes\n// `TOptions[\"codecs\"]` infer as `Partial<{ [K]: ColumnCodec<any, any> }>`,\n// which collapses every field to `any` inside `ApplySchemaCodecs`.\ntype ResolveSchemaType<\n    TSchema extends ZodRawShape,\n    TOptions extends SchemaColumnsOptions<TSchema>\n> = TOptions extends { codecs: infer TCodecs }\n    ? Prettify<ApplySchemaCodecs<z.infer<z.ZodObject<TSchema & BaseSchema>>, TCodecs>>\n    : Prettify<z.infer<z.ZodObject<TSchema & BaseSchema>>>;\n\n// Helper to detect if a Zod type is optional or nullable\ntype IsOptionalField<T> =\n    T extends z.ZodOptional<any> ? true :\n    T extends z.ZodNullable<any> ? true :\n    T extends z.ZodDefault<any> ? true :\n    false;\n\n// Split schema keys into required vs optional\ntype OptionalKeys<TZod extends ZodRawShape> = {\n    [K in keyof TZod]: IsOptionalField<TZod[K]> extends true ? K : never\n}[keyof TZod];\n\ntype RequiredKeys<TZod extends ZodRawShape> = {\n    [K in keyof TZod]: IsOptionalField<TZod[K]> extends true ? never : K\n}[keyof TZod];\n\n// Add a base shape type that all schemas will include\ntype BaseSchema = {\n    id: z.ZodString;\n    commitTs: z.ZodCoercedBigInt;\n};\n\nexport function defineSchema<\n    TSchema extends ZodRawShape,\n    TName extends string,\n    TOptions extends SchemaColumnsOptions<TSchema> = SchemaColumnsOptions<TSchema>\n>(\n    config: DefineSchemaConfig<TSchema> & { name: TName; options?: TOptions }\n): SchemaDefinition<TName, Prettify<TSchema & BaseSchema>, ResolveSchemaType<TSchema, TOptions>> {\n    const columns: Record<string, string> = {};\n\n    if (config.columns) {\n        Object.assign(columns, { 'id': 'id', 'commitTs': 'commit_ts', ...config.columns });\n    } else {\n        // Default: use field name as column name\n        for (const key of Object.keys(config.schema)) {\n            columns[key] = key;\n        }\n        columns['id'] = 'id';\n        columns['commitTs'] = 'commit_ts';\n    }\n\n    // Merge id/commitTs into the Zod schema, user-defined fields win for everything else,\n    // but id/commitTs are always forced to their correct types\n    const augmentedShape = {\n        ...config.schema,\n        id: z.string(),      // always string, even if user defined it differently\n        commitTs: z.coerce.bigint(), // always number, mapped to commit_ts column\n    };\n\n    const userCodecs = config.options?.codecs ?? {};\n    const mergedCodecs = {\n        ...userCodecs,\n        commitTs: commitTsCodec,\n    };\n\n    const result = {\n        tableId: tableNameToId(config.name),\n        table: config.name,\n        schema: z.object(augmentedShape),\n        columnsOptions: {\n            ...config.options,\n            codecs: mergedCodecs,\n        },\n        columns,\n    } as SchemaDefinition<TName, TSchema & BaseSchema, ResolveSchemaType<TSchema, TOptions>>;\n\n    return result\n}\n\nexport function tableNameToId(tableName: string): Uint8Array {\n    return utf8Encode(tableName);\n}\n\n// Stored codec map is intentionally loose: the strict per-field constraint is\n// enforced on the input (`DefineSchemaConfig.options`), but storing the strict\n// type here would break variance when assigning a specific schema to a generic\n// `SchemaDefinition<string, ZodRawShape>` constraint (ColumnCodec.encode is\n// contravariant in its data type).\nexport interface StoredSchemaColumnsOptions {\n    codecs?: Record<string, ColumnCodec<any, any>>;\n}\n\nexport interface SchemaDefinition<\n    TTable extends string,\n    TZod extends ZodRawShape,\n    TData = z.infer<z.ZodObject<TZod>>\n> {\n    tableId: Uint8Array;\n    table: TTable;\n    schema: z.ZodObject<TZod>;\n    columnsOptions: StoredSchemaColumnsOptions;\n    columns: Record<string, string>;\n    _dataType?: TData;\n}\n\nexport type InferSchema<T extends SchemaDefinition<string, ZodRawShape, any>> =\n    T extends SchemaDefinition<string, ZodRawShape, infer TData> ? TData : never;\n\nexport type InsertData<T extends SchemaDefinition<string, ZodRawShape, any>> =\n    T extends SchemaDefinition<string, infer TZod, infer TData>\n    ? {\n        [K in RequiredKeys<TZod> as K extends \"id\" | \"commitTs\" ? never : K]:\n        Extract<K, string> extends keyof TData ? TData[Extract<K, string>] : never\n    } & {\n        [K in OptionalKeys<TZod> as K extends \"id\" | \"commitTs\" ? never : K]?:\n        Extract<K, string> extends keyof TData ? TData[Extract<K, string>] : never\n    }\n    : never;\n\nexport interface Model {\n    table: string;\n    tableId: Uint8Array,\n    columns: Record<string, string>;\n    reverseColumns: Record<string, string>;\n    types: Record<string, string>;\n    codecs: Record<string, ColumnCodec<any, any>>;\n}\n\n\ntype MaybePromise<T> = T | Promise<T>;\n\nexport type ReturnLiveQuery<\n    TLiveQueryFn extends (...args: any[]) => MaybePromise<LiveQueryHandle<any>>\n> =\n    Awaited<ReturnType<TLiveQueryFn>> extends LiveQueryHandle<infer T>\n    ? T\n    : never;\n\nexport type ReturnQuery<TQueryFn extends (...args: any[]) => any> =\n    Awaited<ReturnType<TQueryFn>>;\n\nexport type QueryArgs<TQueryFn extends (...args: any[]) => any> =\n    Parameters<TQueryFn>[0];\n\nexport type MutationArgs<TMutationFn extends (...args: any[]) => any> =\n    Parameters<TMutationFn>[0];\n\nexport type ActionArgs<TActionFn extends (...args: any[]) => any> =\n    Parameters<TActionFn>[0];"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAkMA,SAAgB,qBAAyC;CACvD,OAAO,SAAS,MACd,QACsD;EACtD,OAAO;GACL,OAAO;GACP,eAAe;GACf,aAAa,OAAO;GACpB,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,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,IAAI,OAAO;GACX,UAAW,OAAO,YAAY;EAChC;CACF;AACF;;;ACzNA,SAAgB,oBAMZ,QACwD;CACxD,OAAO;AACX;AAyCA,SAAgB,aAKZ,QAC6F;CAC7F,MAAM,UAAkC,CAAC;CAEzC,IAAI,OAAO,SACP,OAAO,OAAO,SAAS;EAAE,MAAM;EAAM,YAAY;EAAa,GAAG,OAAO;CAAQ,CAAC;MAC9E;EAEH,KAAK,MAAM,OAAO,OAAO,KAAK,OAAO,MAAM,GACvC,QAAQ,OAAO;EAEnB,QAAQ,QAAQ;EAChB,QAAQ,cAAc;CAC1B;CAIA,MAAM,iBAAiB;EACnB,GAAG,OAAO;EACV,IAAIA,IAAE,OAAO;EACb,UAAUA,IAAE,OAAO,OAAO;CAC9B;CAGA,MAAM,eAAe;EACjB,GAFe,OAAO,SAAS,UAAU,CAAC;EAG1C,UAAU;CACd;CAaA,OAAO;EAVH,SAAS,cAAc,OAAO,IAAI;EAClC,OAAO,OAAO;EACd,QAAQA,IAAE,OAAO,cAAc;EAC/B,gBAAgB;GACZ,GAAG,OAAO;GACV,QAAQ;EACZ;EACA;CAGQ;AAChB;AAEA,SAAgB,cAAc,WAA+B;CACzD,OAAO,WAAW,SAAS;AAC/B"}

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

@@ -1,17 +1,2 @@
-export { defineQuery, _resetGlobalDefs } from "../db/query_definition";
-export type { QueryDefinition, AnyQueryDef, ParamsOf, ResultOf, DefsToMap, } from "../db/query_definition";
-export { SupaliveDb, sleep } from "../db/realtime_db";
-export { TxContext, DbReader, DbWriter } from "../db/context";
-export { DbReader as ReadContext, DbWriter as WritableContext } from "../db/context";
-export { defineSchema, defineComputedField } from "../db/schema";
-export type { Model } from "../db/schema";
-export type { ComputedFieldConfig, ColumnCodec, SchemaCodecs, SchemaDefinition, SchemaColumnsOptions, InferSchema, InsertData, } from "../db/schema";
-export type { Database, RawClient, PooledClient, DbQueryResult, } from "../db/db";
-export { matchesPredicate } from "../db/query";
-export * from "../db/types_db";
-export { NO_RETRY, DEFAULT_RETRY, OccConflictError, OccAbortError, } from "../db/types_db";
-export { createQueryBuilder, createMutationBuilder, createActionBuilder, type QueryProcedure, type MutationProcedure, type ActionProcedure, type AnyProcedure, type QueryFn, type MutationFn, type ActionFn, type OutputOf, type TypeOf, type ContextOf, type QueryConfig, type MutationConfig, type ActionConfig, type QueryCtx, type MutationCtx, type ActionCtx, } from "../router/procedure";
-export { router, type Router, type AppRouter, type RegisteredProcedure, type QueryProcedures, type MutationProcedures, type ActionProcedures, type PublicProcedures, type ProcedureNames, } from "../router/router";
-export { WsClientManager, RPCError, type WSClientOptions, type HeartbeatOptions, type ClientPublicState, } from "./ws_client_manager";
-export { createClient, type ClientOptions, type LiveQueryHandle, type LiveQueryState, type LiveQueryStatus, type WSClientMethods, type ClientFromProcedures, type CallOptions, } from "./client";
-//# sourceMappingURL=index.d.ts.map
+import { $ as PublicProcedures, $n as LiveResult, $t as InferSchema, Ar as bytesFromJson, At as ResultOf, Cr as ReadEntry, Ct as createQueryBuilder, Dr as WriteEntrySchema, Dt as DefsToMap, Er as WriteEntry, Et as AnyQueryDef, Ft as TxContext, G as RPCError, Gn as CachedPgMetadataSchema, Gt as matchesPredicate, Hn as AndPredicateSchema, J as ActionProcedures, Jn as CompareOperator, K as WSClientOptions, Kn as CommitLogEntry, Mr as normalizeToBytes, Mt as defineQuery, Nt as DbReader, Or as WriteOp, Ot as ParamsOf, Pt as DbWriter, Q as ProcedureNames, Qn as LeafPredicateSchema, Sn as RawClient, Sr as RawReadEntrySchema, St as createMutationBuilder, Tr as RetryConfig, Tt as sleep, U as ClientPublicState, Un as BigIntSchema, Vn as AndPredicate, W as HeartbeatOptions, Wn as CachedPgMetadata, Xn as DEFAULT_RETRY, Y as AppRouter, Yn as CompareOperatorSchema, Z as MutationProcedures, Zn as LeafPredicate, Zt as ComputedFieldConfig, _n as DbQueryResult, _r as RawPointRead, _t as QueryCtx, a as CallOptions, ar as OrPredicateSchema, at as ActionConfig, bn as PooledClient, br as RawRangeReadSchema, bt as TypeOf, c as LiveQueryHandle, cn as SchemaCodecs, cr as Predicate, ct as ActionProcedure, d as WSClientMethods, dn as SchemaDefinition, dr as QueryCacheEntrySchema, dt as MutationConfig, en as InsertData, er as MutationResult, et as QueryProcedures, f as createClient, fr as QueryCacheMetadata, ft as MutationCtx, gn as Database, gr as RangeReadSchema, gt as QueryConfig, hr as RangeRead, ht as OutputOf, i as createCaller, ir as OrPredicate, it as router, jr as normalizeIdToBytes, jt as _resetGlobalDefs, kr as WriteOpSchema, kt as QueryDefinition, l as LiveQueryState, lr as PredicateSchema, lt as AnyProcedure, mn as defineSchema, mr as QuerySpec, mt as MutationProcedure, n as CallerFromRouter, nr as OccAbortError, nt as Router, o as ClientFromProcedures, or as PointRead, ot as ActionCtx, pn as defineComputedField, pr as QueryCacheMetadataSchema, pt as MutationFn, q as WsClientManager, qn as CommitTs, qt as ColumnCodec, r as CallerOptions, rr as OccConflictError, s as ClientOptions, sr as PointReadSchema, st as ActionFn, t as CallerFromProcedures, tn as Model, tr as NO_RETRY, tt as RegisteredProcedure, u as LiveQueryStatus, un as SchemaColumnsOptions, ur as QueryCacheEntry, ut as ContextOf, vr as RawPointReadSchema, vt as QueryFn, wr as ReadEntrySchema, wt as SupaliveDb, xr as RawReadEntry, xt as createActionBuilder, yr as RawRangeRead, yt as QueryProcedure } from "../../index-CTyXKcq_.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 };