@zintrust/core 0.1.19 → 0.1.21

package/src/seeders/SeederLoader.js

@@ -0,0 +1,60 @@
+import { ErrorFactory } from '../exceptions/ZintrustError.js';
+import * as path from '../node-singletons/path.js';
+import { pathToFileURL } from 'node:url';
+function isFunction(value) {
+    return typeof value === 'function';
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null;
+}
+function hasRun(value) {
+    return typeof value === 'object' && value !== null && 'run' in value;
+}
+function normalizeHandler(fn, label) {
+    if (!isFunction(fn)) {
+        throw ErrorFactory.createValidationError(`Invalid seeder export: expected function for ${label}`);
+    }
+    return async (db) => {
+        // Support both (db) => Promise<void> and () => Promise<void>.
+        if (fn.length <= 0) {
+            await Promise.resolve(fn());
+            return;
+        }
+        await Promise.resolve(fn(db));
+    };
+}
+function selectSeederExport(mod, baseName) {
+    const defaultExport = mod.default;
+    const defaultNamed = isRecord(defaultExport) ? defaultExport[baseName] : undefined;
+    // Prefer conventional exports first.
+    const candidate = mod.seeder ?? mod[baseName] ?? mod.run ?? defaultExport ?? defaultNamed;
+    if (candidate !== undefined)
+        return candidate;
+    // Last resort: pick the first export that looks like a seeder object.
+    for (const value of Object.values(mod)) {
+        if (hasRun(value))
+            return value;
+    }
+    return undefined;
+}
+export const SeederLoader = Object.freeze({
+    async load(filePath) {
+        const url = pathToFileURL(filePath).href;
+        const raw = (await import(url));
+        const mod = isRecord(raw) ? raw : {};
+        const baseName = path.basename(filePath, path.extname(filePath));
+        const picked = selectSeederExport(mod, baseName);
+        const baseExport = mod[baseName];
+        const runFn = (hasRun(picked) ? picked.run : undefined) ??
+            (hasRun(baseExport) ? baseExport.run : undefined) ??
+            mod.run;
+        if (runFn === undefined) {
+            throw ErrorFactory.createValidationError(`Seeder '${filePath}' is missing a runnable export (expected '${baseName}.run()', 'seeder.run()', 'run()', or default export with 'run()')`);
+        }
+        return {
+            name: baseName,
+            filePath,
+            run: normalizeHandler(runFn, 'run'),
+        };
+    },
+});

package/src/seeders/types.d.ts

@@ -0,0 +1,18 @@
+import type { IDatabase } from '../orm/Database';
+export type SeederModule = {
+    /** Common pattern: export const UserSeeder = { run() { ... } } */
+    [key: string]: unknown;
+    /** Alternative: export const seeder = { run() { ... } } */
+    seeder?: unknown;
+    /** Alternative: export async function run() { ... } */
+    run?: unknown;
+    /** Interop: export default { run() { ... } } */
+    default?: unknown;
+};
+export type SeederHandler = (db: IDatabase) => Promise<void>;
+export type LoadedSeeder = {
+    name: string;
+    filePath: string;
+    run: SeederHandler;
+};
+//# sourceMappingURL=types.d.ts.map

package/src/seeders/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/seeders/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AAE/C,MAAM,MAAM,YAAY,GAAG;IACzB,kEAAkE;IAClE,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;IACvB,2DAA2D;IAC3D,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,uDAAuD;IACvD,GAAG,CAAC,EAAE,OAAO,CAAC;IACd,gDAAgD;IAChD,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB,CAAC;AAEF,MAAM,MAAM,aAAa,GAAG,CAAC,EAAE,EAAE,SAAS,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;AAE7D,MAAM,MAAM,YAAY,GAAG;IACzB,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,CAAC;IACjB,GAAG,EAAE,aAAa,CAAC;CACpB,CAAC"}

package/src/seeders/types.js

@@ -0,0 +1 @@
+export {};

package/src/session/SessionManager.js

