@invect/core 0.0.1

package/dist/database/connection.cjs

@@ -0,0 +1,277 @@
+const require_runtime = require("../_virtual/_rolldown/runtime.cjs");
+const require_database_schema_sqlite = require("./schema-sqlite.cjs");
+const require_database_schema_postgres = require("./schema-postgres.cjs");
+const require_database_schema_mysql = require("./schema-mysql.cjs");
+require("./schema.cjs");
+let drizzle_orm_postgres_js = require("drizzle-orm/postgres-js");
+let drizzle_orm_better_sqlite3 = require("drizzle-orm/better-sqlite3");
+let drizzle_orm_mysql2 = require("drizzle-orm/mysql2");
+let postgres = require("postgres");
+postgres = require_runtime.__toESM(postgres);
+let better_sqlite3 = require("better-sqlite3");
+better_sqlite3 = require_runtime.__toESM(better_sqlite3);
+let mysql2_promise = require("mysql2/promise");
+mysql2_promise = require_runtime.__toESM(mysql2_promise);
+let fs = require("fs");
+fs = require_runtime.__toESM(fs);
+let path = require("path");
+path = require_runtime.__toESM(path);
+//#region src/database/connection.ts
+/**
+* Database connection factory
+*/
+var DatabaseConnectionFactory = class {
+	static connections = /* @__PURE__ */ new Map();
+	static queryConnections = /* @__PURE__ */ new Map();
+	/**
+	* Create a database connection for the host database Invect runs on
+	*/
+	static async createHostDBConnection(dbConfig, logger) {
+		const connectionKey = this.generateConnectionKey(dbConfig);
+		if (this.connections.has(connectionKey)) {
+			logger.debug("Reusing existing database connection", { type: dbConfig.type });
+			return this.connections.get(connectionKey);
+		}
+		logger.info("Creating new database connection", { type: dbConfig.type });
+		let connection;
+		switch (dbConfig.type) {
+			case "postgresql":
+				connection = {
+					type: "postgresql",
+					db: await this.createPostgreSQLConnection(dbConfig, logger),
+					schema: require_database_schema_postgres.schema_postgres_exports
+				};
+				break;
+			case "sqlite":
+				connection = {
+					type: "sqlite",
+					db: await this.createSQLiteConnection(dbConfig, logger),
+					schema: require_database_schema_sqlite.schema_sqlite_exports
+				};
+				break;
+			case "mysql":
+				connection = {
+					type: "mysql",
+					db: await this.createMySQLConnection(dbConfig, logger),
+					schema: require_database_schema_mysql.schema_mysql_exports
+				};
+				break;
+			default: throw new Error(`Unsupported database type: ${dbConfig.type}`);
+		}
+		this.connections.set(connectionKey, connection);
+		return connection;
+	}
+	/**
+	* Create a database connection for external query databases (without schema)
+	*/
+	static async createQueryDbConnection(dbConfig, logger) {
+		const connectionKey = this.generateQueryConnectionKey(dbConfig);
+		if (this.queryConnections.has(connectionKey)) {
+			logger.debug("Reusing existing query database connection", {
+				type: dbConfig.type,
+				id: dbConfig.id
+			});
+			return this.queryConnections.get(connectionKey);
+		}
+		logger.info("Creating new query database connection", {
+			type: dbConfig.type,
+			id: dbConfig.id
+		});
+		let connection;
+		switch (dbConfig.type) {
+			case "postgresql":
+				connection = {
+					type: "postgresql",
+					db: await this.createPostgreSQLQueryConnection(dbConfig, logger),
+					config: dbConfig
+				};
+				break;
+			case "sqlite":
+				connection = {
+					type: "sqlite",
+					db: await this.createSQLiteQueryConnection(dbConfig, logger),
+					config: dbConfig
+				};
+				break;
+			case "mysql":
+				connection = {
+					type: "mysql",
+					db: await this.createMySQLQueryConnection(dbConfig, logger),
+					config: dbConfig
+				};
+				break;
+			default: throw new Error(`Unsupported database type: ${dbConfig.type}`);
+		}
+		this.queryConnections.set(connectionKey, connection);
+		return connection;
+	}
+	/**
+	* Helper method to prepare SQLite file path and ensure directory exists
+	*/
+	static prepareSQLiteFilePath(connectionString, logger) {
+		let filePath = connectionString.replace("sqlite:", "").replace("file:", "");
+		if (filePath !== ":memory:") {
+			if (!path.default.isAbsolute(filePath)) filePath = path.default.resolve(process.cwd(), filePath);
+			const dir = path.default.dirname(filePath);
+			if (!fs.default.existsSync(dir)) {
+				fs.default.mkdirSync(dir, { recursive: true });
+				logger.debug("Created SQLite database directory", { dir });
+			}
+		}
+		return filePath;
+	}
+	/**
+	* Helper method to configure SQLite database pragmas via better-sqlite3
+	*/
+	static configureSQLitePragmas(client) {
+		client.pragma("journal_mode = WAL");
+		client.pragma("synchronous = NORMAL");
+		client.pragma("foreign_keys = ON");
+	}
+	/**
+	* Helper method to test PostgreSQL connection
+	*/
+	static async testPostgreSQLConnection(client, logger, isQuery = false, configId) {
+		try {
+			await client`SELECT 1`;
+			const message = isQuery ? "PostgreSQL query connection established successfully" : "PostgreSQL connection established successfully";
+			const logData = isQuery && configId ? { id: configId } : void 0;
+			logger.info(message, logData);
+		} catch (error) {
+			const errorMessage = isQuery ? "Failed to connect to PostgreSQL query database" : "Failed to connect to PostgreSQL";
+			logger.error(errorMessage, error);
+			throw error;
+		}
+	}
+	/**
+	* Helper method to test MySQL connection
+	*/
+	static async testMySQLConnection(connection, logger, isQuery = false, configId) {
+		try {
+			await connection.execute("SELECT 1");
+			const message = isQuery ? "MySQL query connection established successfully" : "MySQL connection established successfully";
+			const logData = isQuery && configId ? { id: configId } : void 0;
+			logger.info(message, logData);
+		} catch (error) {
+			const errorMessage = isQuery ? "Failed to connect to MySQL query database" : "Failed to connect to MySQL";
+			logger.error(errorMessage, error);
+			throw error;
+		}
+	}
+	/**
+	* Create PostgreSQL connection
+	*/
+	static async createPostgreSQLConnection(config, logger) {
+		const client = (0, postgres.default)(config.connectionString, { onnotice: (notice) => logger.debug("PostgreSQL notice", notice) });
+		const db = (0, drizzle_orm_postgres_js.drizzle)(client, { schema: require_database_schema_postgres.schema_postgres_exports });
+		await this.testPostgreSQLConnection(client, logger);
+		return db;
+	}
+	/**
+	* Create SQLite connection
+	*/
+	static async createSQLiteConnection(config, logger) {
+		const filePath = this.prepareSQLiteFilePath(config.connectionString, logger);
+		const client = new better_sqlite3.default(filePath === ":memory:" ? ":memory:" : filePath);
+		this.configureSQLitePragmas(client);
+		const db = (0, drizzle_orm_better_sqlite3.drizzle)(client, { schema: require_database_schema_sqlite.schema_sqlite_exports });
+		logger.debug("Skipping SQLite migrations - assuming database conforms to schema");
+		logger.info("SQLite connection established successfully", { filePath });
+		return db;
+	}
+	/**
+	* Create MySQL connection
+	*/
+	static async createMySQLConnection(config, logger) {
+		const connection = mysql2_promise.default.createPool(config.connectionString);
+		const db = (0, drizzle_orm_mysql2.drizzle)(connection, {
+			schema: require_database_schema_mysql.schema_mysql_exports,
+			mode: "default"
+		});
+		await this.testMySQLConnection(connection, logger);
+		return db;
+	}
+	/**
+	* Create PostgreSQL query connection (without schema)
+	*/
+	static async createPostgreSQLQueryConnection(config, logger) {
+		const client = (0, postgres.default)(config.connectionString, { onnotice: (notice) => logger.debug("PostgreSQL notice", notice) });
+		const db = (0, drizzle_orm_postgres_js.drizzle)(client);
+		await this.testPostgreSQLConnection(client, logger, true, config.id);
+		return db;
+	}
+	/**
+	* Create SQLite query connection (without schema)
+	*/
+	static async createSQLiteQueryConnection(config, logger) {
+		const filePath = this.prepareSQLiteFilePath(config.connectionString, logger);
+		const client = new better_sqlite3.default(filePath === ":memory:" ? ":memory:" : filePath);
+		this.configureSQLitePragmas(client);
+		const db = (0, drizzle_orm_better_sqlite3.drizzle)(client);
+		logger.info("SQLite query connection established successfully", {
+			filePath,
+			id: config.id
+		});
+		return db;
+	}
+	/**
+	* Create MySQL query connection (without schema)
+	*/
+	static async createMySQLQueryConnection(config, logger) {
+		const connection = mysql2_promise.default.createPool(config.connectionString);
+		const db = (0, drizzle_orm_mysql2.drizzle)(connection, { mode: "default" });
+		await this.testMySQLConnection(connection, logger, true, config.id);
+		return db;
+	}
+	/**
+	* Generate a unique key for connection caching
+	*/
+	static generateConnectionKey(config) {
+		return `${config.type}:${config.connectionString}`;
+	}
+	/**
+	* Generate a unique key for query connection caching
+	*/
+	static generateQueryConnectionKey(config) {
+		return `query:${config.type}:${config.id}:${config.connectionString}`;
+	}
+	/**
+	* Close all connections
+	*/
+	static async closeAllConnections(logger) {
+		logger.info("Closing all database connections");
+		for (const [key, _connection] of this.connections) try {
+			logger.debug("Host connection closed", { key });
+		} catch (error) {
+			logger.error("Error closing host connection", {
+				key,
+				error
+			});
+		}
+		for (const [key, _connection] of this.queryConnections) try {
+			logger.debug("Query connection closed", { key });
+		} catch (error) {
+			logger.error("Error closing query connection", {
+				key,
+				error
+			});
+		}
+		this.connections.clear();
+		this.queryConnections.clear();
+	}
+	/**
+	* Get schema for database type
+	*/
+	static getSchema(type) {
+		switch (type) {
+			case "postgresql": return require_database_schema_postgres.schema_postgres_exports;
+			case "sqlite": return require_database_schema_sqlite.schema_sqlite_exports;
+			case "mysql": return require_database_schema_mysql.schema_mysql_exports;
+			default: throw new Error(`Unsupported database type: ${type}`);
+		}
+	}
+};
+//#endregion
+exports.DatabaseConnectionFactory = DatabaseConnectionFactory;
+
+//# sourceMappingURL=connection.cjs.map

