@xopcai/xopc 0.0.286 → 0.0.291

package/dist/src/storage/sqlite/migrations/discover.ts

@@ -1,52 +0,0 @@
-import { existsSync, readdirSync, readFileSync } from 'node:fs';
-import { join } from 'node:path';
-
-import type { SqlMigration } from './types.js';
-
-/** Matches `002_add_notes_index.sql` → target version 2. */
-const MIGRATION_FILENAME = /^(\d{3})_[\w-]+\.sql$/;
-
-export function discoverSqlMigrations(migrationsDir: string): SqlMigration[] {
-  if (!existsSync(migrationsDir)) {
-    return [];
-  }
-
-  const migrations: SqlMigration[] = [];
-  for (const entry of readdirSync(migrationsDir, { withFileTypes: true })) {
-    if (!entry.isFile()) continue;
-    const match = MIGRATION_FILENAME.exec(entry.name);
-    if (!match) continue;
-    const targetVersion = Number.parseInt(match[1]!, 10);
-    if (!Number.isInteger(targetVersion) || targetVersion < 2) {
-      throw new Error(
-        `Invalid SQLite migration filename "${entry.name}" (target version must be >= 2)`,
-      );
-    }
-    migrations.push({
-      targetVersion,
-      filename: entry.name,
-      sql: readFileSync(join(migrationsDir, entry.name), 'utf8'),
-    });
-  }
-
-  migrations.sort((a, b) => a.targetVersion - b.targetVersion);
-  validateMigrationSequence(migrations);
-  return migrations;
-}
-
-export function validateMigrationSequence(migrations: SqlMigration[]): void {
-  for (let index = 0; index < migrations.length; index++) {
-    const expected = index + 2;
-    const actual = migrations[index]!.targetVersion;
-    if (actual !== expected) {
-      throw new Error(
-        `SQLite migration sequence gap: expected migration to version ${expected}, ` +
-          `found ${migrations[index]!.filename} (v${actual})`,
-      );
-    }
-  }
-}
-
-export function listRegisteredMigrationTargets(migrationsDir: string): number[] {
-  return discoverSqlMigrations(migrationsDir).map((migration) => migration.targetVersion);
-}

package/dist/src/storage/sqlite/migrations/errors.ts

@@ -1,32 +0,0 @@
-export class DatabaseSchemaTooNewError extends Error {
-  readonly dbVersion: number;
-  readonly appVersion: number;
-
-  constructor(dbVersion: number, appVersion: number) {
-    super(
-      `xopc database schema version ${dbVersion} is newer than this app supports (${appVersion}). ` +
-        'Upgrade xopc to a newer release or restore xopc.db from backup.',
-    );
-    this.name = 'DatabaseSchemaTooNewError';
-    this.dbVersion = dbVersion;
-    this.appVersion = appVersion;
-  }
-}
-
-export class DatabaseSchemaMigrationGapError extends Error {
-  readonly dbVersion: number;
-  readonly appVersion: number;
-  readonly missingVersion: number;
-
-  constructor(dbVersion: number, appVersion: number, missingVersion: number) {
-    super(
-      `xopc database schema version ${dbVersion} requires migration to v${missingVersion}, ` +
-        `but no migration file is bundled with this app (supports up to v${appVersion}). ` +
-        'Upgrade xopc to a release that includes the missing migration.',
-    );
-    this.name = 'DatabaseSchemaMigrationGapError';
-    this.dbVersion = dbVersion;
-    this.appVersion = appVersion;
-    this.missingVersion = missingVersion;
-  }
-}

package/dist/src/storage/sqlite/migrations/runner.ts

