@rocicorp/zero 0.26.1-canary.9 → 0.26.2-canary.1

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

@@ -1,129 +1,77 @@
 import { assert } from "../../../shared/src/asserts.js";
-import { randInt } from "../../../shared/src/rand.js";
-import "../../../shared/src/valita.js";
+import { valita_exports } from "../../../shared/src/valita.js";
 import { Database } from "../../../zqlite/src/db.js";
-import { object, number } from "@badrap/valita";
+import { randInt } from "../../../shared/src/rand.js";
+//#region ../zero-cache/src/db/migration-lite.ts
+/**
+* Ensures that the schema is compatible with the current code, updating and
+* migrating the schema if necessary.
+*/
 async function runSchemaMigrations(log, debugName, dbPath, setupMigration, incrementalMigrationMap) {
-  const start = Date.now();
-  log = log.withContext(
-    "initSchema",
-    randInt(0, Number.MAX_SAFE_INTEGER).toString(36)
-  );
-  const db = new Database(log, dbPath);
-  try {
-    const versionMigrations = sorted(incrementalMigrationMap);
-    assert(
-      versionMigrations.length,
-      `Must specify a 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 runTransaction(log, db, (tx) => {
-      const versions2 = getVersionHistory(tx);
-      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, versions2, codeVersion);
-      }
-      return versions2;
-    });
-    if (versions.dataVersion < codeVersion) {
-      db.unsafeMode(true);
-      db.pragma("locking_mode = EXCLUSIVE");
-      db.pragma("foreign_keys = OFF");
-      db.pragma("journal_mode = OFF");
-      db.pragma("synchronous = OFF");
-      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 runTransaction(log, db, async (tx) => {
-            let versions2 = getVersionHistory(tx);
-            if (versions2.dataVersion < dest) {
-              versions2 = await runMigration(log, tx, versions2, dest, migration);
-              assert(
-                versions2.dataVersion === dest,
-                () => `Migration did not reach target version: expected ${dest}, got ${versions2.dataVersion}`
-              );
-            }
-            return versions2;
-          });
-        }
-      }
-      db.exec("ANALYZE main");
-      log.info?.("ANALYZE completed");
-    } else {
-      db.pragma("optimize = 0x10002");
-    }
-    db.pragma("synchronous = NORMAL");
-    db.unsafeMode(false);
-    assert(
-      versions.dataVersion === codeVersion,
-      () => `Final dataVersion (${versions.dataVersion}) does not match codeVersion (${codeVersion})`
-    );
-    log.info?.(
-      `Running ${debugName} at schema v${codeVersion} (${Date.now() - start} ms)`
-    );
-  } catch (e) {
-    log.error?.("Error in ensureSchemaMigrated", e);
-    throw e;
-  } finally {
-    db.close();
-    void log.flush();
-  }
+	const start = Date.now();
+	log = log.withContext("initSchema", randInt(0, Number.MAX_SAFE_INTEGER).toString(36));
+	const db = new Database(log, dbPath);
+	try {
+		const versionMigrations = sorted(incrementalMigrationMap);
+		assert(versionMigrations.length, `Must specify a 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 runTransaction(log, db, (tx) => {
+			const versions = getVersionHistory(tx);
+			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, versions, codeVersion);
+			}
+			return versions;
+		});
+		if (versions.dataVersion < codeVersion) {
+			db.unsafeMode(true);
+			db.pragma("locking_mode = EXCLUSIVE");
+			db.pragma("foreign_keys = OFF");
+			db.pragma("journal_mode = OFF");
+			db.pragma("synchronous = OFF");
+			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 runTransaction(log, db, async (tx) => {
+					let versions = getVersionHistory(tx);
+					if (versions.dataVersion < dest) {
+						versions = await runMigration(log, tx, versions, dest, migration);
+						assert(versions.dataVersion === dest, () => `Migration did not reach target version: expected ${dest}, got ${versions.dataVersion}`);
+					}
+					return versions;
+				});
+			}
+			db.exec("ANALYZE main");
+			log.info?.("ANALYZE completed");
+		} else db.pragma("optimize = 0x10002");
+		db.pragma("synchronous = NORMAL");
+		db.unsafeMode(false);
+		assert(versions.dataVersion === codeVersion, () => `Final dataVersion (${versions.dataVersion}) does not match codeVersion (${codeVersion})`);
+		log.info?.(`Running ${debugName} at schema v${codeVersion} (${Date.now() - start} ms)`);
+	} catch (e) {
+		log.error?.("Error in ensureSchemaMigrated", e);
+		throw e;
+	} finally {
+		db.close();
+		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);
 }
