@rocicorp/zero 0.26.1 → 0.26.2-canary.1

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

@@ -1,106 +1,58 @@
 import { assert } from "../../../shared/src/asserts.js";
+import { parse, valita_exports } from "../../../shared/src/valita.js";
 import { must } from "../../../shared/src/must.js";
-import { parse } from "../../../shared/src/valita.js";
 import "../types/pg.js";
 import { runTx } from "./run-transaction.js";
-import { object, number } from "@badrap/valita";
+//#region ../zero-cache/src/db/migration.ts
+/**
+* Ensures that the schema is compatible with the current code, updating and
+* migrating the schema if necessary.
+*/
 async function runSchemaMigrations(log, debugName, schemaName, db, setupMigration, incrementalMigrationMap) {
-  log = log.withContext("initSchema", schemaName);
-  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}`
-  );
-  try {
-    await runTx(db, async (tx) => {
-      const lockName = `migrate-schema:${schemaName}`;
-      await tx`SELECT pg_advisory_xact_lock(hashtext(${lockName}))`;
-      let 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}`
-        );
-        await updateVersionHistory(log, tx, schemaName, versions, codeVersion);
-        return;
-      }
-      if (versions.dataVersion === codeVersion) {
-        return;
-      }
-      const migrations = versions.dataVersion === 0 ? (
-        // For an 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 runMigration(
-            log,
-            schemaName,
-            tx,
-            versions,
-            dest,
-            migration
-          );
-        }
-      }
-    });
-    log.info?.(`Running ${debugName} at schema v${codeVersion}`);
-  } catch (e) {
-    log.error?.("Error in ensureSchemaMigrated", e);
-    throw e;
-  } finally {
-    void log.flush();
-  }
+	log = log.withContext("initSchema", schemaName);
+	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}`);
+	try {
+		await runTx(db, async (tx) => {
+			await tx`SELECT pg_advisory_xact_lock(hashtext(${`migrate-schema:${schemaName}`}))`;
+			let 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}`);
+				await updateVersionHistory(log, tx, schemaName, versions, codeVersion);
+				return;
+			}
+			if (versions.dataVersion === codeVersion) return;
+			const migrations = versions.dataVersion === 0 ? [[codeVersion, setupMigration]] : versionMigrations;
+			for (const [dest, migration] of migrations) if (versions.dataVersion < dest) {
+				log.info?.(`Migrating schema from v${versions.dataVersion} to v${dest}`);
+				log.flush();
+				versions = await runMigration(log, schemaName, tx, versions, dest, migration);
+			}
+		});
+		log.info?.(`Running ${debugName} at schema v${codeVersion}`);
+	} catch (e) {
+		log.error?.("Error in ensureSchemaMigrated", e);
+		throw e;
+	} finally {
+		log.flush();
+	}
 }
 function sorted(incrementalMigrationMap) {
-  const versionMigrations = [];
-  for (const [v2, m] of Object.entries(incrementalMigrationMap)) {
-    versionMigrations.push([Number(v2), m]);
-  }
-  return versionMigrations.sort(([a], [b]) => a - b);
+	const versionMigrations = [];
+	for (const [v, m] of Object.entries(incrementalMigrationMap)) versionMigrations.push([Number(v), m]);
+	return versionMigrations.sort(([a], [b]) => a - b);
 }