package/dist/database/connection.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"connection.cjs","names":["postgresqlSchema","sqliteSchema","mysqlSchema","Database","mysql"],"sources":["../../src/database/connection.ts"],"sourcesContent":["// Database connection management for Invect core\nimport { drizzle } from 'drizzle-orm/postgres-js';\nimport { drizzle as drizzleSQLite } from 'drizzle-orm/better-sqlite3';\nimport { drizzle as drizzleMySQL } from 'drizzle-orm/mysql2';\nimport postgres from 'postgres';\nimport Database from 'better-sqlite3';\nimport mysql from 'mysql2/promise';\nimport fs from 'fs';\nimport path from 'path';\n\nimport { sqliteSchema, mysqlSchema, postgresqlSchema } from './schema';\n\nimport { Logger, InvectDatabaseConfig } from 'src/types/schemas';\n\n/**\n * Database connection type - discriminated union based on database type\n */\nexport type DatabaseConnection =\n  | {\n      type: 'postgresql';\n      db: ReturnType<typeof drizzle<typeof postgresqlSchema>>;\n      schema: typeof postgresqlSchema;\n    }\n  | {\n      type: 'sqlite';\n      db: ReturnType<typeof drizzleSQLite<typeof sqliteSchema>>;\n      schema: typeof sqliteSchema;\n    }\n  | {\n      type: 'mysql';\n      db: ReturnType<typeof drizzleMySQL<typeof mysqlSchema>>;\n      schema: typeof mysqlSchema;\n    };\n\n/**\n * Query database connection type - for external databases without schemas\n */\nexport type QueryDatabaseConnection =\n  | {\n      type: 'postgresql';\n      db: ReturnType<typeof drizzle>;\n      config: InvectDatabaseConfig;\n    }\n  | {\n      type: 'sqlite';\n      db: ReturnType<typeof drizzleSQLite>;\n      config: InvectDatabaseConfig;\n    }\n  | {\n      type: 'mysql';\n      db: ReturnType<typeof drizzleMySQL>;\n      config: InvectDatabaseConfig;\n    };\n\n/**\n * Database connection factory\n */\nexport class DatabaseConnectionFactory {\n  private static connections = new Map<string, DatabaseConnection>();\n  private static queryConnections = new Map<string, QueryDatabaseConnection>();\n\n  /**\n   * Create a database connection for the host database Invect runs on\n   */\n  static async createHostDBConnection(\n    dbConfig: InvectDatabaseConfig,\n    logger: Logger,\n  ): Promise<DatabaseConnection> {\n    const connectionKey = this.generateConnectionKey(dbConfig);\n\n    if (this.connections.has(connectionKey)) {\n      logger.debug('Reusing existing database connection', { type: dbConfig.type });\n      return this.connections.get(connectionKey) as DatabaseConnection;\n    }\n\n    logger.info('Creating new database connection', { type: dbConfig.type });\n\n    let connection: DatabaseConnection;\n\n    switch (dbConfig.type) {\n      case 'postgresql': {\n        const pgDb = await this.createPostgreSQLConnection(dbConfig, logger);\n        connection = {\n          type: 'postgresql',\n          db: pgDb,\n          schema: postgresqlSchema,\n        };\n        break;\n      }\n      case 'sqlite': {\n        const sqliteDb = await this.createSQLiteConnection(dbConfig, logger);\n        connection = {\n          type: 'sqlite',\n          db: sqliteDb,\n          schema: sqliteSchema,\n        };\n        break;\n      }\n      case 'mysql': {\n        const mysqlDb = await this.createMySQLConnection(dbConfig, logger);\n        connection = {\n          type: 'mysql',\n          db: mysqlDb,\n          schema: mysqlSchema,\n        };\n        break;\n      }\n      default:\n        throw new Error(`Unsupported database type: ${dbConfig.type}`);\n    }\n\n    this.connections.set(connectionKey, connection);\n    return connection;\n  }\n\n  /**\n   * Create a database connection for external query databases (without schema)\n   */\n  static async createQueryDbConnection(\n    dbConfig: InvectDatabaseConfig,\n    logger: Logger,\n  ): Promise<QueryDatabaseConnection> {\n    const connectionKey = this.generateQueryConnectionKey(dbConfig);\n\n    if (this.queryConnections.has(connectionKey)) {\n      logger.debug('Reusing existing query database connection', {\n        type: dbConfig.type,\n        id: dbConfig.id,\n      });\n      return this.queryConnections.get(connectionKey) as QueryDatabaseConnection;\n    }\n\n    logger.info('Creating new query database connection', { type: dbConfig.type, id: dbConfig.id });\n\n    let connection: QueryDatabaseConnection;\n\n    switch (dbConfig.type) {\n      case 'postgresql': {\n        const pgDb = await this.createPostgreSQLQueryConnection(dbConfig, logger);\n        connection = {\n          type: 'postgresql',\n          db: pgDb,\n          config: dbConfig,\n        };\n        break;\n      }\n      case 'sqlite': {\n        const sqliteDb = await this.createSQLiteQueryConnection(dbConfig, logger);\n        connection = {\n          type: 'sqlite',\n          db: sqliteDb,\n          config: dbConfig,\n        };\n        break;\n      }\n      case 'mysql': {\n        const mysqlDb = await this.createMySQLQueryConnection(dbConfig, logger);\n        connection = {\n          type: 'mysql',\n          db: mysqlDb,\n          config: dbConfig,\n        };\n        break;\n      }\n      default:\n        throw new Error(`Unsupported database type: ${dbConfig.type}`);\n    }\n\n    this.queryConnections.set(connectionKey, connection);\n    return connection;\n  }\n\n  /**\n   * Helper method to prepare SQLite file path and ensure directory exists\n   */\n  private static prepareSQLiteFilePath(connectionString: string, logger: Logger): string {\n    // Extract file path from SQLite URL\n    let filePath = connectionString.replace('sqlite:', '').replace('file:', '');\n\n    // Ensure the directory exists for SQLite files\n    if (filePath !== ':memory:') {\n      // Resolve relative paths to absolute paths\n      if (!path.isAbsolute(filePath)) {\n        filePath = path.resolve(process.cwd(), filePath);\n      }\n\n      const dir = path.dirname(filePath);\n      if (!fs.existsSync(dir)) {\n        fs.mkdirSync(dir, { recursive: true });\n        logger.debug('Created SQLite database directory', { dir });\n      }\n    }\n\n    return filePath;\n  }\n\n  /**\n   * Helper method to configure SQLite database pragmas via better-sqlite3\n   */\n  private static configureSQLitePragmas(client: InstanceType<typeof Database>): void {\n    client.pragma('journal_mode = WAL');\n    client.pragma('synchronous = NORMAL');\n    client.pragma('foreign_keys = ON');\n  }\n\n  /**\n   * Helper method to test PostgreSQL connection\n   */\n  private static async testPostgreSQLConnection(\n    client: postgres.Sql,\n    logger: Logger,\n    isQuery: boolean = false,\n    configId?: string,\n  ): Promise<void> {\n    try {\n      await client`SELECT 1`;\n      const message = isQuery\n        ? 'PostgreSQL query connection established successfully'\n        : 'PostgreSQL connection established successfully';\n      const logData = isQuery && configId ? { id: configId } : undefined;\n      logger.info(message, logData);\n    } catch (error) {\n      const errorMessage = isQuery\n        ? 'Failed to connect to PostgreSQL query database'\n        : 'Failed to connect to PostgreSQL';\n      logger.error(errorMessage, error);\n      throw error;\n    }\n  }\n\n  /**\n   * Helper method to test MySQL connection\n   */\n  private static async testMySQLConnection(\n    connection: mysql.Pool,\n    logger: Logger,\n    isQuery: boolean = false,\n    configId?: string,\n  ): Promise<void> {\n    try {\n      await connection.execute('SELECT 1');\n      const message = isQuery\n        ? 'MySQL query connection established successfully'\n        : 'MySQL connection established successfully';\n      const logData = isQuery && configId ? { id: configId } : undefined;\n      logger.info(message, logData);\n    } catch (error) {\n      const errorMessage = isQuery\n        ? 'Failed to connect to MySQL query database'\n        : 'Failed to connect to MySQL';\n      logger.error(errorMessage, error);\n      throw error;\n    }\n  }\n\n  /**\n   * Create PostgreSQL connection\n   */\n  private static async createPostgreSQLConnection(\n    config: InvectDatabaseConfig,\n    logger: Logger,\n  ): Promise<ReturnType<typeof drizzle<typeof postgresqlSchema>>> {\n    const client = postgres(config.connectionString, {\n      onnotice: (notice) => logger.debug('PostgreSQL notice', notice),\n    });\n\n    const db = drizzle(client, { schema: postgresqlSchema });\n\n    // Test connection\n    await this.testPostgreSQLConnection(client, logger);\n\n    return db;\n  }\n\n  /**\n   * Create SQLite connection\n   */\n  private static async createSQLiteConnection(\n    config: InvectDatabaseConfig,\n    logger: Logger,\n  ): Promise<ReturnType<typeof drizzleSQLite<typeof sqliteSchema>>> {\n    const filePath = this.prepareSQLiteFilePath(config.connectionString, logger);\n\n    const dbPath = filePath === ':memory:' ? ':memory:' : filePath;\n    const client = new Database(dbPath);\n    this.configureSQLitePragmas(client);\n\n    const db = drizzleSQLite(client, { schema: sqliteSchema });\n\n    // Skip migrations - assume database already conforms to schema\n    logger.debug('Skipping SQLite migrations - assuming database conforms to schema');\n\n    logger.info('SQLite connection established successfully', { filePath });\n    return db;\n  }\n\n  /**\n   * Create MySQL connection\n   */\n  private static async createMySQLConnection(\n    config: InvectDatabaseConfig,\n    logger: Logger,\n  ): Promise<ReturnType<typeof drizzleMySQL<typeof mysqlSchema>>> {\n    const connection = mysql.createPool(config.connectionString);\n\n    const db = drizzleMySQL(connection, { schema: mysqlSchema, mode: 'default' });\n\n    // Test connection\n    await this.testMySQLConnection(connection, logger);\n\n    return db as unknown as ReturnType<typeof drizzleMySQL<typeof mysqlSchema>>;\n  }\n\n  /**\n   * Create PostgreSQL query connection (without schema)\n   */\n  private static async createPostgreSQLQueryConnection(\n    config: InvectDatabaseConfig,\n    logger: Logger,\n  ): Promise<ReturnType<typeof drizzle>> {\n    const client = postgres(config.connectionString, {\n      onnotice: (notice) => logger.debug('PostgreSQL notice', notice),\n    });\n\n    const db = drizzle(client);\n\n    // Test connection\n    await this.testPostgreSQLConnection(client, logger, true, config.id);\n\n    return db;\n  }\n\n  /**\n   * Create SQLite query connection (without schema)\n   */\n  private static async createSQLiteQueryConnection(\n    config: InvectDatabaseConfig,\n    logger: Logger,\n  ): Promise<ReturnType<typeof drizzleSQLite>> {\n    const filePath = this.prepareSQLiteFilePath(config.connectionString, logger);\n\n    const dbPath = filePath === ':memory:' ? ':memory:' : filePath;\n    const client = new Database(dbPath);\n    this.configureSQLitePragmas(client);\n\n    const db = drizzleSQLite(client);\n\n    logger.info('SQLite query connection established successfully', { filePath, id: config.id });\n    return db;\n  }\n\n  /**\n   * Create MySQL query connection (without schema)\n   */\n  private static async createMySQLQueryConnection(\n    config: InvectDatabaseConfig,\n    logger: Logger,\n  ): Promise<ReturnType<typeof drizzleMySQL>> {\n    const connection = mysql.createPool(config.connectionString);\n\n    const db = drizzleMySQL(connection, { mode: 'default' });\n\n    // Test connection\n    await this.testMySQLConnection(connection, logger, true, config.id);\n\n    return db as unknown as ReturnType<typeof drizzleMySQL>;\n  }\n\n  /**\n   * Generate a unique key for connection caching\n   */\n  private static generateConnectionKey(config: InvectDatabaseConfig): string {\n    return `${config.type}:${config.connectionString}`;\n  }\n\n  /**\n   * Generate a unique key for query connection caching\n   */\n  private static generateQueryConnectionKey(config: InvectDatabaseConfig): string {\n    return `query:${config.type}:${config.id}:${config.connectionString}`;\n  }\n\n  /**\n   * Close all connections\n   */\n  static async closeAllConnections(logger: Logger): Promise<void> {\n    logger.info('Closing all database connections');\n\n    // Close host database connections\n    for (const [key, _connection] of this.connections) {\n      try {\n        // The connections are not directly closeable in Drizzle,\n        // but the underlying clients handle cleanup\n        logger.debug('Host connection closed', { key });\n      } catch (error) {\n        logger.error('Error closing host connection', { key, error });\n      }\n    }\n\n    // Close query database connections\n    for (const [key, _connection] of this.queryConnections) {\n      try {\n        // The connections are not directly closeable in Drizzle,\n        // but the underlying clients handle cleanup\n        logger.debug('Query connection closed', { key });\n      } catch (error) {\n        logger.error('Error closing query connection', { key, error });\n      }\n    }\n\n    this.connections.clear();\n    this.queryConnections.clear();\n  }\n\n  /**\n   * Get schema for database type\n   */\n  static getSchema(type: InvectDatabaseConfig['type']) {\n    switch (type) {\n      case 'postgresql':\n        return postgresqlSchema;\n      case 'sqlite':\n        return sqliteSchema;\n      case 'mysql':\n        return mysqlSchema;\n      default:\n        throw new Error(`Unsupported database type: ${type}`);\n    }\n  }\n}\n"],"mappings":"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"}

