@supalive/core 1.1.0 → 1.2.1

package/dist/realtime_db-BtwBABDY.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"realtime_db-BtwBABDY.js","names":["z"],"sources":["../src/db/context.ts","../src/db/realtime_db.ts"],"sourcesContent":["import { z, ZodRawShape } from \"zod\";\nimport { Database } from \"./db\";\nimport { ReadEntry, WriteEntry, } from \"./types_db\";\n\nimport { ColumnCodec, InferSchema, InsertData, Model, SchemaDefinition } from \"./schema\";\nimport { normalizeCodec, unwrapZodType } from \"./codec\";\nimport { QueryBuilder } from \"./query\";\n\n/**\n * Materialize a schema's runtime {@link Model}: column-name mapping, per-column\n * coarse type tags, and the codec used to (de)serialize each column.\n *\n * Codecs are resolved via {@link normalizeCodec}, which supplies a sensible\n * default per Zod type (e.g. a {@link dateCodec} for `z.date()`, so `Date`\n * columns round-trip automatically) while letting a user-supplied codec in\n * `schema.columnsOptions.codecs` override it — partially or fully.\n */\nexport function buildModel(schema: SchemaDefinition<string, ZodRawShape>): Model {\n  const shape = schema.schema.shape;\n  const customColumns = (schema as any).columns;\n  const columns: Record<string, string> = {};\n  const types: Record<string, string> = {};\n  const codecs: Record<string, ColumnCodec<any, any>> = {};\n  const schemaCodecs = schema.columnsOptions.codecs ?? {};\n\n  for (const key of Object.keys(shape)) {\n    columns[key] = customColumns?.[key] ?? key;\n    const field = shape[key];\n    const baseField = unwrapZodType(field);\n    if (baseField instanceof z.ZodNumber) {\n      types[key] = \"integer\";\n    } else if (baseField instanceof z.ZodString) {\n      types[key] = \"string\";\n    } else if (baseField instanceof z.ZodBoolean) {\n      types[key] = \"boolean\";\n    } else if (baseField instanceof z.ZodDate) {\n      types[key] = \"date\";\n    } else if (baseField instanceof z.ZodArray) {\n      types[key] = \"array\";\n    } else {\n      types[key] = \"json\";\n    }\n    codecs[key] = normalizeCodec(schemaCodecs[key], baseField);\n  }\n\n  return {\n    table: schema.table,\n    tableId: schema.tableId,\n    columns,\n    reverseColumns: Object.fromEntries(Object.entries(columns).map(([k, v]) => [v, k])),\n    types,\n    codecs,\n  };\n}\n\nexport class TxContext {\n  readonly beginTs: bigint;\n  readonly db: Database;\n  protected readSet: ReadEntry[] = [];\n  protected writeSet: WriteEntry[] = [];\n  private models: Map<string, Model> = new Map();\n\n  protected getOrCreateModel(schema: SchemaDefinition<string, ZodRawShape>): Model {\n    const existing = this.models.get(schema.table);\n    if (existing) return existing;\n\n    const model = buildModel(schema);\n    this.models.set(schema.table, model);\n    return model;\n  }\n\n  constructor(db: Database, beginTs: bigint) {\n    this.db = db;\n    this.beginTs = beginTs;\n  }\n\n  internalGetReadSet(): ReadEntry[] { return this.readSet; }\n  internalGetWriteSet(): WriteEntry[] { return this.writeSet; }\n\n  /**\n   * Merge a parent procedure's reads into this context's readSet. Used when a\n   * `runMutation` sub-transaction inherits the reads of the procedure that\n   * invoked it, so the sub-tx's OCC validation also fences on those rows.\n   * Entries are shallow-cloned so the two readSets don't alias.\n   */\n  appendInternalReadSet(parentEntries: ReadEntry[]) {\n    this.readSet.push(...parentEntries.map((e) => ({...e})));\n  }\n\n  protected findPendingWrite(table: string, id: string): WriteEntry | undefined {\n    return this.writeSet.find(w => w.table === table && w.id === id);\n  }\n\n  protected findPendingInsert(table: string, id: string): WriteEntry | undefined {\n    return this.writeSet.find(w => w.table === table && w.id === id && w.op === \"insert\");\n  }\n\n  protected encodeWithCodec(model: Model, property: string, value: unknown): unknown {\n    const codec = model.codecs[property];\n    if (!codec?.encode || value === undefined || value === null) return value;\n    return codec.encode(value);\n  }\n}\n\nexport class DbReader extends TxContext {\n  query<S extends SchemaDefinition<string, ZodRawShape>>(schema: S): QueryBuilder<S> {\n    const model = this.getOrCreateModel(schema);\n    return new QueryBuilder<S>(this, model);\n  }\n}\n\nexport class DbWriter extends DbReader {\n  async insert<S extends SchemaDefinition<string, ZodRawShape>, ID extends string>(\n    schema: S,\n    id: ID,\n    data: InsertData<S>\n  ): Promise<void> {\n    const model = this.getOrCreateModel(schema);\n    const mappedData: Record<string, unknown> = { id };\n    const shape = schema.schema.shape;\n\n    for (const key of Object.keys(shape)) {\n      let value = data[key];\n\n      if (value === undefined) {\n        const field = shape[key];\n        if (field instanceof z.ZodDefault) {\n          const defaultVal = field.def.defaultValue;\n          value = (typeof defaultVal === \"function\" ? defaultVal() : defaultVal)\n\n          if (value !== undefined) {\n            const columnName = model.columns[key] ?? key;\n            mappedData[columnName] = this.encodeWithCodec(model, key, value);\n          }\n        }\n      } else {\n        const columnName = model.columns[key] ?? key;\n        mappedData[columnName] = this.encodeWithCodec(model, key, value);\n      }\n    }\n    // ensure id same\n    mappedData[\"id\"] = id;\n\n    // Check for existing pending write for the same ID\n    const existing = this.findPendingWrite(schema.table, id);\n    if (existing) {\n      if (existing.op === \"delete\") {\n        // If there's a pending delete, change it to an update with the new data\n        existing.op = \"update\";\n        existing.data = mappedData;\n      } else {\n        // If there's a pending update or same insert with the same ID , merge the new data\n        existing.data = { ...existing.data, ...mappedData };\n      }\n    } else {\n      this.writeSet.push({ table: schema.table, tableId: schema.tableId, id: id, op: \"insert\", data: mappedData });\n    }\n  }\n\n  async update<S extends SchemaDefinition<string, ZodRawShape>, ID extends string>(\n    schema: S,\n    id: ID,\n    data: Partial<Omit<InferSchema<S>, \"id\" | \"commitTs\">>,\n  ): Promise<void> {\n    const model = this.getOrCreateModel(schema);\n    const mappedData: Record<string, unknown> = {};\n\n    for (const [key, value] of Object.entries(data)) {\n      const columnName = model.columns[key] ?? key;\n      mappedData[columnName] = this.encodeWithCodec(model, key, value);\n    }\n\n    const existing = this.findPendingWrite(schema.table, id);\n    if (existing) {\n      existing.op = existing.op === \"insert\" ? \"insert\" : \"update\";\n      existing.data = { ...existing.data, ...mappedData };\n    } else {\n      // expectedTs will be filled by the committer via batch fetch if not known yet\n      this.writeSet.push({ table: schema.table, tableId: schema.tableId, id, op: \"update\", data: mappedData });\n    }\n  }\n\n  async delete<S extends SchemaDefinition<string, ZodRawShape>, ID extends string>(\n    schema: S,\n    id: ID,\n  ): Promise<void> {\n    // If there's a pending insert for the same ID, remove it instead of adding a delete\n    const existingInsert = this.findPendingInsert(schema.table, id);\n    if (existingInsert) {\n      this.writeSet = this.writeSet.filter(w => w !== existingInsert);\n      return;\n    }\n\n    // expectedTs will be filled by the committer via batch fetch if not known yet\n    this.writeSet.push({ table: schema.table, tableId: schema.tableId, id, op: \"delete\" });\n  }\n}\n","import { Database, LazyCommitTsParam, TxDatabase } from \"./db\";\nimport {\n  OccConflictError, WriteEntry, CommitTs, LiveResult, MutationResult\n} from \"./types_db\";\nimport { DbReader, DbWriter } from \"./context\";\nimport { ExponentialBackoff, handleWhen, retry, RetryPolicy } from \"cockatiel\";\n\nexport const occRetryPolicy = retry(\n  handleWhen((err) => OccConflictError.isOccConflictError(err)),\n  {\n    maxAttempts: 15,\n    backoff: new ExponentialBackoff({\n      initialDelay: 10,\n      maxDelay: 7000,\n      exponent: 2,\n    }),\n  },\n);\n\nexport const getDbclientRetryPolicy = retry(\n  handleWhen((err) => err.message.includes('timeout exceeded')),\n  {\n    maxAttempts: 3,\n    backoff: new ExponentialBackoff({\n      initialDelay: 500,\n      maxDelay: 2000,\n      exponent: 2,\n    }),\n  },\n);\n\nexport class SupaliveDb {\n  constructor(readonly impl: Database) { }\n\n  static create(config: { db: Database }): SupaliveDb {\n    return new SupaliveDb(config.db);\n  }\n\n  protected onAfterCommit?: (writeSet: WriteEntry[], commitTs: CommitTs) => void;\n\n  /**\n   * Register a hook fired once after every successful `mutation()` commit\n   * (never on an OCC conflict/rollback), with the committed writeSet and its\n   * commitTs. The server uses this to drive subscription invalidation for ALL\n   * mutation sources — client WS calls, actions, jobs, and the internal caller —\n   * so a server-side write pushes live updates just like a client write does.\n   * Non-server consumers (migration tooling, tests) leave it unset (no-op).\n   */\n  setOnAfterCommit(cb: (writeSet: WriteEntry[], commitTs: CommitTs) => void): void {\n    this.onAfterCommit = cb;\n  }\n\n  // ── Read-only query ──────────────────────────────────────────────\n\n  async query<T>(fn: (ctx: DbReader) => Promise<T>): Promise<T> {\n    const beginTs = await this.impl.getLatestSnapshotTimestamp();\n    const ctx = new DbReader(this.impl, beginTs);\n    return await fn(ctx);\n  }\n\n  /**\n   * Compute a query once at the latest snapshot, returning the result together\n   * with the snapshot `ts` and the tracked `readSet`. This is a plain one-shot\n   * evaluation — it registers NO live subscription; the `readSet`/`ts` are\n   * returned purely so the caller (e.g. the one-shot query cache) can store\n   * freshness metadata. Use this for cached one-shot query calls (WS `call`,\n   * HTTP RPC). `liveQuery` is the same computation under the subscription path's\n   * name and simply delegates here.\n   */\n  async queryInternal<T>(fn: (ctx: DbReader) => Promise<T>): Promise<LiveResult<T>> {\n    const beginTs = await this.impl.getLatestSnapshotTimestamp();\n    const ctx = new DbReader(this.impl, beginTs);\n    const data = await fn(ctx);\n\n    return {\n      ts: beginTs,\n      data,\n      readSet: ctx.internalGetReadSet(),\n    };\n  }\n\n  async liveQuery<T>(fn: (ctx: DbReader) => Promise<T>): Promise<LiveResult<T>> {\n    return this.queryInternal(fn);\n  }\n\n  // ── Mutation ───────────────────────────────────────────────────────\n\n  async mutation<T>(\n    fn: (ctx: DbWriter) => Promise<T>,\n    retryPolicy: RetryPolicy = occRetryPolicy,\n  ): Promise<MutationResult<T>> {\n    return await retryPolicy.execute(async (p) => {\n      let db: TxDatabase | undefined;\n      try {\n        // Step1: Get latest snapshot timestamp as beginTs\n        const beginTs = await this.impl.getLatestSnapshotTimestamp() + 1n;\n\n        const ctx = new DbWriter(this.impl, beginTs);\n        const result = await fn(ctx);\n\n        const readSet = ctx.internalGetReadSet();\n        const writeSet = ctx.internalGetWriteSet();\n        const commitTsLazy = new LazyCommitTsParam(undefined);\n\n        // Step2: Capture prevData + expectedCommitTs per write. prevData\n        // is consumed by the invalidator (range subs need it to detect\n        // result-set transitions). expectedCommitTs becomes the CAS fence\n        // for the apply step — preferring prior find()-captured ts so\n        // read-then-update patterns get beginTs-level isolation.\n        await this.impl.attachPrevDataToWriteSet(writeSet, readSet);\n\n        // Step3: Prepare quieries before transaction\n        const queries = await this.impl.prepareCommitWrites(\n          readSet,\n          writeSet,\n          commitTsLazy,\n        );\n\n        // Step4: Starts new transaction\n        db = await getDbclientRetryPolicy.execute(() => this.impl.getTransactionClient());\n        await db.begin();\n\n        // Step5: Get commitTs from DB sequence (bigger than all previous)\n        const commitTs = await db.getNextTimestamp();\n        commitTsLazy.value = commitTs;\n\n        // Step6: Apply + validate. CAS UPDATE/DELETE catches concurrent\n        // peer touches on the write set; the readSet is validated either\n        // per-row (fast path, no range reads) or via commit-log scan\n        // (slow path, when range reads are present so phantoms still\n        // need detection).\n        const commitResult = await db.commitWrites(\n          beginTs,\n          queries,\n          commitTs,\n        );\n\n        if (!commitResult.success) {\n          throw new OccConflictError(\"Commit failed\", { commitResult });\n        }\n\n        await db.updateLatestSnapshotTimestamp(commitTs);\n        await db.commit();\n\n        // Notify after successful commit\n        this.onAfterCommit?.(writeSet, commitTs);\n\n        return { result, writeSet, commitTs };\n      } catch (err) {\n        await db?.rollback();\n        throw err;\n      } finally {\n        db?.release();\n      }\n    });\n  }\n}\n\nexport const sleep = (ms: number) => new Promise<void>((res) => setTimeout(res, ms));\n"],"mappings":"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"}