-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()
+var versionHistory = valita_exports.object({
+	schemaVersion: valita_exports.number(),
+	dataVersion: valita_exports.number(),
+	minSafeVersion: valita_exports.number()
 });
 async function createVersionHistoryTable(sql, schemaName) {
-  await sql`
+	await sql`
     CREATE SCHEMA IF NOT EXISTS ${sql(schemaName)};
     CREATE TABLE IF NOT EXISTS ${sql(schemaName)}."versionHistory" (
       "dataVersion" int NOT NULL,
@@ -113,77 +65,56 @@ 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));
 }
 async function getVersionHistory(sql, schemaName, create = false) {
-  const exists = await sql`
+	if ((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;
-    }
-  }
-  const rows = await sql`
+    WHERE nspname = ${schemaName} AND relname = ${"versionHistory"}`).length === 0) if (create) await createVersionHistoryTable(sql, schemaName);
+	else return null;
+	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 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, "newVersion must be positive");
-  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, "newVersion must be positive");
+	const versions = {
+		dataVersion: newVersion,
+		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 === 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;
+	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;
 }
-export {
-  createVersionHistoryTable,
-  getVersionHistory,
-  runSchemaMigrations,
-  versionHistory
-};
-//# sourceMappingURL=migration.js.map
+//#endregion
+export { getVersionHistory, runSchemaMigrations };
+
+//# sourceMappingURL=migration.js.map

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

@@ -1 +1 @@
-{"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 {type PostgresDB, type PostgresTransaction} from '../types/pg.ts';\nimport {runTx} from './run-transaction.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\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\n  log.info?.(\n    `Checking schema for compatibility with ${debugName} at schema v${codeVersion}`,\n  );\n\n  try {\n    await runTx(db, async tx => {\n      // Acquire advisory lock to prevent concurrent migrations from racing.\n      // This can happen during rolling deployments when multiple pods start\n      // up simultaneously. The lock auto-releases when the transaction ends.\n      const lockName = `migrate-schema:${schemaName}`;\n      await tx`SELECT pg_advisory_xact_lock(hashtext(${lockName}))`;\n\n      let versions = await ensureVersionHistory(tx, schemaName);\n\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        await updateVersionHistory(log, tx, schemaName, versions, codeVersion);\n        return;\n      }\n\n      if (versions.dataVersion === codeVersion) {\n        return;\n      }\n\n      const migrations =\n        versions.dataVersion === 0\n          ? // For an 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();\n          versions = await runMigration(\n            log,\n            schemaName,\n            tx,\n            versions,\n            dest,\n            migration,\n          );\n        }\n      }\n    });\n\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();\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, 'newVersion must be positive');\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":["v","v.object","v.number","v.parse"],"mappings":"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"}
+{"version":3,"file":"migration.js","names":[],"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 {type PostgresDB, type PostgresTransaction} from '../types/pg.ts';\nimport {runTx} from './run-transaction.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\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\n  log.info?.(\n    `Checking schema for compatibility with ${debugName} at schema v${codeVersion}`,\n  );\n\n  try {\n    await runTx(db, async tx => {\n      // Acquire advisory lock to prevent concurrent migrations from racing.\n      // This can happen during rolling deployments when multiple pods start\n      // up simultaneously. The lock auto-releases when the transaction ends.\n      const lockName = `migrate-schema:${schemaName}`;\n      await tx`SELECT pg_advisory_xact_lock(hashtext(${lockName}))`;\n\n      let versions = await ensureVersionHistory(tx, schemaName);\n\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        await updateVersionHistory(log, tx, schemaName, versions, codeVersion);\n        return;\n      }\n\n      if (versions.dataVersion === codeVersion) {\n        return;\n      }\n\n      const migrations =\n        versions.dataVersion === 0\n          ? // For an 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();\n          versions = await runMigration(\n            log,\n            schemaName,\n            tx,\n            versions,\n            dest,\n            migration,\n          );\n        }\n      }\n    });\n\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();\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, 'newVersion must be positive');\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"],"mappings":"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"}

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

@@ -1,9 +1,8 @@
-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
+//#region ../zero-cache/src/db/mode-enum.ts
+var SERIALIZABLE = "ISOLATION LEVEL SERIALIZABLE";
+var READ_COMMITTED = "ISOLATION LEVEL READ COMMITTED";
+var READONLY = "ISOLATION LEVEL REPEATABLE READ READ ONLY";
+//#endregion
+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","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;"}
+{"version":3,"file":"mode-enum.js","names":[],"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"],"mappings":";AAAA,IAAa,eAAe;AAC5B,IAAa,iBAAiB;AAC9B,IAAa,WAAW"}

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

@@ -1,56 +1,58 @@
-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)}`
-          );
-        }
-        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));
-  }
-}
-const NULL_BYTE = "\0";
-const ESCAPED_CHARACTERS = {
-  78: NULL_BYTE,
-  // \N signifies the NULL character.
-  92: "\\",
-  98: "\b",
-  102: "\f",
-  110: "\n",
-  114: "\r",
-  116: "	",
-  118: "\v"
+import "node:stream";
+//#region ../zero-cache/src/db/pg-copy.ts
+/**
+* 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.
+*/
+var TsvParser = class {
+	#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)}`);
+				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:
+				case 10:
+					l < r && (this.#currVal += chunk.toString("utf8", l, r));
+					l = r + 1;
+					yield this.#currVal === "\0" ? null : this.#currVal;
+					this.#currVal = "";
+					break;
+			}
+		}
+		l < r && (this.#currVal += chunk.toString("utf8", l, r));
+	}
 };
-export {
-  NULL_BYTE,
-  TsvParser
+var ESCAPED_CHARACTERS = {
+	78: "\0",
+	92: "\\",
+	98: "\b",
+	102: "\f",
+	110: "\n",
+	114: "\r",
+	116: "	",
+	118: "\v"
 };
-//# sourceMappingURL=pg-copy.js.map
+//#endregion
+export { TsvParser };
+
+//# sourceMappingURL=pg-copy.js.map

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

@@ -1 +1 @@
-{"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;"}
+{"version":3,"file":"pg-copy.js","names":["#parser","#escaped","#currVal"],"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"],"mappings":";;;;;;;;;;AA2CA,IAAa,YAAb,MAAuB;CACrB,WAAmB;CACnB,WAAW;CAEX,CAAC,MAAM,OAAwC;EAC7C,IAAI,IAAI;EACR,IAAI,IAAI;AAER,SAAO,IAAI,MAAM,QAAQ,KAAK;GAC5B,MAAM,KAAK,MAAM;AACjB,OAAI,MAAA,SAAe;IACjB,MAAM,cAAc,mBAAmB;AACvC,QAAI,gBAAgB,KAAA,EAClB,OAAM,IAAI,MACR,iCAAiC,OAAO,aAAa,GAAG,GACzD;AAEH,UAAA,WAAiB;AACjB,QAAI,IAAI;AACR,UAAA,UAAgB;AAChB;;AAEF,WAAQ,IAAR;IACE,KAAK;AAEH,SAAI,MAAM,MAAA,WAAiB,MAAM,SAAS,QAAQ,GAAG,EAAE;AACvD,SAAI,IAAI;AACR,WAAA,UAAgB;AAChB;IAEF,KAAK;IACL,KAAK;AAEH,SAAI,MAAM,MAAA,WAAiB,MAAM,SAAS,QAAQ,GAAG,EAAE;AACvD,SAAI,IAAI;AAGR,WAAM,MAAA,YAAA,OAA8B,OAAO,MAAA;AAC3C,WAAA,UAAgB;AAChB;;;AAIN,MAAI,MAAM,MAAA,WAAiB,MAAM,SAAS,QAAQ,GAAG,EAAE;;;AAa3D,IAAM,qBAAyD;CAC7D,IAAA;CACA,IAAM;CACN,IAAM;CACN,KAAM;CACN,KAAM;CACN,KAAM;CACN,KAAM;CACN,KAAM;CACP"}