@@ -1,204 +0,0 @@
-import { backupBeforeConversationCutover } from './conversation-backup.js';
-import { chmodSync, existsSync, writeFileSync } from 'node:fs';
-import { dirname, join } from 'node:path';
-import { fileURLToPath } from 'node:url';
-
-import type { DatabaseSync } from 'node:sqlite';
-
-import { createLogger } from '../../../utils/logger.js';
-import { readSchemaVersion, setSchemaVersion } from '../schema-version.js';
-import { migrateConversationUuids, type ConversationMigrationSummary } from './conversation-uuid.js';
-import { discoverSqlMigrations } from './discover.js';
-import {
-  DatabaseSchemaMigrationGapError,
-  DatabaseSchemaTooNewError,
-} from './errors.js';
-import type { ApplyMigrationsOptions, SqlMigration } from './types.js';
-
-const log = createLogger('Sqlite:Migrations');
-
-/** Baseline schema version applied from schema.sql on first open. */
-export const XOPC_DB_BASELINE_SCHEMA_VERSION = 11;
-
-/** Latest schema version this release supports (increment when adding migrations). */
-export const XOPC_DB_SCHEMA_VERSION = 178;
-
-const MODULE_DIR = dirname(fileURLToPath(import.meta.url));
-
-function backupBeforeTaskCutover(db: DatabaseSync, databasePath: string): string {
-  db.exec('PRAGMA wal_checkpoint(FULL)');
-  const backupPath = `${databasePath}.pre-v100-${Date.now()}.bak`;
-  const quotedPath = backupPath.replaceAll("'", "''");
-  db.exec(`VACUUM INTO '${quotedPath}'`);
-  chmodSync(backupPath, 0o600);
-  return backupPath;
-}
-
-function writeMigrationReport(backupPath: string, report: Record<string, unknown>): void {
-  const reportPath = `${backupPath}.report.json`;
-  writeFileSync(reportPath, `${JSON.stringify(report, null, 2)}\n`, { mode: 0o600 });
-}
-
-export function resolveMigrationsDir(override?: string): string {
-  if (override) {
-    return override;
-  }
-  // Packaged Electron gateway bundle: `out/server/index.js` + `out/server/migrations/`.
-  const siblingDir = join(MODULE_DIR, 'migrations');
-  if (existsSync(siblingDir)) {
-    return siblingDir;
-  }
-  // Dev / dist: SQL files live next to `migrations/runner.js`.
-  return MODULE_DIR;
-}
-
-function migrationByTarget(
-  migrations: SqlMigration[],
-  targetVersion: number,
-): SqlMigration | undefined {
-  return migrations.find((migration) => migration.targetVersion === targetVersion);
-}
-
-function applySingleMigration(db: DatabaseSync, migration: SqlMigration): ConversationMigrationSummary | undefined {
-  log.info({ targetVersion: migration.targetVersion, file: migration.filename }, 'Applying SQLite migration');
-  db.exec('BEGIN IMMEDIATE');
-  try {
-    db.exec(migration.sql);
-    const summary = migration.targetVersion === 178 ? migrateConversationUuids(db) : undefined;
-    setSchemaVersion(db, migration.targetVersion);
-    db.exec('COMMIT');
-    return summary;
-  } catch (error) {
-    try {
-      db.exec('ROLLBACK');
-    } catch {
-      /* preserve original error */
-    }
-    const em = error instanceof Error ? error.message : String(error);
-    throw new Error(
-      `SQLite migration to v${migration.targetVersion} (${migration.filename}) failed: ${em}`,
-      { cause: error },
-    );
-  }
-}
-
-/**
- * Apply sequential SQL migrations from (currentVersion + 1) through targetVersion.
- * Each step runs in its own transaction and updates schema_meta on success.
- */
-export function applyPendingMigrations(
-  db: DatabaseSync,
-  options: ApplyMigrationsOptions = {},
-): number {
-  const targetVersion = options.targetVersion ?? XOPC_DB_SCHEMA_VERSION;
-  let currentVersion = readSchemaVersion(db);
-
-  if (currentVersion > targetVersion) {
-    throw new DatabaseSchemaTooNewError(currentVersion, targetVersion);
-  }
-
-  if (currentVersion >= targetVersion) {
-    return currentVersion;
-  }
-
-  const migrations = discoverSqlMigrations(resolveMigrationsDir(options.migrationsDir));
-  let cutoverBackupPath: string | undefined;
-  let conversationSummary: ConversationMigrationSummary | undefined;
-  const fromVersion = currentVersion;
-  const conversationBackup = currentVersion < 178 && targetVersion >= 178 && options.databasePath && options.databasePath !== ':memory:'
-    ? backupBeforeConversationCutover(db, options.databasePath) : undefined;
-
-  while (currentVersion < targetVersion) {
-    const nextVersion = currentVersion + 1;
-    const migration = migrationByTarget(migrations, nextVersion);
-    if (!migration) {
-      throw new DatabaseSchemaMigrationGapError(currentVersion, targetVersion, nextVersion);
-    }
-    if (nextVersion === 100 && options.databasePath && options.databasePath !== ':memory:') {
-      cutoverBackupPath = backupBeforeTaskCutover(db, options.databasePath);
-    }
-    try {
-      conversationSummary = applySingleMigration(db, migration) ?? conversationSummary;
-    } catch (error) {
-      if (cutoverBackupPath && nextVersion === 100) {
-        writeMigrationReport(cutoverBackupPath, {
-          fromVersion: currentVersion,
-          targetVersion: nextVersion,
-          status: 'failed',
-          rollback: 'transaction',
-          error: error instanceof Error ? error.message : String(error),
-          occurredAt: new Date().toISOString(),
-        });
-      }
-      if (conversationBackup) writeMigrationReport(conversationBackup, { fromVersion, targetVersion, failedVersion: nextVersion, status: 'failed', error: error instanceof Error ? error.message : String(error) });
-      throw error;
-    }
-    currentVersion = nextVersion;
-    if (cutoverBackupPath && currentVersion === 100) {
-      writeMigrationReport(cutoverBackupPath, {
-        fromVersion: 99,
-        targetVersion: 100,
-        status: 'succeeded',
-        backupPath: cutoverBackupPath,
-        occurredAt: new Date().toISOString(),
-      });
-    }
-  }
-
-  if (conversationBackup) writeMigrationReport(conversationBackup, { fromVersion, targetVersion, status: 'succeeded', backupPath: conversationBackup, summary: conversationSummary });
-  return currentVersion;
-}
-
-export type SchemaMigrationStatus = {
-  dbVersion: number;
-  appVersion: number;
-  pendingVersions: number[];
-  isTooNew: boolean;
-  hasMigrationGap: boolean;
-  missingVersion: number | null;
-};
-
-/** Inspect schema version without mutating the database. */
-export function inspectSchemaMigrationStatus(
-  db: DatabaseSync,
-  options: Pick<ApplyMigrationsOptions, 'migrationsDir' | 'targetVersion'> = {},
-): SchemaMigrationStatus {
-  const appVersion = options.targetVersion ?? XOPC_DB_SCHEMA_VERSION;
-  const dbVersion = readSchemaVersion(db);
-  const isTooNew = dbVersion > appVersion;
-
-  if (isTooNew) {
-    return {
-      dbVersion,
-      appVersion,
-      pendingVersions: [],
-      isTooNew: true,
-      hasMigrationGap: false,
-      missingVersion: null,
-    };
-  }
-
-  const migrations = discoverSqlMigrations(resolveMigrationsDir(options.migrationsDir));
-  const pendingVersions: number[] = [];
-  let hasMigrationGap = false;
-  let missingVersion: number | null = null;
-
-  for (let version = dbVersion + 1; version <= appVersion; version++) {
-    if (migrationByTarget(migrations, version)) {
-      pendingVersions.push(version);
-    } else {
-      hasMigrationGap = true;
-      missingVersion = version;
-      break;
-    }
-  }
-
-  return {
-    dbVersion,
-    appVersion,
-    pendingVersions,
-    isTooNew: false,
-    hasMigrationGap,
-    missingVersion,
-  };
-}

package/dist/src/storage/sqlite/migrations/types.ts

@@ -1,15 +0,0 @@
-/** One on-disk SQL migration file (target schema version after apply). */
-export type SqlMigration = {
-  targetVersion: number;
-  filename: string;
-  sql: string;
-};
-
-export type ApplyMigrationsOptions = {
-  /** Override migrations directory (tests). Defaults to `<schema-module>/migrations`. */
-  migrationsDir?: string;
-  /** Target schema version. Defaults to {@link XOPC_DB_SCHEMA_VERSION}. */
-  targetVersion?: number;
-  /** Database file path used for mandatory cutover backups. */
-  databasePath?: string;
-};