package/dist/{router-DlTYWpop.js → router-CiWYeWUR.js}

@@ -39,13 +39,15 @@ var ContextRegistry = class {
 		if (this.procedureRegistry.has(name)) throw new Error(`[router] Procedure "${name}" is already registered. Each procedure name must be unique across the application.`);
 		if (proc.internal) this.markInternalProcedure(name);
 		const queryIdentity = proc.procedureType === "query" ? proc.queryIdentity : void 0;
+		const cron = proc.procedureType === "job" ? proc.cron : void 0;
 		this.procedureRegistry.set(name, {
 			name,
 			type: proc.procedureType,
 			internal: proc.internal,
 			inputSchema: proc.inputSchema,
 			fn: proc.fn,
-			queryIdentity
+			queryIdentity,
+			cron
 		});
 	}
 	/** Get a registered procedure by name (runtime lookup) */
@@ -60,6 +62,10 @@ var ContextRegistry = class {
 	getAllProcedures() {
 		return new Map(this.procedureRegistry);
 	}
+	/** Get all registered job procedures (server-only, scheduler-triggered). */
+	getJobProcedures() {
+		return [...this.procedureRegistry.values()].filter((p) => p.type === "job");
+	}
 	/** Clear the registry (for testing only) */
 	clearRegistry() {
 		this.procedureRegistry.clear();
@@ -78,4 +84,4 @@ var ContextRegistry = class {
 //#endregion
 export { getContextRegistry as n, router as r, ContextRegistry as t };
 
-//# sourceMappingURL=router-DlTYWpop.js.map
+//# sourceMappingURL=router-CiWYeWUR.js.map

package/dist/router-CiWYeWUR.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"router-CiWYeWUR.js","names":[],"sources":["../src/router/router.ts"],"sourcesContent":["import type { AnyProcedure } from \"./procedure\";\n\n// ─── Router Types ────────────────────────────────────────────────────────────\n\n/**\n * A router maps procedure names (keys) to their definitions.\n * This is the type that's exported from your app and used by the client.\n */\nexport type Router<TProcedures extends Record<string, AnyProcedure<TContext>>, TContext = unknown> = {\n  _type: \"router\";\n  procedures: TProcedures;\n  contextName: string;\n};\n\n/**\n * Inferred AppRouter type from router() call.\n * Captures the full procedure map for client type inference.\n */\nexport type AppRouter<\n  TProcedures extends Record<string, AnyProcedure<TContext>> = Record<string, AnyProcedure>,\n  TContext = unknown\n> = Router<TProcedures, TContext>;\n\n// ─── Type Helpers for Client ─────────────────────────────────────────────────\n\n/** Get query procedures only from a router */\nexport type QueryProcedures<T extends Record<string, AnyProcedure>> = {\n  [K in keyof T as T[K] extends { procedureType: \"query\" } ? K : never]: T[K];\n};\n\n/** Get mutation procedures only from a router */\nexport type MutationProcedures<T extends Record<string, AnyProcedure>> = {\n  [K in keyof T as T[K] extends { procedureType: \"mutation\" } ? K : never]: T[K];\n};\n\n/** Get action procedures only from a router */\nexport type ActionProcedures<T extends Record<string, AnyProcedure>> = {\n  [K in keyof T as T[K] extends { procedureType: \"action\" } ? K : never]: T[K];\n};\n\n/** Get job procedures only from a router */\nexport type JobProcedures<T extends Record<string, AnyProcedure>> = {\n  [K in keyof T as T[K] extends { procedureType: \"job\" } ? K : never]: T[K];\n};\n\n/** Get public (non-internal) procedures - for client type safety */\nexport type PublicProcedures<T extends Record<string, AnyProcedure>> = Pick<\n  T,\n  { [K in keyof T]: T[K] extends { internal: true } ? never : K }[keyof T]\n>;\n\n/** Extract procedure names from a router */\nexport type ProcedureNames<T extends Router<any>> =\n  T extends Router<infer P> ? keyof P : never;\n\nexport type RouterConfig<T> = {\n  procedures: T;\n  contextName?: string;\n};\n\n/**\n* Create a router from procedure definitions.\n* Procedure names are inferred from the object keys.\n* \n* @example\n* const appRouter = router({\n*   procedures: {\n*     getUser,\n*     createUser,\n*     internalGetAll,\n*   },\n* });\n* \n* export type AppRouter = typeof appRouter;\n*/\nexport function router<TProcedures extends Record<string, AnyProcedure<any>>, TContext = unknown>(\n  config: RouterConfig<TProcedures>,\n): Router<TProcedures, TContext> {\n  const registry = getContextRegistry(config.contextName ?? \"default\");\n\n  // Register all procedures at router creation time\n  for (const [name, proc] of Object.entries(config.procedures)) {\n    registry.registerProcedure(name, proc);\n  }\n\n\n  return {\n    _type: \"router\",\n    procedures: config.procedures,\n    contextName: config.contextName ?? \"default\",\n  };\n}\n\nexport interface RegisteredProcedure<TContext = unknown> {\n  name: string;\n  type: \"query\" | \"mutation\" | \"action\" | \"job\";\n  internal: boolean;\n  inputSchema: AnyProcedure<TContext>[\"inputSchema\"];\n  fn: AnyProcedure<TContext>[\"fn\"];\n  /** Only present for `type === \"query\"`. See `QueryIdentitySpec`. */\n  queryIdentity?: false | string | ((serverCtx: TContext | undefined, input: unknown) => string | null | undefined);\n  /** Only present for `type === \"job\"`. Cron expression for recurring jobs. */\n  cron?: string;\n}\n\n\nconst contextRegistry = new Map<string, ContextRegistry>();\n\nexport function getContextRegistry(inContext: string): ContextRegistry {\n  let registry = contextRegistry.get(inContext);\n  if (!registry) {\n    registry = new ContextRegistry();\n    contextRegistry.set(inContext, registry);\n  }\n  return registry;\n}\n\nexport class ContextRegistry {\n  procedureRegistry = new Map<string, RegisteredProcedure<any>>();\n  internalProcedureNames = new Set<string>();\n\n  registerProcedure<TContext>(name: string, proc: AnyProcedure<TContext>): void {\n    if (this.procedureRegistry.has(name)) {\n      throw new Error(\n        `[router] Procedure \"${name}\" is already registered. ` +\n        `Each procedure name must be unique across the application.`\n      );\n    }\n\n    // Track internal procedures by name\n    if (proc.internal) {\n      this.markInternalProcedure(name);\n    }\n\n    const queryIdentity =\n      proc.procedureType === \"query\"\n        ? (proc as { queryIdentity?: RegisteredProcedure<TContext>[\"queryIdentity\"] }).queryIdentity\n        : undefined;\n\n    const cron =\n      proc.procedureType === \"job\"\n        ? (proc as { cron?: string }).cron\n        : undefined;\n\n    this.procedureRegistry.set(name, {\n      name,\n      type: proc.procedureType,\n      internal: proc.internal,\n      inputSchema: proc.inputSchema,\n      fn: proc.fn,\n      queryIdentity,\n      cron,\n    });\n  }\n\n  /** Get a registered procedure by name (runtime lookup) */\n  getProcedure<TContext = unknown>(name: string): RegisteredProcedure<TContext> | undefined {\n    return this.procedureRegistry.get(name);\n  }\n\n  /** Get all registered procedure names */\n  getProcedureNames(): string[] {\n    return [...this.procedureRegistry.keys()];\n  }\n\n  /** Get all registered procedures */\n  getAllProcedures(): Map<string, RegisteredProcedure> {\n    return new Map(this.procedureRegistry);\n  }\n\n  /** Get all registered job procedures (server-only, scheduler-triggered). */\n  getJobProcedures(): RegisteredProcedure[] {\n    return [...this.procedureRegistry.values()].filter((p) => p.type === \"job\");\n  }\n\n  /** Clear the registry (for testing only) */\n  clearRegistry(): void {\n    this.procedureRegistry.clear();\n    this.clearInternalProcedures();\n  }\n\n  markInternalProcedure(name: string): void {\n    this.internalProcedureNames.add(name);\n  }\n\n  isInternalProcedure(name: string): boolean {\n    return this.internalProcedureNames.has(name);\n  }\n\n  clearInternalProcedures(): void {\n    this.internalProcedureNames.clear();\n  }\n}"],"mappings":";;;;;;;;;;;;;;;;AA2EA,SAAgB,OACd,QAC+B;CAC/B,MAAM,WAAW,mBAAmB,OAAO,eAAe,SAAS;CAGnE,KAAK,MAAM,CAAC,MAAM,SAAS,OAAO,QAAQ,OAAO,UAAU,GACzD,SAAS,kBAAkB,MAAM,IAAI;CAIvC,OAAO;EACL,OAAO;EACP,YAAY,OAAO;EACnB,aAAa,OAAO,eAAe;CACrC;AACF;AAeA,MAAM,kCAAkB,IAAI,IAA6B;AAEzD,SAAgB,mBAAmB,WAAoC;CACrE,IAAI,WAAW,gBAAgB,IAAI,SAAS;CAC5C,IAAI,CAAC,UAAU;EACb,WAAW,IAAI,gBAAgB;EAC/B,gBAAgB,IAAI,WAAW,QAAQ;CACzC;CACA,OAAO;AACT;AAEA,IAAa,kBAAb,MAA6B;CAC3B,oCAAoB,IAAI,IAAsC;CAC9D,yCAAyB,IAAI,IAAY;CAEzC,kBAA4B,MAAc,MAAoC;EAC5E,IAAI,KAAK,kBAAkB,IAAI,IAAI,GACjC,MAAM,IAAI,MACR,uBAAuB,KAAK,oFAE9B;EAIF,IAAI,KAAK,UACP,KAAK,sBAAsB,IAAI;EAGjC,MAAM,gBACJ,KAAK,kBAAkB,UAClB,KAA4E,gBAC7E,KAAA;EAEN,MAAM,OACJ,KAAK,kBAAkB,QAClB,KAA2B,OAC5B,KAAA;EAEN,KAAK,kBAAkB,IAAI,MAAM;GAC/B;GACA,MAAM,KAAK;GACX,UAAU,KAAK;GACf,aAAa,KAAK;GAClB,IAAI,KAAK;GACT;GACA;EACF,CAAC;CACH;;CAGA,aAAiC,MAAyD;EACxF,OAAO,KAAK,kBAAkB,IAAI,IAAI;CACxC;;CAGA,oBAA8B;EAC5B,OAAO,CAAC,GAAG,KAAK,kBAAkB,KAAK,CAAC;CAC1C;;CAGA,mBAAqD;EACnD,OAAO,IAAI,IAAI,KAAK,iBAAiB;CACvC;;CAGA,mBAA0C;EACxC,OAAO,CAAC,GAAG,KAAK,kBAAkB,OAAO,CAAC,CAAC,CAAC,QAAQ,MAAM,EAAE,SAAS,KAAK;CAC5E;;CAGA,gBAAsB;EACpB,KAAK,kBAAkB,MAAM;EAC7B,KAAK,wBAAwB;CAC/B;CAEA,sBAAsB,MAAoB;EACxC,KAAK,uBAAuB,IAAI,IAAI;CACtC;CAEA,oBAAoB,MAAuB;EACzC,OAAO,KAAK,uBAAuB,IAAI,IAAI;CAC7C;CAEA,0BAAgC;EAC9B,KAAK,uBAAuB,MAAM;CACpC;AACF"}

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

@@ -1,2 +1,2 @@
-import { $ as PublicProcedures, $n as CompareOperator, Ar as RetryConfig, At as ResultOf, Cr as RawPointReadSchema, Ct as createQueryBuilder, Dn as RawClient, Dr as RawReadEntrySchema, Dt as DefsToMap, Er as RawReadEntry, Et as AnyQueryDef, Fr as bytesFromJson, Ft as TxContext, G as RPCError, Gt as matchesPredicate, Ir as normalizeIdToBytes, J as ActionProcedures, Jn as BigIntSchema, K as WSClientOptions, Kn as AndPredicate, Lr as normalizeToBytes, Mr as WriteEntrySchema, Mt as defineQuery, Nr as WriteOp, Nt as DbReader, Or as ReadEntry, Ot as ParamsOf, Pr as WriteOpSchema, Pt as DbWriter, Q as ProcedureNames, Qn as CommitTs, Sn as DbQueryResult, Sr as RawPointRead, St as createMutationBuilder, Tn as PooledClient, Tr as RawRangeReadSchema, Tt as sleep, U as ClientPublicState, W as HeartbeatOptions, Xn as CachedPgMetadataSchema, Y as AppRouter, Yn as CachedPgMetadata, Z as MutationProcedures, Zn as CommitLogEntry, Zt as ComputedFieldConfig, _r as QueryCacheMetadata, _t as QueryCtx, a as CallOptions, ar as MutationResult, at as ActionConfig, br as RangeRead, bt as TypeOf, c as LiveQueryHandle, cr as OccConflictError, ct as ActionProcedure, d as WSClientMethods, dr as PointRead, dt as MutationConfig, er as CompareOperatorSchema, et as QueryProcedures, f as createClient, fn as SchemaColumnsOptions, fr as PointReadSchema, ft as MutationCtx, gn as defineSchema, gr as QueryCacheEntrySchema, gt as QueryConfig, hn as defineComputedField, hr as QueryCacheEntry, ht as OutputOf, i as createCaller, ir as LiveResult, it as router, jr as WriteEntry, jt as _resetGlobalDefs, kr as ReadEntrySchema, kt as QueryDefinition, l as LiveQueryState, lr as OrPredicate, lt as AnyProcedure, mr as PredicateSchema, mt as MutationProcedure, n as CallerFromRouter, nn as InsertData, nr as LeafPredicate, nt as Router, o as ClientFromProcedures, or as NO_RETRY, ot as ActionCtx, pn as SchemaDefinition, pr as Predicate, pt as MutationFn, q as WsClientManager, qn as AndPredicateSchema, qt as ColumnCodec, r as CallerOptions, rn as Model, rr as LeafPredicateSchema, s as ClientOptions, sr as OccAbortError, st as ActionFn, t as CallerFromProcedures, tn as InferSchema, tr as DEFAULT_RETRY, tt as RegisteredProcedure, u as LiveQueryStatus, un as SchemaCodecs, ur as OrPredicateSchema, ut as ContextOf, vr as QueryCacheMetadataSchema, vt as QueryFn, wr as RawRangeRead, wt as SupaliveDb, xn as Database, xr as RangeReadSchema, xt as createActionBuilder, yr as QuerySpec, yt as QueryProcedure } from "../../index-DouKwYL6.js";
+import { $ as ProcedureNames, $n as AndPredicate, $t as ColumnCodec, Ar as RawPointReadSchema, At as SupaliveDb, Br as WriteOp, Bt as DbWriter, Cr as QueryCacheEntrySchema, Ct as QueryFn, Dr as RangeRead, Er as QuerySpec, Et as createActionBuilder, Fr as ReadEntry, Ft as QueryDefinition, G as RPCError, Hr as bytesFromJson, Ir as ReadEntrySchema, It as ResultOf, J as ActionProcedures, K as WSClientOptions, Lr as RetryConfig, Lt as _resetGlobalDefs, Mn as PooledClient, Mr as RawRangeReadSchema, Mt as AnyQueryDef, Nr as RawReadEntry, Nt as DefsToMap, On as Database, Or as RangeReadSchema, Ot as createMutationBuilder, Pn as RawClient, Pr as RawReadEntrySchema, Pt as ParamsOf, Q as MutationProcedures, Rr as WriteEntry, Rt as defineQuery, Sn as defineSchema, Sr as QueryCacheEntry, St as QueryCtx, Tr as QueryCacheMetadataSchema, Tt as TypeOf, U as ClientPublicState, Ur as normalizeIdToBytes, Vr as WriteOpSchema, Vt as TxContext, W as HeartbeatOptions, Wr as normalizeToBytes, Y as AppRouter, Zt as matchesPredicate, _r as OrPredicateSchema, _t as MutationCtx, a as CallOptions, ar as CommitTs, at as router, br as Predicate, bt as OutputOf, c as LiveQueryHandle, cn as InsertData, cr as DEFAULT_RETRY, ct as ActionFn, d as WSClientMethods, dr as LiveResult, dt as ContextOf, er as AndPredicateSchema, et as PublicProcedures, f as createClient, fr as MutationResult, gn as SchemaCodecs, gr as OrPredicate, gt as MutationConfig, hr as OccConflictError, i as createCaller, ir as CommitLogEntry, jr as RawRangeRead, jt as sleep, kn as DbQueryResult, kr as RawPointRead, kt as createQueryBuilder, l as LiveQueryState, ln as Model, lr as LeafPredicate, lt as ActionProcedure, mr as OccAbortError, n as CallerFromRouter, nr as CachedPgMetadata, nt as RegisteredProcedure, o as ClientFromProcedures, or as CompareOperator, ot as ActionConfig, pr as NO_RETRY, q as WsClientManager, r as CallerOptions, rn as ComputedFieldConfig, rr as CachedPgMetadataSchema, rt as Router, s as ClientOptions, sn as InferSchema, sr as CompareOperatorSchema, st as ActionCtx, t as CallerFromProcedures, tr as BigIntSchema, tt as QueryProcedures, u as LiveQueryStatus, ur as LeafPredicateSchema, ut as AnyProcedure, vn as SchemaColumnsOptions, vr as PointRead, vt as MutationFn, wr as QueryCacheMetadata, wt as QueryProcedure, xn as defineComputedField, xr as PredicateSchema, xt as QueryConfig, yn as SchemaDefinition, yr as PointReadSchema, yt as MutationProcedure, zr as WriteEntrySchema, zt as DbReader } from "../../index-DJYvJYR4.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,11 +1,11 @@
-import { n as createMutationBuilder, r as createQueryBuilder, t as createActionBuilder } from "../../procedure-DX87tyef.js";
-import { n as getContextRegistry, r as router } from "../../router-DlTYWpop.js";
-import { o as matchesPredicate } from "../../query-Bh0RNxDz.js";
+import { i as createQueryBuilder, r as createMutationBuilder, t as createActionBuilder } from "../../procedure-Ze1GE-N9.js";
+import { n as getContextRegistry, r as router } from "../../router-CiWYeWUR.js";
+import { o as matchesPredicate } from "../../query-CrbJ_W0W.js";
 import { n as defineSchema, t as defineComputedField } from "../../schema-Dd7u0A1L.js";
 import { r as supaliveStringify } from "../../helper-wGbzz6zo.js";
-import { C as normalizeIdToBytes, S as bytesFromJson, _ as RawRangeReadSchema, a as DEFAULT_RETRY, b as WriteEntrySchema, c as OccAbortError, d as PointReadSchema, f as PredicateSchema, g as RawPointReadSchema, h as RangeReadSchema, i as CompareOperatorSchema, l as OccConflictError, m as QueryCacheMetadataSchema, n as BigIntSchema, o as LeafPredicateSchema, p as QueryCacheEntrySchema, r as CachedPgMetadataSchema, s as NO_RETRY, t as AndPredicateSchema, u as OrPredicateSchema, v as RawReadEntrySchema, w as normalizeToBytes, x as WriteOpSchema, y as ReadEntrySchema } from "../../types_db-DXj_l9n-.js";
+import { C as normalizeIdToBytes, S as bytesFromJson, _ as RawRangeReadSchema, a as DEFAULT_RETRY, b as WriteEntrySchema, c as OccAbortError, d as PointReadSchema, f as PredicateSchema, g as RawPointReadSchema, h as RangeReadSchema, i as CompareOperatorSchema, l as OccConflictError, m as QueryCacheMetadataSchema, n as BigIntSchema, o as LeafPredicateSchema, p as QueryCacheEntrySchema, r as CachedPgMetadataSchema, s as NO_RETRY, t as AndPredicateSchema, u as OrPredicateSchema, v as RawReadEntrySchema, w as normalizeToBytes, x as WriteOpSchema, y as ReadEntrySchema } from "../../types_db-CTRm_awX.js";
 import { l as ServerMessageSchema } from "../../types_client_rpc-CIsjQQGG.js";
-import { a as TxContext, i as DbWriter, n as sleep, r as DbReader, t as SupaliveDb } from "../../realtime_db-DOCgqbwi.js";
+import { a as TxContext, i as DbWriter, n as sleep, r as DbReader, t as SupaliveDb } from "../../realtime_db-BtwBABDY.js";
 import { sha1 } from "hash-wasm";
 //#region src/db/query_definition.ts
 const _globalDefs = /* @__PURE__ */ new Map();
@@ -1112,6 +1112,24 @@ function createCaller(options) {
 					return procedure.fn(ctx, validatedInput);
 				});
 			},
