@zintrust/core 3.5.1 → 3.6.0

package/src/cli/d1/D1SchemaState.ts

@@ -1,343 +0,0 @@
-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

@@ -1,330 +0,0 @@
-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;
-  },
-});