@zintrust/core 0.1.19 → 0.1.21

package/src/orm/SchemaCompiler.js

@@ -0,0 +1,145 @@
+import { ErrorFactory } from '../exceptions/ZintrustError.js';
+const IDENT_RE = /^[A-Za-z_]\w*$/;
+const INT_TYPES = new Set([
+    'integer',
+    'smallInteger',
+    'tinyInteger',
+    'mediumInteger',
+]);
+function assertIdentifier(label, value) {
+    if (!IDENT_RE.test(value)) {
+        throw ErrorFactory.createValidationError(`Invalid ${label} identifier: ${value}`);
+    }
+}
+function quoteIdent(driver, ident) {
+    assertIdentifier('SQL', ident);
+    // MySQL uses backticks; Postgres/SQLite accept double-quotes.
+    if (driver === 'mysql')
+        return `\`${ident}\``;
+    return `"${ident}"`;
+}
+function getAutoIncrementSql(driver, col, type) {
+    const isSqlite = driver === 'sqlite' || driver === 'd1' || driver === 'd1-remote';
+    if (isSqlite) {
+        return `${col} INTEGER PRIMARY KEY AUTOINCREMENT`;
+    }
+    if (driver === 'postgresql') {
+        return `${col} ${type === 'bigInteger' ? 'BIGSERIAL' : 'SERIAL'} PRIMARY KEY`;
+    }
+    if (driver === 'mysql') {
+        const base = type === 'bigInteger' ? 'BIGINT' : 'INT';
+        return `${col} ${base} AUTO_INCREMENT PRIMARY KEY`;
+    }
+    return null;
+}
+function getStringTypeSql(driver, def) {
+    const isSqlite = driver === 'sqlite' || driver === 'd1' || driver === 'd1-remote';
+    const len = typeof def.length === 'number' && Number.isFinite(def.length) ? def.length : 255;
+    return isSqlite ? 'TEXT' : `VARCHAR(${len})`;
+}
+function getDecimalTypeSql(def) {
+    const p = typeof def.precision === 'number' ? def.precision : 10;
+    const s = typeof def.scale === 'number' ? def.scale : 2;
+    return `DECIMAL(${p},${s})`;
+}
+function getDateTimeTypeSql(driver) {
+    if (driver === 'mysql')
+        return 'DATETIME';
+    if (driver === 'postgresql')
+        return 'TIMESTAMP';
+    return 'TEXT';
+}
+function getIntegerTypeSql(driver, type) {
+    if (INT_TYPES.has(type))
+        return driver === 'mysql' ? 'INT' : 'INTEGER';
+    if (type === 'bigInteger')
+        return 'BIGINT';
+    return null;
+}
+function getSpecialTypeSql(driver, type) {
+    if (type === 'boolean')
+        return driver === 'mysql' ? 'TINYINT(1)' : 'BOOLEAN';
+    if (type === 'json')
+        return driver === 'postgresql' ? 'JSONB' : 'TEXT';
+    if (type === 'uuid')
+        return driver === 'postgresql' ? 'UUID' : 'TEXT';
+    return null;
+}
+function getColumnTypeSql(driver, def) {
+    if (def.type === 'string' || def.type === 'char')
+        return getStringTypeSql(driver, def);
+    if (def.type === 'decimal')
+        return getDecimalTypeSql(def);
+    if (def.type === 'datetime' || def.type === 'timestamp')
+        return getDateTimeTypeSql(driver);
+    const intSql = getIntegerTypeSql(driver, def.type);
+    if (intSql !== null)
+        return intSql;
+    const specialSql = getSpecialTypeSql(driver, def.type);
+    if (specialSql !== null)
+        return specialSql;
+    return 'TEXT';
+}
+function getDefaultValueSql(table, def) {
+    if (def.default === undefined)
+        return null;
+    const dv = def.default;
+    if (dv === null)
+        return 'DEFAULT NULL';
+    if (typeof dv === 'number' && Number.isFinite(dv))
+        return `DEFAULT ${dv}`;
+    if (typeof dv === 'boolean')
+        return `DEFAULT ${dv ? 1 : 0}`;
+    if (typeof dv === 'string') {
+        const escaped = dv.replaceAll("'", "''");
+        return `DEFAULT '${escaped}'`;
+    }
+    throw ErrorFactory.createValidationError(`Unsupported default type for ${table}.${def.name}`);
+}
+function columnSql(driver, table, def) {
+    assertIdentifier('table', table);
+    assertIdentifier('column', def.name);
+    const col = quoteIdent(driver, def.name);
+    const isPrimary = def.primary === true;
+    if (def.autoIncrement === true && isPrimary) {
+        const autoInc = getAutoIncrementSql(driver, col, def.type);
+        if (autoInc !== null)
+            return autoInc;
+    }
+    const parts = [`${col} ${getColumnTypeSql(driver, def)}`];
+    if (def.nullable !== true)
+        parts.push('NOT NULL');
+    if (def.unique === true)
+        parts.push('UNIQUE');
+    if (isPrimary)
+        parts.push('PRIMARY KEY');
+    const defaultVal = getDefaultValueSql(table, def);
+    if (defaultVal !== null)
+        parts.push(defaultVal);
+    return parts.join(' ');
+}
+function buildCreateTableSql(driver, schema, ifNotExists) {
+    const table = schema.getTable();
+    assertIdentifier('table', table);
+    const tableSql = quoteIdent(driver, table);
+    const cols = Array.from(schema.getColumns().values()).map((c) => c.getDefinition());
+    if (cols.length === 0) {
+        throw ErrorFactory.createValidationError(`Schema for table '${table}' has no columns`);
+    }
+    const columnLines = cols.map((d) => `  ${columnSql(driver, table, d)}`);
+    const ine = ifNotExists ? 'IF NOT EXISTS ' : '';
+    return `CREATE TABLE ${ine}${tableSql} (\n${columnLines.join(',\n')}\n)`;
+}
+export const SchemaCompiler = Object.freeze({
+    async createTable(db, schema, opts) {
+        const driver = db.getType();
+        const sql = buildCreateTableSql(driver, schema, opts?.ifNotExists !== false);
+        await db.query(sql);
+    },
+    async dropTable(db, table) {
+        const driver = db.getType();
+        assertIdentifier('table', table);
+        const tableSql = quoteIdent(driver, table);
+        await db.query(`DROP TABLE IF EXISTS ${tableSql}`);
+    },
+});