package/dist/database/connection.d.cts

@@ -0,0 +1,115 @@
+import { InvectDatabaseConfig, Logger } from "../types/schemas-fresh/invect-config.cjs";
+import { schema_sqlite_d_exports } from "./schema-sqlite.cjs";
+import { schema_postgres_d_exports } from "./schema-postgres.cjs";
+import { schema_mysql_d_exports } from "./schema-mysql.cjs";
+import { drizzle } from "drizzle-orm/postgres-js";
+import { drizzle as drizzle$1 } from "drizzle-orm/better-sqlite3";
+import { drizzle as drizzle$2 } from "drizzle-orm/mysql2";
+
+//#region src/database/connection.d.ts
+/**
+ * Database connection type - discriminated union based on database type
+ */
+type DatabaseConnection = {
+  type: 'postgresql';
+  db: ReturnType<typeof drizzle<typeof schema_postgres_d_exports>>;
+  schema: typeof schema_postgres_d_exports;
+} | {
+  type: 'sqlite';
+  db: ReturnType<typeof drizzle$1<typeof schema_sqlite_d_exports>>;
+  schema: typeof schema_sqlite_d_exports;
+} | {
+  type: 'mysql';
+  db: ReturnType<typeof drizzle$2<typeof schema_mysql_d_exports>>;
+  schema: typeof schema_mysql_d_exports;
+};
+/**
+ * Query database connection type - for external databases without schemas
+ */
+type QueryDatabaseConnection = {
+  type: 'postgresql';
+  db: ReturnType<typeof drizzle>;
+  config: InvectDatabaseConfig;
+} | {
+  type: 'sqlite';
+  db: ReturnType<typeof drizzle$1>;
+  config: InvectDatabaseConfig;
+} | {
+  type: 'mysql';
+  db: ReturnType<typeof drizzle$2>;
+  config: InvectDatabaseConfig;
+};
+/**
+ * Database connection factory
+ */
+declare class DatabaseConnectionFactory {
+  private static connections;
+  private static queryConnections;
+  /**
+   * Create a database connection for the host database Invect runs on
+   */
+  static createHostDBConnection(dbConfig: InvectDatabaseConfig, logger: Logger): Promise<DatabaseConnection>;
+  /**
+   * Create a database connection for external query databases (without schema)
+   */
+  static createQueryDbConnection(dbConfig: InvectDatabaseConfig, logger: Logger): Promise<QueryDatabaseConnection>;
+  /**
+   * Helper method to prepare SQLite file path and ensure directory exists
+   */
+  private static prepareSQLiteFilePath;
+  /**
+   * Helper method to configure SQLite database pragmas via better-sqlite3
+   */
+  private static configureSQLitePragmas;
+  /**
+   * Helper method to test PostgreSQL connection
+   */
+  private static testPostgreSQLConnection;
+  /**
+   * Helper method to test MySQL connection
+   */
+  private static testMySQLConnection;
+  /**
+   * Create PostgreSQL connection
+   */
+  private static createPostgreSQLConnection;
+  /**
+   * Create SQLite connection
+   */
+  private static createSQLiteConnection;
+  /**
+   * Create MySQL connection
+   */
+  private static createMySQLConnection;
+  /**
+   * Create PostgreSQL query connection (without schema)
+   */
+  private static createPostgreSQLQueryConnection;
+  /**
+   * Create SQLite query connection (without schema)
+   */
+  private static createSQLiteQueryConnection;
+  /**
+   * Create MySQL query connection (without schema)
+   */
+  private static createMySQLQueryConnection;
+  /**
+   * Generate a unique key for connection caching
+   */
+  private static generateConnectionKey;
+  /**
+   * Generate a unique key for query connection caching
+   */
+  private static generateQueryConnectionKey;
+  /**
+   * Close all connections
+   */
+  static closeAllConnections(logger: Logger): Promise<void>;
+  /**
+   * Get schema for database type
+   */
+  static getSchema(type: InvectDatabaseConfig['type']): typeof schema_postgres_d_exports | typeof schema_sqlite_d_exports | typeof schema_mysql_d_exports;
+}
+//#endregion
+export { DatabaseConnection, DatabaseConnectionFactory, QueryDatabaseConnection };
+//# sourceMappingURL=connection.d.cts.map