+			runQuery: async (input, parentCtx) => {
+				if (procedure.type !== "query") throw new Error(`Procedure "${procedureName}" is not a query`);
+				const validatedInput = validateInput(input);
+				if (parentCtx.db instanceof TxContext) {
+					const ctx = {
+						db: parentCtx.db,
+						serverCtx: parentCtx.serverCtx
+					};
+					return procedure.fn(ctx, validatedInput);
+				}
+				return parentCtx.db.query(async (dbCtx) => {
+					const ctx = {
+						db: dbCtx,
+						serverCtx: parentCtx.serverCtx
+					};
+					return procedure.fn(ctx, validatedInput);
+				});
+			},
 			mutate: async (input, serverCtx) => {
 				if (procedure.type !== "mutation") throw new Error(`Procedure "${procedureName}" is not a mutation`);
 				const validatedInput = validateInput(input);
@@ -1123,6 +1141,18 @@ function createCaller(options) {
 					return procedure.fn(ctx, validatedInput);
 				})).result;
 			},
+			runMutation: async (input, parentCtx) => {
+				if (procedure.type !== "mutation") throw new Error(`Procedure "${procedureName}" is not a mutation`);
+				const validatedInput = validateInput(input);
+				return (await (parentCtx.db instanceof TxContext ? db : parentCtx.db).mutation(async (dbCtx) => {
+					const ctx = {
+						db: dbCtx,
+						serverCtx: parentCtx.serverCtx
+					};
+					if (parentCtx.db instanceof TxContext) ctx.db.appendInternalReadSet(parentCtx.db.internalGetReadSet());
+					return procedure.fn(ctx, validatedInput);
+				})).result;
+			},
 			action: async (input, serverCtx) => {
 				if (procedure.type !== "action") throw new Error(`Procedure "${procedureName}" is not an action`);
 				const validatedInput = validateInput(input);
@@ -1132,6 +1162,15 @@ function createCaller(options) {
 				};
 				return procedure.fn(ctx, validatedInput);
 			},
+			run: async (input, serverCtx) => {
+				if (procedure.type !== "job") throw new Error(`Procedure "${procedureName}" is not a job`);
+				const validatedInput = validateInput(input);
+				const ctx = {
+					db,
+					serverCtx
+				};
+				return procedure.fn(ctx, validatedInput);
+			},
 			liveQuery: procedure.type === "query" ? async (input, serverCtx) => {
 				const validatedInput = validateInput(input);
 				return db.liveQuery(async (dbCtx) => {