@supalive/core 1.7.1 → 1.8.1

package/dist/subscription-worker-pTVrvvmW.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"subscription-worker-pTVrvvmW.js","names":["uuidv4","logger","baseLogger","logger","Redis","baseLogger"],"sources":["../src/logger.ts","../src/server/retention-watermark.ts","../src/server/subscription-manager-types.ts","../src/db/cache.ts","../src/db/init_db.ts","../src/server/subscription-worker.ts"],"sourcesContent":["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.ENV === \"prod\";\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 type { Database } from \"../db/db\";\n\n/** Redis pub/sub channel the sub-manager publishes the retention watermark on\n * after each prune (and at startup). App-server instances subscribe and update\n * their in-memory {@link RetentionWatermark}. Payload is the watermark `ts` as a\n * string. */\nexport const RETENTION_WATERMARK_CHANNEL = \"supalive:retention_watermark\";\n\n/**\n * In-memory holder for the commit-log retention watermark: the oldest commit-log\n * ts still retained after prune (see {@link Database.getMinSnapshotTimestamp}).\n * Read on the hot path by the query-cache freshness check — a plain variable, no\n * per-check Redis/DB round trip. Loaded once at startup from the `metadata`\n * table and kept fresh out-of-band: the sub-manager broadcasts the new watermark\n * (in-process to its workers, over Redis pub/sub to app servers) each time it\n * prunes.\n *\n * `set` is monotonic — the watermark only ever moves forward (pruning never\n * un-deletes rows), so an out-of-order or stale update can never lower it, which\n * keeps the freshness guard on the safe side (an over-estimate only costs an\n * extra recompute; an under-estimate could serve stale data).\n *\n * Initial value is the -1n genesis (not 0), matching `getMinSnapshotTimestamp`\n * and the empty-DB snapshot ts — so before anything is pruned the guard never\n * rejects a genesis-era entry (whose snapshot is -1).\n */\nexport class RetentionWatermark {\n  private ts: bigint = -1n;\n\n  get(): bigint {\n    return this.ts;\n  }\n\n  set(ts: bigint): void {\n    if (ts > this.ts) this.ts = ts;\n  }\n\n  /** Seed from the persisted watermark (metadata table). Returns the current value. */\n  async loadFrom(db: Pick<Database, \"getMinSnapshotTimestamp\">): Promise<bigint> {\n    this.set(await db.getMinSnapshotTimestamp());\n    return this.ts;\n  }\n}\n","import z from \"zod\";\nimport { BigIntSchema, RawReadEntry, ReadEntry, ReadEntrySchema, WriteEntrySchema } from \"../db/types_db\";\n\n// ─── RPC Schemas ──────────────────────────────────────────────────────────────\n//\n// The wire protocol intentionally has NO `_clientVersion` / `_resync` /\n// `serverVersion` fields. Ordering of concurrent `updateSubscriptionReadSet`\n// calls is enforced by `lastSnapshotTs` (which is monotonic — it comes from\n// `Database.getLatestSnapshotTimestamp()`). Recovery after a sub-manager\n// restart is driven by the app server iterating its own\n// `serverSubscriptions` map and re-registering each one using params\n// persisted in Redis under `sl:reg:<subId>`.\n\nexport const RegisterSubscriptionParamsSchema = z.object({\n    /**\n     * Caller-computed FNV-1a routing key + identity for this subscription.\n     * The sub-manager trusts these values rather than re-deriving them from\n     * (queryName, args, queryIdentity); this avoids one stringify+SHA1 per\n     * register RPC. Trust is fine: the sub-manager RPC channel is fully\n     * internal.\n     */\n    subId: z.string(),\n    cacheKey: z.string(),\n    queryName: z.string(),\n    args: z.unknown(),\n    /**\n     * Segmentation key used in the subId/cacheKey hash. Defaults to the\n     * authenticated user's id (\"anonymous\" when none), unless the\n     * procedure overrides it via `QueryConfig.queryIdentity`.\n     */\n    queryIdentity: z.string(),\n    instanceName: z.string(),\n    lastSnapshotTs: BigIntSchema,\n});\nexport type RegisterSubscriptionParams = z.infer<typeof RegisterSubscriptionParamsSchema>;\n\nexport const RegisterSubscriptionResultSchema = z.object({\n    cacheKey: z.string(),\n    recompute: z.boolean(),\n    readSet: z.array(ReadEntrySchema),\n    // Version of the cached data the freshness check validated. The app server\n    // serves the cached data blob only when its version matches this (guards a\n    // data/metadata divergence). Absent when the worker had no metadata to\n    // validate against (e.g. a plain recompute), in which case the server does\n    // not serve from cache anyway.\n    version: z.string().optional(),\n});\nexport type RegisterSubscriptionResult = z.infer<typeof RegisterSubscriptionResultSchema>;\n\nexport const RegisterSubscriptionBatchParamsSchema = z.array(RegisterSubscriptionParamsSchema);\nexport type RegisterSubscriptionBatchParams = z.infer<typeof RegisterSubscriptionBatchParamsSchema>;\n\nexport const RegisterSubscriptionBatchResultSchema = z.array(RegisterSubscriptionResultSchema);\nexport type RegisterSubscriptionBatchResult = z.infer<typeof RegisterSubscriptionBatchResultSchema>;\n\nexport const UpdateSubscriptionReadSetParamsSchema = z.object({\n    cacheKey: z.string(),\n    subId: z.string(),\n    instanceName: z.string(),\n    lastSnapshotTs: BigIntSchema,\n    readSet: z.array(ReadEntrySchema),\n});\nexport type UpdateSubscriptionReadSetParams = z.infer<typeof UpdateSubscriptionReadSetParamsSchema>;\n\n/**\n * `tracked: false` means the sub-manager has no record of this subId (e.g.\n * a restart wiped state and the caller hasn't re-registered yet). The app\n * server should treat this as a signal to register the sub before retrying.\n */\nexport const UpdateSubscriptionReadSetResultSchema = z.object({\n    tracked: z.boolean(),\n});\nexport type UpdateSubscriptionReadSetResult = z.infer<typeof UpdateSubscriptionReadSetResultSchema>;\n\nexport const UnregisterSubscriptionParamsSchema = z.object({\n    subId: z.string(),\n    instanceName: z.string(),\n});\nexport type UnregisterSubscriptionParams = z.infer<typeof UnregisterSubscriptionParamsSchema>;\n\nexport const UnregisterSubscriptionsParamsSchema = z.array(UnregisterSubscriptionParamsSchema);\nexport type UnregisterSubscriptionsParams = z.infer<typeof UnregisterSubscriptionsParamsSchema>;\n\nexport const UnregisterSubscriptionResultSchema = z.object({ ok: z.boolean() });\nexport type UnregisterSubscriptionResult = z.infer<typeof UnregisterSubscriptionResultSchema>;\n\nexport const UnregisterSubscriptionsResultSchema = z.array(z.object({ ok: z.boolean() }));\nexport type UnregisterSubscriptionsResult = z.infer<typeof UnregisterSubscriptionsResultSchema>;\n\nexport const InvalidateWritesetParamsSchema = z.object({\n    writeSet: z.array(WriteEntrySchema),\n});\nexport type InvalidateWritesetParams = z.infer<typeof InvalidateWritesetParamsSchema>;\n\nexport const AffectedSubscriptionSchema = z.object({\n    subId: z.string(),\n    queryName: z.string(),\n    args: z.unknown(),\n    cacheKey: z.string(),\n    /**\n     * Every live instance that currently holds this subId. Routing rules:\n     *   • If the writer is in this list, it recomputes locally and publishes\n     *     an `update` to the rest (its own id is filtered by the publisher).\n     *   • Otherwise the writer broadcasts a `recompute-race` to every entry;\n     *     receivers race for a Redis lock and the winner recomputes.\n     */\n    notifyInstances: z.array(z.string()),\n});\nexport type AffectedSubscription = z.infer<typeof AffectedSubscriptionSchema>;\n\nexport const InvalidateWritesetResultSchema = z.object({\n    affected: z.array(AffectedSubscriptionSchema),\n});\nexport type InvalidateWritesetResult = z.infer<typeof InvalidateWritesetResultSchema>;\n\n// ─── Registration record persisted to Redis ──────────────────────────────────\n//\n// Stored at `sl:reg:<subId>` by the sub-manager when a brand-new subscription\n// is created, and deleted by the sub-manager when the last instance leaves.\n// The app server reads this on reconnect to know how to re-register its\n// known subIds.\n\nexport const RegistrationRecordSchema = z.object({\n    queryName: z.string(),\n    args: z.unknown(),\n    queryIdentity: z.string(),\n    cacheKey: z.string(),\n});\nexport type RegistrationRecord = z.infer<typeof RegistrationRecordSchema>;\n\nexport interface TrackedSubscription {\n    subId: string;\n    queryName: string;\n    args: unknown;\n    cacheKey: string;\n    lastSnapshotTs: bigint;\n    readSet: ReadEntry[];\n    rawReadSet: RawReadEntry[];\n    /** All app server instances that currently hold this subscription. */\n    instances: Set<string>;\n    timeout: NodeJS.Timeout | null;\n}","import type { Redis as UpstashRedis } from \"@upstash/redis\";\nimport {\n  CachedPgMetadata,\n  CachedPgMetadataSchema,\n  QueryCacheEntry, QueryCacheEntrySchema,\n  QueryCacheMetadata, QueryCacheMetadataSchema\n} from \"./types_db\";\nimport { retry, handleAll, ExponentialBackoff } from \"cockatiel\";\nimport { RegistrationRecord, RegistrationRecordSchema } from \"../server/subscription-manager-types\";\nimport Redis from \"ioredis\";\nimport { createHash } from \"node:crypto\";\nimport { logger as baseLogger, logLevelOf } from \"../logger\";\nimport { supaliveStringify } from \"../helper\";\n\nconst logger = baseLogger.child({\n  \"name\": \"CACHE_LAYER\",\n},\n  { level: logLevelOf(\"SERVER_LOG_LEVEL\") },\n);\n\nexport const redisRetryPolicy = retry(handleAll, {\n  maxAttempts: 3,\n  backoff: new ExponentialBackoff({\n    initialDelay: 5,\n    maxDelay: 2300,\n    exponent: 2,\n  }),\n});\n\n// ─── Query-cache Lua scripts ────────────────────────────────────────────────\n//\n// The query cache is two string keys per query — data (`sl:cache:*`) and\n// metadata (`sl:meta:*`). They are written by several code paths across two\n// processes (app server + sub-worker), so a plain pipeline can't keep them\n// consistent (and on a non-atomic client a pipeline isn't even atomic). These\n// scripts make each write ATOMIC and MONOTONIC:\n//   • atomic  — data + metadata are set in one server-side script.\n//   • monotonic (CAS) — a write is applied only when it is NOT older than what\n//     is stored, so a slow/older writer can never clobber a newer entry.\n// \"Newer\" is compared on `version` (the data's compute-ts, a decimal string;\n// `tonumber` is exact for the real ts range and handles the -1 genesis value).\n// cjson is used ONLY to READ the stored comparand; the value written is always\n// the caller-serialized ARGV string, so we never hit cjson's empty-array\n// re-encode pitfall.\n\n/** Atomic one-shot recompute write: set data + metadata iff incoming version\n *  (ARGV[3]) is not older than the stored one. KEYS: data, meta. */\nconst WRITE_DATA_AND_META = `\nlocal cur = redis.call('GET', KEYS[2])\nif cur then\n  local ok, m = pcall(cjson.decode, cur)\n  if ok and type(m) == 'table' and m.version and tonumber(ARGV[3]) < tonumber(m.version) then\n    return 0\n  end\nend\nredis.call('SET', KEYS[1], ARGV[1], 'EX', tonumber(ARGV[4]))\nredis.call('SET', KEYS[2], ARGV[2], 'EX', tonumber(ARGV[4]))\nreturn 1`;\n\n/** Data-only write (subscribe path): set data iff incoming version (ARGV[2]) is\n *  not older than the stored metadata's version. KEYS: data, meta. */\nconst WRITE_DATA_ONLY = `\nlocal cur = redis.call('GET', KEYS[2])\nif cur then\n  local ok, m = pcall(cjson.decode, cur)\n  if ok and type(m) == 'table' and m.version and tonumber(ARGV[2]) < tonumber(m.version) then\n    return 0\n  end\nend\nredis.call('SET', KEYS[1], ARGV[1], 'EX', tonumber(ARGV[3]))\nreturn 1`;\n\n/** Metadata-only replace (subscription recompute): set meta iff incoming version\n *  (ARGV[2]) is not older than the stored one. KEYS: meta. */\nconst REPLACE_META = `\nlocal cur = redis.call('GET', KEYS[1])\nif cur then\n  local ok, m = pcall(cjson.decode, cur)\n  if ok and type(m) == 'table' and m.version and tonumber(ARGV[2]) < tonumber(m.version) then\n    return 0\n  end\nend\nredis.call('SET', KEYS[1], ARGV[1], 'EX', tonumber(ARGV[3]))\nreturn 1`;\n\n/** Metadata-only horizon advance (still-fresh subscription): bump lastSnapshotTs\n *  ONLY, without recomputing. Applies ARGV[1] iff the new horizon (ARGV[2]) is\n *  strictly ahead of the stored one AND no newer computation (stored.version >\n *  ARGV[3], the version the caller based its advance on) has landed meanwhile —\n *  so an advance never reverts a fresh recompute. KEYS: meta. */\nconst ADVANCE_META = `\nlocal cur = redis.call('GET', KEYS[1])\nif not cur then return 0 end\nlocal ok, m = pcall(cjson.decode, cur)\nif not ok or type(m) ~= 'table' then return 0 end\nif tonumber(ARGV[2]) <= tonumber(m.lastSnapshotTs) then return 0 end\nif m.version and tonumber(m.version) > tonumber(ARGV[3]) then return 0 end\nredis.call('SET', KEYS[1], ARGV[1], 'EX', tonumber(ARGV[4]))\nreturn 1`;\n\nexport class CacheLayer {\n  public redis: Redis | UpstashRedis;\n  private readonly ttlSeconds: number;\n  /** Cached EVALSHA digests keyed by Lua source (see evalScript). */\n  private readonly scriptShaCache = new Map<string, string>();\n\n  constructor(upstash: Redis | UpstashRedis, ttlSeconds: number = 3600) {\n    this.redis = upstash;\n    this.ttlSeconds = ttlSeconds;\n  }\n\n  /**\n   * Run a Lua script via EVALSHA using the script's SHA1 (computed locally — the\n   * same digest Redis keys scripts by, so no SCRIPT LOAD round-trip is needed on\n   * the hot path). On NOSCRIPT (the script isn't in Redis's cache yet, e.g. first\n   * use or after a Redis restart/failover) load it explicitly via SCRIPT LOAD and\n   * re-run via EVALSHA — so the script ends up cached server-side and subsequent\n   * EVALSHA calls hit. The runtime client is always ioredis (see initCacheLayer).\n   */\n  private async evalScript(src: string, keys: string[], args: (string | number)[]): Promise<unknown> {\n    const redis = this.redis as Redis;\n    let sha = this.scriptShaCache.get(src);\n    if (!sha) {\n      sha = createHash(\"sha1\").update(src).digest(\"hex\");\n      this.scriptShaCache.set(src, sha);\n    }\n    return redisRetryPolicy.execute(async () => {\n      try {\n        return await redis.evalsha(sha!, keys.length, ...keys, ...args);\n      } catch (err) {\n        if (err instanceof Error && err.message.includes(\"NOSCRIPT\")) {\n          // Not in Redis's script cache yet — load it, then execute by digest.\n          const loadedSha = (await redis.call(\"SCRIPT\", \"LOAD\", src)) as string;\n          this.scriptShaCache.set(src, loadedSha);\n          return await redis.evalsha(loadedSha, keys.length, ...keys, ...args);\n        }\n        throw err;\n      }\n    });\n  }\n\n  /** One-shot recompute: atomically write data + metadata (CAS on version). */\n  async setQueryCacheAndMetadataFor(\n    cacheKey: string, data: unknown,\n    metaData: QueryCacheMetadata,\n    ttlSeconds?: number,\n  ): Promise<void> {\n    const ttl = ttlSeconds ?? this.ttlSeconds;\n    const dataJson = supaliveStringify({ data, version: metaData.version });\n    const metaJson = supaliveStringify(metaData);\n    await this.evalScript(\n      WRITE_DATA_AND_META,\n      [this.getQueryCacheDataKey(cacheKey), this.getQeruyCacheMetaKey(cacheKey)],\n      [dataJson, metaJson, metaData.version, String(ttl)],\n    );\n  }\n\n  /** Subscribe path: write the data blob only (CAS against the metadata's\n   *  version). The metadata is written separately by the sub-worker; the\n   *  `version` links the two so a divergent pair is detected on read. */\n  async setQueryCacheFor(cacheKey: string, data: unknown, version: string, ttlSeconds?: number): Promise<void> {\n    const ttl = ttlSeconds ?? this.ttlSeconds;\n    const dataJson = supaliveStringify({ data, version });\n    await this.evalScript(\n      WRITE_DATA_ONLY,\n      [this.getQueryCacheDataKey(cacheKey), this.getQeruyCacheMetaKey(cacheKey)],\n      [dataJson, version, String(ttl)],\n    );\n  }\n\n  async getQueryCacheFor(cacheKey: string): Promise<QueryCacheEntry | null> {\n    const dataRaw = await redisRetryPolicy.execute(() => this.redis.get(this.getQueryCacheDataKey(cacheKey)));\n\n    if (!dataRaw) return null;\n\n    try {\n      const parsed = typeof dataRaw === \"string\" ? JSON.parse(dataRaw) : dataRaw;\n      return QueryCacheEntrySchema.parse(parsed);\n    } catch {\n      return null;\n    }\n  }\n\n  /** Subscription recompute: replace the whole metadata (CAS on version). */\n  async replaceQueryCacheMetadata(cacheKey: string, metaData: QueryCacheMetadata, ttlSeconds?: number): Promise<void> {\n    const ttl = ttlSeconds ?? this.ttlSeconds;\n    const metaJson = supaliveStringify(metaData);\n    await this.evalScript(\n      REPLACE_META,\n      [this.getQeruyCacheMetaKey(cacheKey)],\n      [metaJson, metaData.version, String(ttl)],\n    );\n  }\n\n  /** Still-fresh subscription: advance `lastSnapshotTs` only, preserving the\n   *  data's `version` + `readSet` (no recompute). Monotonic and non-clobbering\n   *  — see ADVANCE_META. `metaData` carries the new horizon plus the version +\n   *  readSet the caller read, which the script keeps unless a newer computation\n   *  has since landed. */\n  async advanceQueryCacheMetadata(cacheKey: string, metaData: QueryCacheMetadata, ttlSeconds?: number): Promise<void> {\n    const ttl = ttlSeconds ?? this.ttlSeconds;\n    const metaJson = supaliveStringify(metaData);\n    await this.evalScript(\n      ADVANCE_META,\n      [this.getQeruyCacheMetaKey(cacheKey)],\n      [metaJson, String(metaData.lastSnapshotTs), metaData.version, String(ttl)],\n    );\n  }\n\n  async getQueryCacheMetaData(cacheKey: string): Promise<QueryCacheMetadata | null> {\n    const dataRaw = await redisRetryPolicy.execute(() => this.redis.get(this.getQeruyCacheMetaKey(cacheKey)));\n\n    if (!dataRaw) return null;\n\n    try {\n      const parsed = typeof dataRaw === \"string\" ? JSON.parse(dataRaw) : dataRaw;\n      return QueryCacheMetadataSchema.parse(parsed);\n    } catch {\n      return null;\n    }\n  }\n\n  async persistRegistrationRecord(subId: string, record: RegistrationRecord): Promise<void> {\n    const data = supaliveStringify(record);\n    await redisRetryPolicy.execute(() => this.redis.set(this.getRegistrationKey(subId), data));\n  }\n\n  async deleteRegistrationRecord(subId: string): Promise<void> {\n    await redisRetryPolicy.execute(() => this.redis.del(this.getRegistrationKey(subId)));\n  }\n\n  async deleteRegistrationsRecord(subIds: string[]): Promise<void> {\n    if (subIds.length === 0) return;\n\n    await redisRetryPolicy.execute(() =>\n      this.redis.del(...subIds.map((subId) => this.getRegistrationKey(subId))),\n    );\n  }\n\n  async fetchRegistrationRecordsBatch(\n    subIds: string[],\n  ): Promise<Map<string, RegistrationRecord | null>> {\n    const result = new Map<string, RegistrationRecord | null>();\n    const CHUNK_SIZE = 100;\n\n    for (let i = 0; i < subIds.length; i += CHUNK_SIZE) {\n      const chunk = subIds.slice(i, i + CHUNK_SIZE);\n      const keys = chunk.map((id) => `sl:reg:${id}`);\n      try {\n        if (keys.length === 0) continue;\n\n        const rawValues = await redisRetryPolicy.execute(() =>\n          this.redis.mget(...keys),\n        );\n\n        for (let j = 0; j < chunk.length; j++) {\n          const subId = chunk[j]!;\n          const raw = rawValues[j];\n          const rawJson = typeof raw === \"string\" ? JSON.parse(raw) : raw;\n\n          if (!raw) {\n            result.set(subId, null);\n          } else {\n            try {\n              const parsed = RegistrationRecordSchema.parse(rawJson);\n              result.set(subId, parsed);\n            } catch {\n              logger.error(`Failed to parse sl:reg:${subId} during batch recovery`);\n              result.set(subId, null);\n            }\n          }\n        }\n      } catch (err) {\n        logger.error(err, \"Failed to fetch registration records batch\");\n        for (const subId of chunk) {\n          result.set(subId, null);\n        }\n      }\n    }\n    return result;\n  }\n\n  async getCachedTableColumnTypes(key: string): Promise<CachedPgMetadata | null> {\n    const dataRaw = await redisRetryPolicy.execute(() => this.redis.get(key));\n    if (!dataRaw) return null;\n\n    try {\n      const parsed = typeof dataRaw === \"string\" ? JSON.parse(dataRaw) : dataRaw;\n      return CachedPgMetadataSchema.parse(parsed);\n    } catch {\n      return null;\n    }\n  }\n\n  async setCachedTableColumnsTypes(key: string, value: CachedPgMetadata): Promise<void> {\n    await redisRetryPolicy.execute(() =>\n      this.redis.set(key, supaliveStringify(value)),\n    );\n  }\n\n  /**\n   * Race participant: try to claim `lock:recompute:<subId>:<commitTs>`\n   * with `SET NX EX`. The single Redis round-trip both arbitrates and\n   * sets a TTL fallback in case the winner crashes mid-recompute.\n   */\n  async tryAcquireRecomputeLock(instanceId: string, subId: string, commitTs: string, ttl: number): Promise<boolean> {\n    const key = `lock:recompute:${subId}:${commitTs}`;\n    return redisRetryPolicy.execute(async () => {\n      try {\n        const res = await this.redis.set(key, instanceId, \"EX\", ttl, \"NX\");\n        return res === \"OK\";\n      } catch (err) {\n        logger.error(err, `Failed to acquire recompute lock ${key}`);\n        // Fail-closed: if Redis is misbehaving, don't run a recompute that\n        // we can't coordinate. The next mutation will trigger another race.\n        return false;\n      }\n    });\n  }\n\n\n  private getRegistrationKey(subId: string): string {\n    return `sl:reg:${subId}`;\n  }\n\n  private getQueryCacheDataKey(cacheKey: string): string {\n    return `sl:cache:${cacheKey}`;\n  }\n\n  private getQeruyCacheMetaKey(cacheKey: string): string {\n    return `sl:meta:${cacheKey}`;\n  }\n}","import { DatabaseConfig, SupaliveServerConfig, UpstashConfig } from \"../config\";\nimport { logger } from \"../logger\";\nimport { CacheLayer } from \"./cache\";\nimport { Database } from \"./db\";\nimport { MySqlDatabase } from \"./mysql\";\nimport { PgDatabase } from \"./postgres\";\nimport { SupaliveDb } from \"./realtime_db\";\nimport Redis from \"ioredis\";\n\n/**\n * Current core runtime-bootstrap version. Bump this whenever core needs a new\n * runtime database operation — a data seed, a backfill, or a schema change that\n * must be applied directly at runtime rather than through the migration\n * pipeline. Each increment adds a case to `Database.coreMigrationStatements`.\n *\n * The core *schema* (the `commit_logs`/`metadata` tables and the\n * `global_commit_ts` sequence/counter) is NOT versioned here — it comes from\n * the generated schema (`coreTablesSql` / `generateSchemaSql`), which must be\n * applied to the database BEFORE `initCore` runs.\n */\nexport const CORE_VERSION = 1n;\n\n/**\n * Bring the core runtime state up to {@link CORE_VERSION}. Idempotent and safe\n * to call from every process at startup: a lock-free version read short-circuits\n * the common \"already current\" case, and the actual migration runs under a\n * cross-process lock with a re-check so only one process applies it.\n *\n * Assumes the core schema already exists (apply the generated schema first);\n * the `metadata` table is where the version and seed rows live.\n */\nexport async function initCore(db: Database): Promise<void> {\n    // Fast path: no lock, no transaction.\n    const current = await db.getCoreVersion();\n    if (current >= CORE_VERSION) return;\n\n    await db.withCoreInitLock(async (ctx) => {\n        // Re-check under the lock — another process may have migrated while we\n        // were waiting to acquire it.\n        const from = await ctx.getVersion();\n        if (from >= CORE_VERSION) return;\n\n        for (let v = from + 1n; v <= CORE_VERSION; v++) {\n            const statements = db.coreMigrationStatements(v);\n            logger.info(`Migrating core schema ${v - 1n} -> ${v} (${statements.length} statements)`);\n            for (const sql of statements) {\n                await ctx.exec(sql);\n            }\n        }\n\n        await ctx.setVersion(CORE_VERSION);\n        logger.info(`Core schema now at version ${CORE_VERSION}`);\n    });\n}\n\n/**\n * Default and env override for the per-statement DB timeout. PG enforces\n * this via `statement_timeout` (server cancels), MySQL via the per-query\n * `timeout` option (driver issues KILL QUERY). Set 0 to disable.\n */\nexport const DB_QUERY_TIMEOUT_MS = Number(\n    process.env.SUPALIVE_DB_QUERY_TIMEOUT_MS ?? 30_000,\n);\n\nexport type InitDbOptions = {\n    DbConfig: DatabaseConfig;\n    CacheLayer: CacheLayer;\n    forceBootstrapReload?: boolean;\n    workerId?: number;\n};\n\nexport async function initDatabase(options: InitDbOptions): Promise<SupaliveDb> {\n    const impl = createDatabase(options.DbConfig, options.workerId);\n    const supaliveDb = SupaliveDb.create({ db: impl });\n    // Seed core runtime state (metadata rows, MySQL counter seed) up to date.\n    // The core schema (tables, indexes, global_commit_ts) is expected to already\n    // exist from the applied schema.\n    await initCore(impl);\n    await bootstrapDbTypes(supaliveDb, options.CacheLayer, options.forceBootstrapReload ?? false);\n    return supaliveDb;\n}\n\nexport function createDatabase(config: DatabaseConfig, workerId?: number): PgDatabase | MySqlDatabase {\n    const bindings: Record<string, any> = {\n        \"db\": config.type,\n    };\n    if (workerId) {\n        bindings[\"worker\"] = workerId;\n    }\n\n    if (config.type === \"postgres\") {\n        return new PgDatabase(\n            logger.child(bindings), {\n            ...config,\n            connectionString: config.connectionString,\n            min: config.minConnections ?? 0,\n            max: config.maxConnections ?? 20,\n            connectionTimeoutMillis: config.connectionTimeoutMillis ?? 15_000,\n            idleTimeoutMillis: config.idleTimeoutMillis ?? 30_000,\n            // server-enforced per-statement timeout; pg cancels the running\n            // query when it fires. 0 disables it.\n            statement_timeout: DB_QUERY_TIMEOUT_MS > 0 ? DB_QUERY_TIMEOUT_MS : undefined,\n        });\n    } else {\n        return new MySqlDatabase(\n            logger.child(bindings), {\n            ...config,\n            connectionLimit: config.maxConnections ?? 20,\n            connectTimeout: config.connectionTimeoutMillis ?? 15_000,\n            // mysql2 pool: 0 = wait forever for a free conn (default). queueLimit\n            // bounds the wait queue length so backpressure surfaces as an error\n            // rather than unbounded growth.\n            queueLimit: config.queueLimit ?? 0,\n            // driver-side per-statement timeout applied uniformly in\n            // MySqlDatabase.query.\n            queryTimeoutMs: DB_QUERY_TIMEOUT_MS,\n        });\n    }\n}\n\n/**\n * Eagerly load column types into the apply-path cache at server start.\n * In production, the result is cached in Redis under\n * `supalive:schema:types:${SUPALIVE_SCHEMA_VERSION ?? \"v1\"}` so other\n * instances starting cold can skip the pg_attribute round-trip. In any\n * other env we go straight to PG every time so local schema iteration\n * is never blocked by stale Redis state. Migrations should publish a\n * `schema:reload` message (see {@link publishSchemaReload}) after\n * applying DDL — every instance picks that up and re-bootstraps.\n */\nexport async function bootstrapDbTypes(db: SupaliveDb, cache: CacheLayer, forceReload = false): Promise<void> {\n    // TODO: remove this check if we needs mysql column types\n    if (db.impl.dbType === \"mysql\") {\n        // currently we don't use mysql column type\n        return;\n    }\n\n    const inProd = process.env.NODE_ENV === \"production\";\n    const version = process.env.SUPALIVE_SCHEMA_VERSION ?? \"v1\";\n    const key = `supalive:schema:types:${version}`;\n    try {\n        await db.impl.bootstrapColumnTypes({\n            cacheKey: key,\n            redis: inProd && !forceReload ? cache : undefined,\n        });\n        logger.info({ columnsTypes: db.impl.columnTypes }, `Bootstrapped db column types (redis=${inProd}, key=${key})`);\n    } catch (err) {\n        logger.error(err, \"Failed to bootstrap db column types\");\n        throw err;\n    }\n}\n\nexport type InitCacheLayerOptions = {\n    upstash: UpstashConfig;\n    /* Default 3600 */\n    cacheTtlSeconds?: number;\n    /* Default 15_000 */\n    connectionTimeout?: number;\n    /* Default 1 */\n    commandMaxRetries?: number;\n    /* Default 5 */\n    commandSubMaxRetries?: number;\n    /* Default true */\n    createSubClient?: boolean;\n};\n\nexport function initCacheLayer(config: InitCacheLayerOptions): { cacheLayer: CacheLayer, redisSubClient?: Redis } {\n    const redis = new Redis(config.upstash.redisUrl, {\n        connectTimeout: config.connectionTimeout ?? 15_000,\n        maxRetriesPerRequest: config.commandMaxRetries ?? 1,\n        keepAlive: 3000,\n    });\n    \n    const redisSub = config.createSubClient ? new Redis(config.upstash.redisUrl, {\n        connectTimeout: config.connectionTimeout ?? 15_000,\n        maxRetriesPerRequest: config.commandSubMaxRetries ?? 5,\n        disableClientInfo: true,\n        retryStrategy: (times) => {\n            if (times > 5) return null;\n            return Math.min(times * 200, 2000);\n        }\n    }) : undefined;\n\n    return {\n        cacheLayer: new CacheLayer(redis, config.cacheTtlSeconds ?? 3600),\n        redisSubClient: redisSub\n    };\n}\n\n","import type { Database } from \"../db/db\";\nimport type { RawReadEntry, ReadEntry } from \"../db/types_db\";\nimport type { CacheLayer } from \"../db/cache\";\nimport {\n  checkWriteSetAffectsReadSet,\n  evaluateCacheFreshness,\n  mapReadSetToRaw,\n  type RawWriteEntry,\n} from \"./overlap-checker\";\nimport {\n  AffectedSubscription,\n  RegisterSubscriptionParams,\n  RegisterSubscriptionResult,\n  RegistrationRecord,\n  TrackedSubscription,\n  UnregisterSubscriptionParams,\n  UnregisterSubscriptionResult,\n  UnregisterSubscriptionsParams,\n  UnregisterSubscriptionsResult,\n  UpdateSubscriptionReadSetParams,\n  UpdateSubscriptionReadSetResult,\n} from \"./subscription-manager-types\";\nimport { logger as baseLogger, logLevelOf } from \"../logger\";\nimport { RetentionWatermark, RETENTION_WATERMARK_CHANNEL } from \"./retention-watermark\";\n\n// A logical worker that owns a disjoint slice of subscriptions. The dispatcher\n// routes each operation here by FNV-1a(subId) % numWorkers. Each worker is\n// independent: no shared state, no locks, no cross-worker coordination.\n// invalidate() is a pure function of the worker's own state + the writeSet.\n\nexport class SubscriptionWorker {\n  readonly id: number;\n  private subscriptions = new Map<string, TrackedSubscription>();\n  private cache: CacheLayer;\n  private db: Database;\n  // In-memory retained commit-log watermark. Seeded at startup and moved forward on\n  // prune; read on the register hot path instead of a per-check Redis GET.\n  private retentionWatermark = new RetentionWatermark();\n  public logger: ReturnType<typeof baseLogger.child>;\n\n  constructor(id: number, cache: CacheLayer, db: Database) {\n    this.id = id;\n    this.cache = cache;\n    this.db = db;\n    this.logger = baseLogger.child(\n      { name: \"SUBS_WRK\", wid: id },\n      { level: logLevelOf(\"SUBS_MANAGER_SERVER_LOG_LEVEL\") },\n    );\n  }\n\n  size(): number {\n    return this.subscriptions.size;\n  }\n\n  has(subId: string): boolean {\n    return this.subscriptions.has(subId);\n  }\n\n  /**\n   * Lowest `lastSnapshotTs` across this worker's subscriptions, or `null`\n   * when there are none. Used by the dispatcher to derive a safe prune watermark.\n   */\n  minSubscriptionTs(): bigint | null {\n    let min: bigint | null = null;\n    for (const sub of this.subscriptions.values()) {\n      if (min === null || sub.lastSnapshotTs < min) min = sub.lastSnapshotTs;\n    }\n    return min;\n  }\n\n  /**\n   * Seed/repair the persisted retained watermark from the actual oldest retained\n   * commit log (`min(ts)`), then load it into memory and broadcast it. Called\n   * once at sub-manager startup — the `min(ts)` scan is off the hot path, and\n   * it corrects `metadata.min_retained_ts` even for a DB that was pruned before\n   * this feature existed. Returns the resulting watermark so the manager can\n   * broadcast it to the other workers.\n   */\n  async refreshRetentionWatermark(): Promise<bigint> {\n    const real = (await this.db.getMinCommitLogTs()) ?? 0n;\n    await this.db.updateMinSnapshotTimestamp(real);\n    // Read back so our in-memory copy matches the persisted (monotonic) value.\n    const persisted = await this.db.getMinSnapshotTimestamp();\n    this.retentionWatermark.set(persisted);\n    await this.publishRetentionWatermark(persisted);\n    return this.retentionWatermark.get();\n  }\n\n  /** Adopt a watermark broadcast by the manager (in-process from the pruning\n   * worker). Monotonic, so an out-of-order message can't lower it. */\n  setRetentionWatermark(ts: bigint): void {\n    this.retentionWatermark.set(ts);\n  }\n\n  /**\n   * Prune commit logs older than `minRetainedTs`. Advertises the new watermark FIRST —\n   * persist it, bump our in-memory copy, and broadcast it over Redis — and only\n   * then deletes, so no reader ever trusts a cache entry whose freshness scan\n   * would include rows we're about to remove. Returns rows deleted.\n   */\n  async prune(minRetainedTs: bigint): Promise<bigint> {\n    await this.db.updateMinSnapshotTimestamp(minRetainedTs);\n    this.retentionWatermark.set(minRetainedTs);\n    await this.publishRetentionWatermark(minRetainedTs);\n    const deleted = await this.db.pruneCommitLogsBefore(minRetainedTs);\n    return deleted;\n  }\n\n  /** Broadcast the watermark to app-server instances over Redis pub/sub. Workers in\n   * this process get it in-process via {@link setRetentionWatermark}. */\n  private async publishRetentionWatermark(ts: bigint): Promise<void> {\n    try {\n      await this.cache.redis.publish(RETENTION_WATERMARK_CHANNEL, ts.toString());\n    } catch (err) {\n      this.logger.error(err, \"failed to publish commit-log watermark\");\n    }\n  }\n\n  async register(\n    params: RegisterSubscriptionParams,\n  ): Promise<RegisterSubscriptionResult> {\n    const { subId, cacheKey, queryName, args, queryIdentity, instanceName, lastSnapshotTs } = params;\n    this.logger.info(`registering subscription: ${subId} from ${instanceName}`);\n\n    const existing = this.subscriptions.get(subId);\n\n    if (existing && !existing.timeout) {\n      existing.instances.add(instanceName);\n      return {\n        cacheKey,\n        recompute: false,\n        readSet: existing.readSet,\n      };\n    }\n\n    if (existing?.timeout) {\n      this.logger.info(`reactivating subscription: ${subId} from: ${instanceName}`);\n      clearTimeout(existing.timeout);\n      existing.timeout = null;\n    }\n\n    const metadata = await this.cache.getQueryCacheMetaData(cacheKey);\n    const freshness = await evaluateCacheFreshness(this.db, metadata, lastSnapshotTs, this.retentionWatermark.get());\n    let needsRecompute = !freshness.fresh;\n    const readSet: ReadEntry[] = freshness.readSet;\n    const rawReadSet: RawReadEntry[] = freshness.rawReadSet;\n\n    if (!needsRecompute && metadata && lastSnapshotTs > metadata.lastSnapshotTs) {\n      // Cache is still valid at a newer snapshot — advance the stored horizon\n      // so the next freshness scan starts from here (and stays above the\n      // watermark). Preserve the data's version + readSet; the CAS in\n      // advanceQueryCacheMetadata won't revert a fresher recompute.\n      this.cache\n        .advanceQueryCacheMetadata(cacheKey, { lastSnapshotTs, version: metadata.version, readSet })\n        .catch((err) => this.logger.error(err, `Failed to advance cache metadata for ${cacheKey}`));\n    }\n\n    let newSubscription: TrackedSubscription = {\n      subId,\n      queryName,\n      args,\n      cacheKey,\n      lastSnapshotTs: lastSnapshotTs,\n      readSet,\n      rawReadSet,\n      instances: new Set([instanceName]),\n      timeout: null,\n    };\n\n    const createdWhileChecking = this.subscriptions.get(subId);\n    if (createdWhileChecking) {\n      if (createdWhileChecking.timeout) {\n        clearTimeout(createdWhileChecking.timeout);\n        createdWhileChecking.timeout = null;\n      }\n\n      if (createdWhileChecking.lastSnapshotTs > lastSnapshotTs) {\n        newSubscription = {\n          ...newSubscription,\n          ...createdWhileChecking,\n          instances: new Set([...createdWhileChecking.instances, instanceName]),\n        };\n        needsRecompute = false;\n      }\n    }\n\n    this.subscriptions.set(subId, newSubscription);\n\n    this.persistRegistration(subId, { queryName, args, queryIdentity, cacheKey });\n\n    // `version` lets the app server verify the cached data blob it serves\n    // matches the metadata we validated (undefined when there was no metadata,\n    // i.e. a plain recompute — the server won't serve from cache then anyway).\n    return { cacheKey, recompute: needsRecompute, readSet, version: metadata?.version };\n  }\n\n  async updateReadSet(\n    params: UpdateSubscriptionReadSetParams,\n  ): Promise<UpdateSubscriptionReadSetResult> {\n    const { cacheKey, subId, instanceName, lastSnapshotTs, readSet } = params;\n    this.logger.info(`updating subscription readSet: ${subId} from ${instanceName}`);\n\n    const existing = this.subscriptions.get(subId);\n    if (!existing) {\n      return { tracked: false };\n    }\n\n    if (lastSnapshotTs < existing.lastSnapshotTs) {\n      return { tracked: true };\n    }\n\n    const rawReadSet = mapReadSetToRaw(readSet);\n    this.subscriptions.set(subId, { ...existing, readSet, rawReadSet, lastSnapshotTs });\n    // Fresh recompute: version == the compute ts (== lastSnapshotTs here). The\n    // server writes the matching data blob with this same version.\n    await this.cache.replaceQueryCacheMetadata(cacheKey, { lastSnapshotTs, version: String(lastSnapshotTs), readSet });\n\n    return { tracked: true };\n  }\n\n  async unregister(\n    params: UnregisterSubscriptionParams,\n    jitter: number = 0,\n  ): Promise<UnregisterSubscriptionResult> {\n    const { subId, instanceName } = params;\n    this.logger.info(`unregistering subscription: ${subId} from: ${instanceName}`);\n\n    const sub = this.subscriptions.get(subId);\n    if (!sub) return { ok: true };\n\n    if (sub.timeout) {\n      clearTimeout(sub.timeout);\n    }\n\n    if (sub.instances.size > 1) {\n      sub.instances.delete(instanceName);\n      return { ok: true };\n    }\n\n    this.logger.debug(`scheduling unregister subscription: ${subId} from: ${instanceName} in 15s`);\n    sub.timeout = setTimeout(async () => {\n      sub.instances.delete(instanceName);\n\n      if (sub.instances.size === 0) {\n        this.logger.info(`unregistered subscription: ${subId} from: ${instanceName}`);\n        this.subscriptions.delete(subId);\n        await this.deleteRegistration(subId);\n      }\n    }, 15_000 + jitter);\n\n    return { ok: true };\n  }\n\n  async unregisters(\n    params: UnregisterSubscriptionsParams,\n  ): Promise<UnregisterSubscriptionsResult> {\n    this.logger.info({ subIds: params }, `scheduling unregistering subscriptions`);\n    for (const param of params) {\n      this.unregister(param, Math.floor(Math.random() * 100));\n    }\n\n    return params.map(() => ({ ok: true }));\n  }\n\n  /**\n   * Synchronous, CPU-bound. Scans this worker's slice of subscriptions and\n   * returns the ones affected by the writeSet.\n   */\n  invalidate(rawWriteSet: RawWriteEntry[]): AffectedSubscription[] {\n    const affected: AffectedSubscription[] = [];\n\n    for (const [, sub] of this.subscriptions) {\n      if (sub.instances.size === 0) continue;\n      if (!checkWriteSetAffectsReadSet(rawWriteSet, sub.rawReadSet)) continue;\n\n      affected.push({\n        subId: sub.subId,\n        queryName: sub.queryName,\n        args: sub.args,\n        cacheKey: sub.cacheKey,\n        notifyInstances: Array.from(sub.instances),\n      });\n    }\n\n    return affected;\n  }\n\n  private async persistRegistration(subId: string, record: RegistrationRecord): Promise<void> {\n    try {\n      await this.cache.persistRegistrationRecord(subId, record);\n    } catch (err) {\n      this.logger.error(err, `[worker ${this.id}] Failed to persist registration for ${subId}`);\n    }\n  }\n\n  private async deleteRegistration(subId: string): Promise<void> {\n    try {\n      await this.cache.deleteRegistrationRecord(subId);\n    } catch (err) {\n      this.logger.error(err, `[worker ${this.id}] Failed to delete registration for ${subId}`);\n    }\n  }\n}\n"],"mappings":"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"}