package/src/orm/adapters/D1Adapter.d.ts

@@ -1,7 +1,7 @@
 /**
  * Cloudflare D1 Database Adapter
  */
-import { DatabaseConfig, IDatabaseAdapter } from '../DatabaseAdapter';
+import type { DatabaseConfig, IDatabaseAdapter } from '../DatabaseAdapter';
 /**
  * D1 adapter implementation
  */

package/src/orm/adapters/D1Adapter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"D1Adapter.d.ts","sourceRoot":"","sources":["../../../../src/orm/adapters/D1Adapter.ts"],"names":[],"mappings":"AAAA;;GAEG;AAMH,OAAO,EAAE,cAAc,EAAe,gBAAgB,EAAe,MAAM,sBAAsB,CAAC;AAUlG;;GAEG;AACH,eAAO,MAAM,SAAS;IACpB;;OAEG;oBAEa,cAAc,GAAG,gBAAgB;EAkHjD,CAAC;AAEH,eAAe,SAAS,CAAC"}
+{"version":3,"file":"D1Adapter.d.ts","sourceRoot":"","sources":["../../../../src/orm/adapters/D1Adapter.ts"],"names":[],"mappings":"AAAA;;GAEG;AAMH,OAAO,KAAK,EAAE,cAAc,EAAe,gBAAgB,EAAe,MAAM,sBAAsB,CAAC;AAUvG;;GAEG;AACH,eAAO,MAAM,SAAS;IACpB;;OAEG;oBAEa,cAAc,GAAG,gBAAgB;EAkHjD,CAAC;AAEH,eAAe,SAAS,CAAC"}

package/src/orm/adapters/MySQLAdapter.d.ts

@@ -1,7 +1,7 @@
 /**
  * MySQL Database Adapter
  */
