@zintrust/core 0.1.28 → 0.1.29

package/src/orm/adapters/SQLiteAdapter.ts

@@ -1,314 +0,0 @@
-/* eslint-disable @typescript-eslint/require-await */
-/**
- * SQLite Database Adapter
- * Production Implementation
- */
-
-import { databaseConfig } from '@config/database';
-import { FeatureFlags } from '@config/features';
-import { Logger } from '@config/logger';
-import { ErrorFactory } from '@exceptions/ZintrustError';
-import { AdaptersEnum, type SupportedDriver } from '@migrations/enum';
-import fs from '@node-singletons/fs';
-import * as path from '@node-singletons/path';
-import { performance } from '@node-singletons/perf-hooks';
-import type { DatabaseConfig, IDatabaseAdapter, QueryResult } from '@orm/DatabaseAdapter';
-import { QueryBuilder } from '@orm/QueryBuilder';
-
-type SqliteRunInfo = { changes: number; lastInsertRowid: number | bigint };
-type SqliteStatement = {
-  all: (params?: readonly unknown[]) => unknown[];
-  run: (params?: readonly unknown[]) => SqliteRunInfo;
-};
-type SqliteDatabase = {
-  prepare: (sql: string) => SqliteStatement;
-  pragma: (value: string) => void;
-  close: () => void;
-};
-
-type SqliteIdentifier = string & { readonly __sqliteIdentifier: unique symbol };
-
-const SAFE_SQLITE_IDENTIFIER = /^[A-Za-z_]\w*$/;
-
-const toSqliteIdentifier = (value: string): SqliteIdentifier => {
-  if (!SAFE_SQLITE_IDENTIFIER.test(value)) {
-    throw ErrorFactory.createDatabaseError('Unsafe sqlite identifier');
-  }
-  return value as SqliteIdentifier;
-};
-
-const quoteSqliteIdentifier = (id: SqliteIdentifier): string => {
-  // Safe due to SAFE_SQLITE_IDENTIFIER allowlist.
-  return `"${id}"`;
-};
-
-function isMissingEsmPackage(error: unknown, packageName: string): boolean {
-  if (typeof error !== 'object' || error === null) return false;
-  const maybe = error as { code?: unknown; message?: unknown };
-  const code = typeof maybe.code === 'string' ? maybe.code : '';
-  const message = typeof maybe.message === 'string' ? maybe.message : '';
-  // Some runners/wrappers preserve `code` but sanitize/omit the message.
-  if (code === 'ERR_MODULE_NOT_FOUND' && message.length === 0) return true;
-  if (code === 'ERR_MODULE_NOT_FOUND' && message.includes(`'${packageName}'`)) return true;
-  if (message.includes(`Cannot find package '${packageName}'`)) return true;
-  return false;
-}
-
-async function importSqliteDatabaseConstructor(): Promise<
-  new (filename: string) => SqliteDatabase
-> {
-  try {
-    // Avoid a literal dynamic import so bundlers (e.g. Wrangler/esbuild) don't
-    // try to bundle the native sqlite driver into non-Node targets.
-    const pkg = (globalThis as unknown as { __zintrustSqliteDriver?: string })
-      .__zintrustSqliteDriver;
-    const mod = (await import(pkg ?? 'better-sqlite3')) as unknown as {
-      default?: new (filename: string) => SqliteDatabase;
-    };
-
-    const ctor = (mod as unknown as { default?: unknown }).default;
-    if (typeof ctor === 'function') return ctor as new (filename: string) => SqliteDatabase;
-
-    // Some CJS packages may not present a `default` export under certain loaders.
-    return mod as unknown as new (filename: string) => SqliteDatabase;
-  } catch (error) {
-    if (isMissingEsmPackage(error, 'better-sqlite3')) {
-      throw ErrorFactory.createConfigError(
-        "SQLite adapter requires the 'better-sqlite3' package (run `zin add db:sqlite` or `zin plugin install db:sqlite`)."
-      );
-    }
-
-    throw ErrorFactory.createTryCatchError('Failed to load SQLite driver', { cause: error });
-  }
-}
-
-function normalizeFilename(database: string | null | undefined): string {
-  const value = (database ?? '').trim();
-  return value.length > 0 ? value : ':memory:';
-}
-
-function isSelectQuery(sql: string): boolean {
-  return sql.trimStart().toLowerCase().startsWith('select');
-}
-
-function requireDb(db: SqliteDatabase | null): SqliteDatabase {
-  if (db === null) throw ErrorFactory.createConnectionError('Database not connected');
-  return db;
-}
-
-function executeQuery(
-  db: SqliteDatabase,
-  sql: string,
-  parameters: readonly unknown[]
-): QueryResult {
-  const start = performance.now();
-
-  const stmt = db.prepare(sql);
-  if (isSelectQuery(sql)) {
-    const rows = stmt.all(parameters) as Record<string, unknown>[];
-    if (databaseConfig.logging.enabled) {
-      Logger.debug('SQLite query executed', { durationMs: performance.now() - start, sql });
-    }
-    return { rows, rowCount: rows.length };
-  }
-
-  const info = stmt.run(parameters);
-  if (databaseConfig.logging.enabled) {
-    Logger.debug('SQLite query executed', { durationMs: performance.now() - start, sql });
-  }
-  return { rows: [], rowCount: info.changes, lastInsertId: info.lastInsertRowid };
-}
-
-function executeRawQuery<T>(db: SqliteDatabase, sql: string, parameters: readonly unknown[]): T[] {
-  const stmt = db.prepare(sql);
-  if (isSelectQuery(sql)) return stmt.all(parameters) as T[];
-  stmt.run(parameters);
-  return [];
-}
-
-type SQLiteAdapterState = {
-  db: SqliteDatabase | null;
-  config: DatabaseConfig;
-};
-
-async function connectSQLite(state: SQLiteAdapterState): Promise<void> {
-  if (state.db !== null) return;
-
-  const filename = normalizeFilename(state.config.database);
-
-  // Ensure file-backed sqlite DB directories exist (e.g. .zintrust/dbs/*.sqlite).
-  if (filename !== ':memory:') {
-    try {
-      fs.mkdirSync(path.dirname(filename), { recursive: true });
-    } catch (error) {
-      throw ErrorFactory.createTryCatchError('Failed to create SQLite database directory', {
-        filename,
-        cause: error,
-      });
-    }
-  }
-
-  const SqliteDatabaseCtor = await importSqliteDatabaseConstructor();
-  state.db = new SqliteDatabaseCtor(filename);
-
-  // Enable WAL mode for better concurrency
-  state.db.pragma('journal_mode = WAL');
-
-  Logger.info(`✓ SQLite connected (${filename})`);
-}
-
-async function disconnectSQLite(state: SQLiteAdapterState): Promise<void> {
-  if (state.db === null) return;
-
-  state.db.close();
-  state.db = null;
-  Logger.info('✓ SQLite disconnected');
-}
-
-async function querySQLite(
-  state: SQLiteAdapterState,
-  sql: string,
-  parameters: readonly unknown[]
-): Promise<QueryResult> {
-  const currentDb = requireDb(state.db);
-
-  try {
-    return executeQuery(currentDb, sql, parameters);
-  } catch (error: unknown) {
-    throw ErrorFactory.createTryCatchError('Query failed', { sql, parameters, cause: error });
-  }
-}
-
-async function rawQuerySQLite<T>(
-  state: SQLiteAdapterState,
-  sql: string,
-  parameters: readonly unknown[]
-): Promise<T[]> {
-  if (!FeatureFlags.isRawQueryEnabled()) {
-    throw ErrorFactory.createConfigError('Raw SQL queries are disabled');
-  }
-
-  const currentDb = requireDb(state.db);
-
-  Logger.warn(`Raw SQL Query executed: ${sql}`);
-
-  try {
-    return executeRawQuery<T>(currentDb, sql, parameters);
-  } catch (error: unknown) {
-    throw ErrorFactory.createTryCatchError('Raw query failed', { sql, parameters, cause: error });
-  }
-}
-
-async function transactionSQLite<T>(
-  state: SQLiteAdapterState,
-  adapter: IDatabaseAdapter,
-  callback: (adapter: IDatabaseAdapter, db: SqliteDatabase) => Promise<T>
-): Promise<T> {
-  const currentDb = requireDb(state.db);
-
-  await adapter.query('BEGIN', []);
-  try {
-    const result = await callback(adapter, currentDb);
-    await adapter.query('COMMIT', []);
-    return result;
-  } catch (error: unknown) {
-    await adapter.query('ROLLBACK', []);
-    throw ErrorFactory.createTryCatchError('Transaction failed', { cause: error });
-  }
-}
-
-function createSQLiteAdapter(config: DatabaseConfig): IDatabaseAdapter {
-  const state: SQLiteAdapterState = { db: null, config };
-
-  const adapter: IDatabaseAdapter = {
-    async connect(): Promise<void> {
-      await connectSQLite(state);
-    },
-
-    async disconnect(): Promise<void> {
-      await disconnectSQLite(state);
-    },
-
-    async query(sql: string, parameters: unknown[] = []): Promise<QueryResult> {
-      return querySQLite(state, sql, parameters);
-    },
-
-    async queryOne(
-      sql: string,
-      parameters: unknown[] = []
-    ): Promise<Record<string, unknown> | null> {
-      const result = await adapter.query(sql, parameters);
-      return result.rows[0] ?? null;
-    },
-
-    async ping(): Promise<void> {
-      await adapter.query(QueryBuilder.create('').select('1').toSQL(), []);
-    },
-
-    async transaction<T>(
-      callback: (adapter: IDatabaseAdapter, db: SqliteDatabase) => Promise<T>
-    ): Promise<T> {
-      return transactionSQLite(state, adapter, callback);
-    },
-
-    async rawQuery<T = unknown>(sql: string, parameters: unknown[] = []): Promise<T[]> {
-      return rawQuerySQLite<T>(state, sql, parameters);
-    },
-
-    async ensureMigrationsTable(): Promise<void> {
-      await adapter.query(
-        `CREATE TABLE IF NOT EXISTS migrations (
-          id INTEGER PRIMARY KEY AUTOINCREMENT,
-          name TEXT NOT NULL,
-          scope TEXT NOT NULL DEFAULT 'global',
-          service TEXT NOT NULL DEFAULT '',
-          batch INTEGER NOT NULL,
-          status TEXT NOT NULL,
-          applied_at TEXT NULL,
-          created_at TEXT NOT NULL,
-          UNIQUE(name, scope, service)
-        )`,
-        []
-      );
-    },
-
-    async resetSchema(): Promise<void> {
-      // Best-effort for SQLite.
-      await adapter.query('PRAGMA foreign_keys = OFF', []);
-
-      const tables = (await adapter.query(
-        "SELECT name FROM sqlite_master WHERE type='table' AND name NOT LIKE 'sqlite_%'",
-        []
-      )) as unknown as { rows: Array<{ name?: unknown }> };
-
-      await Promise.all(
-        tables.rows.map(async (t) => {
-          const name = typeof t.name === 'string' ? t.name : '';
-          if (name.length === 0) return;
-          const tableName = toSqliteIdentifier(name);
-          await adapter.query(`DROP TABLE IF EXISTS ${quoteSqliteIdentifier(tableName)}`, []);
-        })
-      );
-
-      await adapter.query('PRAGMA foreign_keys = ON', []);
-    },
-
-    getType(): SupportedDriver {
-      return AdaptersEnum.sqlite;
-    },
-
-    isConnected(): boolean {
-      return Boolean(state.db);
-    },
-
-    getPlaceholder(_index: number): string {
-      return '?';
-    },
-  };
-
-  return adapter;
-}
-
-export const SQLiteAdapter = Object.freeze({
-  create: createSQLiteAdapter,
-});

