@llmops/core 0.1.0-beta.7 → 0.1.0

package/dist/{db-D9v8S6D5.mjs → db-DCfAacY7.mjs}

@@ -1,4 +1,5 @@
-import { Kysely, MssqlDialect, MysqlDialect, PostgresDialect, SqliteDialect } from "kysely";
+import { Kysely, MssqlDialect, MysqlDialect, PostgresDialect, SqliteDialect, sql } from "kysely";
+import pino from "pino";
 
 //#region rolldown:runtime
 var __defProp = Object.defineProperty;
@@ -9428,7 +9429,7 @@ function initializeContext(params) {
 		external: params?.external ?? void 0
 	};
 }
-function process(schema, ctx, _params = {
+function process$1(schema, ctx, _params = {
 	path: [],
 	schemaPath: []
 }) {
@@ -9458,7 +9459,7 @@ function process(schema, ctx, _params = {
 		const parent = schema._zod.parent;
 		if (parent) {
 			result.ref = parent;
-			process(parent, ctx, params);
+			process$1(parent, ctx, params);
 			ctx.seen.get(parent).isParent = true;
 		} else if (schema._zod.processJSONSchema) schema._zod.processJSONSchema(ctx, result.schema, params);
 		else {
@@ -9648,7 +9649,7 @@ const createToJSONSchemaMethod = (schema, processors = {}) => (params) => {
 		...params,
 		processors
 	});
-	process(schema, ctx);
+	process$1(schema, ctx);
 	extractDefs(ctx, schema);
 	return finalize(ctx, schema);
 };
@@ -9660,7 +9661,7 @@ const createStandardJSONSchemaMethod = (schema, io) => (params) => {
 		io,
 		processors: {}
 	});
-	process(schema, ctx);
+	process$1(schema, ctx);
 	extractDefs(ctx, schema);
 	return finalize(ctx, schema);
 };
@@ -9833,7 +9834,7 @@ const arrayProcessor = (schema, ctx, _json, params) => {
 	if (typeof minimum === "number") json$1.minItems = minimum;
 	if (typeof maximum === "number") json$1.maxItems = maximum;
 	json$1.type = "array";
-	json$1.items = process(def.element, ctx, {
+	json$1.items = process$1(def.element, ctx, {
 		...params,
 		path: [...params.path, "items"]
 	});
@@ -9844,7 +9845,7 @@ const objectProcessor = (schema, ctx, _json, params) => {
 	json$1.type = "object";
 	json$1.properties = {};
 	const shape = def.shape;
-	for (const key in shape) json$1.properties[key] = process(shape[key], ctx, {
+	for (const key in shape) json$1.properties[key] = process$1(shape[key], ctx, {
 		...params,
 		path: [
 			...params.path,
@@ -9862,7 +9863,7 @@ const objectProcessor = (schema, ctx, _json, params) => {
 	if (def.catchall?._zod.def.type === "never") json$1.additionalProperties = false;
 	else if (!def.catchall) {
 		if (ctx.io === "output") json$1.additionalProperties = false;
-	} else if (def.catchall) json$1.additionalProperties = process(def.catchall, ctx, {
+	} else if (def.catchall) json$1.additionalProperties = process$1(def.catchall, ctx, {
 		...params,
 		path: [...params.path, "additionalProperties"]
 	});
@@ -9870,7 +9871,7 @@ const objectProcessor = (schema, ctx, _json, params) => {
 const unionProcessor = (schema, ctx, json$1, params) => {
 	const def = schema._zod.def;
 	const isExclusive = def.inclusive === false;
-	const options = def.options.map((x, i) => process(x, ctx, {
+	const options = def.options.map((x, i) => process$1(x, ctx, {
 		...params,
 		path: [
 			...params.path,
@@ -9883,7 +9884,7 @@ const unionProcessor = (schema, ctx, json$1, params) => {
 };
 const intersectionProcessor = (schema, ctx, json$1, params) => {
 	const def = schema._zod.def;
-	const a = process(def.left, ctx, {
+	const a = process$1(def.left, ctx, {
 		...params,
 		path: [
 			...params.path,
@@ -9891,7 +9892,7 @@ const intersectionProcessor = (schema, ctx, json$1, params) => {
 			0
 		]
 	});
-	const b = process(def.right, ctx, {
+	const b = process$1(def.right, ctx, {
 		...params,
 		path: [
 			...params.path,
@@ -9908,7 +9909,7 @@ const tupleProcessor = (schema, ctx, _json, params) => {
 	json$1.type = "array";
 	const prefixPath = ctx.target === "draft-2020-12" ? "prefixItems" : "items";
 	const restPath = ctx.target === "draft-2020-12" ? "items" : ctx.target === "openapi-3.0" ? "items" : "additionalItems";
-	const prefixItems = def.items.map((x, i) => process(x, ctx, {
+	const prefixItems = def.items.map((x, i) => process$1(x, ctx, {
 		...params,
 		path: [
 			...params.path,
@@ -9916,7 +9917,7 @@ const tupleProcessor = (schema, ctx, _json, params) => {
 			i
 		]
 	}));
-	const rest = def.rest ? process(def.rest, ctx, {
+	const rest = def.rest ? process$1(def.rest, ctx, {
 		...params,
 		path: [
 			...params.path,
@@ -9944,18 +9945,18 @@ const recordProcessor = (schema, ctx, _json, params) => {
 	const json$1 = _json;
 	const def = schema._zod.def;
 	json$1.type = "object";
-	if (ctx.target === "draft-07" || ctx.target === "draft-2020-12") json$1.propertyNames = process(def.keyType, ctx, {
+	if (ctx.target === "draft-07" || ctx.target === "draft-2020-12") json$1.propertyNames = process$1(def.keyType, ctx, {
 		...params,
 		path: [...params.path, "propertyNames"]
 	});
-	json$1.additionalProperties = process(def.valueType, ctx, {
+	json$1.additionalProperties = process$1(def.valueType, ctx, {
 		...params,
 		path: [...params.path, "additionalProperties"]
 	});
 };
 const nullableProcessor = (schema, ctx, json$1, params) => {
 	const def = schema._zod.def;
-	const inner = process(def.innerType, ctx, params);
+	const inner = process$1(def.innerType, ctx, params);
 	const seen = ctx.seen.get(schema);
 	if (ctx.target === "openapi-3.0") {
 		seen.ref = def.innerType;
@@ -9964,27 +9965,27 @@ const nullableProcessor = (schema, ctx, json$1, params) => {
 };
 const nonoptionalProcessor = (schema, ctx, _json, params) => {
 	const def = schema._zod.def;
-	process(def.innerType, ctx, params);
+	process$1(def.innerType, ctx, params);
 	const seen = ctx.seen.get(schema);
 	seen.ref = def.innerType;
 };
 const defaultProcessor = (schema, ctx, json$1, params) => {
 	const def = schema._zod.def;
-	process(def.innerType, ctx, params);
+	process$1(def.innerType, ctx, params);
 	const seen = ctx.seen.get(schema);
 	seen.ref = def.innerType;
 	json$1.default = JSON.parse(JSON.stringify(def.defaultValue));
 };
 const prefaultProcessor = (schema, ctx, json$1, params) => {
 	const def = schema._zod.def;
-	process(def.innerType, ctx, params);
+	process$1(def.innerType, ctx, params);
 	const seen = ctx.seen.get(schema);
 	seen.ref = def.innerType;
 	if (ctx.io === "input") json$1._prefault = JSON.parse(JSON.stringify(def.defaultValue));
 };
 const catchProcessor = (schema, ctx, json$1, params) => {
 	const def = schema._zod.def;
-	process(def.innerType, ctx, params);
+	process$1(def.innerType, ctx, params);
 	const seen = ctx.seen.get(schema);
 	seen.ref = def.innerType;
 	let catchValue;
@@ -9998,32 +9999,32 @@ const catchProcessor = (schema, ctx, json$1, params) => {
 const pipeProcessor = (schema, ctx, _json, params) => {
 	const def = schema._zod.def;
 	const innerType = ctx.io === "input" ? def.in._zod.def.type === "transform" ? def.out : def.in : def.out;
-	process(innerType, ctx, params);
+	process$1(innerType, ctx, params);
 	const seen = ctx.seen.get(schema);
 	seen.ref = innerType;
 };
 const readonlyProcessor = (schema, ctx, json$1, params) => {
 	const def = schema._zod.def;
-	process(def.innerType, ctx, params);
+	process$1(def.innerType, ctx, params);
 	const seen = ctx.seen.get(schema);
 	seen.ref = def.innerType;
 	json$1.readOnly = true;
 };
 const promiseProcessor = (schema, ctx, _json, params) => {
 	const def = schema._zod.def;
-	process(def.innerType, ctx, params);
+	process$1(def.innerType, ctx, params);
 	const seen = ctx.seen.get(schema);
 	seen.ref = def.innerType;
 };
 const optionalProcessor = (schema, ctx, _json, params) => {
 	const def = schema._zod.def;
-	process(def.innerType, ctx, params);
+	process$1(def.innerType, ctx, params);
 	const seen = ctx.seen.get(schema);
 	seen.ref = def.innerType;
 };
 const lazyProcessor = (schema, ctx, _json, params) => {
 	const innerType = schema._zod.innerType;
-	process(innerType, ctx, params);
+	process$1(innerType, ctx, params);
 	const seen = ctx.seen.get(schema);
 	seen.ref = innerType;
 };
@@ -10078,7 +10079,7 @@ function toJSONSchema(input, params) {
 		const defs = {};
 		for (const entry of registry$1._idmap.entries()) {
 			const [_, schema] = entry;
-			process(schema, ctx$1);
+			process$1(schema, ctx$1);
 		}
 		const schemas$1 = {};
 		ctx$1.external = {
@@ -10098,7 +10099,7 @@ function toJSONSchema(input, params) {
 		...params,
 		processors: allProcessors
 	});
-	process(input, ctx);
+	process$1(input, ctx);
 	extractDefs(ctx, input);
 	return finalize(ctx, input);
 }
@@ -10175,7 +10176,7 @@ var JSONSchemaGenerator = class {
 		path: [],
 		schemaPath: []
 	}) {
-		return process(schema, this.ctx, _params);
+		return process$1(schema, this.ctx, _params);
 	}
 	/**
 	* Emit the final JSON Schema after processing.
@@ -10458,7 +10459,7 @@ var core_exports = /* @__PURE__ */ __export({
 	parse: () => parse$1,
 	parseAsync: () => parseAsync$1,
 	prettifyError: () => prettifyError,
-	process: () => process,
+	process: () => process$1,
 	regexes: () => regexes_exports,
 	registry: () => registry,
 	safeDecode: () => safeDecode$1,
@@ -12680,6 +12681,275 @@ function parsePartialTableData(table, data) {
 	return schemas[table].partial().parse(data);
 }
 
+//#endregion
+//#region src/utils/logger.ts
+const logger = pino();
+
+//#endregion
+//#region src/db/migrations.ts
+const typeMap = {
+	postgres: {
+		uuid: [
+			"character varying",
+			"varchar",
+			"text",
+			"uuid"
+		],
+		text: [
+			"character varying",
+			"varchar",
+			"text"
+		],
+		timestamp: [
+			"timestamptz",
+			"timestamp",
+			"date"
+		],
+		jsonb: ["json", "jsonb"],
+		integer: [
+			"integer",
+			"int4",
+			"int",
+			"smallint",
+			"bigint",
+			"int2",
+			"int8"
+		],
+		boolean: ["boolean", "bool"]
+	},
+	mysql: {
+		text: ["varchar", "text"],
+		timestamp: [
+			"timestamp",
+			"datetime",
+			"date"
+		],
+		jsonb: ["json"]
+	},
+	sqlite: {
+		text: ["TEXT"],
+		date: ["DATE", "INTEGER"],
+		integer: ["INTEGER"],
+		boolean: [
+			"INTEGER",
+			"BOOLEAN",
+			"TEXT"
+		],
+		jsonb: ["TEXT"]
+	},
+	mssql: {
+		varchar: [
+			"varchar",
+			"nvarchar",
+			"uniqueidentifier"
+		],
+		datetime2: [
+			"datetime2",
+			"date",
+			"datetime"
+		],
+		jsonb: ["varchar", "nvarchar"]
+	}
+};
+function matchType(columnDataType, fieldType, dbType) {
+	const normalize = (type) => type.toLowerCase().split("(")[0].trim();
+	const types = typeMap[dbType];
+	for (const [expectedType, variants] of Object.entries(types)) if (fieldType.toLowerCase().includes(expectedType.toLowerCase())) return variants.some((variant) => variant.toLowerCase() === normalize(columnDataType));
+	return false;
+}
+/**
+* Get the current PostgreSQL schema (search_path) for the database connection
+*/
+async function getPostgresSchema(db) {
+	try {
+		const result = await sql`SHOW search_path`.execute(db);
+		if (result.rows[0]?.search_path) return result.rows[0].search_path.split(",").map((s) => s.trim()).map((s) => s.replace(/^["']|["']$/g, "")).filter((s) => !s.startsWith("$"))[0] || "public";
+	} catch {}
+	return "public";
+}
+async function getMigrations(db, dbType) {
+	let currentSchema = "public";
+	if (dbType === "postgres") {
+		currentSchema = await getPostgresSchema(db);
+		logger.debug(`PostgreSQL migration: Using schema '${currentSchema}'`);
+	}
+	const allTableMetadata = await db.introspection.getTables();
+	let tableMetadata = allTableMetadata;
+	if (dbType === "postgres") try {
+		const tablesInSchema = await sql`
+        SELECT table_name
+        FROM information_schema.tables
+        WHERE table_schema = ${currentSchema}
+        AND table_type = 'BASE TABLE'
+      `.execute(db);
+		const tableNamesInSchema = new Set(tablesInSchema.rows.map((row) => row.table_name));
+		tableMetadata = allTableMetadata.filter((table) => table.schema === currentSchema && tableNamesInSchema.has(table.name));
+		logger.debug(`Found ${tableMetadata.length} table(s) in schema '${currentSchema}'`);
+	} catch (error$45) {
+		logger.warn("Could not filter tables by schema. Using all discovered tables.");
+	}
+	const schema = SCHEMA_METADATA.tables;
+	const toBeCreated = [];
+	const toBeAdded = [];
+	for (const [tableName, tableConfig] of Object.entries(schema)) {
+		const existingTable = tableMetadata.find((t) => t.name === tableName);
+		if (!existingTable) {
+			toBeCreated.push({
+				table: tableName,
+				fields: tableConfig.fields,
+				order: tableConfig.order
+			});
+			continue;
+		}
+		const missingFields = {};
+		for (const [fieldName, fieldConfig] of Object.entries(tableConfig.fields)) {
+			const existingColumn = existingTable.columns.find((c) => c.name === fieldName);
+			if (!existingColumn) {
+				missingFields[fieldName] = fieldConfig;
+				continue;
+			}
+			if (!matchType(existingColumn.dataType, fieldConfig.type, dbType)) logger.warn(`Field ${fieldName} in table ${tableName} has a different type. Expected ${fieldConfig.type} but got ${existingColumn.dataType}.`);
+		}
+		if (Object.keys(missingFields).length > 0) toBeAdded.push({
+			table: tableName,
+			fields: missingFields,
+			order: tableConfig.order
+		});
+	}
+	toBeCreated.sort((a, b) => a.order - b.order);
+	toBeAdded.sort((a, b) => a.order - b.order);
+	const migrations = [];
+	function getColumnType(fieldConfig, fieldName) {
+		const { type } = fieldConfig;
+		return {
+			uuid: {
+				postgres: "uuid",
+				mysql: "varchar(36)",
+				sqlite: "text",
+				mssql: "varchar(36)"
+			},
+			text: {
+				postgres: "text",
+				mysql: fieldConfig.unique ? "varchar(255)" : "text",
+				sqlite: "text",
+				mssql: fieldConfig.unique ? "varchar(255)" : "varchar(8000)"
+			},
+			timestamp: {
+				postgres: "timestamptz",
+				mysql: "timestamp(3)",
+				sqlite: "date",
+				mssql: sql`datetime2(3)`
+			},
+			jsonb: {
+				postgres: "jsonb",
+				mysql: "json",
+				sqlite: "text",
+				mssql: "varchar(8000)"
+			},
+			boolean: {
+				postgres: "boolean",
+				mysql: "boolean",
+				sqlite: "integer",
+				mssql: sql`bit`
+			},
+			integer: {
+				postgres: "integer",
+				mysql: "integer",
+				sqlite: "integer",
+				mssql: "integer"
+			}
+		}[type]?.[dbType] || "text";
+	}
+	for (const table of toBeCreated) {
+		let builder = db.schema.createTable(table.table);
+		for (const [fieldName, fieldConfig] of Object.entries(table.fields)) {
+			const type = getColumnType(fieldConfig, fieldName);
+			builder = builder.addColumn(fieldName, type, (col) => {
+				let c = col;
+				if (fieldName === "id") if (dbType === "postgres") c = c.primaryKey().defaultTo(sql`gen_random_uuid()`).notNull();
+				else c = c.primaryKey().notNull();
+				else if (!fieldConfig.nullable) c = c.notNull();
+				if (fieldConfig.references && fieldName !== "id") {
+					const refTable = fieldConfig.references.table;
+					const refColumn = fieldConfig.references.column;
+					c = c.references(`${refTable}.${refColumn}`).onDelete("cascade");
+				}
+				if (fieldConfig.unique && fieldName !== "id") c = c.unique();
+				if (fieldConfig.default === "now()" && fieldName !== "id" && dbType !== "sqlite") if (dbType === "mysql") c = c.defaultTo(sql`CURRENT_TIMESTAMP(3)`);
+				else c = c.defaultTo(sql`CURRENT_TIMESTAMP`);
+				return c;
+			});
+		}
+		migrations.push(builder);
+	}
+	for (const table of toBeAdded) for (const [fieldName, fieldConfig] of Object.entries(table.fields)) {
+		const type = getColumnType(fieldConfig, fieldName);
+		const builder = db.schema.alterTable(table.table).addColumn(fieldName, type, (col) => {
+			let c = col;
+			if (!fieldConfig.nullable) c = c.notNull();
+			if (fieldConfig.references) {
+				const refTable = fieldConfig.references.table;
+				const refColumn = fieldConfig.references.column;
+				c = c.references(`${refTable}.${refColumn}`).onDelete("cascade");
+			}
+			if (fieldConfig.unique) c = c.unique();
+			if (fieldConfig.default === "now()" && dbType !== "sqlite") if (dbType === "mysql") c = c.defaultTo(sql`CURRENT_TIMESTAMP(3)`);
+			else c = c.defaultTo(sql`CURRENT_TIMESTAMP`);
+			return c;
+		});
+		migrations.push(builder);
+	}
+	async function runMigrations() {
+		for (const migration of migrations) await migration.execute();
+	}
+	async function compileMigrations() {
+		return migrations.map((m) => m.compile().sql).join(";\n\n") + ";";
+	}
+	return {
+		toBeCreated,
+		toBeAdded,
+		runMigrations,
+		compileMigrations,
+		migrations,
+		needsMigration: toBeCreated.length > 0 || toBeAdded.length > 0
+	};
+}
+/**
+* Run migrations if needed based on autoMigrate config
+* @param db - Kysely database instance
+* @param dbType - Database type
+* @param autoMigrate - Auto-migrate configuration
+* @returns true if migrations were run, false otherwise
+*/
+async function runAutoMigrations(db, dbType, autoMigrate) {
+	if (!(autoMigrate === true || autoMigrate === "development" && process.env.NODE_ENV === "development")) return {
+		ran: false,
+		tables: [],
+		fields: []
+	};
+	const { toBeCreated, toBeAdded, runMigrations, needsMigration } = await getMigrations(db, dbType);
+	if (!needsMigration) {
+		logger.debug("Auto-migration: No migrations needed");
+		return {
+			ran: false,
+			tables: [],
+			fields: []
+		};
+	}
+	const tables = toBeCreated.map((t) => t.table);
+	const fields = toBeAdded.flatMap((t) => Object.keys(t.fields).map((f) => `${t.table}.${f}`));
+	logger.info(`Auto-migration: Running migrations for ${tables.length} table(s) and ${fields.length} field(s)`);
+	if (tables.length > 0) logger.debug(`Auto-migration: Creating tables: ${tables.join(", ")}`);
+	if (fields.length > 0) logger.debug(`Auto-migration: Adding fields: ${fields.join(", ")}`);
+	await runMigrations();
+	logger.info("Auto-migration: Completed successfully");
+	return {
+		ran: true,
+		tables,
+		fields
+	};
+}
+
 //#endregion
 //#region src/db/index.ts
 /**
@@ -12742,4 +13012,4 @@ async function createDatabaseFromConnection(rawConnection) {
 }
 
 //#endregion
-export { number$1 as C, union as D, string$1 as E, unknown as O, literal as S, record as T, zod_default as _, parseTableData as a, array as b, SCHEMA_METADATA as c, environmentSecretsSchema as d, environmentsSchema as f, variantsSchema as g, variantVersionsSchema as h, parsePartialTableData as i, configVariantsSchema as l, targetingRulesSchema as m, createDatabaseFromConnection as n, validatePartialTableData as o, schemas as p, detectDatabaseType as r, validateTableData as s, createDatabase as t, configsSchema as u, _enum as v, object as w, boolean$1 as x, any as y };
+export { string$1 as A, any as C, number$1 as D, literal as E, unknown as M, object as O, _enum as S, boolean$1 as T, schemas as _, matchType as a, variantsSchema as b, parsePartialTableData as c, validateTableData as d, SCHEMA_METADATA as f, environmentsSchema as g, environmentSecretsSchema as h, getMigrations as i, union as j, record as k, parseTableData as l, configsSchema as m, createDatabaseFromConnection as n, runAutoMigrations as o, configVariantsSchema as p, detectDatabaseType as r, logger as s, createDatabase as t, validatePartialTableData as u, targetingRulesSchema as v, array as w, zod_default as x, variantVersionsSchema as y };