-import { DatabaseConfig, IDatabaseAdapter } from '../DatabaseAdapter';
+import type { DatabaseConfig, IDatabaseAdapter } from '../DatabaseAdapter';
 /**
  * MySQL adapter implementation
  * Sealed namespace for immutability

package/src/orm/adapters/MySQLAdapter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"MySQLAdapter.d.ts","sourceRoot":"","sources":["../../../../src/orm/adapters/MySQLAdapter.ts"],"names":[],"mappings":"AACA;;GAEG;AAKH,OAAO,EAAE,cAAc,EAAE,gBAAgB,EAAe,MAAM,sBAAsB,CAAC;AAGrF;;;GAGG;AACH,eAAO,MAAM,YAAY;IACvB;;OAEG;mBACY,cAAc,GAAG,gBAAgB;EA8EhD,CAAC;AAEH,eAAe,YAAY,CAAC"}
+{"version":3,"file":"MySQLAdapter.d.ts","sourceRoot":"","sources":["../../../../src/orm/adapters/MySQLAdapter.ts"],"names":[],"mappings":"AACA;;GAEG;AAKH,OAAO,KAAK,EAAE,cAAc,EAAE,gBAAgB,EAAe,MAAM,sBAAsB,CAAC;AAyG1F;;;GAGG;AACH,eAAO,MAAM,YAAY;IACvB;;OAEG;mBACY,cAAc,GAAG,gBAAgB;EAIhD,CAAC;AAEH,eAAe,YAAY,CAAC"}

package/src/orm/adapters/MySQLAdapter.js

@@ -6,6 +6,92 @@ import { FeatureFlags } from '../../config/features.js';
 import { Logger } from '../../config/logger.js';
 import { ErrorFactory } from '../../exceptions/ZintrustError.js';
 import { QueryBuilder } from '../QueryBuilder.js';
+function createRawQuery(state) {
+    return async function rawQuery(sql, parameters) {
+        if (!FeatureFlags.isRawQueryEnabled()) {
+            throw ErrorFactory.createConfigError('Raw SQL queries are disabled');
+        }
+        if (!state.connected) {
+            throw ErrorFactory.createConnectionError('Database not connected');
+        }
+        try {
+            Logger.warn(`Raw SQL Query executed: ${sql}`, { parameters });
+            // Mock implementation for tests
+            if (sql.includes('INVALID')) {
+                throw ErrorFactory.createDatabaseError('Invalid SQL syntax');
+            }
+            return [];
+        }
+        catch (error) {
+            throw ErrorFactory.createTryCatchError(`Raw SQL query failed: ${sql}`, error);
+        }
+    };
+}
+function createMySQLAdapterInstance(config, state) {
+    return {
+        async connect() {
+            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 disconnect() {
+            state.connected = false;
+            Logger.info('✓ MySQL disconnected');
+        },
+        async query(_sql, _parameters) {
+            if (!state.connected)
+                throw ErrorFactory.createConnectionError('Database not connected');
+            // Mock implementation
+            return { rows: [], rowCount: 0 };
+        },
+        async queryOne(sql, parameters) {
+            const result = await this.query(sql, parameters);
+            return result.rows[0] ?? null;
+        },
+        async ping() {
+            await this.query(QueryBuilder.create('').select('1').toSQL(), []);
+        },
+        async transaction(callback) {
+            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);
+            }
+        },
+        getType() {
+            return 'mysql';
+        },
+        isConnected() {
+            return state.connected;
+        },
+        rawQuery: createRawQuery(state),
+        getPlaceholder(_index) {
+            return '?';
+        },
+        async ensureMigrationsTable() {
+            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
@@ -15,75 +101,8 @@ export const MySQLAdapter = Object.freeze({
      * Create a new MySQL adapter instance
      */
     create(config) {
-        let connected = false;
-        return {
-            async connect() {
-                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})`);
-            },
-            async disconnect() {
-                connected = false;
-                Logger.info('✓ MySQL disconnected');
-            },
-            async query(_sql, _parameters) {
-                if (!connected)
-                    throw ErrorFactory.createConnectionError('Database not connected');
-                // Mock implementation
-                return { rows: [], rowCount: 0 };
-            },
-            async queryOne(sql, parameters) {
-                const result = await this.query(sql, parameters);
-                return result.rows[0] ?? null;
-            },
-            async ping() {
-                await this.query(QueryBuilder.create('').select('1').toSQL(), []);
-            },
-            async transaction(callback) {
-                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);
-                }
-            },
-            getType() {
-                return 'mysql';
-            },
-            isConnected() {
-                return connected;
-            },
-            async rawQuery(sql, parameters) {
-                if (!FeatureFlags.isRawQueryEnabled()) {
-                    throw ErrorFactory.createConfigError('Raw SQL queries are disabled');
-                }
-                if (!connected) {
-                    throw ErrorFactory.createConnectionError('Database not connected');
-                }
-                try {
-                    Logger.warn(`Raw SQL Query executed: ${sql}`, { parameters });
-                    // Mock implementation for tests
-                    if (sql.includes('INVALID')) {
-                        throw ErrorFactory.createDatabaseError('Invalid SQL syntax');
-                    }
-                    return [];
-                }
-                catch (error) {
-                    throw ErrorFactory.createTryCatchError(`Raw SQL query failed: ${sql}`, error);
-                }
-            },
-            getPlaceholder(_index) {
-                return '?';
-            },
-        };
+        const state = { connected: false };
+        return createMySQLAdapterInstance(config, state);
     },
 });
 export default MySQLAdapter;

package/src/orm/adapters/PostgreSQLAdapter.d.ts

@@ -1,7 +1,7 @@
 /**
  * PostgreSQL Database Adapter
  */
-import { DatabaseConfig, IDatabaseAdapter } from '../DatabaseAdapter';
+import type { DatabaseConfig, IDatabaseAdapter } from '../DatabaseAdapter';
 /**
  * PostgreSQL adapter implementation
  * Sealed namespace for immutability

package/src/orm/adapters/PostgreSQLAdapter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"PostgreSQLAdapter.d.ts","sourceRoot":"","sources":["../../../../src/orm/adapters/PostgreSQLAdapter.ts"],"names":[],"mappings":"AACA;;GAEG;AAKH,OAAO,EAAE,cAAc,EAAE,gBAAgB,EAAe,MAAM,sBAAsB,CAAC;AAGrF;;;GAGG;AACH,eAAO,MAAM,iBAAiB;IAC5B;;OAEG;mBACY,cAAc,GAAG,gBAAgB;EAiFhD,CAAC;AAEH,eAAe,iBAAiB,CAAC"}
+{"version":3,"file":"PostgreSQLAdapter.d.ts","sourceRoot":"","sources":["../../../../src/orm/adapters/PostgreSQLAdapter.ts"],"names":[],"mappings":"AACA;;GAEG;AAKH,OAAO,KAAK,EAAE,cAAc,EAAE,gBAAgB,EAAe,MAAM,sBAAsB,CAAC;AA6H1F;;;GAGG;AACH,eAAO,MAAM,iBAAiB;IAC5B;;OAEG;mBACY,cAAc,GAAG,gBAAgB;EAIhD,CAAC;AAEH,eAAe,iBAAiB,CAAC"}

package/src/orm/adapters/PostgreSQLAdapter.js

@@ -6,6 +6,92 @@ import { FeatureFlags } from '../../config/features.js';
 import { Logger } from '../../config/logger.js';
 import { ErrorFactory } from '../../exceptions/ZintrustError.js';
 import { QueryBuilder } from '../QueryBuilder.js';
+function assertConnected(state) {
+    if (!state.connected)
+        throw ErrorFactory.createConnectionError('Database not connected');
+}
+async function pgConnect(config, state) {
+    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) {
+    state.connected = false;
+    Logger.info('✓ PostgreSQL disconnected');
+}
+async function pgQuery(state, _sql, _parameters) {
+    assertConnected(state);
+    // Mock implementation
+    return { rows: [], rowCount: 0 };
+}
+async function pgQueryOne(adapter, sql, parameters) {
+    const result = await adapter.query(sql, parameters);
+    return result.rows[0] ?? null;
+}
+async function pgPing(adapter) {
+    await adapter.query(QueryBuilder.create('').select('1').toSQL(), []);
+}
+async function pgTransaction(state, adapter, callback) {
+    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(state, sql, parameters) {
+    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 [];
+    }
+    catch (error) {
+        throw ErrorFactory.createTryCatchError('Raw SQL Query failed', error);
+    }
+}
+async function pgEnsureMigrationsTable(adapter) {
+    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, state) {
+    const adapter = {
+        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
  * Sealed namespace for immutability
@@ -15,75 +101,8 @@ export const PostgreSQLAdapter = Object.freeze({
      * Create a new PostgreSQL adapter instance
      */
     create(config) {
-        let connected = false;
-        return {
-            async connect() {
-                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() {
-                connected = false;
-                Logger.info('✓ PostgreSQL disconnected');
-            },
-            async query(_sql, _parameters) {
-                if (!connected)
-                    throw ErrorFactory.createConnectionError('Database not connected');
-                // Mock implementation
-                return { rows: [], rowCount: 0 };
-            },
-            async queryOne(sql, parameters) {
-                const result = await this.query(sql, parameters);
-                return result.rows[0] ?? null;
-            },
-            async ping() {
-                await this.query(QueryBuilder.create('').select('1').toSQL(), []);
-            },
-            async transaction(callback) {
-                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() {
-                return 'postgresql';
-            },
-            isConnected() {
-                return connected;
-            },
-            async rawQuery(sql, parameters) {
-                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 [];
-                }
-                catch (error) {
-                    throw ErrorFactory.createTryCatchError('Raw SQL Query failed', error);
-                }
-            },
-            getPlaceholder(index) {
-                return `$${index}`;
-            },
-        };
+        const state = { connected: false };
+        return createAdapter(config, state);
     },
 });
 export default PostgreSQLAdapter;

package/src/orm/adapters/SQLServerAdapter.d.ts

@@ -1,7 +1,7 @@
 /**
  * SQL Server Database Adapter
  */
-import { DatabaseConfig, IDatabaseAdapter } from '../DatabaseAdapter';
+import type { DatabaseConfig, IDatabaseAdapter } from '../DatabaseAdapter';
 /**
  * SQL Server adapter implementation
  * Sealed namespace for immutability

package/src/orm/adapters/SQLServerAdapter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"SQLServerAdapter.d.ts","sourceRoot":"","sources":["../../../../src/orm/adapters/SQLServerAdapter.ts"],"names":[],"mappings":"AACA;;GAEG;AAKH,OAAO,EAAE,cAAc,EAAE,gBAAgB,EAAe,MAAM,sBAAsB,CAAC;AAGrF;;;GAGG;AACH,eAAO,MAAM,gBAAgB;IAC3B;;OAEG;mBACY,cAAc,GAAG,gBAAgB;EA4EhD,CAAC;AAEH,eAAe,gBAAgB,CAAC"}
+{"version":3,"file":"SQLServerAdapter.d.ts","sourceRoot":"","sources":["../../../../src/orm/adapters/SQLServerAdapter.ts"],"names":[],"mappings":"AACA;;GAEG;AAKH,OAAO,KAAK,EAAE,cAAc,EAAE,gBAAgB,EAAe,MAAM,sBAAsB,CAAC;AAG1F;;;GAGG;AACH,eAAO,MAAM,gBAAgB;IAC3B;;OAEG;mBACY,cAAc,GAAG,gBAAgB;EA4EhD,CAAC;AAEH,eAAe,gBAAgB,CAAC"}

package/src/orm/adapters/SQLiteAdapter.d.ts

@@ -2,7 +2,7 @@
  * SQLite Database Adapter
  * Production Implementation
  */
-import { DatabaseConfig, IDatabaseAdapter } from '../DatabaseAdapter';
+import type { DatabaseConfig, IDatabaseAdapter } from '../DatabaseAdapter';
 declare function createSQLiteAdapter(config: DatabaseConfig): IDatabaseAdapter;
 export declare const SQLiteAdapter: Readonly<{
     create: typeof createSQLiteAdapter;

package/src/orm/adapters/SQLiteAdapter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"SQLiteAdapter.d.ts","sourceRoot":"","sources":["../../../../src/orm/adapters/SQLiteAdapter.ts"],"names":[],"mappings":"AACA;;;GAGG;AAMH,OAAO,EAAE,cAAc,EAAE,gBAAgB,EAAe,MAAM,sBAAsB,CAAC;AA6KrF,iBAAS,mBAAmB,CAAC,MAAM,EAAE,cAAc,GAAG,gBAAgB,CAoDrE;AAED,eAAO,MAAM,aAAa;;EAExB,CAAC"}
+{"version":3,"file":"SQLiteAdapter.d.ts","sourceRoot":"","sources":["../../../../src/orm/adapters/SQLiteAdapter.ts"],"names":[],"mappings":"AACA;;;GAGG;AASH,OAAO,KAAK,EAAE,cAAc,EAAE,gBAAgB,EAAe,MAAM,sBAAsB,CAAC;AA6M1F,iBAAS,mBAAmB,CAAC,MAAM,EAAE,cAAc,GAAG,gBAAgB,CA0FrE;AAED,eAAO,MAAM,aAAa;;EAExB,CAAC"}

package/src/orm/adapters/SQLiteAdapter.js

@@ -3,11 +3,25 @@
  * SQLite Database Adapter
  * Production Implementation
  */
+import { databaseConfig } from '../../config/database.js';
 import { FeatureFlags } from '../../config/features.js';
 import { Logger } from '../../config/logger.js';
 import { ErrorFactory } from '../../exceptions/ZintrustError.js';
+import fs from '../../node-singletons/fs.js';
+import * as path from '../../node-singletons/path.js';
 import { performance } from '../../node-singletons/perf-hooks.js';
 import { QueryBuilder } from '../QueryBuilder.js';
+const SAFE_SQLITE_IDENTIFIER = /^[A-Za-z_]\w*$/;
+const toSqliteIdentifier = (value) => {
+    if (!SAFE_SQLITE_IDENTIFIER.test(value)) {
+        throw ErrorFactory.createDatabaseError('Unsafe sqlite identifier');
+    }
+    return value;
+};
+const quoteSqliteIdentifier = (id) => {
+    // Safe due to SAFE_SQLITE_IDENTIFIER allowlist.
+    return `"${id}"`;
+};
 function isMissingEsmPackage(error, packageName) {
     if (typeof error !== 'object' || error === null)
         return false;
@@ -60,12 +74,16 @@ function executeQuery(db, sql, parameters) {
     const stmt = db.prepare(sql);
     if (isSelectQuery(sql)) {
         const rows = stmt.all(parameters);
-        Logger.debug('SQLite query executed', { durationMs: performance.now() - start, sql });
+        if (databaseConfig.logging.enabled) {
+            Logger.debug('SQLite query executed', { durationMs: performance.now() - start, sql });
+        }
         return { rows, rowCount: rows.length };
     }
     const info = stmt.run(parameters);
-    Logger.debug('SQLite query executed', { durationMs: performance.now() - start, sql });
-    return { rows: [], rowCount: info.changes };
+    if (databaseConfig.logging.enabled) {
+        Logger.debug('SQLite query executed', { durationMs: performance.now() - start, sql });
+    }
+    return { rows: [], rowCount: info.changes, lastInsertId: info.lastInsertRowid };
 }
 function executeRawQuery(db, sql, parameters) {
     const stmt = db.prepare(sql);
@@ -78,6 +96,18 @@ async function connectSQLite(state) {
     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
@@ -151,6 +181,32 @@ function createSQLiteAdapter(config) {
         async rawQuery(sql, parameters = []) {
             return rawQuerySQLite(state, sql, parameters);
         },
+        async ensureMigrationsTable() {
+            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() {
+            // 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_%'", []));
+            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() {
             return 'sqlite';
         },

package/src/orm/maintenance/SqliteMaintenance.d.ts

@@ -0,0 +1,5 @@
+import type { IDatabase } from '../Database';
+export declare const SqliteMaintenance: Readonly<{
+    dropAllTables(db: IDatabase): Promise<void>;
+}>;
+//# sourceMappingURL=SqliteMaintenance.d.ts.map

package/src/orm/maintenance/SqliteMaintenance.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SqliteMaintenance.d.ts","sourceRoot":"","sources":["../../../../src/orm/maintenance/SqliteMaintenance.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AAQ/C,eAAO,MAAM,iBAAiB;sBACJ,SAAS,GAAG,OAAO,CAAC,IAAI,CAAC;EAWjD,CAAC"}