package/src/orm/maintenance/SqliteMaintenance.ts

@@ -1,22 +0,0 @@
-import { ErrorFactory } from '@exceptions/ZintrustError';
-import type { IDatabase } from '@orm/Database';
-import type { IDatabaseAdapter } from '@orm/DatabaseAdapter';
-
-const supportsResetSchema = (
-  adapter: IDatabaseAdapter
-): adapter is IDatabaseAdapter & { resetSchema: () => Promise<void> } =>
-  typeof adapter.resetSchema === 'function';
-
-export const SqliteMaintenance = Object.freeze({
-  async dropAllTables(db: IDatabase): Promise<void> {
-    if (db.getType() !== 'sqlite') {
-      throw ErrorFactory.createDatabaseError('dropAllTables is only supported for sqlite');
-    }
-
-    const adapter: IDatabaseAdapter = db.getAdapterInstance(false);
-    if (!supportsResetSchema(adapter)) {
-      throw ErrorFactory.createDatabaseError('SQLite adapter does not support resetSchema()');
-    }
-    await adapter.resetSchema();
-  },
-});

package/src/orm/migrations/MigrationStore.ts

@@ -1,232 +0,0 @@
-import { ErrorFactory } from '@exceptions/ZintrustError';
-import type { IDatabase } from '@orm/Database';
-import type { IDatabaseAdapter } from '@orm/DatabaseAdapter';
-import { QueryBuilder } from '@orm/QueryBuilder';
-
-import type { MigrationRecord, MigrationRecordStatus, MigrationScope } from '@migrations/types';
-
-function nowIso(): string {
-  // MySQL/MariaDB DATETIME does not accept ISO8601 with timezone (e.g. trailing 'Z').
-  // Use a portable UTC datetime string.
-  return new Date().toISOString().slice(0, 19).replace('T', ' ');
-}
-
-const toSafeService = (service: string | null | undefined): string => {
-  if (typeof service !== 'string') return '';
-  return service.length > 0 ? service : '';
-};
-
-const assertDbSupportsMigrations = (db: IDatabase): void => {
-  const t = db.getType();
-  if (t === 'd1' || t === 'd1-remote') {
-    throw ErrorFactory.createCliError(
-      'This project is configured for D1. Use `zin d1:migrate --local|--remote` for now.'
-    );
-  }
-};
-
-type IMigrationsTableCapableAdapter = IDatabaseAdapter & {
-  ensureMigrationsTable: () => Promise<void>;
-};
-
-const hasMigrationsTableSupport = (
-  adapter: IDatabaseAdapter
-): adapter is IMigrationsTableCapableAdapter => {
-  return (
-    typeof (adapter as Partial<IMigrationsTableCapableAdapter>).ensureMigrationsTable === 'function'
-  );
-};
-
-const requireMigrationsTableSupport = (adapter: IDatabaseAdapter): (() => Promise<void>) => {
-  if (!hasMigrationsTableSupport(adapter)) {
-    throw ErrorFactory.createCliError(
-      'Migrations tracking is not supported for this database adapter yet.'
-    );
-  }
-
-  return async (): Promise<void> => {
-    await adapter.ensureMigrationsTable();
-  };
-};
-
-export const MigrationStore = Object.freeze({
-  async ensureTable(db: IDatabase): Promise<void> {
-    assertDbSupportsMigrations(db);
-
-    const adapter = db.getAdapterInstance(false);
-    const ensure = requireMigrationsTableSupport(adapter);
-    await ensure();
-  },
-
-  async getLastCompletedBatch(
-    db: IDatabase,
-    scope: MigrationScope = 'global',
-    service: string = ''
-  ): Promise<number> {
-    assertDbSupportsMigrations(db);
-
-    const normalizedService = toSafeService(service);
-
-    const row = await QueryBuilder.create('migrations', db)
-      .max('batch', 'max_batch')
-      .where('status', '=', 'completed')
-      .andWhere('scope', '=', scope)
-      .andWhere('service', '=', normalizedService)
-      .first<{ max_batch?: unknown }>();
-
-    const value = row?.max_batch;
-    return typeof value === 'number' && Number.isFinite(value) ? value : 0;
-  },
-
-  async getAppliedMap(
-    db: IDatabase,
-    scope: MigrationScope,
-    service: string
-  ): Promise<Map<string, MigrationRecord>> {
-    assertDbSupportsMigrations(db);
-
-    const normalizedService = toSafeService(service);
-
-    const rows = await QueryBuilder.create('migrations', db)
-      .select('name', 'scope', 'service', 'batch', 'status')
-      .selectAs('applied_at', 'appliedAt')
-      .where('scope', '=', scope)
-      .andWhere('service', '=', normalizedService)
-      .get<MigrationRecord>();
-
-    const map = new Map<string, MigrationRecord>();
-    for (const r of rows) {
-      if (typeof r.name === 'string' && r.name.length > 0) {
-        map.set(r.name, {
-          ...r,
-          service: toSafeService(r.service),
-        });
-      }
-    }
-    return map;
-  },
-
-  async insertRunning(
-    db: IDatabase,
-    params: { name: string; scope: MigrationScope; service: string; batch: number }
-  ): Promise<void> {
-    assertDbSupportsMigrations(db);
-
-    const normalizedService = toSafeService(params.service);
-
-    const existing = await QueryBuilder.create('migrations', db)
-      .select('id')
-      .where('name', '=', params.name)
-      .andWhere('scope', '=', params.scope)
-      .andWhere('service', '=', normalizedService)
-      .first<{ id?: unknown }>();
-
-    // Allow re-running previously failed/running migrations by updating the existing row.
-    // This avoids tripping the UNIQUE(name, scope, service) constraint.
-    if (existing?.id !== undefined && existing.id !== null) {
-      await QueryBuilder.create('migrations', db)
-        .where('name', '=', params.name)
-        .andWhere('scope', '=', params.scope)
-        .andWhere('service', '=', normalizedService)
-        .update({
-          batch: params.batch,
-          status: 'running',
-          applied_at: null,
-        });
-      return;
-    }
-
-    await QueryBuilder.create('migrations', db).insert({
-      name: params.name,
-      scope: params.scope,
-      service: normalizedService,
-      batch: params.batch,
-      status: 'running',
-      applied_at: null,
-      created_at: nowIso(),
-    });
-  },
-
-  async markStatus(
-    db: IDatabase,
-    params: {
-      name: string;
-      scope: MigrationScope;
-      service: string;
-      status: MigrationRecordStatus;
-      appliedAt?: string | null;
-    }
-  ): Promise<void> {
-    assertDbSupportsMigrations(db);
-
-    const builder = QueryBuilder.create('migrations', db)
-      .where('name', '=', params.name)
-      .andWhere('scope', '=', params.scope)
-      .andWhere('service', '=', toSafeService(params.service));
-
-    if (params.appliedAt !== undefined) {
-      await builder.update({ status: params.status, applied_at: params.appliedAt });
-      return;
-    }
-
-    await builder.update({ status: params.status });
-  },
-
-  async listCompletedInBatchesGte(
-    db: IDatabase,
-    params: { scope: MigrationScope; service: string; minBatch: number }
-  ): Promise<Array<{ name: string; batch: number }>> {
-    assertDbSupportsMigrations(db);
-
-    const rows = await QueryBuilder.create('migrations', db)
-      .select('name', 'batch')
-      .where('status', '=', 'completed')
-      .andWhere('scope', '=', params.scope)
-      .andWhere('service', '=', toSafeService(params.service))
-      .andWhere('batch', '>=', params.minBatch)
-      .orderBy('batch', 'DESC')
-      .orderBy('id', 'DESC')
-      .get<{ name?: unknown; batch?: unknown }>();
-
-    const out: Array<{ name: string; batch: number }> = [];
-    for (const r of rows) {
-      const name = typeof r.name === 'string' ? r.name : '';
-      const batch = typeof r.batch === 'number' ? r.batch : Number(r.batch);
-      if (name.length === 0) continue;
-      if (!Number.isFinite(batch)) continue;
-      out.push({ name, batch });
-    }
-    return out;
-  },
-
-  async listAllCompletedNames(
-    db: IDatabase,
-    params: { scope: MigrationScope; service: string }
-  ): Promise<string[]> {
-    assertDbSupportsMigrations(db);
-
-    const rows = await QueryBuilder.create('migrations', db)
-      .select('name')
-      .where('status', '=', 'completed')
-      .andWhere('scope', '=', params.scope)
-      .andWhere('service', '=', toSafeService(params.service))
-      .orderBy('batch', 'DESC')
-      .orderBy('id', 'DESC')
-      .get<{ name?: unknown }>();
-
-    return rows.map((r) => (typeof r.name === 'string' ? r.name : '')).filter((n) => n.length > 0);
-  },
-
-  async deleteRecord(
-    db: IDatabase,
-    params: { name: string; scope: MigrationScope; service: string }
-  ): Promise<void> {
-    assertDbSupportsMigrations(db);
-
-    await QueryBuilder.create('migrations', db)
-      .where('name', '=', params.name)
-      .andWhere('scope', '=', params.scope)
-      .andWhere('service', '=', toSafeService(params.service))
-      .delete();
-  },
-});