package/dist/database/connection.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"connection.d.cts","names":[],"sources":["../../src/database/connection.ts"],"mappings":";;;;;;;;;;;;KAiBY,kBAAA;EAEN,IAAA;EACA,EAAA,EAAI,UAAA,QAAkB,OAAA,QAAe,yBAAA;EACrC,MAAA,SAAe,yBAAA;AAAA;EAGf,IAAA;EACA,EAAA,EAAI,UAAA,QAAkB,SAAA,QAAqB,uBAAA;EAC3C,MAAA,SAAe,uBAAA;AAAA;EAGf,IAAA;EACA,EAAA,EAAI,UAAA,QAAkB,SAAA,QAAoB,sBAAA;EAC1C,MAAA,SAAe,sBAAA;AAAA;;;;KAMT,uBAAA;EAEN,IAAA;EACA,EAAA,EAAI,UAAA,QAAkB,OAAA;EACtB,MAAA,EAAQ,oBAAA;AAAA;EAGR,IAAA;EACA,EAAA,EAAI,UAAA,QAAkB,SAAA;EACtB,MAAA,EAAQ,oBAAA;AAAA;EAGR,IAAA;EACA,EAAA,EAAI,UAAA,QAAkB,SAAA;EACtB,MAAA,EAAQ,oBAAA;AAAA;;;;cAMD,yBAAA;EAAA,eACI,WAAA;EAAA,eACA,gBAAA;EA7BP;;;EAAA,OAkCK,sBAAA,CACX,QAAA,EAAU,oBAAA,EACV,MAAA,EAAQ,MAAA,GACP,OAAA,CAAQ,kBAAA;EApCQ;;;EAAA,OAuFN,uBAAA,CACX,QAAA,EAAU,oBAAA,EACV,MAAA,EAAQ,MAAA,GACP,OAAA,CAAQ,uBAAA;EApFsB;;;EAAA,eA0IlB,qBAAA;EAtIH;;;EAAA,eA8JG,sBAAA;EArJW;;;EAAA,eA8JL,wBAAA;EA7JW;;;EAAA,eAsLX,mBAAA;EAjMK;;;EAAA,eA0NL,0BAAA;EArNjB;;;EAAA,eAwOiB,sBAAA;EAvOT;;;EAAA,eA6PS,qBAAA;EAzPK;;;EAAA,eA0QL,+BAAA;EAzQW;AAMlC;;EANkC,eA4RX,2BAAA;EA9QT;;;EAAA,eAiSS,0BAAA;EA3OT;;;EAAA,eA4PG,qBAAA;EAc0B;;;EAAA,eAP1B,0BAAA;EAuCoC;;;EAAA,OAhCtC,mBAAA,CAAoB,MAAA,EAAQ,MAAA,GAAS,OAAA;EAvUnC;;;EAAA,OAuWR,SAAA,CAAU,IAAA,EAAM,oBAAA,kBAA4B,yBAAA,UAAA,uBAAA,UAAA,sBAAA;AAAA"}

