@supalive/core 1.20.1 → 1.21.0

package/dist/realtime_db-CTGOrFuV.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"realtime_db-CTGOrFuV.js","names":["z","uuidv4"],"sources":["../src/db/context.ts","../src/logger.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\";\nimport {\n  createBufferedEphemeralWriter,\n  createTrackedEphemeralReader,\n  type EphemeralReader,\n  type EphemeralStore,\n  type EphemeralWriter,\n  type PendingEphemeralWrite,\n} from \"./ephemeral\";\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  // Not `readonly`: a query's read connection can be rebound (primary↔replica)\n  // via {@link useConnection} before the first read — see the replica routing in\n  // realtime_db.ts / one-shot-query.ts. Mutations never rebind.\n  beginTs: bigint;\n  db: Database;\n  protected readSet: ReadEntry[] = [];\n  protected writeSet: WriteEntry[] = [];\n  /**\n   * Ephemeral keys read by this context, in first-read order and de-duplicated.\n   * Kept separate from {@link readSet} on purpose: an ephemeral key has no\n   * snapshot ts and no commit log, so letting it into the read set would feed\n   * the OCC validator and the commit-log freshness scan a dependency neither\n   * can reason about.\n   *\n   * `null` until the first ephemeral read. The vast majority of queries never\n   * touch the store, and this context is constructed once per query execution —\n   * so the array is allocated on demand rather than on every read path.\n   */\n  protected ephemeralKeys: string[] | null = null;\n  /** `set`/`delete` calls awaiting a commit — see {@link DbWriter.ephemeral}.\n   *  Lazily allocated, like {@link ephemeralKeys}. */\n  protected ephemeralWrites: PendingEphemeralWrite[] | null = null;\n  /** Backing store for `ctx.db.ephemeral`. */\n  protected readonly ephemeralStore: EphemeralStore;\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, ephemeralStore: EphemeralStore) {\n    this.db = db;\n    this.beginTs = beginTs;\n    this.ephemeralStore = ephemeralStore;\n  }\n\n  /**\n   * Record a live-query dependency on `key` (idempotent within a context).\n   * @internal — called by the wrappers in db/ephemeral.ts.\n   */\n  internalTrackEphemeralRead(key: string): void {\n    if (this.ephemeralKeys === null) {\n      this.ephemeralKeys = [key];\n      return;\n    }\n    if (!this.ephemeralKeys.includes(key)) this.ephemeralKeys.push(key);\n  }\n\n  /**\n   * Queue an ephemeral write for the post-commit flush, replacing any earlier\n   * write to the same key so the last write in an attempt wins.\n   * @internal — called by the wrapper in db/ephemeral.ts.\n   */\n  internalBufferEphemeralWrite(write: PendingEphemeralWrite): void {\n    if (this.ephemeralWrites === null) {\n      this.ephemeralWrites = [write];\n      return;\n    }\n    const existing = this.ephemeralWrites.findIndex((w) => w.key === write.key);\n    if (existing >= 0) this.ephemeralWrites[existing] = write;\n    else this.ephemeralWrites.push(write);\n  }\n\n  /**\n   * Rebind the read connection (and its snapshot ts). Used by the replica\n   * router when a query handler calls `ctx.usePrimaryConn()`/`useReplicaConn()`.\n   * Must be called BEFORE any read — the readSet/beginTs would otherwise mix\n   * snapshots — so this throws if a read or write has already happened.\n   */\n  useConnection(db: Database, beginTs: bigint): void {\n    if (this.readSet.length > 0 || this.writeSet.length > 0) {\n      throw new Error(\n        \"useConnection()/usePrimaryConn()/useReplicaConn() must be called before any read or write in the handler\",\n      );\n    }\n    this.db = db;\n    this.beginTs = beginTs;\n  }\n\n  internalGetReadSet(): ReadEntry[] { return this.readSet; }\n  internalGetWriteSet(): WriteEntry[] { return this.writeSet; }\n  /** Null when this context read no ephemeral state — see {@link ephemeralKeys}. */\n  internalGetEphemeralKeys(): string[] | null { return this.ephemeralKeys; }\n  /** Null when this context buffered no ephemeral writes. */\n  internalGetEphemeralWrites(): PendingEphemeralWrite[] | null { return this.ephemeralWrites; }\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  /**\n   * Merge ephemeral dependencies recorded elsewhere into this context. The\n   * counterpart of {@link appendInternalReadSet}: used when a nested query is\n   * served from cache, so the parent still depends on the keys the cached\n   * computation read and re-runs when any of them change.\n   */\n  appendInternalEphemeralKeys(keys: string[]) {\n    for (const key of keys) this.internalTrackEphemeralRead(key);\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  private ephemeralApi?: EphemeralReader;\n\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  /**\n   * Read ephemeral state — values that drive live queries but are never stored\n   * in the database (a device's latest GPS fix, a presence flag).\n   *\n   * Every read here records a dependency on the key, so a subscribed query\n   * re-runs and pushes automatically when an action or mutation writes it. The\n   * dependency is on the KEY, not the value: reading a key that is currently\n   * absent still subscribes you to it being set later.\n   *\n   * Built on first access — a query that never reaches for ephemeral state\n   * allocates neither the wrapper nor its key list.\n   */\n  get ephemeral(): EphemeralReader {\n    return (this.ephemeralApi ??= createTrackedEphemeralReader(this, this.ephemeralStore));\n  }\n}\n\nexport class DbWriter extends DbReader {\n  private ephemeralWriteApi?: EphemeralWriter;\n\n  /**\n   * Read AND write ephemeral state. Reads behave exactly as on a\n   * {@link DbReader}; writes are BUFFERED and applied only once the surrounding\n   * mutation commits (see `SupaliveDb.mutation` and\n   * {@link createBufferedEphemeralWriter} for why).\n   */\n  override get ephemeral(): EphemeralWriter {\n    return (this.ephemeralWriteApi ??= createBufferedEphemeralWriter(this, this.ephemeralStore));\n  }\n\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 pino, { Level } from \"pino\";\nimport { v4 as uuidv4 } from \"uuid\";\nimport pinoPretty from \"pino-pretty\";\nconst _ = pinoPretty; // Prevents tree shaking of pino-pretty\n\nexport const appInstanceId = `instance-${uuidv4().slice(0, 8)}`;\nexport const isProduction = process.env.NODE_ENV === \"production\";\nexport const logger = pino({\n    level: process.env.LOG_LEVEL || \"info\",\n    timestamp: pino.stdTimeFunctions.isoTime,\n    redact: { paths: [\"user.password\"] },\n    transport: isProduction ? undefined : {\n        target: 'pino-pretty',\n        options: {\n            colorize: true\n        },\n    },\n    serializers: {\n        \"columnsTypes\": (map) => {\n            if (map instanceof Map) return serializeMapValue(map);\n            return map;\n        },\n    },\n    base: {\n        \"srv\": appInstanceId,\n    },\n});\n\nexport function logLevelOf(name: string): Level {\n    const defaultLogLevel = process.env.DEFAULT_LOG_LEVEL || \"info\";\n    return (process.env[name]?.toLowerCase() || defaultLogLevel) as Level;\n}\n\nexport function serializeMapValue<K extends string | number | symbol, V>(map: Map<K, V>): Record<K, V> {\n    const obj: Record<K, any> = {} as Record<K, any>;\n    for (const [k, v] of map.entries()) {\n        obj[k] = {} as V;\n        if (v instanceof Map) {\n            for (const [innerK, innerV] of v.entries()) {\n                obj[k][innerK] = innerV;\n            }\n        } else {\n            obj[k] = v;\n        }\n    }\n\n    return obj as Record<K, V>;\n}","import { Database, LazyCommitTsParam, TxDatabase } from \"./db\";\nimport {\n  OccConflictError, WriteEntry, CommitTs, LiveResult, MutationResult\n} from \"./types_db\";\nimport { DbReader, DbWriter } from \"./context\";\nimport { traceDbCall } from \"./db-trace\";\nimport { ExponentialBackoff, handleWhen, retry, RetryPolicy } from \"cockatiel\";\nimport {\n  EMPTY_EPHEMERAL_KEYS,\n  EphemeralFlushError,\n  type EphemeralStore,\n  type PendingEphemeralWrite,\n} from \"./ephemeral\";\nimport { logger } from \"../logger\";\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  /**\n   * @param impl      the PRIMARY (writer) connection — all mutations, the OCC\n   *                  commit-ts source, and cache-freshness commit-log scans run here.\n   * @param ephemeral Redis-backed store behind `ctx.db.ephemeral` (db/ephemeral.ts).\n   *                  Required: it is reachable from every handler context, so a\n   *                  db that could be missing one would push the failure out to\n   *                  request time. A replica SHARES the primary's store —\n   *                  ephemeral state lives in Redis rather than in either\n   *                  connection, so read routing must not change what it sees.\n   * @param replica   optional read replica for query/action reads (see the\n   *                  routing in one-shot-query.ts). Undefined → reads use primary.\n   */\n  constructor(\n    readonly impl: Database,\n    readonly ephemeral: EphemeralStore,\n    readonly replica?: SupaliveDb,\n  ) { }\n\n  static create(config: {\n    db: Database;\n    /** See the constructor: shared with the replica, never per-connection. */\n    ephemeral: EphemeralStore;\n    replica?: Database;\n  }): SupaliveDb {\n    return new SupaliveDb(\n      config.db,\n      config.ephemeral,\n      config.replica ? new SupaliveDb(config.replica, config.ephemeral) : undefined,\n    );\n  }\n\n  /** True when a distinct read replica is configured. */\n  get hasReplica(): boolean {\n    return this.replica !== undefined;\n  }\n\n  /**\n   * Register a hook fired after every batch of ephemeral writes lands in Redis.\n   * The ephemeral twin of {@link setOnAfterCommit}: the server uses it to drive\n   * subscription invalidation for writes from any source — an action, a job, or\n   * a mutation's post-commit flush.\n   */\n  setOnAfterEphemeralWrite(cb: (keys: string[], version: string) => void): void {\n    this.ephemeral.onAfterWrite = cb;\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  /**\n   * One-shot read against an EXPLICIT connection + snapshot ts (rather than this\n   * db's own latest). Used by the replica router: the caller pre-resolves the\n   * default read connection (replica for queries) and hands the handler a\n   * `DbReader` it can rebind via `useConnection` (ctx.usePrimaryConn/…). The\n   * returned `ts` is the FINAL bound connection's snapshot, so the cache entry is\n   * stamped with the ts actually read at.\n   */\n  async queryInternalOn<T>(\n    read: { impl: Database; beginTs: bigint },\n    fn: (ctx: DbReader) => Promise<T>,\n  ): Promise<LiveResult<T>> {\n    const ctx = new DbReader(read.impl, read.beginTs, this.ephemeral);\n    const data = await fn(ctx);\n    return {\n      ts: ctx.beginTs,\n      data,\n      readSet: ctx.internalGetReadSet(),\n      ephemeralKeys: ctx.internalGetEphemeralKeys() ?? EMPTY_EPHEMERAL_KEYS,\n    };\n  }\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, this.ephemeral);\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, this.ephemeral);\n    const data = await fn(ctx);\n\n    return {\n      ts: beginTs,\n      data: data,\n      readSet: ctx.internalGetReadSet(),\n      ephemeralKeys: ctx.internalGetEphemeralKeys() ?? EMPTY_EPHEMERAL_KEYS,\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    // Ephemeral writes buffered by the attempt that COMMITTED. Captured here,\n    // outside the retry loop, because they must be applied after the loop has\n    // finished — see the flush below.\n    let committedEphemeralWrites: PendingEphemeralWrite[] | null = null;\n\n    const mutationResult = 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, this.ephemeral);\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 traceDbCall(\n          \"commit\",\n          \"\",\n          this.impl.dbType,\n          () => db!.commitWrites(beginTs, queries, 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        // Hand this attempt's buffered ephemeral writes to the post-loop flush.\n        // Only an attempt that reaches this line — i.e. one that committed — ever\n        // assigns, so a losing OCC attempt's buffer is discarded with its context\n        // and never becomes visible.\n        committedEphemeralWrites = ctx.internalGetEphemeralWrites();\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    // Flush AFTER the commit, and outside the retry loop / try-catch above.\n    //\n    // Why not before `db.commit()`, so a Redis failure would roll the mutation\n    // back? Because applying early publishes ephemeral state for a transaction\n    // that may still abort, in two ways that matter:\n    //\n    //   1. Before `commitWrites`, every OCC conflict — the routine path under\n    //      contention, retried up to 15 times — would publish state from an\n    //      attempt that never committed. That is precisely what buffering the\n    //      writes exists to prevent.\n    //   2. Even placed after `commitWrites` (OCC already resolved), `apply`\n    //      fires `onAfterWrite`, whose recompute opens a FRESH read on the\n    //      primary. Our transaction is not committed yet, so that read sees the\n    //      OLD rows next to the NEW ephemeral value — a query reading both\n    //      pushes a torn frame to subscribers before the commit lands.\n    //\n    // Publishing state for a transaction that never happened is worse than\n    // failing to publish state for one that did: the former is silent and\n    // permanent, the latter is logged, TTL-bounded, and healed by the next\n    // write. Ephemeral state is expendable by design — silent TTL expiry is\n    // already its contract.\n    //\n    // A failure here is therefore NOT a mutation failure and is not thrown: the\n    // rows are durable and their invalidation has already gone out, so rejecting\n    // would report a successful mutation as failed and tempt a caller into a\n    // retry that re-applies the row writes. It is logged instead — the operator,\n    // not the caller, is who can act on \"Redis is unreachable\".\n    if (committedEphemeralWrites) {\n      const writes: PendingEphemeralWrite[] = committedEphemeralWrites;\n      try {\n        await this.ephemeral.apply(writes);\n      } catch (cause) {\n        logger.error(\n          new EphemeralFlushError(writes.map((w) => w.key), { cause }),\n          \"ephemeral flush failed after commit\",\n        );\n      }\n    }\n\n    return mutationResult;\n  }\n}\n\nexport const sleep = (ms: number) => new Promise<void>((res) => setTimeout(res, ms));\n"],"mappings":"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"}

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