@@ -1,4 +1,4 @@
-import { generateSecureJobId } from '../common/uuid.js';
+import { generateSecureJobId } from '../common/utility.js';
 const DEFAULT_OPTIONS = {
     cookieName: 'ZIN_SESSION_ID',
     headerName: 'x-session-id',

package/src/templates/adapters/MySQLAdapter.ts.tpl

@@ -3,101 +3,125 @@
  * MySQL Database Adapter
  */
 
-import {
-  ErrorFactory,
-  FeatureFlags,
-  Logger,
-  QueryBuilder,
-  type DatabaseConfig,
-  type IDatabaseAdapter,
-  type QueryResult,
-} from '@zintrust/core';
+import { FeatureFlags } from '@zintrust/core';
+import { Logger } from '@zintrust/core';
+import { ErrorFactory } from '@zintrust/core';
+import { DatabaseConfig, IDatabaseAdapter, QueryResult } from '@zintrust/core';
+import { QueryBuilder } from '@zintrust/core';
 
-/**
- * MySQL adapter implementation
- * Sealed namespace for immutability
- */
-export const MySQLAdapter = Object.freeze({
-  /**
-   * Create a new MySQL adapter instance
-   */
-  create(config: DatabaseConfig): IDatabaseAdapter {
-    let connected = false;
+type AdapterState = {
+  connected: boolean;
+};
+
+function createRawQuery(state: AdapterState) {
+  return async function rawQuery<T = unknown>(sql: string, parameters?: unknown[]): Promise<T[]> {
+    if (!FeatureFlags.isRawQueryEnabled()) {
+      throw ErrorFactory.createConfigError('Raw SQL queries are disabled');
+    }
+
+    if (!state.connected) {
+      throw ErrorFactory.createConnectionError('Database not connected');
+    }
 
-    return {
-      async connect(): Promise<void> {
-        if (config.host === 'error') {
-          throw ErrorFactory.createConnectionError(
-            'Failed to connect to MySQL: Error: Connection failed'
-          );
-        }
-        connected = true;
-        Logger.info(`✓ MySQL connected (${config.host}:${config.port})`);
-      },
+    try {
+      Logger.warn(`Raw SQL Query executed: ${sql}`, { parameters });
+      // Mock implementation for tests
+      if (sql.includes('INVALID')) {
+        throw ErrorFactory.createDatabaseError('Invalid SQL syntax');
+      }
+      return [] as T[];
+    } catch (error) {
+      throw ErrorFactory.createTryCatchError(`Raw SQL query failed: ${sql}`, error);
+    }
+  };
+}
 
-      async disconnect(): Promise<void> {
-        connected = false;
-        Logger.info('✓ MySQL disconnected');
-      },
+function createMySQLAdapterInstance(config: DatabaseConfig, state: AdapterState): IDatabaseAdapter {
+  return {
+    async connect(): Promise<void> {
+      if (config.host === 'error') {
+        throw ErrorFactory.createConnectionError(
+          'Failed to connect to MySQL: Error: Connection failed'
+        );
+      }
+      state.connected = true;
+      Logger.info(`✓ MySQL connected (${config.host}:${config.port})`);
+    },
 
-      async query(_sql: string, _parameters: unknown[]): Promise<QueryResult> {
-        if (!connected) throw ErrorFactory.createConnectionError('Database not connected');
-        // Mock implementation
-        return { rows: [], rowCount: 0 };
-      },
+    async disconnect(): Promise<void> {
+      state.connected = false;
+      Logger.info('✓ MySQL disconnected');
+    },
 
-      async queryOne(sql: string, parameters: unknown[]): Promise<Record<string, unknown> | null> {
-        const result = await this.query(sql, parameters);
-        return result.rows[0] ?? null;
-      },
+    async query(_sql: string, _parameters: unknown[]): Promise<QueryResult> {
+      if (!state.connected) throw ErrorFactory.createConnectionError('Database not connected');
+      // Mock implementation
+      return { rows: [], rowCount: 0 };
+    },
 
-      async ping(): Promise<void> {
-        await this.query(QueryBuilder.create('').select('1').toSQL(), []);
-      },
+    async queryOne(sql: string, parameters: unknown[]): Promise<Record<string, unknown> | null> {
+      const result = await this.query(sql, parameters);
+      return result.rows[0] ?? null;
+    },
 
-      async transaction<T>(callback: (adapter: IDatabaseAdapter) => Promise<T>): Promise<T> {
-        if (!connected) throw ErrorFactory.createConnectionError('Database not connected');
-        try {
-          await this.query('START TRANSACTION', []);
-          const result = await callback(this);
-          await this.query('COMMIT', []);
-          return result;
-        } catch (error) {
-          await this.query('ROLLBACK', []);
-          throw ErrorFactory.createTryCatchError('MySQL transaction failed', error);
-        }
-      },
+    async ping(): Promise<void> {
+      await this.query(QueryBuilder.create('').select('1').toSQL(), []);
+    },
 
-      getType(): string {
-        return 'mysql';
-      },
-      isConnected(): boolean {
-        return connected;
-      },
-      async rawQuery<T = unknown>(sql: string, parameters?: unknown[]): Promise<T[]> {
-        if (!FeatureFlags.isRawQueryEnabled()) {
-          throw ErrorFactory.createConfigError('Raw SQL queries are disabled');
-        }
+    async transaction<T>(callback: (adapter: IDatabaseAdapter) => Promise<T>): Promise<T> {
+      if (!state.connected) throw ErrorFactory.createConnectionError('Database not connected');
+      try {
+        await this.query('START TRANSACTION', []);
+        const result = await callback(this);
+        await this.query('COMMIT', []);
+        return result;
+      } catch (error) {
+        await this.query('ROLLBACK', []);
+        throw ErrorFactory.createTryCatchError('MySQL transaction failed', error);
+      }
+    },
 
-        if (!connected) {
-          throw ErrorFactory.createConnectionError('Database not connected');
-        }
+    getType(): string {
+      return 'mysql';
+    },
+    isConnected(): boolean {
+      return state.connected;
+    },
+    rawQuery: createRawQuery(state),
+    getPlaceholder(_index: number): string {
+      return '?';
+    },
 
-        try {
-          Logger.warn(`Raw SQL Query executed: ${sql}`, { parameters });
-          // Mock implementation for tests
-          if (sql.includes('INVALID')) {
-            throw ErrorFactory.createDatabaseError('Invalid SQL syntax');
-          }
-          return [] as T[];
-        } catch (error) {
-          throw ErrorFactory.createTryCatchError(`Raw SQL query failed: ${sql}`, error);
-        }
-      },
-      getPlaceholder(_index: number): string {
-        return '?';
-      },
-    };
+    async ensureMigrationsTable(): Promise<void> {
+      await this.query(
+        `CREATE TABLE IF NOT EXISTS migrations (
+            id INTEGER PRIMARY KEY AUTO_INCREMENT,
+            name VARCHAR(255) NOT NULL,
+            scope VARCHAR(255) NOT NULL DEFAULT 'global',
+            service VARCHAR(255) NOT NULL DEFAULT '',
+            batch INTEGER NOT NULL,
+            status VARCHAR(255) NOT NULL,
+            applied_at DATETIME NULL,
+            created_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
+            UNIQUE(name, scope, service)
+          )`,
+        []
+      );
+    },
+  };
+}
+
+/**
+ * MySQL adapter implementation
+ * Sealed namespace for immutability
+ */
+export const MySQLAdapter = Object.freeze({
+  /**
+   * Create a new MySQL adapter instance
+   */
+  create(config: DatabaseConfig): IDatabaseAdapter {
+    const state: AdapterState = { connected: false };
+    return createMySQLAdapterInstance(config, state);
   },
 });
 

package/src/templates/adapters/PostgreSQLAdapter.ts.tpl

@@ -3,15 +3,133 @@
  * PostgreSQL Database Adapter
  */
 
-import {
-  ErrorFactory,
-  FeatureFlags,
-  Logger,
-  QueryBuilder,
-  type DatabaseConfig,
-  type IDatabaseAdapter,
-  type QueryResult,
-} from '@zintrust/core';
+import { FeatureFlags } from '@zintrust/core';
+import { Logger } from '@zintrust/core';
+import { ErrorFactory } from '@zintrust/core';
+import { DatabaseConfig, IDatabaseAdapter, QueryResult } from '@zintrust/core';
+import { QueryBuilder } from '@zintrust/core';
+
+type AdapterState = {
+  connected: boolean;
+};
+
+function assertConnected(state: AdapterState): void {
+  if (!state.connected) throw ErrorFactory.createConnectionError('Database not connected');
+}
+
+async function pgConnect(config: DatabaseConfig, state: AdapterState): Promise<void> {
+  if (config.host === 'error') {
+    throw ErrorFactory.createConnectionError('Failed to connect to PostgreSQL: Connection failed');
+  }
+  state.connected = true;
+  Logger.info(`✓ PostgreSQL connected (${config.host}:${config.port})`);
+}
+
+async function pgDisconnect(state: AdapterState): Promise<void> {
+  state.connected = false;
+  Logger.info('✓ PostgreSQL disconnected');
+}
+
+async function pgQuery(
+  state: AdapterState,
+  _sql: string,
+  _parameters: unknown[]
+): Promise<QueryResult> {
+  assertConnected(state);
+  // Mock implementation
+  return { rows: [], rowCount: 0 };
+}
+
+async function pgQueryOne(
+  adapter: IDatabaseAdapter,
+  sql: string,
+  parameters: unknown[]
+): Promise<Record<string, unknown> | null> {
+  const result = await adapter.query(sql, parameters);
+  return result.rows[0] ?? null;
+}
+
+async function pgPing(adapter: IDatabaseAdapter): Promise<void> {
+  await adapter.query(QueryBuilder.create('').select('1').toSQL(), []);
+}
+
+async function pgTransaction<T>(
+  state: AdapterState,
+  adapter: IDatabaseAdapter,
+  callback: (adapter: IDatabaseAdapter) => Promise<T>
+): Promise<T> {
+  assertConnected(state);
+  try {
+    await adapter.query('BEGIN', []);
+    const result = await callback(adapter);
+    await adapter.query('COMMIT', []);
+    return result;
+  } catch (error) {
+    await adapter.query('ROLLBACK', []);
+    throw ErrorFactory.createTryCatchError('PostgreSQL transaction failed', error);
+  }
+}
+
+async function pgRawQuery<T = unknown>(
+  state: AdapterState,
+  sql: string,
+  parameters?: unknown[]
+): Promise<T[]> {
+  if (!FeatureFlags.isRawQueryEnabled()) {
+    throw ErrorFactory.createConfigError(
+      'Raw SQL queries are disabled. Set USE_RAW_QRY=true environment variable to enable.'
+    );
+  }
+
+  assertConnected(state);
+
+  Logger.warn(`Raw SQL Query executed: ${sql}`, { parameters });
+
+  try {
+    if (sql.toUpperCase().includes('INVALID')) {
+      throw ErrorFactory.createDatabaseError('Invalid SQL syntax');
+    }
+    // Mock implementation
+    return [] as T[];
+  } catch (error) {
+    throw ErrorFactory.createTryCatchError('Raw SQL Query failed', error);
+  }
+}
+
+async function pgEnsureMigrationsTable(adapter: IDatabaseAdapter): Promise<void> {
+  await adapter.query(
+    `CREATE TABLE IF NOT EXISTS migrations (
+            id SERIAL PRIMARY KEY,
+            name VARCHAR(255) NOT NULL,
+            scope VARCHAR(255) NOT NULL DEFAULT 'global',
+            service VARCHAR(255) NOT NULL DEFAULT '',
+            batch INTEGER NOT NULL,
+            status VARCHAR(255) NOT NULL,
+            applied_at TIMESTAMP NULL,
+            created_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
+            UNIQUE(name, scope, service)
+          )`,
+    []
+  );
+}
+
+function createAdapter(config: DatabaseConfig, state: AdapterState): IDatabaseAdapter {
+  const adapter: IDatabaseAdapter = {
+    connect: async () => pgConnect(config, state),
+    disconnect: async () => pgDisconnect(state),
+    query: async (sql, parameters) => pgQuery(state, sql, parameters),
+    queryOne: async (sql, parameters) => pgQueryOne(adapter, sql, parameters),
+    ping: async () => pgPing(adapter),
+    transaction: async (callback) => pgTransaction(state, adapter, callback),
+    getType: () => 'postgresql',
+    isConnected: () => state.connected,
+    rawQuery: async (sql, parameters) => pgRawQuery(state, sql, parameters),
+    getPlaceholder: (index) => `$${index}`,
+    ensureMigrationsTable: async () => pgEnsureMigrationsTable(adapter),
+  };
+
+  return adapter;
+}
 
 /**
  * PostgreSQL adapter implementation
@@ -22,85 +140,8 @@ export const PostgreSQLAdapter = Object.freeze({
    * Create a new PostgreSQL adapter instance
    */
   create(config: DatabaseConfig): IDatabaseAdapter {
-    let connected = false;
-
-    return {
-      async connect(): Promise<void> {
-        if (config.host === 'error') {
-          throw ErrorFactory.createConnectionError(
-            'Failed to connect to PostgreSQL: Connection failed'
-          );
-        }
-        connected = true;
-        Logger.info(`✓ PostgreSQL connected (${config.host}:${config.port})`);
-      },
-
-      async disconnect(): Promise<void> {
-        connected = false;
-        Logger.info('✓ PostgreSQL disconnected');
-      },
-
-      async query(_sql: string, _parameters: unknown[]): Promise<QueryResult> {
-        if (!connected) throw ErrorFactory.createConnectionError('Database not connected');
-        // Mock implementation
-        return { rows: [], rowCount: 0 };
-      },
-
-      async queryOne(sql: string, parameters: unknown[]): Promise<Record<string, unknown> | null> {
-        const result = await this.query(sql, parameters);
-        return result.rows[0] ?? null;
-      },
-
-      async ping(): Promise<void> {
-        await this.query(QueryBuilder.create('').select('1').toSQL(), []);
-      },
-
-      async transaction<T>(callback: (adapter: IDatabaseAdapter) => Promise<T>): Promise<T> {
-        if (!connected) throw ErrorFactory.createConnectionError('Database not connected');
-        try {
-          await this.query('BEGIN', []);
-          const result = await callback(this);
-          await this.query('COMMIT', []);
-          return result;
-        } catch (error) {
-          await this.query('ROLLBACK', []);
-          throw ErrorFactory.createTryCatchError('PostgreSQL transaction failed', error);
-        }
-      },
-
-      getType(): string {
-        return 'postgresql';
-      },
-      isConnected(): boolean {
-        return connected;
-      },
-      async rawQuery<T = unknown>(sql: string, parameters?: unknown[]): Promise<T[]> {
-        if (!FeatureFlags.isRawQueryEnabled()) {
-          throw ErrorFactory.createConfigError(
-            'Raw SQL queries are disabled. Set USE_RAW_QRY=true environment variable to enable.'
-          );
-        }
-
-        if (!connected) {
-          throw ErrorFactory.createConnectionError('Database not connected');
-        }
-
-        Logger.warn(`Raw SQL Query executed: ${sql}`, { parameters });
-
-        try {
-          if (sql.toUpperCase().includes('INVALID')) {
-            throw ErrorFactory.createDatabaseError('Invalid SQL syntax');
-          }
-          // Mock implementation
-          return [] as T[];
-        } catch (error) {
-          throw ErrorFactory.createTryCatchError('Raw SQL Query failed', error);
-        }
-      },
-      getPlaceholder(index: number): string {
-        return `$${index}`;
-      },
-    };
+    const state: AdapterState = { connected: false };
+    return createAdapter(config, state);
   },
 });
 

package/src/templates/adapters/SQLServerAdapter.ts.tpl

@@ -3,15 +3,11 @@
  * SQL Server Database Adapter
  */
 
-import {
-  ErrorFactory,
-  FeatureFlags,
-  Logger,
-  QueryBuilder,
-  type DatabaseConfig,
-  type IDatabaseAdapter,
-  type QueryResult,
-} from '@zintrust/core';
+import { FeatureFlags } from '@zintrust/core';
+import { Logger } from '@zintrust/core';
+import { ErrorFactory } from '@zintrust/core';
+import { DatabaseConfig, IDatabaseAdapter, QueryResult } from '@zintrust/core';
+import { QueryBuilder } from '@zintrust/core';
 
 /**
  * SQL Server adapter implementation

package/src/templates/adapters/SQLiteAdapter.ts.tpl

@@ -4,17 +4,14 @@
  * Production Implementation
  */
 
+import { FeatureFlags } from '@zintrust/core';
+import { Logger } from '@zintrust/core';
+import { ErrorFactory } from '@zintrust/core';
+import fs from 'node:fs';
+import * as path from 'node:path';
 import { performance } from 'node:perf_hooks';
-
-import {
-  ErrorFactory,
-  FeatureFlags,
-  Logger,
-  QueryBuilder,
-  type DatabaseConfig,
-  type IDatabaseAdapter,
-  type QueryResult,
-} from '@zintrust/core';
+import { DatabaseConfig, IDatabaseAdapter, QueryResult } from '@zintrust/core';
+import { QueryBuilder } from '@zintrust/core';
 
 type SqliteRunInfo = { changes: number };
 type SqliteStatement = {
@@ -27,6 +24,22 @@ type SqliteDatabase = {
   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 };
@@ -43,7 +56,11 @@ async function importSqliteDatabaseConstructor(): Promise<
   new (filename: string) => SqliteDatabase
 > {
   try {
-    const mod = (await import('better-sqlite3')) as unknown as {
+    // 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;
     };
 
@@ -113,6 +130,18 @@ async function connectSQLite(state: SQLiteAdapterState): Promise<void> {
 
   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);
 
@@ -220,6 +249,44 @@ function createSQLiteAdapter(config: DatabaseConfig): IDatabaseAdapter {
       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(): string {
       return 'sqlite';
     },