@rocicorp/zero 0.25.0-canary.7 → 0.25.0-canary.9

package/out/zero-cache/src/db/migration.js

@@ -1,99 +1,111 @@
 import { assert } from "../../../shared/src/asserts.js";
 import { must } from "../../../shared/src/must.js";
-import * as v from "../../../shared/src/valita.js";
-import { disableStatementTimeout, } from "../types/pg.js";
-/**
- * Ensures that the schema is compatible with the current code, updating and
- * migrating the schema if necessary.
- */
-export async function runSchemaMigrations(log, debugName, schemaName, db, setupMigration, incrementalMigrationMap) {
-    log = log.withContext('initSchema', schemaName);
-    try {
-        const versionMigrations = sorted(incrementalMigrationMap);
-        assert(versionMigrations.length, `Must specify at least one version migration`);
-        assert(versionMigrations[0][0] > 0, `Versions must be non-zero positive numbers`);
-        const codeVersion = versionMigrations[versionMigrations.length - 1][0];
-        log.info?.(`Checking schema for compatibility with ${debugName} at schema v${codeVersion}`);
-        let versions = await db.begin(async (tx) => {
-            const versions = await ensureVersionHistory(tx, schemaName);
-            if (codeVersion < versions.minSafeVersion) {
-                throw new Error(`Cannot run ${debugName} at schema v${codeVersion} because rollback limit is v${versions.minSafeVersion}`);
-            }
-            if (versions.dataVersion > codeVersion) {
-                log.info?.(`Data is at v${versions.dataVersion}. Resetting to v${codeVersion}`);
-                return updateVersionHistory(log, tx, schemaName, versions, codeVersion);
-            }
-            return versions;
-        });
-        if (versions.dataVersion < codeVersion) {
-            const migrations = versions.dataVersion === 0
-                ? // For the empty database v0, only run the setup migration.
-                    [[codeVersion, setupMigration]]
-                : versionMigrations;
-            for (const [dest, migration] of migrations) {
-                if (versions.dataVersion < dest) {
-                    log.info?.(`Migrating schema from v${versions.dataVersion} to v${dest}`);
-                    void log.flush(); // Flush logs before each migration to help debug crash-y migrations.
-                    versions = await db.begin(async (tx) => {
-                        disableStatementTimeout(tx);
-                        // Fetch meta from within the transaction to make the migration atomic.
-                        let versions = await ensureVersionHistory(tx, schemaName);
-                        if (versions.dataVersion < dest) {
-                            versions = await runMigration(log, schemaName, tx, versions, dest, migration);
-                            assert(versions.dataVersion === dest);
-                        }
-                        return versions;
-                    });
-                }
+import { parse } from "../../../shared/src/valita.js";
+import { disableStatementTimeout } from "../types/pg.js";
+import { object, number } from "@badrap/valita";
+async function runSchemaMigrations(log, debugName, schemaName, db, setupMigration, incrementalMigrationMap) {
+  log = log.withContext("initSchema", schemaName);
+  try {
+    const versionMigrations = sorted(incrementalMigrationMap);
+    assert(
+      versionMigrations.length,
+      `Must specify at least one version migration`
+    );
+    assert(
+      versionMigrations[0][0] > 0,
+      `Versions must be non-zero positive numbers`
+    );
+    const codeVersion = versionMigrations[versionMigrations.length - 1][0];
+    log.info?.(
+      `Checking schema for compatibility with ${debugName} at schema v${codeVersion}`
+    );
+    let versions = await db.begin(async (tx) => {
+      const versions2 = await ensureVersionHistory(tx, schemaName);
+      if (codeVersion < versions2.minSafeVersion) {
+        throw new Error(
+          `Cannot run ${debugName} at schema v${codeVersion} because rollback limit is v${versions2.minSafeVersion}`
+        );
+      }
+      if (versions2.dataVersion > codeVersion) {
+        log.info?.(
+          `Data is at v${versions2.dataVersion}. Resetting to v${codeVersion}`
+        );
+        return updateVersionHistory(log, tx, schemaName, versions2, codeVersion);
+      }
+      return versions2;
+    });
+    if (versions.dataVersion < codeVersion) {
+      const migrations = versions.dataVersion === 0 ? (
+        // For the empty database v0, only run the setup migration.
+        [[codeVersion, setupMigration]]
+      ) : versionMigrations;
+      for (const [dest, migration] of migrations) {
+        if (versions.dataVersion < dest) {
+          log.info?.(
+            `Migrating schema from v${versions.dataVersion} to v${dest}`
+          );
+          void log.flush();
+          versions = await db.begin(async (tx) => {
+            disableStatementTimeout(tx);
+            let versions2 = await ensureVersionHistory(tx, schemaName);
+            if (versions2.dataVersion < dest) {
+              versions2 = await runMigration(
+                log,
+                schemaName,
+                tx,
+                versions2,
+                dest,
+                migration
+              );
+              assert(versions2.dataVersion === dest);
             }
+            return versions2;
+          });
         }
-        assert(versions.dataVersion === codeVersion);
-        log.info?.(`Running ${debugName} at schema v${codeVersion}`);
-    }
-    catch (e) {
-        log.error?.('Error in ensureSchemaMigrated', e);
-        throw e;
-    }
-    finally {
-        void log.flush(); // Flush the logs but do not block server progress on it.
+      }
     }
+    assert(versions.dataVersion === codeVersion);
+    log.info?.(`Running ${debugName} at schema v${codeVersion}`);
+  } catch (e) {
+    log.error?.("Error in ensureSchemaMigrated", e);
+    throw e;
+  } finally {
+    void log.flush();
+  }
 }
 function sorted(incrementalMigrationMap) {
-    const versionMigrations = [];
-    for (const [v, m] of Object.entries(incrementalMigrationMap)) {
-        versionMigrations.push([Number(v), m]);
-    }
-    return versionMigrations.sort(([a], [b]) => a - b);
+  const versionMigrations = [];
+  for (const [v2, m] of Object.entries(incrementalMigrationMap)) {
+    versionMigrations.push([Number(v2), m]);
+  }
+  return versionMigrations.sort(([a], [b]) => a - b);
 }
-// Exposed for tests.
-export const versionHistory = v.object({
-    /**
-     * The `schemaVersion` is highest code version that has ever been run
-     * on the database, and is used to delineate the structure of the tables
-     * in the database. A schemaVersion only moves forward; rolling back to
-     * an earlier (safe) code version does not revert schema changes that
-     * have already been applied.
-     */
-    schemaVersion: v.number(),
-    /**
-     * The data version is the code version of the latest server that ran.
-     * Note that this may be less than the schemaVersion in the case that
-     * a server is rolled back to an earlier version after a schema change.
-     * In such a case, data (but not schema), may need to be re-migrated
-     * when rolling forward again.
-     */
-    dataVersion: v.number(),
-    /**
-     * The minimum code version that is safe to run. This is used when
-     * a schema migration is not backwards compatible with an older version
-     * of the code.
-     */
-    minSafeVersion: v.number(),
+const versionHistory = object({
+  /**
+   * The `schemaVersion` is highest code version that has ever been run
+   * on the database, and is used to delineate the structure of the tables
+   * in the database. A schemaVersion only moves forward; rolling back to
+   * an earlier (safe) code version does not revert schema changes that
+   * have already been applied.
+   */
+  schemaVersion: number(),
+  /**
+   * The data version is the code version of the latest server that ran.
+   * Note that this may be less than the schemaVersion in the case that
+   * a server is rolled back to an earlier version after a schema change.
+   * In such a case, data (but not schema), may need to be re-migrated
+   * when rolling forward again.
+   */
+  dataVersion: number(),
+  /**
+   * The minimum code version that is safe to run. This is used when
+   * a schema migration is not backwards compatible with an older version
+   * of the code.
+   */
+  minSafeVersion: number()
 });
-// Exposed for tests.
-export async function createVersionHistoryTable(sql, schemaName) {
-    // Note: The `lock` column transparently ensures that at most one row exists.
-    await sql `
+async function createVersionHistoryTable(sql, schemaName) {
+  await sql`
     CREATE SCHEMA IF NOT EXISTS ${sql(schemaName)};
     CREATE TABLE IF NOT EXISTS ${sql(schemaName)}."versionHistory" (
       "dataVersion" int NOT NULL,
@@ -106,69 +118,77 @@ export async function createVersionHistoryTable(sql, schemaName) {
     );`.simple();
 }
 async function ensureVersionHistory(sql, schemaName) {
-    return must(await getVersionHistory(sql, schemaName, true));
+  return must(await getVersionHistory(sql, schemaName, true));
 }
-export async function getVersionHistory(sql, schemaName, create = false) {
-    const exists = await sql `
+async function getVersionHistory(sql, schemaName, create = false) {
+  const exists = await sql`
   SELECT nspname, relname FROM pg_class 
     JOIN pg_namespace ON relnamespace = pg_namespace.oid
-    WHERE nspname = ${schemaName} AND relname = ${'versionHistory'}`;
-    if (exists.length === 0) {
-        if (create) {
-            await createVersionHistoryTable(sql, schemaName);
-        }
-        else {
-            return null;
-        }
+    WHERE nspname = ${schemaName} AND relname = ${"versionHistory"}`;
+  if (exists.length === 0) {
+    if (create) {
+      await createVersionHistoryTable(sql, schemaName);
+    } else {
+      return null;
     }
-    const rows = await sql `
+  }
+  const rows = await sql`
     SELECT "dataVersion", "schemaVersion", "minSafeVersion" 
        FROM ${sql(schemaName)}."versionHistory"`;
-    if (rows.length === 0) {
-        return create
-            ? { schemaVersion: 0, dataVersion: 0, minSafeVersion: 0 }
-            : null;
-    }
-    return v.parse(rows[0], versionHistory);
+  if (rows.length === 0) {
+    return create ? { schemaVersion: 0, dataVersion: 0, minSafeVersion: 0 } : null;
+  }
+  return parse(rows[0], versionHistory);
 }
 async function updateVersionHistory(log, sql, schemaName, prev, newVersion, minSafeVersion) {
-    assert(newVersion > 0);
-    const versions = {
-        dataVersion: newVersion,
-        // The schemaVersion never moves backwards.
-        schemaVersion: Math.max(newVersion, prev.schemaVersion),
-        minSafeVersion: getMinSafeVersion(log, prev, minSafeVersion),
-    };
-    await sql `
+  assert(newVersion > 0);
+  const versions = {
+    dataVersion: newVersion,
+    // The schemaVersion never moves backwards.
+    schemaVersion: Math.max(newVersion, prev.schemaVersion),
+    minSafeVersion: getMinSafeVersion(log, prev, minSafeVersion)
+  };
+  await sql`
     INSERT INTO ${sql(schemaName)}."versionHistory" ${sql(versions)}
       ON CONFLICT (lock) DO UPDATE SET ${sql(versions)}
   `;
-    return versions;
+  return versions;
 }
 async function runMigration(log, schemaName, tx, versions, destinationVersion, migration) {
-    if (versions.schemaVersion < destinationVersion) {
-        await migration.migrateSchema?.(log, tx);
-    }
-    if (versions.dataVersion < destinationVersion) {
-        await migration.migrateData?.(log, tx);
-    }
-    return updateVersionHistory(log, tx, schemaName, versions, destinationVersion, migration.minSafeVersion);
+  if (versions.schemaVersion < destinationVersion) {
+    await migration.migrateSchema?.(log, tx);
+  }
+  if (versions.dataVersion < destinationVersion) {
+    await migration.migrateData?.(log, tx);
+  }
+  return updateVersionHistory(
+    log,
+    tx,
+    schemaName,
+    versions,
+    destinationVersion,
+    migration.minSafeVersion
+  );
 }
-/**
- * Bumps the rollback limit [[toAtLeast]] the specified version.
- * Leaves the rollback limit unchanged if it is equal or greater.
- */
 function getMinSafeVersion(log, current, proposedSafeVersion) {
-    if (proposedSafeVersion === undefined) {
-        return current.minSafeVersion;
-    }
-    if (current.minSafeVersion >= proposedSafeVersion) {
-        // The rollback limit must never move backwards.
-        log.debug?.(`rollback limit is already at ${current.minSafeVersion}, ` +
-            `don't need to bump to ${proposedSafeVersion}`);
-        return current.minSafeVersion;
-    }
-    log.info?.(`bumping rollback limit from ${current.minSafeVersion} to ${proposedSafeVersion}`);
-    return proposedSafeVersion;
+  if (proposedSafeVersion === void 0) {
+    return current.minSafeVersion;
+  }
+  if (current.minSafeVersion >= proposedSafeVersion) {
+    log.debug?.(
+      `rollback limit is already at ${current.minSafeVersion}, don't need to bump to ${proposedSafeVersion}`
+    );
+    return current.minSafeVersion;
+  }
+  log.info?.(
+    `bumping rollback limit from ${current.minSafeVersion} to ${proposedSafeVersion}`
+  );
+  return proposedSafeVersion;
 }
-//# sourceMappingURL=migration.js.map
+export {
+  createVersionHistoryTable,
+  getVersionHistory,
+  runSchemaMigrations,
+  versionHistory
+};
+//# sourceMappingURL=migration.js.map

package/out/zero-cache/src/db/migration.js.map

@@ -1 +1 @@
-{"version":3,"file":"migration.js","sourceRoot":"","sources":["../../../../../zero-cache/src/db/migration.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"migration.js","sources":["../../../../../zero-cache/src/db/migration.ts"],"sourcesContent":["import type {LogContext} from '@rocicorp/logger';\nimport type postgres from 'postgres';\nimport {assert} from '../../../shared/src/asserts.ts';\nimport {must} from '../../../shared/src/must.ts';\nimport * as v from '../../../shared/src/valita.ts';\nimport {\n  disableStatementTimeout,\n  type PostgresDB,\n  type PostgresTransaction,\n} from '../types/pg.ts';\n\ntype Operations = (log: LogContext, tx: PostgresTransaction) => Promise<void>;\n\n/**\n * Encapsulates the logic for setting up or upgrading to a new schema. After the\n * Migration code successfully completes, {@link runSchemaMigrations}\n * will update the schema version and commit the transaction.\n */\nexport type Migration = {\n  /**\n   * Perform database operations that create or alter table structure. This is\n   * called at most once during lifetime of the application. If a `migrateData()`\n   * operation is defined, that will be performed after `migrateSchema()` succeeds.\n   */\n  migrateSchema?: Operations;\n\n  /**\n   * Perform database operations to migrate data to the new schema. This is\n   * called after `migrateSchema()` (if defined), and may be called again\n   * to re-migrate data after the server was rolled back to an earlier version,\n   * and rolled forward again.\n   *\n   * Consequently, the logic in `migrateData()` must be idempotent.\n   */\n  migrateData?: Operations;\n\n  /**\n   * Sets the `minSafeVersion` to the specified value, prohibiting running\n   * any earlier code versions.\n   */\n  minSafeVersion?: number;\n};\n\n/**\n * Mapping of incremental migrations to move from the previous old code\n * version to next one. Versions must be non-zero.\n *\n * The schema resulting from performing incremental migrations should be\n * equivalent to that of the `setupMigration` on a blank database.\n *\n * The highest destinationVersion of this map denotes the current\n * \"code version\", and is also used as the destination version when\n * running the initial setup migration on a blank database.\n */\nexport type IncrementalMigrationMap = {\n  [destinationVersion: number]: Migration;\n};\n\n/**\n * Ensures that the schema is compatible with the current code, updating and\n * migrating the schema if necessary.\n */\nexport async function runSchemaMigrations(\n  log: LogContext,\n  debugName: string,\n  schemaName: string,\n  db: PostgresDB,\n  setupMigration: Migration,\n  incrementalMigrationMap: IncrementalMigrationMap,\n): Promise<void> {\n  log = log.withContext('initSchema', schemaName);\n  try {\n    const versionMigrations = sorted(incrementalMigrationMap);\n    assert(\n      versionMigrations.length,\n      `Must specify at least one version migration`,\n    );\n    assert(\n      versionMigrations[0][0] > 0,\n      `Versions must be non-zero positive numbers`,\n    );\n    const codeVersion = versionMigrations[versionMigrations.length - 1][0];\n    log.info?.(\n      `Checking schema for compatibility with ${debugName} at schema v${codeVersion}`,\n    );\n\n    let versions = await db.begin(async tx => {\n      const versions = await ensureVersionHistory(tx, schemaName);\n      if (codeVersion < versions.minSafeVersion) {\n        throw new Error(\n          `Cannot run ${debugName} at schema v${codeVersion} because rollback limit is v${versions.minSafeVersion}`,\n        );\n      }\n\n      if (versions.dataVersion > codeVersion) {\n        log.info?.(\n          `Data is at v${versions.dataVersion}. Resetting to v${codeVersion}`,\n        );\n        return updateVersionHistory(log, tx, schemaName, versions, codeVersion);\n      }\n      return versions;\n    });\n\n    if (versions.dataVersion < codeVersion) {\n      const migrations =\n        versions.dataVersion === 0\n          ? // For the empty database v0, only run the setup migration.\n            ([[codeVersion, setupMigration]] as const)\n          : versionMigrations;\n\n      for (const [dest, migration] of migrations) {\n        if (versions.dataVersion < dest) {\n          log.info?.(\n            `Migrating schema from v${versions.dataVersion} to v${dest}`,\n          );\n          void log.flush(); // Flush logs before each migration to help debug crash-y migrations.\n\n          versions = await db.begin(async tx => {\n            disableStatementTimeout(tx);\n\n            // Fetch meta from within the transaction to make the migration atomic.\n            let versions = await ensureVersionHistory(tx, schemaName);\n            if (versions.dataVersion < dest) {\n              versions = await runMigration(\n                log,\n                schemaName,\n                tx,\n                versions,\n                dest,\n                migration,\n              );\n              assert(versions.dataVersion === dest);\n            }\n            return versions;\n          });\n        }\n      }\n    }\n\n    assert(versions.dataVersion === codeVersion);\n    log.info?.(`Running ${debugName} at schema v${codeVersion}`);\n  } catch (e) {\n    log.error?.('Error in ensureSchemaMigrated', e);\n    throw e;\n  } finally {\n    void log.flush(); // Flush the logs but do not block server progress on it.\n  }\n}\n\nfunction sorted(\n  incrementalMigrationMap: IncrementalMigrationMap,\n): [number, Migration][] {\n  const versionMigrations: [number, Migration][] = [];\n  for (const [v, m] of Object.entries(incrementalMigrationMap)) {\n    versionMigrations.push([Number(v), m]);\n  }\n  return versionMigrations.sort(([a], [b]) => a - b);\n}\n\n// Exposed for tests.\nexport const versionHistory = v.object({\n  /**\n   * The `schemaVersion` is highest code version that has ever been run\n   * on the database, and is used to delineate the structure of the tables\n   * in the database. A schemaVersion only moves forward; rolling back to\n   * an earlier (safe) code version does not revert schema changes that\n   * have already been applied.\n   */\n  schemaVersion: v.number(),\n\n  /**\n   * The data version is the code version of the latest server that ran.\n   * Note that this may be less than the schemaVersion in the case that\n   * a server is rolled back to an earlier version after a schema change.\n   * In such a case, data (but not schema), may need to be re-migrated\n   * when rolling forward again.\n   */\n  dataVersion: v.number(),\n\n  /**\n   * The minimum code version that is safe to run. This is used when\n   * a schema migration is not backwards compatible with an older version\n   * of the code.\n   */\n  minSafeVersion: v.number(),\n});\n\n// Exposed for tests.\nexport type VersionHistory = v.Infer<typeof versionHistory>;\n\n// Exposed for tests.\nexport async function createVersionHistoryTable(\n  sql: postgres.Sql,\n  schemaName: string,\n) {\n  // Note: The `lock` column transparently ensures that at most one row exists.\n  await sql`\n    CREATE SCHEMA IF NOT EXISTS ${sql(schemaName)};\n    CREATE TABLE IF NOT EXISTS ${sql(schemaName)}.\"versionHistory\" (\n      \"dataVersion\" int NOT NULL,\n      \"schemaVersion\" int NOT NULL,\n      \"minSafeVersion\" int NOT NULL,\n\n      lock char(1) NOT NULL CONSTRAINT DF_schema_meta_lock DEFAULT 'v',\n      CONSTRAINT PK_schema_meta_lock PRIMARY KEY (lock),\n      CONSTRAINT CK_schema_meta_lock CHECK (lock='v')\n    );`.simple();\n}\n\nasync function ensureVersionHistory(\n  sql: postgres.Sql,\n  schemaName: string,\n): Promise<VersionHistory> {\n  return must(await getVersionHistory(sql, schemaName, true));\n}\n\nexport async function getVersionHistory(\n  sql: postgres.Sql,\n  schemaName: string,\n  create = false,\n): Promise<VersionHistory | null> {\n  const exists = await sql`\n  SELECT nspname, relname FROM pg_class \n    JOIN pg_namespace ON relnamespace = pg_namespace.oid\n    WHERE nspname = ${schemaName} AND relname = ${'versionHistory'}`;\n\n  if (exists.length === 0) {\n    if (create) {\n      await createVersionHistoryTable(sql, schemaName);\n    } else {\n      return null;\n    }\n  }\n  const rows = await sql`\n    SELECT \"dataVersion\", \"schemaVersion\", \"minSafeVersion\" \n       FROM ${sql(schemaName)}.\"versionHistory\"`;\n\n  if (rows.length === 0) {\n    return create\n      ? {schemaVersion: 0, dataVersion: 0, minSafeVersion: 0}\n      : null;\n  }\n  return v.parse(rows[0], versionHistory);\n}\n\nasync function updateVersionHistory(\n  log: LogContext,\n  sql: postgres.Sql,\n  schemaName: string,\n  prev: VersionHistory,\n  newVersion: number,\n  minSafeVersion?: number,\n): Promise<VersionHistory> {\n  assert(newVersion > 0);\n  const versions = {\n    dataVersion: newVersion,\n    // The schemaVersion never moves backwards.\n    schemaVersion: Math.max(newVersion, prev.schemaVersion),\n    minSafeVersion: getMinSafeVersion(log, prev, minSafeVersion),\n  } satisfies VersionHistory;\n\n  await sql`\n    INSERT INTO ${sql(schemaName)}.\"versionHistory\" ${sql(versions)}\n      ON CONFLICT (lock) DO UPDATE SET ${sql(versions)}\n  `;\n  return versions;\n}\n\nasync function runMigration(\n  log: LogContext,\n  schemaName: string,\n  tx: PostgresTransaction,\n  versions: VersionHistory,\n  destinationVersion: number,\n  migration: Migration,\n): Promise<VersionHistory> {\n  if (versions.schemaVersion < destinationVersion) {\n    await migration.migrateSchema?.(log, tx);\n  }\n  if (versions.dataVersion < destinationVersion) {\n    await migration.migrateData?.(log, tx);\n  }\n  return updateVersionHistory(\n    log,\n    tx,\n    schemaName,\n    versions,\n    destinationVersion,\n    migration.minSafeVersion,\n  );\n}\n\n/**\n * Bumps the rollback limit [[toAtLeast]] the specified version.\n * Leaves the rollback limit unchanged if it is equal or greater.\n */\nfunction getMinSafeVersion(\n  log: LogContext,\n  current: VersionHistory,\n  proposedSafeVersion?: number,\n): number {\n  if (proposedSafeVersion === undefined) {\n    return current.minSafeVersion;\n  }\n  if (current.minSafeVersion >= proposedSafeVersion) {\n    // The rollback limit must never move backwards.\n    log.debug?.(\n      `rollback limit is already at ${current.minSafeVersion}, ` +\n        `don't need to bump to ${proposedSafeVersion}`,\n    );\n    return current.minSafeVersion;\n  }\n  log.info?.(\n    `bumping rollback limit from ${current.minSafeVersion} to ${proposedSafeVersion}`,\n  );\n  return proposedSafeVersion;\n}\n"],"names":["versions","v","v.object","v.number","v.parse"],"mappings":"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"}

package/out/zero-cache/src/db/mode-enum.js

@@ -1,4 +1,9 @@
-export const SERIALIZABLE = 'ISOLATION LEVEL SERIALIZABLE';
-export const READ_COMMITTED = 'ISOLATION LEVEL READ COMMITTED';
-export const READONLY = 'ISOLATION LEVEL REPEATABLE READ READ ONLY';
-//# sourceMappingURL=mode-enum.js.map
+const SERIALIZABLE = "ISOLATION LEVEL SERIALIZABLE";
+const READ_COMMITTED = "ISOLATION LEVEL READ COMMITTED";
+const READONLY = "ISOLATION LEVEL REPEATABLE READ READ ONLY";
+export {
+  READONLY,
+  READ_COMMITTED,
+  SERIALIZABLE
+};
+//# sourceMappingURL=mode-enum.js.map

package/out/zero-cache/src/db/mode-enum.js.map

@@ -1 +1 @@
-{"version":3,"file":"mode-enum.js","sourceRoot":"","sources":["../../../../../zero-cache/src/db/mode-enum.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,MAAM,YAAY,GAAG,8BAA8B,CAAC;AAC3D,MAAM,CAAC,MAAM,cAAc,GAAG,gCAAgC,CAAC;AAC/D,MAAM,CAAC,MAAM,QAAQ,GAAG,2CAA2C,CAAC"}
+{"version":3,"file":"mode-enum.js","sources":["../../../../../zero-cache/src/db/mode-enum.ts"],"sourcesContent":["export const SERIALIZABLE = 'ISOLATION LEVEL SERIALIZABLE';\nexport const READ_COMMITTED = 'ISOLATION LEVEL READ COMMITTED';\nexport const READONLY = 'ISOLATION LEVEL REPEATABLE READ READ ONLY';\n\nexport type SERIALIZABLE = typeof SERIALIZABLE;\nexport type READ_COMMITTED = typeof READ_COMMITTED;\nexport type READONLY = typeof READONLY;\n"],"names":[],"mappings":"AAAO,MAAM,eAAe;AACrB,MAAM,iBAAiB;AACvB,MAAM,WAAW;"}

package/out/zero-cache/src/db/pg-copy.js

@@ -1,95 +1,56 @@
-import { Transform } from 'node:stream';
-/**
- * A stream Transform that parses a Postgres `COPY ... TO` text stream into
- * individual text values. The special {@link NULL_BYTE} string is used to
- * indicate a `null` value (as the `null` value itself indicates the end of
- * the stream and cannot be pushed as an element).
- *
- * Note that the transform assumes that the next step of the pipeline
- * understands the cardinality of values per row and does not push any
- * special value when reaching the end of a row.
- */
-export class TextTransform extends Transform {
-    #parser = new TsvParser();
-    constructor() {
-        super({ objectMode: true });
-    }
-    _transform(chunk, _encoding, callback) {
-        try {
-            for (const value of this.#parser.parse(chunk)) {
-                this.push(value === null ? NULL_BYTE : value);
-            }
-            callback();
-        }
-        catch (e) {
-            callback(e instanceof Error ? e : new Error(String(e)));
-        }
-    }
-}
-/**
- * Parsing a stream of tab-separated values from a Postgres `COPY` command.
- * The object keeps state and should be reused across chunks of a stream in
- * order to properly recognize that values are split across chunks.
- *
- * Note that `null` values are yielded as `null`. This object does not return
- * the {@link NULL_BYTE} string.
- */
-export class TsvParser {
-    #currVal = '';
-    #escaped = false;
-    *parse(chunk) {
-        let l = 0;
-        let r = 0;
-        for (; r < chunk.length; r++) {
-            const ch = chunk[r];
-            if (this.#escaped) {
-                const escapedChar = ESCAPED_CHARACTERS[ch];
-                if (escapedChar === undefined) {
-                    throw new Error(`Unexpected escape character \\${String.fromCharCode(ch)}`);
-                }
-                this.#currVal += escapedChar;
-                l = r + 1;
-                this.#escaped = false;
-                continue;
-            }
-            switch (ch) {
-                case 0x5c: // '\'
-                    // flush segment
-                    l < r && (this.#currVal += chunk.toString('utf8', l, r));
-                    l = r + 1;
-                    this.#escaped = true;
-                    break;
-                case 0x09: // '\t'
-                case 0x0a: // '\n'
-                    // flush segment
-                    l < r && (this.#currVal += chunk.toString('utf8', l, r));
-                    l = r + 1;
-                    // Value is done in both cases.
-                    yield this.#currVal === NULL_BYTE ? null : this.#currVal;
-                    this.#currVal = '';
-                    break;
-            }
+class TsvParser {
+  #currVal = "";
+  #escaped = false;
+  *parse(chunk) {
+    let l = 0;
+    let r = 0;
+    for (; r < chunk.length; r++) {
+      const ch = chunk[r];
+      if (this.#escaped) {
+        const escapedChar = ESCAPED_CHARACTERS[ch];
+        if (escapedChar === void 0) {
+          throw new Error(
+            `Unexpected escape character \\${String.fromCharCode(ch)}`
+          );
         }
-        // flush segment
-        l < r && (this.#currVal += chunk.toString('utf8', l, r));
+        this.#currVal += escapedChar;
+        l = r + 1;
+        this.#escaped = false;
+        continue;
+      }
+      switch (ch) {
+        case 92:
+          l < r && (this.#currVal += chunk.toString("utf8", l, r));
+          l = r + 1;
+          this.#escaped = true;
+          break;
+        case 9:
+        // '\t'
+        case 10:
+          l < r && (this.#currVal += chunk.toString("utf8", l, r));
+          l = r + 1;
+          yield this.#currVal === NULL_BYTE ? null : this.#currVal;
+          this.#currVal = "";
+          break;
+      }
     }
+    l < r && (this.#currVal += chunk.toString("utf8", l, r));
+  }
 }
-// The lone NULL byte signifies that the column value is `null`.
-// (Postgres does not permit NULL bytes in TEXT values).
-//
-// Note that although NULL bytes can appear in JSON strings,
-// those will always be represented within double-quotes,
-// and thus never as a lone NULL byte.
-export const NULL_BYTE = '\u0000';
-// escaped characters used in https://www.postgresql.org/docs/current/sql-copy.html
+const NULL_BYTE = "\0";
 const ESCAPED_CHARACTERS = {
-    0x4e: NULL_BYTE, // \N signifies the NULL character.
-    0x5c: '\\',
-    0x62: '\b',
-    0x66: '\f',
-    0x6e: '\n',
-    0x72: '\r',
-    0x74: '\t',
-    0x76: '\v',
+  78: NULL_BYTE,
+  // \N signifies the NULL character.
+  92: "\\",
+  98: "\b",
+  102: "\f",
+  110: "\n",
+  114: "\r",
+  116: "	",
+  118: "\v"
+};
+export {
+  NULL_BYTE,
+  TsvParser
 };
-//# sourceMappingURL=pg-copy.js.map
+//# sourceMappingURL=pg-copy.js.map

package/out/zero-cache/src/db/pg-copy.js.map

@@ -1 +1 @@
-{"version":3,"file":"pg-copy.js","sourceRoot":"","sources":["../../../../../zero-cache/src/db/pg-copy.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"pg-copy.js","sources":["../../../../../zero-cache/src/db/pg-copy.ts"],"sourcesContent":["import {Transform} from 'node:stream';\n\n/**\n * A stream Transform that parses a Postgres `COPY ... TO` text stream into\n * individual text values. The special {@link NULL_BYTE} string is used to\n * indicate a `null` value (as the `null` value itself indicates the end of\n * the stream and cannot be pushed as an element).\n *\n * Note that the transform assumes that the next step of the pipeline\n * understands the cardinality of values per row and does not push any\n * special value when reaching the end of a row.\n */\nexport class TextTransform extends Transform {\n  readonly #parser = new TsvParser();\n\n  constructor() {\n    super({objectMode: true});\n  }\n\n  _transform(\n    chunk: Buffer,\n    _encoding: BufferEncoding,\n    callback: (e?: Error) => void,\n  ) {\n    try {\n      for (const value of this.#parser.parse(chunk)) {\n        this.push(value === null ? NULL_BYTE : value);\n      }\n      callback();\n    } catch (e) {\n      callback(e instanceof Error ? e : new Error(String(e)));\n    }\n  }\n}\n\n/**\n * Parsing a stream of tab-separated values from a Postgres `COPY` command.\n * The object keeps state and should be reused across chunks of a stream in\n * order to properly recognize that values are split across chunks.\n *\n * Note that `null` values are yielded as `null`. This object does not return\n * the {@link NULL_BYTE} string.\n */\nexport class TsvParser {\n  #currVal: string = '';\n  #escaped = false;\n\n  *parse(chunk: Buffer): Iterable<string | null> {\n    let l = 0;\n    let r = 0;\n\n    for (; r < chunk.length; r++) {\n      const ch = chunk[r];\n      if (this.#escaped) {\n        const escapedChar = ESCAPED_CHARACTERS[ch];\n        if (escapedChar === undefined) {\n          throw new Error(\n            `Unexpected escape character \\\\${String.fromCharCode(ch)}`,\n          );\n        }\n        this.#currVal += escapedChar;\n        l = r + 1;\n        this.#escaped = false;\n        continue;\n      }\n      switch (ch) {\n        case 0x5c: // '\\'\n          // flush segment\n          l < r && (this.#currVal += chunk.toString('utf8', l, r));\n          l = r + 1;\n          this.#escaped = true;\n          break;\n\n        case 0x09: // '\\t'\n        case 0x0a: // '\\n'\n          // flush segment\n          l < r && (this.#currVal += chunk.toString('utf8', l, r));\n          l = r + 1;\n\n          // Value is done in both cases.\n          yield this.#currVal === NULL_BYTE ? null : this.#currVal;\n          this.#currVal = '';\n          break;\n      }\n    }\n    // flush segment\n    l < r && (this.#currVal += chunk.toString('utf8', l, r));\n  }\n}\n\n// The lone NULL byte signifies that the column value is `null`.\n// (Postgres does not permit NULL bytes in TEXT values).\n//\n// Note that although NULL bytes can appear in JSON strings,\n// those will always be represented within double-quotes,\n// and thus never as a lone NULL byte.\nexport const NULL_BYTE = '\\u0000';\n\n// escaped characters used in https://www.postgresql.org/docs/current/sql-copy.html\nconst ESCAPED_CHARACTERS: Record<number, string | undefined> = {\n  0x4e: NULL_BYTE, // \\N signifies the NULL character.\n  0x5c: '\\\\',\n  0x62: '\\b',\n  0x66: '\\f',\n  0x6e: '\\n',\n  0x72: '\\r',\n  0x74: '\\t',\n  0x76: '\\v',\n} as const;\n"],"names":[],"mappings":"AA2CO,MAAM,UAAU;AAAA,EACrB,WAAmB;AAAA,EACnB,WAAW;AAAA,EAEX,CAAC,MAAM,OAAwC;AAC7C,QAAI,IAAI;AACR,QAAI,IAAI;AAER,WAAO,IAAI,MAAM,QAAQ,KAAK;AAC5B,YAAM,KAAK,MAAM,CAAC;AAClB,UAAI,KAAK,UAAU;AACjB,cAAM,cAAc,mBAAmB,EAAE;AACzC,YAAI,gBAAgB,QAAW;AAC7B,gBAAM,IAAI;AAAA,YACR,iCAAiC,OAAO,aAAa,EAAE,CAAC;AAAA,UAAA;AAAA,QAE5D;AACA,aAAK,YAAY;AACjB,YAAI,IAAI;AACR,aAAK,WAAW;AAChB;AAAA,MACF;AACA,cAAQ,IAAA;AAAA,QACN,KAAK;AAEH,cAAI,MAAM,KAAK,YAAY,MAAM,SAAS,QAAQ,GAAG,CAAC;AACtD,cAAI,IAAI;AACR,eAAK,WAAW;AAChB;AAAA,QAEF,KAAK;AAAA;AAAA,QACL,KAAK;AAEH,cAAI,MAAM,KAAK,YAAY,MAAM,SAAS,QAAQ,GAAG,CAAC;AACtD,cAAI,IAAI;AAGR,gBAAM,KAAK,aAAa,YAAY,OAAO,KAAK;AAChD,eAAK,WAAW;AAChB;AAAA,MAAA;AAAA,IAEN;AAEA,QAAI,MAAM,KAAK,YAAY,MAAM,SAAS,QAAQ,GAAG,CAAC;AAAA,EACxD;AACF;AAQO,MAAM,YAAY;AAGzB,MAAM,qBAAyD;AAAA,EAC7D,IAAM;AAAA;AAAA,EACN,IAAM;AAAA,EACN,IAAM;AAAA,EACN,KAAM;AAAA,EACN,KAAM;AAAA,EACN,KAAM;AAAA,EACN,KAAM;AAAA,EACN,KAAM;AACR;"}