@llmops/core 0.1.0-beta.11 → 0.1.0-beta.12

package/dist/bun-sqlite-dialect-D0Q9d80w.cjs

@@ -0,0 +1,156 @@
+const require_db = require('./db-CUPUfhtT.cjs');
+let kysely = require("kysely");
+
+//#region src/db/bun-sqlite-dialect.ts
+var BunSqliteAdapter = class {
+	get supportsCreateIfNotExists() {
+		return true;
+	}
+	get supportsTransactionalDdl() {
+		return false;
+	}
+	get supportsReturning() {
+		return true;
+	}
+	async acquireMigrationLock() {}
+	async releaseMigrationLock() {}
+	get supportsOutput() {
+		return true;
+	}
+};
+var BunSqliteDriver = class {
+	#config;
+	#connectionMutex = new ConnectionMutex();
+	#db;
+	#connection;
+	constructor(config) {
+		this.#config = { ...config };
+	}
+	async init() {
+		this.#db = this.#config.database;
+		this.#connection = new BunSqliteConnection(this.#db);
+		if (this.#config.onCreateConnection) await this.#config.onCreateConnection(this.#connection);
+	}
+	async acquireConnection() {
+		await this.#connectionMutex.lock();
+		return this.#connection;
+	}
+	async beginTransaction(connection) {
+		await connection.executeQuery(kysely.CompiledQuery.raw("begin"));
+	}
+	async commitTransaction(connection) {
+		await connection.executeQuery(kysely.CompiledQuery.raw("commit"));
+	}
+	async rollbackTransaction(connection) {
+		await connection.executeQuery(kysely.CompiledQuery.raw("rollback"));
+	}
+	async releaseConnection() {
+		this.#connectionMutex.unlock();
+	}
+	async destroy() {
+		this.#db?.close();
+	}
+};
+var BunSqliteConnection = class {
+	#db;
+	constructor(db) {
+		this.#db = db;
+	}
+	executeQuery(compiledQuery) {
+		const { sql: sql$1, parameters } = compiledQuery;
+		const stmt = this.#db.prepare(sql$1);
+		return Promise.resolve({ rows: stmt.all(parameters) });
+	}
+	async *streamQuery() {
+		throw new Error("Streaming query is not supported by SQLite driver.");
+	}
+};
+var ConnectionMutex = class {
+	#promise;
+	#resolve;
+	async lock() {
+		while (this.#promise) await this.#promise;
+		this.#promise = new Promise((resolve) => {
+			this.#resolve = resolve;
+		});
+	}
+	unlock() {
+		const resolve = this.#resolve;
+		this.#promise = void 0;
+		this.#resolve = void 0;
+		resolve?.();
+	}
+};
+var BunSqliteIntrospector = class {
+	#db;
+	constructor(db) {
+		this.#db = db;
+	}
+	async getSchemas() {
+		return [];
+	}
+	async getTables(options = { withInternalKyselyTables: false }) {
+		let query = this.#db.selectFrom("sqlite_schema").where("type", "=", "table").where("name", "not like", "sqlite_%").select("name").$castTo();
+		if (!options.withInternalKyselyTables) query = query.where("name", "!=", kysely.DEFAULT_MIGRATION_TABLE).where("name", "!=", kysely.DEFAULT_MIGRATION_LOCK_TABLE);
+		const tables = await query.execute();
+		return Promise.all(tables.map(({ name }) => this.#getTableMetadata(name)));
+	}
+	async getMetadata(options) {
+		return { tables: await this.getTables(options) };
+	}
+	async #getTableMetadata(table) {
+		const db = this.#db;
+		const autoIncrementCol = (await db.selectFrom("sqlite_master").where("name", "=", table).select("sql").$castTo().execute())[0]?.sql?.split(/[\(\),]/)?.find((it) => it.toLowerCase().includes("autoincrement"))?.split(/\s+/)?.[0]?.replace(/["`]/g, "");
+		return {
+			name: table,
+			columns: (await db.selectFrom(kysely.sql`pragma_table_info(${table})`.as("table_info")).select([
+				"name",
+				"type",
+				"notnull",
+				"dflt_value"
+			]).execute()).map((col) => ({
+				name: col.name,
+				dataType: col.type,
+				isNullable: !col.notnull,
+				isAutoIncrementing: col.name === autoIncrementCol,
+				hasDefaultValue: col.dflt_value != null
+			})),
+			isView: true
+		};
+	}
+};
+var BunSqliteQueryCompiler = class extends kysely.DefaultQueryCompiler {
+	getCurrentParameterPlaceholder() {
+		return "?";
+	}
+	getLeftIdentifierWrapper() {
+		return "\"";
+	}
+	getRightIdentifierWrapper() {
+		return "\"";
+	}
+	getAutoIncrement() {
+		return "autoincrement";
+	}
+};
+var BunSqliteDialect = class {
+	#config;
+	constructor(config) {
+		this.#config = { ...config };
+	}
+	createDriver() {
+		return new BunSqliteDriver(this.#config);
+	}
+	createQueryCompiler() {
+		return new BunSqliteQueryCompiler();
+	}
+	createAdapter() {
+		return new BunSqliteAdapter();
+	}
+	createIntrospector(db) {
+		return new BunSqliteIntrospector(db);
+	}
+};
+
+//#endregion
+exports.BunSqliteDialect = BunSqliteDialect;

package/dist/db/index.cjs

@@ -0,0 +1,18 @@
+const require_db = require('../db-CUPUfhtT.cjs');
+
+exports.SCHEMA_METADATA = require_db.SCHEMA_METADATA;
+exports.configVariantsSchema = require_db.configVariantsSchema;
+exports.configsSchema = require_db.configsSchema;
+exports.createDatabase = require_db.createDatabase;
+exports.createDatabaseFromConnection = require_db.createDatabaseFromConnection;
+exports.detectDatabaseType = require_db.detectDatabaseType;
+exports.environmentSecretsSchema = require_db.environmentSecretsSchema;
+exports.environmentsSchema = require_db.environmentsSchema;
+exports.parsePartialTableData = require_db.parsePartialTableData;
+exports.parseTableData = require_db.parseTableData;
+exports.schemas = require_db.schemas;
+exports.targetingRulesSchema = require_db.targetingRulesSchema;
+exports.validatePartialTableData = require_db.validatePartialTableData;
+exports.validateTableData = require_db.validateTableData;
+exports.variantVersionsSchema = require_db.variantVersionsSchema;
+exports.variantsSchema = require_db.variantsSchema;

package/dist/db/index.d.cts

@@ -0,0 +1,2 @@
+import { A as configVariantsSchema, C as TargetingRule, D as VariantVersion, E as Variant, F as targetingRulesSchema, I as variantVersionsSchema, L as variantsSchema, M as environmentSecretsSchema, N as environmentsSchema, O as VariantVersionsTable, P as schemas, S as TableName, T as Updateable, _ as EnvironmentSecretsTable, a as detectDatabaseType, b as SCHEMA_METADATA, c as validatePartialTableData, d as ConfigVariant, f as ConfigVariantsTable, g as EnvironmentSecret, h as Environment, i as createDatabaseFromConnection, j as configsSchema, k as VariantsTable, l as validateTableData, m as Database, n as DatabaseType, o as parsePartialTableData, p as ConfigsTable, r as createDatabase, s as parseTableData, t as DatabaseConnection, u as Config, v as EnvironmentsTable, w as TargetingRulesTable, x as Selectable, y as Insertable } from "../index-B-ZIrOBc.cjs";
+export { Config, ConfigVariant, ConfigVariantsTable, ConfigsTable, Database, DatabaseConnection, DatabaseType, Environment, EnvironmentSecret, EnvironmentSecretsTable, EnvironmentsTable, Insertable, SCHEMA_METADATA, Selectable, TableName, TargetingRule, TargetingRulesTable, Updateable, Variant, VariantVersion, VariantVersionsTable, VariantsTable, configVariantsSchema, configsSchema, createDatabase, createDatabaseFromConnection, detectDatabaseType, environmentSecretsSchema, environmentsSchema, parsePartialTableData, parseTableData, schemas, targetingRulesSchema, validatePartialTableData, validateTableData, variantVersionsSchema, variantsSchema };