package/dist/database/connection.d.ts

@@ -0,0 +1,115 @@
+import { InvectDatabaseConfig, Logger } from "../types/schemas-fresh/invect-config.js";
+import { schema_sqlite_d_exports } from "./schema-sqlite.js";
+import { schema_postgres_d_exports } from "./schema-postgres.js";
+import { schema_mysql_d_exports } from "./schema-mysql.js";
+import { drizzle } from "drizzle-orm/postgres-js";
+import { drizzle as drizzle$1 } from "drizzle-orm/better-sqlite3";
+import { drizzle as drizzle$2 } from "drizzle-orm/mysql2";
+
+//#region src/database/connection.d.ts
+/**
+ * Database connection type - discriminated union based on database type
+ */
+type DatabaseConnection = {
+  type: 'postgresql';
+  db: ReturnType<typeof drizzle<typeof schema_postgres_d_exports>>;
+  schema: typeof schema_postgres_d_exports;
+} | {
+  type: 'sqlite';
+  db: ReturnType<typeof drizzle$1<typeof schema_sqlite_d_exports>>;
+  schema: typeof schema_sqlite_d_exports;
+} | {
+  type: 'mysql';
+  db: ReturnType<typeof drizzle$2<typeof schema_mysql_d_exports>>;
+  schema: typeof schema_mysql_d_exports;
+};
+/**
+ * Query database connection type - for external databases without schemas
+ */
+type QueryDatabaseConnection = {
+  type: 'postgresql';
+  db: ReturnType<typeof drizzle>;
+  config: InvectDatabaseConfig;
+} | {
+  type: 'sqlite';
+  db: ReturnType<typeof drizzle$1>;
+  config: InvectDatabaseConfig;
+} | {
+  type: 'mysql';
+  db: ReturnType<typeof drizzle$2>;
+  config: InvectDatabaseConfig;
+};
+/**
+ * Database connection factory
+ */
+declare class DatabaseConnectionFactory {
+  private static connections;
+  private static queryConnections;
+  /**
+   * Create a database connection for the host database Invect runs on
+   */
+  static createHostDBConnection(dbConfig: InvectDatabaseConfig, logger: Logger): Promise<DatabaseConnection>;
+  /**
+   * Create a database connection for external query databases (without schema)
+   */
+  static createQueryDbConnection(dbConfig: InvectDatabaseConfig, logger: Logger): Promise<QueryDatabaseConnection>;
+  /**
+   * Helper method to prepare SQLite file path and ensure directory exists
+   */
+  private static prepareSQLiteFilePath;
+  /**
+   * Helper method to configure SQLite database pragmas via better-sqlite3
+   */
+  private static configureSQLitePragmas;
+  /**
+   * Helper method to test PostgreSQL connection
+   */
+  private static testPostgreSQLConnection;
+  /**
+   * Helper method to test MySQL connection
+   */
+  private static testMySQLConnection;
+  /**
+   * Create PostgreSQL connection
+   */
+  private static createPostgreSQLConnection;
+  /**
+   * Create SQLite connection
+   */
+  private static createSQLiteConnection;
+  /**
+   * Create MySQL connection
+   */
+  private static createMySQLConnection;
+  /**
+   * Create PostgreSQL query connection (without schema)
+   */
+  private static createPostgreSQLQueryConnection;
+  /**
+   * Create SQLite query connection (without schema)
+   */
+  private static createSQLiteQueryConnection;
+  /**
+   * Create MySQL query connection (without schema)
+   */
+  private static createMySQLQueryConnection;
+  /**
+   * Generate a unique key for connection caching
+   */
+  private static generateConnectionKey;
+  /**
+   * Generate a unique key for query connection caching
+   */
+  private static generateQueryConnectionKey;
+  /**
+   * Close all connections
+   */
+  static closeAllConnections(logger: Logger): Promise<void>;
+  /**
+   * Get schema for database type
+   */
+  static getSchema(type: InvectDatabaseConfig['type']): typeof schema_postgres_d_exports | typeof schema_sqlite_d_exports | typeof schema_mysql_d_exports;
+}
+//#endregion
+export { DatabaseConnection, DatabaseConnectionFactory, QueryDatabaseConnection };
+//# sourceMappingURL=connection.d.ts.map