-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()
+valita_exports.object({
+	schemaVersion: valita_exports.number(),
+	dataVersion: valita_exports.number(),
+	minSafeVersion: valita_exports.number()
 });
 function getVersionHistory(db) {
-  db.prepare(
-    `
+	db.prepare(`
     CREATE TABLE IF NOT EXISTS "_zero.versionHistory" (
       dataVersion INTEGER NOT NULL,
       schemaVersion INTEGER NOT NULL,
@@ -131,78 +79,62 @@ function getVersionHistory(db) {
 
       lock INTEGER PRIMARY KEY DEFAULT 1 CHECK (lock=1)
     );
-  `
-  ).run();
-  const result = db.prepare(
-    'SELECT dataVersion, schemaVersion, minSafeVersion FROM "_zero.versionHistory"'
-  ).get();
-  return result ?? { dataVersion: 0, schemaVersion: 0, minSafeVersion: 0 };
+  `).run();
+	return db.prepare("SELECT dataVersion, schemaVersion, minSafeVersion FROM \"_zero.versionHistory\"").get() ?? {
+		dataVersion: 0,
+		schemaVersion: 0,
+		minSafeVersion: 0
+	};
 }
 function updateVersionHistory(log, db, prev, newVersion, minSafeVersion) {
-  assert(newVersion > 0, "newVersion must be positive");
-  const meta = {
-    ...prev,
-    dataVersion: newVersion,
-    // The schemaVersion never moves backwards.
-    schemaVersion: Math.max(newVersion, prev.schemaVersion),
-    minSafeVersion: getMinSafeVersion(log, prev, minSafeVersion)
-  };
-  db.prepare(
-    `
+	assert(newVersion > 0, "newVersion must be positive");
+	const meta = {
+		...prev,
+		dataVersion: newVersion,
+		schemaVersion: Math.max(newVersion, prev.schemaVersion),
+		minSafeVersion: getMinSafeVersion(log, prev, minSafeVersion)
+	};
+	db.prepare(`
     INSERT INTO "_zero.versionHistory" (dataVersion, schemaVersion, minSafeVersion, lock)
     VALUES (@dataVersion, @schemaVersion, @minSafeVersion, 1)
     ON CONFLICT (lock) DO UPDATE
     SET dataVersion=@dataVersion,
         schemaVersion=@schemaVersion,
         minSafeVersion=@minSafeVersion
-  `
-  ).run(meta);
-  return meta;
+  `).run(meta);
+	return meta;
 }
 async function runMigration(log, 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,
-    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, 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;
 }
 async function runTransaction(log, db, tx) {
-  db.prepare("BEGIN EXCLUSIVE").run();
-  try {
-    const result = await tx(db);
-    db.prepare("COMMIT").run();
-    return result;
-  } catch (e) {
-    log.error?.("Aborted transaction due to error", e);
-    db.prepare("ROLLBACK").run();
-    throw e;
-  }
+	db.prepare("BEGIN EXCLUSIVE").run();
+	try {
+		const result = await tx(db);
+		db.prepare("COMMIT").run();
+		return result;
+	} catch (e) {
+		log.error?.("Aborted transaction due to error", e);
+		db.prepare("ROLLBACK").run();
+		throw e;
+	}
 }
-export {
-  getVersionHistory,
-  runSchemaMigrations
-};
-//# sourceMappingURL=migration-lite.js.map
+//#endregion
+export { runSchemaMigrations };
+
+//# sourceMappingURL=migration-lite.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"migration-lite.js","sources":["../../../../../zero-cache/src/db/migration-lite.ts"],"sourcesContent":["import type {LogContext} from '@rocicorp/logger';\nimport {assert} from '../../../shared/src/asserts.ts';\nimport {randInt} from '../../../shared/src/rand.ts';\nimport * as v from '../../../shared/src/valita.ts';\nimport type {Database as Db} from '../../../zqlite/src/db.ts';\nimport {Database} from '../../../zqlite/src/db.ts';\n\ntype Operations = (log: LogContext, tx: Db) => Promise<void> | 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  dbPath: string,\n  setupMigration: Migration,\n  incrementalMigrationMap: IncrementalMigrationMap,\n): Promise<void> {\n  const start = Date.now();\n  log = log.withContext(\n    'initSchema',\n    randInt(0, Number.MAX_SAFE_INTEGER).toString(36),\n  );\n  const db = new Database(log, dbPath);\n\n  try {\n    const versionMigrations = sorted(incrementalMigrationMap);\n    assert(\n      versionMigrations.length,\n      `Must specify a 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 runTransaction(log, db, tx => {\n      const versions = getVersionHistory(tx);\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, versions, codeVersion);\n      }\n      return versions;\n    });\n\n    if (versions.dataVersion < codeVersion) {\n      db.unsafeMode(true); // Enables journal_mode = OFF\n      db.pragma('locking_mode = EXCLUSIVE');\n      db.pragma('foreign_keys = OFF');\n      db.pragma('journal_mode = OFF');\n      db.pragma('synchronous = OFF');\n      // Unfortunately, AUTO_VACUUM is not compatible with BEGIN CONCURRENT,\n      // so it is not an option for the replica file.\n      // https://sqlite.org/forum/forumpost/25f183416a\n      // db.pragma('auto_vacuum = INCREMENTAL');\n\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 runTransaction(log, db, async tx => {\n            // Fetch meta from within the transaction to make the migration atomic.\n            let versions = getVersionHistory(tx);\n            if (versions.dataVersion < dest) {\n              versions = await runMigration(log, tx, versions, dest, migration);\n              assert(\n                versions.dataVersion === dest,\n                () =>\n                  `Migration did not reach target version: expected ${dest}, got ${versions.dataVersion}`,\n              );\n            }\n            return versions;\n          });\n        }\n      }\n\n      db.exec('ANALYZE main');\n      log.info?.('ANALYZE completed');\n    } else {\n      // Run optimize whenever opening an sqlite db file as recommended in\n      // https://www.sqlite.org/pragma.html#pragma_optimize\n      // It is important to run the same initialization steps as is done\n      // in the view-syncer (i.e. when preparing database for serving\n      // replication) so that any corruption detected in the view-syncer is\n      // similarly detected in the change-streamer, facilitating an eventual\n      // recovery by resyncing the replica anew.\n      db.pragma('optimize = 0x10002');\n\n      // TODO: Investigate running `integrity_check` or `quick_check` as well,\n      // provided that they are not inordinately expensive on large databases.\n    }\n\n    db.pragma('synchronous = NORMAL');\n    db.unsafeMode(false);\n\n    assert(\n      versions.dataVersion === codeVersion,\n      () =>\n        `Final dataVersion (${versions.dataVersion}) does not match codeVersion (${codeVersion})`,\n    );\n    log.info?.(\n      `Running ${debugName} at schema v${codeVersion} (${\n        Date.now() - start\n      } ms)`,\n    );\n  } catch (e) {\n    log.error?.('Error in ensureSchemaMigrated', e);\n    throw e;\n  } finally {\n    db.close();\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 function getVersionHistory(db: Db): VersionHistory {\n  // Note: The `lock` column transparently ensures that at most one row exists.\n  db.prepare(\n    `\n    CREATE TABLE IF NOT EXISTS \"_zero.versionHistory\" (\n      dataVersion INTEGER NOT NULL,\n      schemaVersion INTEGER NOT NULL,\n      minSafeVersion INTEGER NOT NULL,\n\n      lock INTEGER PRIMARY KEY DEFAULT 1 CHECK (lock=1)\n    );\n  `,\n  ).run();\n  const result = db\n    .prepare(\n      'SELECT dataVersion, schemaVersion, minSafeVersion FROM \"_zero.versionHistory\"',\n    )\n    .get() as VersionHistory;\n  return result ?? {dataVersion: 0, schemaVersion: 0, minSafeVersion: 0};\n}\n\nfunction updateVersionHistory(\n  log: LogContext,\n  db: Db,\n  prev: VersionHistory,\n  newVersion: number,\n  minSafeVersion?: number,\n): VersionHistory {\n  assert(newVersion > 0, 'newVersion must be positive');\n  const meta = {\n    ...prev,\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  db.prepare(\n    `\n    INSERT INTO \"_zero.versionHistory\" (dataVersion, schemaVersion, minSafeVersion, lock)\n    VALUES (@dataVersion, @schemaVersion, @minSafeVersion, 1)\n    ON CONFLICT (lock) DO UPDATE\n    SET dataVersion=@dataVersion,\n        schemaVersion=@schemaVersion,\n        minSafeVersion=@minSafeVersion\n  `,\n  ).run(meta);\n\n  return meta;\n}\n\nasync function runMigration(\n  log: LogContext,\n  tx: Db,\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    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\n// Note: We use a custom transaction wrapper (instead of db.begin(...)) in order\n// to support async operations within the transaction.\nasync function runTransaction<T>(\n  log: LogContext,\n  db: Db,\n  tx: (db: Db) => Promise<T> | T,\n): Promise<T> {\n  db.prepare('BEGIN EXCLUSIVE').run();\n  try {\n    const result = await tx(db);\n    db.prepare('COMMIT').run();\n    return result;\n  } catch (e) {\n    log.error?.('Aborted transaction due to error', e);\n    db.prepare('ROLLBACK').run();\n    throw e;\n  }\n}\n"],"names":["versions","v","v.object","v.number"],"mappings":"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"}
+{"version":3,"file":"migration-lite.js","names":[],"sources":["../../../../../zero-cache/src/db/migration-lite.ts"],"sourcesContent":["import type {LogContext} from '@rocicorp/logger';\nimport {assert} from '../../../shared/src/asserts.ts';\nimport {randInt} from '../../../shared/src/rand.ts';\nimport * as v from '../../../shared/src/valita.ts';\nimport type {Database as Db} from '../../../zqlite/src/db.ts';\nimport {Database} from '../../../zqlite/src/db.ts';\n\ntype Operations = (log: LogContext, tx: Db) => Promise<void> | 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  dbPath: string,\n  setupMigration: Migration,\n  incrementalMigrationMap: IncrementalMigrationMap,\n): Promise<void> {\n  const start = Date.now();\n  log = log.withContext(\n    'initSchema',\n    randInt(0, Number.MAX_SAFE_INTEGER).toString(36),\n  );\n  const db = new Database(log, dbPath);\n\n  try {\n    const versionMigrations = sorted(incrementalMigrationMap);\n    assert(\n      versionMigrations.length,\n      `Must specify a 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 runTransaction(log, db, tx => {\n      const versions = getVersionHistory(tx);\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, versions, codeVersion);\n      }\n      return versions;\n    });\n\n    if (versions.dataVersion < codeVersion) {\n      db.unsafeMode(true); // Enables journal_mode = OFF\n      db.pragma('locking_mode = EXCLUSIVE');\n      db.pragma('foreign_keys = OFF');\n      db.pragma('journal_mode = OFF');\n      db.pragma('synchronous = OFF');\n      // Unfortunately, AUTO_VACUUM is not compatible with BEGIN CONCURRENT,\n      // so it is not an option for the replica file.\n      // https://sqlite.org/forum/forumpost/25f183416a\n      // db.pragma('auto_vacuum = INCREMENTAL');\n\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 runTransaction(log, db, async tx => {\n            // Fetch meta from within the transaction to make the migration atomic.\n            let versions = getVersionHistory(tx);\n            if (versions.dataVersion < dest) {\n              versions = await runMigration(log, tx, versions, dest, migration);\n              assert(\n                versions.dataVersion === dest,\n                () =>\n                  `Migration did not reach target version: expected ${dest}, got ${versions.dataVersion}`,\n              );\n            }\n            return versions;\n          });\n        }\n      }\n\n      db.exec('ANALYZE main');\n      log.info?.('ANALYZE completed');\n    } else {\n      // Run optimize whenever opening an sqlite db file as recommended in\n      // https://www.sqlite.org/pragma.html#pragma_optimize\n      // It is important to run the same initialization steps as is done\n      // in the view-syncer (i.e. when preparing database for serving\n      // replication) so that any corruption detected in the view-syncer is\n      // similarly detected in the change-streamer, facilitating an eventual\n      // recovery by resyncing the replica anew.\n      db.pragma('optimize = 0x10002');\n\n      // TODO: Investigate running `integrity_check` or `quick_check` as well,\n      // provided that they are not inordinately expensive on large databases.\n    }\n\n    db.pragma('synchronous = NORMAL');\n    db.unsafeMode(false);\n\n    assert(\n      versions.dataVersion === codeVersion,\n      () =>\n        `Final dataVersion (${versions.dataVersion}) does not match codeVersion (${codeVersion})`,\n    );\n    log.info?.(\n      `Running ${debugName} at schema v${codeVersion} (${\n        Date.now() - start\n      } ms)`,\n    );\n  } catch (e) {\n    log.error?.('Error in ensureSchemaMigrated', e);\n    throw e;\n  } finally {\n    db.close();\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 function getVersionHistory(db: Db): VersionHistory {\n  // Note: The `lock` column transparently ensures that at most one row exists.\n  db.prepare(\n    `\n    CREATE TABLE IF NOT EXISTS \"_zero.versionHistory\" (\n      dataVersion INTEGER NOT NULL,\n      schemaVersion INTEGER NOT NULL,\n      minSafeVersion INTEGER NOT NULL,\n\n      lock INTEGER PRIMARY KEY DEFAULT 1 CHECK (lock=1)\n    );\n  `,\n  ).run();\n  const result = db\n    .prepare(\n      'SELECT dataVersion, schemaVersion, minSafeVersion FROM \"_zero.versionHistory\"',\n    )\n    .get() as VersionHistory;\n  return result ?? {dataVersion: 0, schemaVersion: 0, minSafeVersion: 0};\n}\n\nfunction updateVersionHistory(\n  log: LogContext,\n  db: Db,\n  prev: VersionHistory,\n  newVersion: number,\n  minSafeVersion?: number,\n): VersionHistory {\n  assert(newVersion > 0, 'newVersion must be positive');\n  const meta = {\n    ...prev,\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  db.prepare(\n    `\n    INSERT INTO \"_zero.versionHistory\" (dataVersion, schemaVersion, minSafeVersion, lock)\n    VALUES (@dataVersion, @schemaVersion, @minSafeVersion, 1)\n    ON CONFLICT (lock) DO UPDATE\n    SET dataVersion=@dataVersion,\n        schemaVersion=@schemaVersion,\n        minSafeVersion=@minSafeVersion\n  `,\n  ).run(meta);\n\n  return meta;\n}\n\nasync function runMigration(\n  log: LogContext,\n  tx: Db,\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    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\n// Note: We use a custom transaction wrapper (instead of db.begin(...)) in order\n// to support async operations within the transaction.\nasync function runTransaction<T>(\n  log: LogContext,\n  db: Db,\n  tx: (db: Db) => Promise<T> | T,\n): Promise<T> {\n  db.prepare('BEGIN EXCLUSIVE').run();\n  try {\n    const result = await tx(db);\n    db.prepare('COMMIT').run();\n    return result;\n  } catch (e) {\n    log.error?.('Aborted transaction due to error', e);\n    db.prepare('ROLLBACK').run();\n    throw e;\n  }\n}\n"],"mappings":"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"}