@an5/adapters 0.1.0

package/typescript/mssql/engine.ts

@@ -0,0 +1,132 @@
+import sql from 'mssql';
+import type { An5AdapterConfig, Dialect, QueryEngine, TransactionHandle } from '../base/types';
+
+// ─── MSSQL Connection Config ───────────────────────────────────────────────────────
+
+export function parseMssqlConnectionString(url: string): sql.config {
+  let cleanUrl = (url || '').trim();
+  // Strip scheme prefix
+  cleanUrl = cleanUrl.replace(/^(?:sqlserver|mssql):\/\//i, '');
+
+  const parts = cleanUrl.split(';');
+  const firstPart = parts[0].trim();
+
+  // host:port or host,port (SQL Server native style)
+  let server = firstPart;
+  let port = 1433;
+  const commaIdx = firstPart.lastIndexOf(',');
+  const colonIdx = firstPart.lastIndexOf(':');
+  if (commaIdx !== -1) {
+    server = firstPart.slice(0, commaIdx).trim();
+    port = parseInt(firstPart.slice(commaIdx + 1), 10) || 1433;
+  } else if (colonIdx !== -1 && !firstPart.includes('=')) {
+    server = firstPart.slice(0, colonIdx).trim();
+    port = parseInt(firstPart.slice(colonIdx + 1), 10) || 1433;
+  }
+
+  const config: any = {
+    server,
+    port,
+    options: { encrypt: true, trustServerCertificate: true },
+    pool: { max: 10, min: 0, idleTimeoutMillis: 30000 },
+    requestTimeout: 60000,
+    connectionTimeout: 15000,
+  };
+
+  for (let i = 1; i < parts.length; i++) {
+    const part = parts[i].trim();
+    if (!part) continue;
+    const eqIdx = part.indexOf('=');
+    if (eqIdx === -1) continue;
+    const key = part.slice(0, eqIdx).trim().toLowerCase();
+    const value = decodeURIComponent(part.slice(eqIdx + 1).trim());
+    if (key === 'database' || key === 'initial catalog') config.database = value;
+    else if (key === 'user' || key === 'uid' || key === 'user id') config.user = value;
+    else if (key === 'password' || key === 'pwd') config.password = value;
+    else if (key === 'server' || key === 'data source') {
+      // SERVER=host,port style (key-value form)
+      const [s, p] = value.split(',');
+      config.server = s.trim();
+      if (p) config.port = parseInt(p.trim(), 10) || 1433;
+    }
+    else if (key === 'encrypt') config.options.encrypt = value.toLowerCase() === 'true';
+    else if (key === 'trustservercertificate') config.options.trustServerCertificate = value.toLowerCase() === 'true';
+    else if (key === 'connection timeout') config.connectionTimeout = parseInt(value, 10) * 1000;
+  }
+  return config;
+}
+
+// ─── MSSQL Engine ──────────────────────────────────────────────────────────────────
+
+export class MssqlEngine implements QueryEngine {
+  dialect: Dialect = 'mssql';
+  private pool: Promise<sql.ConnectionPool> | null = null;
+  private config: sql.config;
+
+  constructor(adapterConfig: An5AdapterConfig) {
+    this.config = parseMssqlConnectionString(adapterConfig.connectionString);
+    if (adapterConfig.poolMax) this.config.pool = { ...this.config.pool, max: adapterConfig.poolMax };
+    if (adapterConfig.requestTimeout) this.config.requestTimeout = adapterConfig.requestTimeout;
+    if (adapterConfig.connectionTimeout) this.config.connectionTimeout = adapterConfig.connectionTimeout;
+  }
+
+  private async getPool(): Promise<sql.ConnectionPool> {
+    if (!this.pool) this.pool = new sql.ConnectionPool(this.config).connect();
+    return this.pool;
+  }
+
+  private attachParams(req: sql.Request, params?: Record<string, any>): void {
+    if (params) for (const [k, v] of Object.entries(params)) req.input(k, v ?? null);
+  }
+
+  async exec<T = any>(query: string, params?: Record<string, any>): Promise<T[]> {
+    const pool = await this.getPool();
+    const req = new sql.Request(pool);
+    this.attachParams(req, params);
+    const result = await req.query(query);
+    return (result.recordset || []) as T[];
+  }
+
+  async executeRaw(query: string, params?: Record<string, any>): Promise<number> {
+    const pool = await this.getPool();
+    const req = new sql.Request(pool);
+    this.attachParams(req, params);
+    const result = await req.query(query);
+    return result.rowsAffected[0] ?? 0;
+  }
+
+  async connect(): Promise<void> { await this.getPool(); }
+
+  async disconnect(): Promise<void> {
+    if (this.pool) {
+      const p = await this.pool;
+      await p.close();
+      this.pool = null;
+    }
+  }
+
+  async beginTransaction(): Promise<TransactionHandle> {
+    const pool = await this.getPool();
+    const tx = new sql.Transaction(pool);
+    await tx.begin();
+
+    const buildReq = (params?: Record<string, any>) => {
+      const req = new sql.Request(tx);
+      if (params) for (const [k, v] of Object.entries(params)) req.input(k, v ?? null);
+      return req;
+    };
+
+    return {
+      exec: async <T>(q: string, p?: Record<string, any>) => {
+        const r = await buildReq(p).query(q);
+        return (r.recordset || []) as T[];
+      },
+      executeRaw: async (q: string, p?: Record<string, any>) => {
+        const r = await buildReq(p).query(q);
+        return r.rowsAffected[0] ?? 0;
+      },
+      commit: () => tx.commit(),
+      rollback: () => tx.rollback(),
+    };
+  }
+}

package/typescript/mssql/index.d.ts

@@ -0,0 +1 @@
+export * from './engine';

package/typescript/mssql/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./engine"), exports);

package/typescript/mssql/index.ts

@@ -0,0 +1 @@
+export * from './engine';

package/typescript/mysql/engine.d.ts

@@ -0,0 +1,13 @@
+import type { An5AdapterConfig, Dialect, QueryEngine, TransactionHandle } from '../base/types';
+export declare class MysqlEngine implements QueryEngine {
+    dialect: Dialect;
+    private pool;
+    constructor(adapterConfig: An5AdapterConfig);
+    /** Convert @name → ? (positional); return ordered values */
+    private transform;
+    exec<T = any>(query: string, params?: Record<string, any>): Promise<T[]>;
+    executeRaw(query: string, params?: Record<string, any>): Promise<number>;
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    beginTransaction(): Promise<TransactionHandle>;
+}

package/typescript/mysql/engine.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MysqlEngine = void 0;
+// ─── MySQL Engine ──────────────────────────────────────────────────────────────────
+let Mysql2 = null;
+try {
+    Mysql2 = require('mysql2/promise');
+}
+catch { }
+class MysqlEngine {
+    constructor(adapterConfig) {
+        this.dialect = 'mysql';
+        this.pool = null;
+        if (!Mysql2)
+            throw new Error('mysql2 package is required for MySQL support. Run: npm install mysql2');
+        this.pool = Mysql2.createPool({
+            uri: adapterConfig.connectionString,
+            connectionLimit: adapterConfig.poolMax ?? 10,
+            connectTimeout: adapterConfig.connectionTimeout ?? 15000,
+        });
+    }
+    /** Convert @name → ? (positional); return ordered values */
+    transform(query, params) {
+        if (!params || Object.keys(params).length === 0)
+            return { text: query, values: [] };
+        const values = [];
+        const text = query.replace(/@(\w+)/g, (_, name) => {
+            values.push(params[name] ?? null);
+            return '?';
+        });
+        return { text, values };
+    }
+    async exec(query, params) {
+        const { text, values } = this.transform(query, params);
+        const [rows] = await this.pool.query(text, values);
+        return rows;
+    }
+    async executeRaw(query, params) {
+        const { text, values } = this.transform(query, params);
+        const [result] = await this.pool.query(text, values);
+        return result.affectedRows ?? 0;
+    }
+    async connect() {
+        const conn = await this.pool.getConnection();
+        conn.release();
+    }
+    async disconnect() { await this.pool.end(); }
+    async beginTransaction() {
+        const conn = await this.pool.getConnection();
+        await conn.beginTransaction();
+        const transform = (query, params) => {
+            if (!params || Object.keys(params).length === 0)
+                return { text: query, values: [] };
+            const values = [];
+            const text = query.replace(/@(\w+)/g, (_, name) => {
+                values.push(params[name] ?? null);
+                return '?';
+            });
+            return { text, values };
+        };
+        return {
+            exec: async (q, p) => {
+                const { text, values } = transform(q, p);
+                const [rows] = await conn.query(text, values);
+                return rows;
+            },
+            executeRaw: async (q, p) => {
+                const { text, values } = transform(q, p);
+                const [result] = await conn.query(text, values);
+                return result.affectedRows ?? 0;
+            },
+            commit: async () => { await conn.commit(); conn.release(); },
+            rollback: async () => { await conn.rollback(); conn.release(); },
+        };
+    }
+}
+exports.MysqlEngine = MysqlEngine;

package/typescript/mysql/engine.ts

@@ -0,0 +1,80 @@
+import type { An5AdapterConfig, Dialect, QueryEngine, TransactionHandle } from '../base/types';
+
+// ─── MySQL Engine ──────────────────────────────────────────────────────────────────
+
+let Mysql2: any = null;
+try { Mysql2 = require('mysql2/promise'); } catch { }
+
+export class MysqlEngine implements QueryEngine {
+  dialect: Dialect = 'mysql';
+  private pool: any = null;
+
+  constructor(adapterConfig: An5AdapterConfig) {
+    if (!Mysql2) throw new Error('mysql2 package is required for MySQL support. Run: npm install mysql2');
+    this.pool = Mysql2.createPool({
+      uri: adapterConfig.connectionString,
+      connectionLimit: adapterConfig.poolMax ?? 10,
+      connectTimeout: adapterConfig.connectionTimeout ?? 15000,
+    });
+  }
+
+  /** Convert @name → ? (positional); return ordered values */
+  private transform(query: string, params?: Record<string, any>): { text: string; values: any[] } {
+    if (!params || Object.keys(params).length === 0) return { text: query, values: [] };
+    const values: any[] = [];
+    const text = query.replace(/@(\w+)/g, (_, name: string) => {
+      values.push(params[name] ?? null);
+      return '?';
+    });
+    return { text, values };
+  }
+
+  async exec<T = any>(query: string, params?: Record<string, any>): Promise<T[]> {
+    const { text, values } = this.transform(query, params);
+    const [rows] = await this.pool.query(text, values);
+    return rows as T[];
+  }
+
+  async executeRaw(query: string, params?: Record<string, any>): Promise<number> {
+    const { text, values } = this.transform(query, params);
+    const [result] = await this.pool.query(text, values);
+    return (result as any).affectedRows ?? 0;
+  }
+
+  async connect(): Promise<void> {
+    const conn = await this.pool.getConnection();
+    conn.release();
+  }
+
+  async disconnect(): Promise<void> { await this.pool.end(); }
+
+  async beginTransaction(): Promise<TransactionHandle> {
+    const conn = await this.pool.getConnection();
+    await conn.beginTransaction();
+
+    const transform = (query: string, params?: Record<string, any>) => {
+      if (!params || Object.keys(params).length === 0) return { text: query, values: [] };
+      const values: any[] = [];
+      const text = query.replace(/@(\w+)/g, (_, name: string) => {
+        values.push(params[name] ?? null);
+        return '?';
+      });
+      return { text, values };
+    };
+
+    return {
+      exec: async <T>(q: string, p?: Record<string, any>) => {
+        const { text, values } = transform(q, p);
+        const [rows] = await conn.query(text, values);
+        return rows as T[];
+      },
+      executeRaw: async (q: string, p?: Record<string, any>) => {
+        const { text, values } = transform(q, p);
+        const [result] = await conn.query(text, values);
+        return (result as any).affectedRows ?? 0;
+      },
+      commit: async () => { await conn.commit(); conn.release(); },
+      rollback: async () => { await conn.rollback(); conn.release(); },
+    };
+  }
+}

package/typescript/mysql/index.d.ts

@@ -0,0 +1 @@
+export * from './engine';

package/typescript/mysql/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./engine"), exports);

package/typescript/mysql/index.ts

@@ -0,0 +1 @@
+export * from './engine';

package/typescript/postgres/engine.d.ts

@@ -0,0 +1,13 @@
+import type { An5AdapterConfig, Dialect, QueryEngine, TransactionHandle } from '../base/types';
+export declare class PostgresEngine implements QueryEngine {
+    dialect: Dialect;
+    private pool;
+    constructor(adapterConfig: An5AdapterConfig);
+    /** Convert @name → $N; identical names reuse the same $N */
+    private transform;
+    exec<T = any>(query: string, params?: Record<string, any>): Promise<T[]>;
+    executeRaw(query: string, params?: Record<string, any>): Promise<number>;
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    beginTransaction(): Promise<TransactionHandle>;
+}

package/typescript/postgres/engine.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PostgresEngine = void 0;
+// ─── PostgreSQL Engine ─────────────────────────────────────────────────────────────
+let PgPool = null;
+try {
+    PgPool = require('pg').Pool;
+}
+catch { }
+class PostgresEngine {
+    constructor(adapterConfig) {
+        this.dialect = 'postgres';
+        this.pool = null;
+        if (!PgPool)
+            throw new Error('pg package is required for PostgreSQL support. Run: npm install pg');
+        this.pool = new PgPool({
+            connectionString: adapterConfig.connectionString,
+            max: adapterConfig.poolMax ?? 10,
+        });
+    }
+    /** Convert @name → $N; identical names reuse the same $N */
+    transform(query, params) {
+        if (!params || Object.keys(params).length === 0)
+            return { text: query, values: [] };
+        const values = [];
+        const seen = {};
+        const text = query.replace(/@(\w+)/g, (_, name) => {
+            if (seen[name] !== undefined)
+                return `$${seen[name]}`;
+            const idx = values.length + 1;
+            seen[name] = idx;
+            values.push(params[name] ?? null);
+            return `$${idx}`;
+        });
+        return { text, values };
+    }
+    async exec(query, params) {
+        const { text, values } = this.transform(query, params);
+        const result = await this.pool.query(text, values);
+        return result.rows;
+    }
+    async executeRaw(query, params) {
+        const { text, values } = this.transform(query, params);
+        const result = await this.pool.query(text, values);
+        return result.rowCount ?? 0;
+    }
+    async connect() {
+        const client = await this.pool.connect();
+        client.release();
+    }
+    async disconnect() { await this.pool.end(); }
+    async beginTransaction() {
+        const client = await this.pool.connect();
+        await client.query('BEGIN');
+        const transform = (query, params) => {
+            if (!params || Object.keys(params).length === 0)
+                return { text: query, values: [] };
+            const values = [];
+            const seen = {};
+            const text = query.replace(/@(\w+)/g, (_, name) => {
+                if (seen[name] !== undefined)
+                    return `$${seen[name]}`;
+                const idx = values.length + 1;
+                seen[name] = idx;
+                values.push(params[name] ?? null);
+                return `$${idx}`;
+            });
+            return { text, values };
+        };
+        return {
+            exec: async (q, p) => {
+                const { text, values } = transform(q, p);
+                const r = await client.query(text, values);
+                return (r.rows || []);
+            },
+            executeRaw: async (q, p) => {
+                const { text, values } = transform(q, p);
+                const r = await client.query(text, values);
+                return r.rowCount ?? 0;
+            },
+            commit: async () => { await client.query('COMMIT'); client.release(); },
+            rollback: async () => { await client.query('ROLLBACK'); client.release(); },
+        };
+    }
+}
+exports.PostgresEngine = PostgresEngine;

package/typescript/postgres/engine.ts

@@ -0,0 +1,87 @@
+import type { An5AdapterConfig, Dialect, QueryEngine, TransactionHandle } from '../base/types';
+
+// ─── PostgreSQL Engine ─────────────────────────────────────────────────────────────
+
+let PgPool: any = null;
+try { PgPool = require('pg').Pool; } catch { }
+
+export class PostgresEngine implements QueryEngine {
+  dialect: Dialect = 'postgres';
+  private pool: any = null;
+
+  constructor(adapterConfig: An5AdapterConfig) {
+    if (!PgPool) throw new Error('pg package is required for PostgreSQL support. Run: npm install pg');
+    this.pool = new PgPool({
+      connectionString: adapterConfig.connectionString,
+      max: adapterConfig.poolMax ?? 10,
+    });
+  }
+
+  /** Convert @name → $N; identical names reuse the same $N */
+  private transform(query: string, params?: Record<string, any>): { text: string; values: any[] } {
+    if (!params || Object.keys(params).length === 0) return { text: query, values: [] };
+    const values: any[] = [];
+    const seen: Record<string, number> = {};
+    const text = query.replace(/@(\w+)/g, (_, name: string) => {
+      if (seen[name] !== undefined) return `$${seen[name]}`;
+      const idx = values.length + 1;
+      seen[name] = idx;
+      values.push(params[name] ?? null);
+      return `$${idx}`;
+    });
+    return { text, values };
+  }
+
+  async exec<T = any>(query: string, params?: Record<string, any>): Promise<T[]> {
+    const { text, values } = this.transform(query, params);
+    const result = await this.pool.query(text, values);
+    return result.rows as T[];
+  }
+
+  async executeRaw(query: string, params?: Record<string, any>): Promise<number> {
+    const { text, values } = this.transform(query, params);
+    const result = await this.pool.query(text, values);
+    return result.rowCount ?? 0;
+  }
+
+  async connect(): Promise<void> {
+    const client = await this.pool.connect();
+    client.release();
+  }
+
+  async disconnect(): Promise<void> { await this.pool.end(); }
+
+  async beginTransaction(): Promise<TransactionHandle> {
+    const client = await this.pool.connect();
+    await client.query('BEGIN');
+
+    const transform = (query: string, params?: Record<string, any>) => {
+      if (!params || Object.keys(params).length === 0) return { text: query, values: [] };
+      const values: any[] = [];
+      const seen: Record<string, number> = {};
+      const text = query.replace(/@(\w+)/g, (_, name: string) => {
+        if (seen[name] !== undefined) return `$${seen[name]}`;
+        const idx = values.length + 1;
+        seen[name] = idx;
+        values.push(params[name] ?? null);
+        return `$${idx}`;
+      });
+      return { text, values };
+    };
+
+    return {
+      exec: async <T>(q: string, p?: Record<string, any>) => {
+        const { text, values } = transform(q, p);
+        const r = await client.query(text, values);
+        return (r.rows || []) as T[];
+      },
+      executeRaw: async (q: string, p?: Record<string, any>) => {
+        const { text, values } = transform(q, p);
+        const r = await client.query(text, values);
+        return r.rowCount ?? 0;
+      },
+      commit: async () => { await client.query('COMMIT'); client.release(); },
+      rollback: async () => { await client.query('ROLLBACK'); client.release(); },
+    };
+  }
+}

package/typescript/postgres/index.d.ts

@@ -0,0 +1 @@
+export * from './engine';

package/typescript/postgres/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./engine"), exports);

package/typescript/postgres/index.ts

@@ -0,0 +1 @@
+export * from './engine';

package/typescript/sqlite/engine.d.ts

@@ -0,0 +1,13 @@
+import type { An5AdapterConfig, Dialect, QueryEngine, TransactionHandle } from '../base/types';
+export declare class SqliteEngine implements QueryEngine {
+    dialect: Dialect;
+    private db;
+    private readonly filePath;
+    constructor(adapterConfig: An5AdapterConfig);
+    private getDb;
+    exec<T = any>(query: string, params?: Record<string, any>): Promise<T[]>;
+    executeRaw(query: string, params?: Record<string, any>): Promise<number>;
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    beginTransaction(): Promise<TransactionHandle>;
+}

package/typescript/sqlite/engine.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SqliteEngine = void 0;
+// ─── SQLite Engine ─────────────────────────────────────────────────────────────────
+let BetterSqlite3 = null;
+try {
+    BetterSqlite3 = require('better-sqlite3');
+}
+catch { }
+class SqliteEngine {
+    constructor(adapterConfig) {
+        this.dialect = 'sqlite';
+        this.db = null;
+        if (!BetterSqlite3)
+            throw new Error('better-sqlite3 package is required for SQLite support. Run: npm install better-sqlite3');
+        this.filePath = adapterConfig.connectionString
+            .replace(/^sqlite:\/\/\//i, '/')
+            .replace(/^sqlite:\/\//i, '');
+    }
+    getDb() {
+        if (!this.db)
+            this.db = new BetterSqlite3(this.filePath);
+        return this.db;
+    }
+    // better-sqlite3 natively supports @name parameters
+    async exec(query, params) {
+        return this.getDb().prepare(query).all(params ?? {});
+    }
+    async executeRaw(query, params) {
+        const info = this.getDb().prepare(query).run(params ?? {});
+        return info.changes ?? 0;
+    }
+    async connect() { this.getDb(); }
+    async disconnect() {
+        if (this.db) {
+            this.db.close();
+            this.db = null;
+        }
+    }
+    async beginTransaction() {
+        const db = this.getDb();
+        db.prepare('BEGIN').run();
+        let done = false;
+        return {
+            exec: async (q, p) => db.prepare(q).all(p ?? {}),
+            executeRaw: async (q, p) => (db.prepare(q).run(p ?? {}).changes ?? 0),
+            commit: async () => { if (!done) {
+                db.prepare('COMMIT').run();
+                done = true;
+            } },
+            rollback: async () => { if (!done) {
+                db.prepare('ROLLBACK').run();
+                done = true;
+            } },
+        };
+    }
+}
+exports.SqliteEngine = SqliteEngine;