package/dist/database/connection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"connection.d.ts","names":[],"sources":["../../src/database/connection.ts"],"mappings":";;;;;;;;;;;;KAiBY,kBAAA;EAEN,IAAA;EACA,EAAA,EAAI,UAAA,QAAkB,OAAA,QAAe,yBAAA;EACrC,MAAA,SAAe,yBAAA;AAAA;EAGf,IAAA;EACA,EAAA,EAAI,UAAA,QAAkB,SAAA,QAAqB,uBAAA;EAC3C,MAAA,SAAe,uBAAA;AAAA;EAGf,IAAA;EACA,EAAA,EAAI,UAAA,QAAkB,SAAA,QAAoB,sBAAA;EAC1C,MAAA,SAAe,sBAAA;AAAA;;;;KAMT,uBAAA;EAEN,IAAA;EACA,EAAA,EAAI,UAAA,QAAkB,OAAA;EACtB,MAAA,EAAQ,oBAAA;AAAA;EAGR,IAAA;EACA,EAAA,EAAI,UAAA,QAAkB,SAAA;EACtB,MAAA,EAAQ,oBAAA;AAAA;EAGR,IAAA;EACA,EAAA,EAAI,UAAA,QAAkB,SAAA;EACtB,MAAA,EAAQ,oBAAA;AAAA;;;;cAMD,yBAAA;EAAA,eACI,WAAA;EAAA,eACA,gBAAA;EA7BX;;;EAAA,OAkCS,sBAAA,CACX,QAAA,EAAU,oBAAA,EACV,MAAA,EAAQ,MAAA,GACP,OAAA,CAAQ,kBAAA;EApCP;;;EAAA,OAuFS,uBAAA,CACX,QAAA,EAAU,oBAAA,EACV,MAAA,EAAQ,MAAA,GACP,OAAA,CAAQ,uBAAA;EApFD;;;EAAA,eA0IK,qBAAA;EAvIP;;;EAAA,eA+JO,sBAAA;EAzJH;;;EAAA,eAkKS,wBAAA;EA7JW;;;EAAA,eAsLX,mBAAA;EAjMb;;;EAAA,eA0Na,0BAAA;EAtNjB;;;EAAA,eAyOiB,sBAAA;EAvOjB;;;EAAA,eA6PiB,qBAAA;EAzPb;;;EAAA,eA0Qa,+BAAA;EAzQW;;AAMlC;EANkC,eA4RX,2BAAA;;;;iBAmBA,0BAAA;EA/RlB;;;EAAA,eAgTY,qBAAA;EA1PZ;;;EAAA,eAiQY,0BAAA;EAuCoC;;;EAAA,OAhCtC,mBAAA,CAAoB,MAAA,EAAQ,MAAA,GAAS,OAAA;EAgCC;;;EAAA,OAA5C,SAAA,CAAU,IAAA,EAAM,oBAAA,kBAA4B,yBAAA,UAAA,uBAAA,UAAA,sBAAA;AAAA"}