@zintrust/core 3.4.0 → 3.5.1

package/src/cli/d1/D1SchemaState.ts

@@ -0,0 +1,343 @@
+type ColumnState = { name: string; type: string };
+type TableState = { name: string; columns: ColumnState[] };
+type ObjectState = { name: string; table: string };
+
+export type SchemaState = {
+  tables: Map<string, TableState>;
+  indexes: Map<string, ObjectState>;
+  triggers: Map<string, ObjectState>;
+};
+
+type Ident = { name: string; rest: string };
+type Row = Record<string, unknown>;
+
+const IDENT_PATTERN = /^("(?:[^"]|"")+"|`[^`]+`|\[[^\]]+\]|[A-Za-z_][\w$]*)\s*/;
+const IF_NOT_EXISTS = /^IF\s+NOT\s+EXISTS\s+/i;
+const IF_EXISTS = /^IF\s+EXISTS\s+/i;
+const TABLE_CONSTRAINT = /^(?:CONSTRAINT|PRIMARY|UNIQUE|CHECK|FOREIGN)\b/i;
+const COLUMN_KEYWORDS = new Set([
+  'constraint',
+  'primary',
+  'not',
+  'null',
+  'unique',
+  'check',
+  'default',
+  'collate',
+  'references',
+  'generated',
+  'as',
+]);
+const QUOTE_CLOSERS = new Map<string, string>([
+  ['"', '"'],
+  ["'", "'"],
+  ['`', '`'],
+  ['[', ']'],
+]);
+
+const keyOf = (name: string): string => name.toLowerCase();
+
+const readIdent = (text: string): Ident | null => {
+  const m = IDENT_PATTERN.exec(text);
+  if (m === null) return null;
+  const raw = m[1];
+  const quoted = raw.startsWith('"') || raw.startsWith('`') || raw.startsWith('[');
+  const name = quoted ? raw.slice(1, -1).replaceAll('""', '"') : raw;
+  return { name, rest: text.slice(m[0].length) };
+};
+
+const skipPrefix = (text: string, pattern: RegExp): { matched: boolean; rest: string } => {
+  const m = pattern.exec(text);
+  return m === null
+    ? { matched: false, rest: text }
+    : { matched: true, rest: text.slice(m[0].length) };
+};
+
+const readParenBody = (text: string): string | null => {
+  const open = text.indexOf('(');
+  const close = text.lastIndexOf(')');
+  if (open === -1 || close <= open) return null;
+  return text.slice(open + 1, close);
+};
+
+const splitTopLevel = (body: string): string[] => {
+  const parts: string[] = [];
+  let depth = 0;
+  let closer: string | null = null;
+  let current = '';
+
+  for (const ch of body) {
+    if (closer !== null) {
+      if (ch === closer) closer = null;
+    } else if (QUOTE_CLOSERS.has(ch)) {
+      closer = QUOTE_CLOSERS.get(ch) ?? null;
+    } else if (ch === '(') {
+      depth += 1;
+    } else if (ch === ')') {
+      depth -= 1;
+    } else if (ch === ',' && depth === 0) {
+      parts.push(current.trim());
+      current = '';
+      continue;
+    }
+    current += ch;
+  }
+
+  if (current.trim() !== '') parts.push(current.trim());
+  return parts;
+};
+
+const parseColumn = (definition: string): ColumnState | null => {
+  if (TABLE_CONSTRAINT.test(definition)) return null;
+  const ident = readIdent(definition);
+  if (ident === null) return null;
+
+  const word = /^([A-Za-z_]\w*)/.exec(ident.rest)?.[1] ?? '';
+  const type = word !== '' && !COLUMN_KEYWORDS.has(word.toLowerCase()) ? word : '';
+  return { name: ident.name, type };
+};
+
+const parseColumns = (body: string): ColumnState[] =>
+  splitTopLevel(body)
+    .map((definition) => parseColumn(definition))
+    .filter((column): column is ColumnState => column !== null);
+
+const parseVirtualColumns = (body: string): ColumnState[] =>
+  splitTopLevel(body)
+    .filter((arg) => !arg.includes('='))
+    .flatMap((arg) => {
+      const ident = readIdent(arg);
+      return ident === null ? [] : [{ name: ident.name, type: '' }];
+    });
+
+const deleteObjectsOf = (objects: Map<string, ObjectState>, table: string): void => {
+  for (const [key, object] of objects) {
+    if (object.table === table) objects.delete(key);
+  }
+};
+
+const renameTable = (state: SchemaState, fromKey: string, toName: string): void => {
+  const table = state.tables.get(fromKey);
+  if (table === undefined) return;
+
+  const toKey = keyOf(toName);
+  state.tables.delete(fromKey);
+  state.tables.set(toKey, { name: toName, columns: table.columns });
+
+  for (const object of [...state.indexes.values(), ...state.triggers.values()]) {
+    if (object.table === fromKey) object.table = toKey;
+  }
+};
+
+const applyCreateTable = (state: SchemaState, text: string): void => {
+  const { matched: ifNotExists, rest } = skipPrefix(text, IF_NOT_EXISTS);
+  const ident = readIdent(rest);
+  if (ident === null) return;
+
+  const key = keyOf(ident.name);
+  if (ifNotExists && state.tables.has(key)) return;
+
+  const body = ident.rest.trimStart().startsWith('(') ? readParenBody(ident.rest) : null;
+  state.tables.set(key, {
+    name: ident.name,
+    columns: body === null ? [] : parseColumns(body),
+  });
+};
+
+const applyCreateVirtualTable = (state: SchemaState, text: string): void => {
+  const { matched: ifNotExists, rest } = skipPrefix(text, IF_NOT_EXISTS);
+  const ident = readIdent(rest);
+  if (ident === null) return;
+
+  const key = keyOf(ident.name);
+  if (ifNotExists && state.tables.has(key)) return;
+
+  const body = readParenBody(ident.rest);
+  state.tables.set(key, {
+    name: ident.name,
+    columns: body === null ? [] : parseVirtualColumns(body),
+  });
+};
+
+const applyCreateIndex = (state: SchemaState, text: string): void => {
+  const { matched: ifNotExists, rest } = skipPrefix(text, IF_NOT_EXISTS);
+  const index = readIdent(rest);
+  if (index === null) return;
+
+  const on = skipPrefix(index.rest, /^ON\s+/i);
+  const table = on.matched ? readIdent(on.rest) : null;
+  if (table === null) return;
+
+  const key = keyOf(index.name);
+  if (ifNotExists && state.indexes.has(key)) return;
+  state.indexes.set(key, { name: index.name, table: keyOf(table.name) });
+};
+
+const applyCreateTrigger = (state: SchemaState, text: string): void => {
+  const { matched: ifNotExists, rest } = skipPrefix(text, IF_NOT_EXISTS);
+  const trigger = readIdent(rest);
+  if (trigger === null) return;
+
+  const onMatch = /\bON\s+/i.exec(trigger.rest);
+  if (onMatch === null) return;
+  const table = readIdent(trigger.rest.slice(onMatch.index + onMatch[0].length));
+  if (table === null) return;
+
+  const key = keyOf(trigger.name);
+  if (ifNotExists && state.triggers.has(key)) return;
+  state.triggers.set(key, { name: trigger.name, table: keyOf(table.name) });
+};
+
+const applyCreate = (state: SchemaState, sql: string): void => {
+  const virtual = /^CREATE\s+VIRTUAL\s+TABLE\s+/i.exec(sql);
+  if (virtual !== null) return applyCreateVirtualTable(state, sql.slice(virtual[0].length));
+
+  const table = /^CREATE\s+(?:TEMP(?:ORARY)?\s+)?TABLE\s+/i.exec(sql);
+  if (table !== null) return applyCreateTable(state, sql.slice(table[0].length));
+
+  const index = /^CREATE\s+(?:UNIQUE\s+)?INDEX\s+/i.exec(sql);
+  if (index !== null) return applyCreateIndex(state, sql.slice(index[0].length));
+
+  const trigger = /^CREATE\s+(?:TEMP(?:ORARY)?\s+)?TRIGGER\s+/i.exec(sql);
+  if (trigger !== null) return applyCreateTrigger(state, sql.slice(trigger[0].length));
+};
+
+const applyAlter = (state: SchemaState, sql: string): void => {
+  const prefix = /^ALTER\s+TABLE\s+/i.exec(sql);
+  if (prefix === null) return;
+
+  const ident = readIdent(sql.slice(prefix[0].length));
+  if (ident === null) return;
+
+  const key = keyOf(ident.name);
+  const table = state.tables.get(key);
+  const action = ident.rest;
+
+  const add = /^ADD\s+(?:COLUMN\s+)?/i.exec(action);
+  if (add !== null) {
+    const column = parseColumn(action.slice(add[0].length));
+    if (table === undefined || column === null) return;
+    const exists = table.columns.some((c) => keyOf(c.name) === keyOf(column.name));
+    if (!exists) table.columns.push(column);
+    return;
+  }
+
+  const drop = /^DROP\s+(?:COLUMN\s+)?/i.exec(action);
+  if (drop !== null) {
+    const column = readIdent(action.slice(drop[0].length));
+    if (table === undefined || column === null) return;
+    const columnKey = keyOf(column.name);
+    table.columns = table.columns.filter((c) => keyOf(c.name) !== columnKey);
+    return;
+  }
+
+  const renameTo = /^RENAME\s+TO\s+/i.exec(action);
+  if (renameTo !== null) {
+    const target = readIdent(action.slice(renameTo[0].length));
+    if (target !== null) renameTable(state, key, target.name);
+  }
+};
+
+const applyDrop = (state: SchemaState, sql: string): void => {
+  const prefix = /^DROP\s+(TABLE|INDEX|TRIGGER)\s+/i.exec(sql);
+  if (prefix === null) return;
+
+  const { rest } = skipPrefix(sql.slice(prefix[0].length), IF_EXISTS);
+  const ident = readIdent(rest);
+  if (ident === null) return;
+
+  const key = keyOf(ident.name);
+  const kind = prefix[1].toUpperCase();
+
+  if (kind === 'TABLE') {
+    state.tables.delete(key);
+    deleteObjectsOf(state.indexes, key);
+    deleteObjectsOf(state.triggers, key);
+  } else if (kind === 'INDEX') {
+    state.indexes.delete(key);
+  } else {
+    state.triggers.delete(key);
+  }
+};
+
+const createSchemaState = (): SchemaState => ({
+  tables: new Map(),
+  indexes: new Map(),
+  triggers: new Map(),
+});
+
+const applyDdl = (state: SchemaState, sql: string): void => {
+  const statement = sql.trim();
+  if (/^CREATE\b/i.test(statement)) applyCreate(state, statement);
+  else if (/^ALTER\b/i.test(statement)) applyAlter(state, statement);
+  else if (/^DROP\b/i.test(statement)) applyDrop(state, statement);
+};
+
+/**
+ * Answers the introspection queries migrations use to decide whether to skip work, using the
+ * schema produced by the DDL captured so far. Returns null for any other statement.
+ */
+const introspect = (state: SchemaState, sql: string, parameters: unknown[]): Row[] | null => {
+  const statement = sql.trim();
+
+  const tableInfo = /^PRAGMA\s+table_info\s*\((.*)\)$/i.exec(statement);
+  if (tableInfo !== null) {
+    const table = readIdent(tableInfo[1].trim());
+    if (table === null) return [];
+    const columns = state.tables.get(keyOf(table.name))?.columns ?? [];
+    return columns.map((column, cid) => ({
+      cid,
+      name: column.name,
+      type: column.type,
+      notnull: 0,
+      dflt_value: null,
+      pk: 0,
+    }));
+  }
+
+  const indexList = /^PRAGMA\s+index_list\s*\((.*)\)$/i.exec(statement);
+  if (indexList !== null) {
+    const table = readIdent(indexList[1].trim());
+    if (table === null) return [];
+    const key = keyOf(table.name);
+    return [...state.indexes.values()]
+      .filter((index) => index.table === key)
+      .map((index, seq) => ({ seq, name: index.name, unique: 0, origin: 'c', partial: 0 }));
+  }
+
+  if (
+    /^SELECT\s+1\s+FROM\s+sqlite_master\s+WHERE\s+type\s*=\s*'table'\s+AND\s+name\s*=\s*\?/i.test(
+      statement
+    )
+  ) {
+    const exists = state.tables.has(keyOf(String(parameters[0] ?? '')));
+    return exists ? [{ 1: 1 }] : [];
+  }
+
+  if (
+    /^SELECT\s+name\s+FROM\s+sqlite_master\s+WHERE\s+type\s*=\s*'trigger'\s+AND\s+name\s+IN\s*\(/i.test(
+      statement
+    )
+  ) {
+    const wanted = new Set(parameters.map((value) => keyOf(String(value))));
+    return [...state.triggers.values()]
+      .filter((trigger) => wanted.has(keyOf(trigger.name)))
+      .map((trigger) => ({ name: trigger.name }));
+  }
+
+  if (
+    /^SELECT\s+name\s+FROM\s+sqlite_master\s+WHERE\s+type\s*=\s*'table'\s+AND\s+name\s+NOT\s+LIKE\s+'sqlite_%'$/i.test(
+      statement
+    )
+  ) {
+    return [...state.tables.values()].map((table) => ({ name: table.name }));
+  }
+
+  return null;
+};
+
+export const D1SchemaState = Object.freeze({
+  create: createSchemaState,
+  applyDdl,
+  introspect,
+});

package/src/cli/d1/D1SqlMigrations.ts

@@ -0,0 +1,330 @@
+import { D1SchemaState, type SchemaState } from '@cli/d1/D1SchemaState';
+import { ErrorFactory } from '@exceptions/ZintrustError';
+import * as fs from '@node-singletons/fs';
+import * as path from '@node-singletons/path';
+
+import { AdaptersEnum, type SupportedDriver } from '@migrations/enum';
+import { MigrationDiscovery } from '@migrations/MigrationDiscovery';
+import { MigrationLoader } from '@migrations/MigrationLoader';
+import type { LoadedMigration } from '@migrations/types';
+import type { IDatabase } from '@orm/Database';
+import type { DatabaseConfig, IDatabaseAdapter, QueryResult } from '@orm/DatabaseAdapter';
+import { BaseAdapter } from '@orm/DatabaseAdapter';
+
+type D1SqlMigrationsCompileOptions = {
+  projectRoot: string;
+  globalDir: string;
+  extension: string;
+  service?: string;
+  includeGlobal?: boolean;
+  serviceDirOverride?: string;
+  outputDir: string;
+};
+
+type GeneratedSqlMigration = {
+  sourceName: string;
+  outputFileName: string;
+  outputFilePath: string;
+  statements: string[];
+};
+
+const RESOLVED_VOID: Promise<void> = Promise.resolve();
+
+const ensureDir = (dir: string): void => {
+  if (fs.existsSync(dir)) return;
+  fs.mkdirSync(dir, { recursive: true });
+};
+
+const getDefaultOutputFileName = (migrationName: string, index: number): string => {
+  const m = /^(\d+)_(.+)$/.exec(migrationName);
+  if (m !== null) {
+    return `${m[1]}_${m[2]}.sql`;
+  }
+
+  const padded = String(index).padStart(4, '0');
+  return `${padded}_${migrationName}.sql`;
+};
+
+const normalizeSql = (sql: string): string => {
+  const trimmed = sql.trim();
+  if (trimmed === '') return '';
+  return trimmed.endsWith(';') ? trimmed : `${trimmed};`;
+};
+
+const normalizeAlterTableAddColumn = (sql: string): string => {
+  const lowered = sql.trimStart().toLowerCase();
+  if (!lowered.startsWith('alter table')) return sql;
+  if (!/\badd\b/i.test(sql)) return sql;
+  if (/\badd\s+column\b/i.test(sql)) return sql;
+
+  return sql.replace(/\bADD\b\s+(?!COLUMN\b)/i, 'ADD COLUMN ');
+};
+
+const interpolateSql = (sql: string, parameters: unknown[]): string => {
+  const placeholders = (sql.match(/\?/g) ?? []).length;
+  if (placeholders !== parameters.length) {
+    throw ErrorFactory.createValidationError(
+      `Cannot compile parameterized SQL: expected ${placeholders} params but got ${parameters.length}. SQL: ${sql}`
+    );
+  }
+
+  let idx = 0;
+  return sql.replaceAll('?', () => {
+    const value = parameters[idx];
+    idx += 1;
+    return BaseAdapter.sanitize(value);
+  });
+};
+
+const isMutatingSql = (sql: string): boolean => {
+  const s = sql.trimStart().toLowerCase();
+  return (
+    s.startsWith('insert') ||
+    s.startsWith('update') ||
+    s.startsWith('delete') ||
+    s.startsWith('create') ||
+    s.startsWith('drop') ||
+    s.startsWith('alter') ||
+    s.startsWith('replace') ||
+    s.startsWith('pragma')
+  );
+};
+
+const createNoopAdapter = (
+  isConnected: () => boolean,
+  setConnected: (v: boolean) => void
+): IDatabaseAdapter | never => ({
+  async connect(): Promise<void> {
+    setConnected(true);
+    await RESOLVED_VOID;
+  },
+  async disconnect(): Promise<void> {
+    setConnected(false);
+    await RESOLVED_VOID;
+  },
+  async query(): Promise<{ rows: Record<string, unknown>[]; rowCount: number }> {
+    await RESOLVED_VOID;
+    return { rows: [], rowCount: 0 };
+  },
+  async queryOne(): Promise<Record<string, unknown> | null> {
+    await RESOLVED_VOID;
+    return null;
+  },
+  async ping(): Promise<void> {
+    await RESOLVED_VOID;
+  },
+  async transaction<T>(callback: (adapter: IDatabaseAdapter) => Promise<T>): Promise<T> {
+    await RESOLVED_VOID;
+    return callback(this);
+  },
+  async rawQuery<T = unknown>(): Promise<T[]> {
+    await RESOLVED_VOID;
+    return [] as T[];
+  },
+  getType(): SupportedDriver {
+    return AdaptersEnum.d1;
+  },
+  isConnected(): boolean {
+    return isConnected();
+  },
+  getPlaceholder(): string {
+    return '?';
+  },
+});
+
+const captureSql = (
+  onSql: (sql: string) => void,
+  schema: SchemaState,
+  sql: string,
+  parameters: unknown[]
+): void => {
+  const compiled = parameters.length > 0 ? interpolateSql(sql, parameters) : sql;
+  D1SchemaState.applyDdl(schema, compiled);
+  if (!isMutatingSql(compiled)) return;
+  const normalized = normalizeSql(normalizeAlterTableAddColumn(compiled));
+  if (normalized !== '') onSql(normalized);
+};
+
+const runSql = (
+  onSql: (sql: string) => void,
+  schema: SchemaState,
+  sql: string,
+  parameters: unknown[]
+): Record<string, unknown>[] => {
+  const introspected = D1SchemaState.introspect(schema, sql, parameters);
+  if (introspected !== null) return introspected;
+  captureSql(onSql, schema, sql, parameters);
+  return [];
+};
+
+const createCaptureDb = (onSql: (sql: string) => void, schema: SchemaState): IDatabase => {
+  let connected = false;
+  const setConnected = (v: boolean): void => {
+    connected = v;
+  };
+
+  const noopAdapter = createNoopAdapter(() => connected, setConnected);
+
+  const db = (<IDatabase>{
+    async connect(): Promise<void> {
+      connected = true;
+      await RESOLVED_VOID;
+    },
+    async disconnect(): Promise<void> {
+      connected = false;
+      await RESOLVED_VOID;
+    },
+    isConnected(): boolean {
+      return connected;
+    },
+    async query(sql: string, parameters: unknown[] = []): Promise<unknown[]> {
+      const rows = runSql(onSql, schema, sql, parameters);
+      await RESOLVED_VOID;
+      return rows;
+    },
+    async queryOne(sql: string, parameters: unknown[] = []): Promise<unknown> {
+      const rows = runSql(onSql, schema, sql, parameters);
+      await RESOLVED_VOID;
+      return rows.length > 0 ? rows[0] : null;
+    },
+    async execute(sql: string, parameters: unknown[] = []): Promise<QueryResult> {
+      captureSql(onSql, schema, sql, parameters);
+      await RESOLVED_VOID;
+      return { rows: [], rowCount: 0 };
+    },
+    raw(value: string): { __raw: string } {
+      return { __raw: value };
+    },
+    async transaction<T>(callback: (db: IDatabase) => Promise<T>): Promise<T> {
+      await RESOLVED_VOID;
+      return callback(this as unknown as IDatabase);
+    },
+    async withReadSession<T>(
+      fn: (db: IDatabase) => Promise<T>
+    ): Promise<{ result: T; bookmark: string | null }> {
+      const result = await fn(this as unknown as IDatabase);
+      return { result, bookmark: null };
+    },
+    table(): never {
+      throw ErrorFactory.createCliError(
+        'D1 SQL compilation does not support QueryBuilder-based migrations yet. Use db.query(...) with explicit SQL.'
+      );
+    },
+    onBeforeQuery(): void {
+      return;
+    },
+    onAfterQuery(): void {
+      return;
+    },
+    offBeforeQuery(): void {
+      return;
+    },
+    offAfterQuery(): void {
+      return;
+    },
+    getAdapterInstance(): IDatabaseAdapter {
+      return noopAdapter;
+    },
+    getType(): string {
+      return AdaptersEnum.d1;
+    },
+    getConfig(): DatabaseConfig {
+      return { driver: AdaptersEnum.d1 };
+    },
+    dispose(): void {
+      // No resources to dispose for capture DB
+    },
+  }) satisfies IDatabase;
+
+  return db;
+};
+
+async function runSerial<T>(
+  items: T[],
+  fn: (item: T, index: number) => Promise<void>
+): Promise<void> {
+  let chain = Promise.resolve();
+  let idx = 0;
+  for (const item of items) {
+    const current = idx;
+    chain = chain.then(async () => fn(item, current));
+    idx += 1;
+  }
+  await chain;
+}
+
+const resolveServiceDir = (opts: D1SqlMigrationsCompileOptions): string | null => {
+  const service = typeof opts.service === 'string' && opts.service.length > 0 ? opts.service : null;
+  if (service === null) return null;
+
+  const rel = opts.serviceDirOverride ?? path.join('services', service, 'database/migrations');
+  return MigrationDiscovery.resolveDir(opts.projectRoot, rel);
+};
+
+const discoverMigrations = async (
+  opts: D1SqlMigrationsCompileOptions
+): Promise<LoadedMigration[]> => {
+  const globalDir = MigrationDiscovery.resolveDir(opts.projectRoot, opts.globalDir);
+  const includeGlobal = opts.includeGlobal !== false;
+
+  const dirs: string[] = [];
+  if (includeGlobal) dirs.push(globalDir);
+
+  const serviceDir = resolveServiceDir(opts);
+  if (serviceDir !== null) dirs.push(serviceDir);
+
+  const files = dirs.flatMap((dir) => MigrationDiscovery.listMigrationFiles(dir, opts.extension));
+
+  const loaded: LoadedMigration[] = [];
+  let chain = Promise.resolve();
+  for (const file of files) {
+    chain = chain.then(async () => {
+      loaded.push(await MigrationLoader.load(file));
+    });
+  }
+  await chain;
+
+  return loaded.sort((a, b) => a.name.localeCompare(b.name));
+};
+
+export const D1SqlMigrations = Object.freeze({
+  async compileAndWrite(opts: D1SqlMigrationsCompileOptions): Promise<GeneratedSqlMigration[]> {
+    const migrations = await discoverMigrations(opts);
+
+    ensureDir(opts.outputDir);
+
+    const out: GeneratedSqlMigration[] = [];
+    const schema = D1SchemaState.create();
+
+    await runSerial(migrations, async (m, idx) => {
+      const statements: string[] = [];
+      const db = createCaptureDb((sql) => statements.push(sql), schema);
+
+      await db.connect();
+      try {
+        await m.up(db);
+      } finally {
+        await db.disconnect();
+      }
+
+      const outputFileName = getDefaultOutputFileName(m.name, idx);
+      const outputFilePath = path.join(opts.outputDir, outputFileName);
+
+      const header = `-- Generated from ${m.name}\n`;
+      const body =
+        statements.length > 0
+          ? `${statements.join('\n')}\n`
+          : '-- No statements: this migration is a no-op for the D1 driver.\n';
+      fs.writeFileSync(outputFilePath, `${header}${body}`, 'utf8');
+
+      out.push({
+        sourceName: m.name,
+        outputFileName,
+        outputFilePath,
+        statements,
+      });
+    });
+
+    return out;
+  },
+});