@@ -1,2 +1,2 @@
-import { $ as ActionProcedures, $n as RawClient, $r as RawReadEntry, $t as ResultOf, Ar as LeafPredicateSchema, At as QueryFn, Br as Predicate, Cn as ComputedFieldConfig, Cr as CachedPgMetadataSchema, Ct as MutationConfig, Dn as InferSchema, Dr as CompareOperatorSchema, Dt as OutputOf, Er as CompareOperator, Et as MutationProcedure, Fr as OccConflictError, Ft as createMutationBuilder, G as ClientLogLevel, Gr as QueryCacheMetadataSchema, Hn as defineSchema, Hr as QueryCacheEntry, In as SchemaCodecs, Ir as OrPredicate, It as createQueryBuilder, J as HeartbeatOptions, Jn as DbQueryResult, Jr as RangeReadSchema, Jt as sleep, K as ClientLogger, Kr as QuerySpec, Lr as OrPredicateSchema, Mr as MutationResult, Mt as TypeOf, Nr as NO_RETRY, Nt as createActionBuilder, On as InsertData, Or as DEFAULT_RETRY, Ot as QueryConfig, Pr as OccAbortError, Q as createConsoleLogger, Qr as RawRangeReadSchema, Qt as QueryDefinition, Rn as SchemaColumnsOptions, Rr as PointRead, Sr as CachedPgMetadata, Tr as CommitTs, Tt as MutationFn, Ur as QueryCacheEntrySchema, Vn as defineComputedField, Vr as PredicateSchema, W as ClientEvent, Wr as QueryCacheMetadata, X as WSClientOptions, Xr as RawPointReadSchema, Xt as DefsToMap, Y as RPCError, Yr as RawPointRead, Yt as AnyQueryDef, Z as WsClientManager, Zn as PooledClient, Zr as RawRangeRead, Zt as ParamsOf, _n as matchesPredicate, _t as HandlerLogger, a as createCaller, ai as WriteEntrySchema, at as PublicProcedures, br as AndPredicateSchema, c as ClientOptions, ci as bytesFromJson, ct as Router, d as LiveQueryStatus, dt as ActionConfig, ei as RawReadEntrySchema, en as _resetGlobalDefs, et as AppRouter, f as WSClientMethods, ft as ActionCtx, gt as ContextOf, ht as AnyProcedure, i as CallerOptions, ii as WriteEntry, in as TxContext, it as ProcedureNames, jr as LiveResult, jt as QueryProcedure, kn as Model, kr as LeafPredicate, kt as QueryCtx, l as LiveQueryHandle, li as normalizeIdToBytes, mt as ActionProcedure, n as CallerFromProcedures, ni as ReadEntrySchema, nn as DbReader, o as CallOptions, oi as WriteOp, ot as QueryProcedures, p as createClient, pt as ActionFn, q as ClientPublicState, qn as Database, qr as RangeRead, qt as SupaliveDb, r as CallerFromRouter, ri as RetryConfig, rn as DbWriter, rt as MutationProcedures, s as ClientFromProcedures, si as WriteOpSchema, st as RegisteredProcedure, t as CallerClientInitConfig, ti as ReadEntry, tn as defineQuery, u as LiveQueryState, ui as normalizeToBytes, ut as router, vt as HandlerObservability, wr as CommitLogEntry, wt as MutationCtx, xr as BigIntSchema, yn as ColumnCodec, yr as AndPredicate, zn as SchemaDefinition, zr as PointReadSchema } from "../../index-DsBAE32T.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, CallerClientInitConfig, CallerFromProcedures, CallerFromRouter, CallerOptions, type ClientEvent, type ClientFromProcedures, type ClientLogLevel, type ClientLogger, 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 HandlerLogger, type HandlerObservability, 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, createConsoleLogger, createMutationBuilder, createQueryBuilder, defineComputedField, defineQuery, defineSchema, matchesPredicate, normalizeIdToBytes, normalizeToBytes, router, sleep };
+import { $ as ActionProcedures, $r as Predicate, $t as ResultOf, At as QueryFn, Br as CompareOperatorSchema, Ci as normalizeToBytes, Ct as MutationConfig, Dn as matchesPredicate, Dt as OutputOf, Et as MutationProcedure, Fr as CachedPgMetadata, Ft as createMutationBuilder, G as ClientLogLevel, Gr as MutationResult, Hr as LeafPredicate, Ir as CachedPgMetadataSchema, It as createQueryBuilder, J as HeartbeatOptions, Jn as SchemaColumnsOptions, Jr as OccConflictError, Jt as sleep, K as ClientLogger, Kn as SchemaCodecs, Kr as NO_RETRY, Ln as InferSchema, Lr as CommitLogEntry, Mr as AndPredicate, Mt as TypeOf, Nn as ComputedFieldConfig, Nr as AndPredicateSchema, Nt as createActionBuilder, Ot as QueryConfig, Pr as BigIntSchema, Q as createConsoleLogger, Qn as defineSchema, Qr as PointReadSchema, Qt as QueryDefinition, Rn as InsertData, Rr as CommitTs, Si as normalizeIdToBytes, Tt as MutationFn, Ur as LeafPredicateSchema, Vr as DEFAULT_RETRY, W as ClientEvent, Wr as LiveResult, X as WSClientOptions, Xr as OrPredicateSchema, Xt as DefsToMap, Y as RPCError, Yn as SchemaDefinition, Yr as OrPredicate, Yt as AnyQueryDef, Z as WsClientManager, Zn as defineComputedField, Zr as PointRead, Zt as ParamsOf, _i as WriteEntry, _t as HandlerLogger, a as createCaller, ai as QuerySpec, an as EMPTY_EPHEMERAL_KEYS, at as PublicProcedures, bi as WriteOpSchema, c as ClientOptions, ci as RawPointRead, cn as EphemeralFlushError, ct as Router, d as LiveQueryStatus, di as RawRangeReadSchema, dn as EphemeralSetOptions, dt as ActionConfig, ei as PredicateSchema, en as _resetGlobalDefs, et as AppRouter, f as WSClientMethods, fi as RawReadEntry, fn as EphemeralStore, ft as ActionCtx, gi as RetryConfig, gt as ContextOf, hi as ReadEntrySchema, ht as AnyProcedure, i as CallerOptions, ii as QueryCacheMetadataSchema, in as TxContext, ir as DbQueryResult, it as ProcedureNames, jt as QueryProcedure, kn as ColumnCodec, kt as QueryCtx, l as LiveQueryHandle, li as RawPointReadSchema, ln as EphemeralKeyNotFoundError, lr as RawClient, mi as ReadEntry, mn as createMemoryEphemeralStore, mt as ActionProcedure, n as CallerFromProcedures, ni as QueryCacheEntrySchema, nn as DbReader, o as CallOptions, oi as RangeRead, on as EPHEMERAL_DEFAULT_TTL_SECONDS, ot as QueryProcedures, p as createClient, pi as RawReadEntrySchema, pn as EphemeralWriter, pt as ActionFn, q as ClientPublicState, qr as OccAbortError, qt as SupaliveDb, r as CallerFromRouter, ri as QueryCacheMetadata, rn as DbWriter, rr as Database, rt as MutationProcedures, s as ClientFromProcedures, si as RangeReadSchema, sn as EphemeralDecodeError, sr as PooledClient, st as RegisteredProcedure, t as CallerClientInitConfig, ti as QueryCacheEntry, tn as defineQuery, u as LiveQueryState, ui as RawRangeRead, un as EphemeralReader, ut as router, vi as WriteEntrySchema, vt as HandlerObservability, wt as MutationCtx, xi as bytesFromJson, yi as WriteOp, zn as Model, zr as CompareOperator } from "../../index-DB7_pv9P.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, CallerClientInitConfig, CallerFromProcedures, CallerFromRouter, CallerOptions, type ClientEvent, type ClientFromProcedures, type ClientLogLevel, type ClientLogger, 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, EMPTY_EPHEMERAL_KEYS, EPHEMERAL_DEFAULT_TTL_SECONDS, EphemeralDecodeError, EphemeralFlushError, EphemeralKeyNotFoundError, type EphemeralReader, type EphemeralSetOptions, EphemeralStore, type EphemeralWriter, type HandlerLogger, type HandlerObservability, 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, createConsoleLogger, createMemoryEphemeralStore, createMutationBuilder, createQueryBuilder, defineComputedField, defineQuery, defineSchema, matchesPredicate, normalizeIdToBytes, normalizeToBytes, router, sleep };

package/dist/src/client/index.js

@@ -2,10 +2,11 @@ import { i as createActionBuilder, l as primaryOnlyConn, n as getContextRegistry
 import { r as supaliveStringify } from "../../helper-zdJT5FUc.js";
 import { o as matchesPredicate } from "../../query-LJranz0c.js";
 import { n as defineSchema, t as defineComputedField } from "../../schema-DRtz5h5l.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-OUou3o2Z.js";
-import { l as ServerMessageSchema } from "../../types_client_rpc-B8jh6MKl.js";
-import { c as DbReader, l as DbWriter, o as SupaliveDb, s as sleep, u as TxContext } from "../../logger-DrXccWFZ.js";
-import { n as runCachedQueryInParent, t as runCachedQuery } from "../../one-shot-query-BBiv9LGP.js";
+import { a as EphemeralKeyNotFoundError, c as createMemoryEphemeralStore, i as EphemeralFlushError, n as EPHEMERAL_DEFAULT_TTL_SECONDS, o as EphemeralStore, r as EphemeralDecodeError, t as EMPTY_EPHEMERAL_KEYS } from "../../ephemeral-CkidSG9y.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-DPMeNETt.js";
+import { l as ServerMessageSchema } from "../../types_client_rpc-CqUVHTwT.js";
+import { c as DbReader, l as DbWriter, n as sleep, t as SupaliveDb, u as TxContext } from "../../realtime_db-CTGOrFuV.js";
+import { n as runCachedQueryInParent, t as runCachedQuery } from "../../one-shot-query-DAAHGTcI.js";
 import { sha1 } from "hash-wasm";
 //#region src/db/query_definition.ts
 const _globalDefs = /* @__PURE__ */ new Map();
@@ -1305,6 +1306,6 @@ function createCaller(options) {
 	} });
 }
 //#endregion
-export { AndPredicateSchema, BigIntSchema, CachedPgMetadataSchema, CompareOperatorSchema, DEFAULT_RETRY, DbReader, DbReader as ReadContext, DbWriter, DbWriter as WritableContext, LeafPredicateSchema, NO_RETRY, OccAbortError, OccConflictError, OrPredicateSchema, PointReadSchema, PredicateSchema, QueryCacheEntrySchema, QueryCacheMetadataSchema, RPCError, RangeReadSchema, RawPointReadSchema, RawRangeReadSchema, RawReadEntrySchema, ReadEntrySchema, SupaliveDb, TxContext, WriteEntrySchema, WriteOpSchema, WsClientManager, _resetGlobalDefs, bytesFromJson, createActionBuilder, createCaller, createClient, createConsoleLogger, createMutationBuilder, createQueryBuilder, defineComputedField, defineQuery, defineSchema, matchesPredicate, normalizeIdToBytes, normalizeToBytes, router, sleep };
+export { AndPredicateSchema, BigIntSchema, CachedPgMetadataSchema, CompareOperatorSchema, DEFAULT_RETRY, DbReader, DbReader as ReadContext, DbWriter, DbWriter as WritableContext, EMPTY_EPHEMERAL_KEYS, EPHEMERAL_DEFAULT_TTL_SECONDS, EphemeralDecodeError, EphemeralFlushError, EphemeralKeyNotFoundError, EphemeralStore, LeafPredicateSchema, NO_RETRY, OccAbortError, OccConflictError, OrPredicateSchema, PointReadSchema, PredicateSchema, QueryCacheEntrySchema, QueryCacheMetadataSchema, RPCError, RangeReadSchema, RawPointReadSchema, RawRangeReadSchema, RawReadEntrySchema, ReadEntrySchema, SupaliveDb, TxContext, WriteEntrySchema, WriteOpSchema, WsClientManager, _resetGlobalDefs, bytesFromJson, createActionBuilder, createCaller, createClient, createConsoleLogger, createMemoryEphemeralStore, createMutationBuilder, createQueryBuilder, defineComputedField, defineQuery, defineSchema, matchesPredicate, normalizeIdToBytes, normalizeToBytes, router, sleep };
 
 //# sourceMappingURL=index.js.map