@llmops/core 0.1.0 → 0.1.1

package/dist/{bun-sqlite-dialect-BY9UbL3J.cjs → bun-sqlite-dialect-Dzur5J1r.cjs}

@@ -1,4 +1,4 @@
-const require_db = require('./db-16I7_mus.cjs');
+const require_db = require('./db-gMDwCuHR.cjs');
 let kysely = require("kysely");
 
 //#region src/db/bun-sqlite-dialect.ts

package/dist/db/index.cjs

@@ -1,4 +1,4 @@
-const require_db = require('../db-16I7_mus.cjs');
+const require_db = require('../db-gMDwCuHR.cjs');
 
 exports.SCHEMA_METADATA = require_db.SCHEMA_METADATA;
 exports.configVariantsSchema = require_db.configVariantsSchema;

package/dist/db/index.d.cts

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

package/dist/db/index.d.mts

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

package/dist/db/index.mjs

@@ -1,3 +1,3 @@
-import { _ as schemas, a as matchType, b as variantsSchema, c as parsePartialTableData, d as validateTableData, f as SCHEMA_METADATA, g as environmentsSchema, h as environmentSecretsSchema, i as getMigrations, l as parseTableData, m as configsSchema, n as createDatabaseFromConnection, o as runAutoMigrations, p as configVariantsSchema, r as detectDatabaseType, t as createDatabase, u as validatePartialTableData, v as targetingRulesSchema, y as variantVersionsSchema } from "../db-DCfAacY7.mjs";
+import { _ as schemas, a as matchType, b as variantsSchema, c as parsePartialTableData, d as validateTableData, f as SCHEMA_METADATA, g as environmentsSchema, h as environmentSecretsSchema, i as getMigrations, l as parseTableData, m as configsSchema, n as createDatabaseFromConnection, o as runAutoMigrations, p as configVariantsSchema, r as detectDatabaseType, t as createDatabase, u as validatePartialTableData, v as targetingRulesSchema, y as variantVersionsSchema } from "../db-DN6gkyRp.mjs";
 
 export { SCHEMA_METADATA, configVariantsSchema, configsSchema, createDatabase, createDatabaseFromConnection, detectDatabaseType, environmentSecretsSchema, environmentsSchema, getMigrations, matchType, parsePartialTableData, parseTableData, runAutoMigrations, schemas, targetingRulesSchema, validatePartialTableData, validateTableData, variantVersionsSchema, variantsSchema };

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

@@ -1,4 +1,4 @@
-import { Kysely, MssqlDialect, MysqlDialect, PostgresDialect, SqliteDialect, sql } from "kysely";
+import { CompiledQuery, Kysely, MssqlDialect, MysqlDialect, PostgresDialect, SqliteDialect, sql } from "kysely";
 import pino from "pino";
 
 //#region rolldown:runtime
@@ -12767,10 +12767,35 @@ async function getPostgresSchema(db) {
 	} catch {}
 	return "public";
 }
-async function getMigrations(db, dbType) {
+/**
+* Ensure the PostgreSQL schema exists, creating it if necessary
+*/
+async function ensurePostgresSchemaExists(db, schema) {
+	if (schema === "public") return;
+	try {
+		if (!(await sql`
+      SELECT EXISTS (
+        SELECT 1 FROM information_schema.schemata 
+        WHERE schema_name = ${schema}
+      ) as exists
+    `.execute(db)).rows[0]?.exists) {
+			logger.info(`Creating PostgreSQL schema: ${schema}`);
+			await sql`CREATE SCHEMA IF NOT EXISTS ${sql.ref(schema)}`.execute(db);
+		}
+	} catch (error$45) {
+		logger.warn(`Could not ensure schema exists: ${error$45}`);
+		try {
+			await sql`CREATE SCHEMA IF NOT EXISTS ${sql.ref(schema)}`.execute(db);
+		} catch {}
+	}
+}
+async function getMigrations(db, dbType, options) {
 	let currentSchema = "public";
 	if (dbType === "postgres") {
-		currentSchema = await getPostgresSchema(db);
+		if (options?.schema) {
+			await ensurePostgresSchemaExists(db, options.schema);
+			currentSchema = options.schema;
+		} else currentSchema = await getPostgresSchema(db);
 		logger.debug(`PostgreSQL migration: Using schema '${currentSchema}'`);
 	}
 	const allTableMetadata = await db.introspection.getTables();
@@ -12919,15 +12944,16 @@ async function getMigrations(db, dbType) {
 * @param db - Kysely database instance
 * @param dbType - Database type
 * @param autoMigrate - Auto-migrate configuration
+* @param options - Migration options (schema, etc.)
 * @returns true if migrations were run, false otherwise
 */
-async function runAutoMigrations(db, dbType, autoMigrate) {
+async function runAutoMigrations(db, dbType, autoMigrate, options) {
 	if (!(autoMigrate === true || autoMigrate === "development" && process.env.NODE_ENV === "development")) return {
 		ran: false,
 		tables: [],
 		fields: []
 	};
-	const { toBeCreated, toBeAdded, runMigrations, needsMigration } = await getMigrations(db, dbType);
+	const { toBeCreated, toBeAdded, runMigrations, needsMigration } = await getMigrations(db, dbType, options);
 	if (!needsMigration) {
 		logger.debug("Auto-migration: No migrations needed");
 		return {
@@ -12979,11 +13005,15 @@ function detectDatabaseType(db) {
 }
 /**
 * Create database from raw connection
+*
+* @param rawConnection - The raw database connection (pg Pool, sqlite Database, etc.)
+* @param options - Optional configuration (schema for PostgreSQL)
 */
-async function createDatabaseFromConnection(rawConnection) {
+async function createDatabaseFromConnection(rawConnection, options) {
 	const dbType = detectDatabaseType(rawConnection);
 	if (!dbType) return null;
 	let dialect;
+	const schema = options?.schema ?? "llmops";
 	switch (dbType) {
 		case "sqlite":
 			if ("aggregate" in rawConnection && !("createSession" in rawConnection)) dialect = new SqliteDialect({ database: rawConnection });
@@ -13002,7 +13032,12 @@ async function createDatabaseFromConnection(rawConnection) {
 			dialect = new MysqlDialect(rawConnection);
 			break;
 		case "postgres":
-			dialect = new PostgresDialect({ pool: rawConnection });
+			dialect = new PostgresDialect({
+				pool: rawConnection,
+				onCreateConnection: async (connection) => {
+					await connection.executeQuery(CompiledQuery.raw(`SET search_path TO "${schema}"`));
+				}
+			});
 			break;
 		case "mssql":
 			if ("createDriver" in rawConnection) dialect = rawConnection;

package/dist/{db-16I7_mus.cjs → db-gMDwCuHR.cjs}

@@ -12791,10 +12791,35 @@ async function getPostgresSchema(db) {
 	} catch {}
 	return "public";
 }
-async function getMigrations(db, dbType) {
+/**
+* Ensure the PostgreSQL schema exists, creating it if necessary
+*/
+async function ensurePostgresSchemaExists(db, schema) {
+	if (schema === "public") return;
+	try {
+		if (!(await kysely.sql`
+      SELECT EXISTS (
+        SELECT 1 FROM information_schema.schemata 
+        WHERE schema_name = ${schema}
+      ) as exists
+    `.execute(db)).rows[0]?.exists) {
+			logger.info(`Creating PostgreSQL schema: ${schema}`);
+			await kysely.sql`CREATE SCHEMA IF NOT EXISTS ${kysely.sql.ref(schema)}`.execute(db);
+		}
+	} catch (error$45) {
+		logger.warn(`Could not ensure schema exists: ${error$45}`);
+		try {
+			await kysely.sql`CREATE SCHEMA IF NOT EXISTS ${kysely.sql.ref(schema)}`.execute(db);
+		} catch {}
+	}
+}
+async function getMigrations(db, dbType, options) {
 	let currentSchema = "public";
 	if (dbType === "postgres") {
-		currentSchema = await getPostgresSchema(db);
+		if (options?.schema) {
+			await ensurePostgresSchemaExists(db, options.schema);
+			currentSchema = options.schema;
+		} else currentSchema = await getPostgresSchema(db);
 		logger.debug(`PostgreSQL migration: Using schema '${currentSchema}'`);
 	}
 	const allTableMetadata = await db.introspection.getTables();
@@ -12943,15 +12968,16 @@ async function getMigrations(db, dbType) {
 * @param db - Kysely database instance
 * @param dbType - Database type
 * @param autoMigrate - Auto-migrate configuration
+* @param options - Migration options (schema, etc.)
 * @returns true if migrations were run, false otherwise
 */
-async function runAutoMigrations(db, dbType, autoMigrate) {
+async function runAutoMigrations(db, dbType, autoMigrate, options) {
 	if (!(autoMigrate === true || autoMigrate === "development" && process.env.NODE_ENV === "development")) return {
 		ran: false,
 		tables: [],
 		fields: []
 	};
-	const { toBeCreated, toBeAdded, runMigrations, needsMigration } = await getMigrations(db, dbType);
+	const { toBeCreated, toBeAdded, runMigrations, needsMigration } = await getMigrations(db, dbType, options);
 	if (!needsMigration) {
 		logger.debug("Auto-migration: No migrations needed");
 		return {
@@ -13003,21 +13029,25 @@ function detectDatabaseType(db) {
 }
 /**
 * Create database from raw connection
+*
+* @param rawConnection - The raw database connection (pg Pool, sqlite Database, etc.)
+* @param options - Optional configuration (schema for PostgreSQL)
 */
-async function createDatabaseFromConnection(rawConnection) {
+async function createDatabaseFromConnection(rawConnection, options) {
 	const dbType = detectDatabaseType(rawConnection);
 	if (!dbType) return null;
 	let dialect;
+	const schema = options?.schema ?? "llmops";
 	switch (dbType) {
 		case "sqlite":
 			if ("aggregate" in rawConnection && !("createSession" in rawConnection)) dialect = new kysely.SqliteDialect({ database: rawConnection });
 			else if ("fileControl" in rawConnection) {
-				const { BunSqliteDialect } = await Promise.resolve().then(() => require("./bun-sqlite-dialect-BY9UbL3J.cjs"));
+				const { BunSqliteDialect } = await Promise.resolve().then(() => require("./bun-sqlite-dialect-Dzur5J1r.cjs"));
 				dialect = new BunSqliteDialect({ database: rawConnection });
 			} else if ("createSession" in rawConnection && typeof window === "undefined") try {
 				const { DatabaseSync } = await import("node:sqlite");
 				if (rawConnection instanceof DatabaseSync) {
-					const { NodeSqliteDialect } = await Promise.resolve().then(() => require("./node-sqlite-dialect-CuJrXyHn.cjs"));
+					const { NodeSqliteDialect } = await Promise.resolve().then(() => require("./node-sqlite-dialect-BTbo14Y2.cjs"));
 					dialect = new NodeSqliteDialect({ database: rawConnection });
 				}
 			} catch {}
@@ -13026,7 +13056,12 @@ async function createDatabaseFromConnection(rawConnection) {
 			dialect = new kysely.MysqlDialect(rawConnection);
 			break;
 		case "postgres":
-			dialect = new kysely.PostgresDialect({ pool: rawConnection });
+			dialect = new kysely.PostgresDialect({
+				pool: rawConnection,
+				onCreateConnection: async (connection) => {
+					await connection.executeQuery(kysely.CompiledQuery.raw(`SET search_path TO "${schema}"`));
+				}
+			});
 			break;
 		case "mssql":
 			if ("createDriver" in rawConnection) dialect = rawConnection;

package/dist/{index-BKx9C2tK.d.mts → index-DGUMebzL.d.cts}

@@ -788,6 +788,16 @@ declare function parsePartialTableData<T extends TableName>(table: T, data: unkn
 //#endregion
 //#region src/db/migrations.d.ts
 type DatabaseType$1 = 'postgres' | 'mysql' | 'sqlite' | 'mssql';
+/**
+ * Options for migration operations
+ */
+interface MigrationOptions {
+  /**
+   * PostgreSQL schema name to use.
+   * If provided, the schema will be created if it doesn't exist.
+   */
+  schema?: string;
+}
 declare function matchType(columnDataType: string, fieldType: string, dbType: DatabaseType$1): boolean;
 interface MigrationResult {
   toBeCreated: Array<{
@@ -805,15 +815,16 @@ interface MigrationResult {
   migrations: any[];
   needsMigration: boolean;
 }
-declare function getMigrations(db: Kysely<Database>, dbType: DatabaseType$1): Promise<MigrationResult>;
+declare function getMigrations(db: Kysely<Database>, dbType: DatabaseType$1, options?: MigrationOptions): Promise<MigrationResult>;
 /**
  * Run migrations if needed based on autoMigrate config
  * @param db - Kysely database instance
  * @param dbType - Database type
  * @param autoMigrate - Auto-migrate configuration
+ * @param options - Migration options (schema, etc.)
  * @returns true if migrations were run, false otherwise
  */
-declare function runAutoMigrations(db: Kysely<Database>, dbType: DatabaseType$1, autoMigrate: boolean | 'development'): Promise<{
+declare function runAutoMigrations(db: Kysely<Database>, dbType: DatabaseType$1, autoMigrate: boolean | 'development', options?: MigrationOptions): Promise<{
   ran: boolean;
   tables: string[];
   fields: string[];
@@ -824,6 +835,16 @@ declare function runAutoMigrations(db: Kysely<Database>, dbType: DatabaseType$1,
  * Supported database types
  */
 type DatabaseType = 'postgres' | 'mysql' | 'sqlite' | 'mssql';
+/**
+ * Options for creating a database connection
+ */
+interface DatabaseOptions {
+  /**
+   * PostgreSQL schema name (sets search_path).
+   * Defaults to 'llmops'.
+   */
+  schema?: string;
+}
 /**
  * Database connection options
  */
@@ -853,7 +874,10 @@ declare function createDatabase(connection: DatabaseConnection): Kysely<Database
 declare function detectDatabaseType(db: unknown): DatabaseType | null;
 /**
  * Create database from raw connection
+ *
+ * @param rawConnection - The raw database connection (pg Pool, sqlite Database, etc.)
+ * @param options - Optional configuration (schema for PostgreSQL)
  */
-declare function createDatabaseFromConnection(rawConnection: any): Promise<Kysely<Database> | null>;
+declare function createDatabaseFromConnection(rawConnection: any, options?: DatabaseOptions): Promise<Kysely<Database> | null>;
 //#endregion
-export { Variant as A, variantVersionsSchema as B, Insertable as C, TargetingRule as D, TableName as E, configsSchema as F, environmentSecretsSchema as I, environmentsSchema as L, VariantVersionsTable as M, VariantsTable as N, TargetingRulesTable as O, configVariantsSchema as P, schemas as R, EnvironmentsTable as S, Selectable as T, variantsSchema as V, ConfigsTable as _, detectDatabaseType as a, EnvironmentSecret as b, matchType as c, parseTableData as d, validatePartialTableData as f, ConfigVariantsTable as g, ConfigVariant as h, createDatabaseFromConnection as i, VariantVersion as j, Updateable as k, runAutoMigrations as l, Config as m, DatabaseType as n, MigrationResult as o, validateTableData as p, createDatabase as r, getMigrations as s, DatabaseConnection as t, parsePartialTableData as u, Database as v, SCHEMA_METADATA as w, EnvironmentSecretsTable as x, Environment as y, targetingRulesSchema as z };
+export { TargetingRulesTable as A, schemas as B, EnvironmentSecretsTable as C, Selectable as D, SCHEMA_METADATA as E, VariantsTable as F, variantVersionsSchema as H, configVariantsSchema as I, configsSchema as L, Variant as M, VariantVersion as N, TableName as O, VariantVersionsTable as P, environmentSecretsSchema as R, EnvironmentSecret as S, Insertable as T, variantsSchema as U, targetingRulesSchema as V, ConfigVariant as _, createDatabaseFromConnection as a, Database as b, MigrationResult as c, runAutoMigrations as d, parsePartialTableData as f, Config as g, validateTableData as h, createDatabase as i, Updateable as j, TargetingRule as k, getMigrations as l, validatePartialTableData as m, DatabaseOptions as n, detectDatabaseType as o, parseTableData as p, DatabaseType as r, MigrationOptions as s, DatabaseConnection as t, matchType as u, ConfigVariantsTable as v, EnvironmentsTable as w, Environment as x, ConfigsTable as y, environmentsSchema as z };

package/dist/{index-9HhrwwZi.d.cts → index-DbVk2Vpc.d.mts}

@@ -1,5 +1,5 @@
 import { ColumnType, Generated, Kysely, MssqlDialect, MysqlDialect, PostgresDialect, SqliteDialect } from "kysely";
-import * as zod0 from "zod";
+import * as zod302 from "zod";
 import { z } from "zod";
 
 //#region src/db/schema.d.ts
@@ -520,29 +520,29 @@ declare const schemas: {
  * Validate data against table schema
  * Useful for runtime validation before inserting/updating
  */
-declare function validateTableData<T extends TableName>(table: T, data: unknown): zod0.ZodSafeParseSuccess<{
+declare function validateTableData<T extends TableName>(table: T, data: unknown): zod302.ZodSafeParseSuccess<{
   slug: string;
   id: string;
   createdAt: Date;
   updatedAt: Date;
   name?: string | undefined;
-}> | zod0.ZodSafeParseError<{
+}> | zod302.ZodSafeParseError<{
   slug: string;
   id: string;
   createdAt: Date;
   updatedAt: Date;
   name?: string | undefined;
-}> | zod0.ZodSafeParseSuccess<{
+}> | zod302.ZodSafeParseSuccess<{
   name: string;
   id: string;
   createdAt: Date;
   updatedAt: Date;
-}> | zod0.ZodSafeParseError<{
+}> | zod302.ZodSafeParseError<{
   name: string;
   id: string;
   createdAt: Date;
   updatedAt: Date;
-}> | zod0.ZodSafeParseSuccess<{
+}> | zod302.ZodSafeParseSuccess<{
   variantId: string;
   version: number;
   provider: string;
@@ -551,7 +551,7 @@ declare function validateTableData<T extends TableName>(table: T, data: unknown)
   id: string;
   createdAt: Date;
   updatedAt: Date;
-}> | zod0.ZodSafeParseError<{
+}> | zod302.ZodSafeParseError<{
   variantId: string;
   version: number;
   provider: string;
@@ -560,33 +560,33 @@ declare function validateTableData<T extends TableName>(table: T, data: unknown)
   id: string;
   createdAt: Date;
   updatedAt: Date;
-}> | zod0.ZodSafeParseSuccess<{
+}> | zod302.ZodSafeParseSuccess<{
   environmentId: string;
   keyName: string;
   keyValue: string;
   id: string;
   createdAt: Date;
   updatedAt: Date;
-}> | zod0.ZodSafeParseError<{
+}> | zod302.ZodSafeParseError<{
   environmentId: string;
   keyName: string;
   keyValue: string;
   id: string;
   createdAt: Date;
   updatedAt: Date;
-}> | zod0.ZodSafeParseSuccess<{
+}> | zod302.ZodSafeParseSuccess<{
   configId: string;
   variantId: string;
   id: string;
   createdAt: Date;
   updatedAt: Date;
-}> | zod0.ZodSafeParseError<{
+}> | zod302.ZodSafeParseError<{
   configId: string;
   variantId: string;
   id: string;
   createdAt: Date;
   updatedAt: Date;
-}> | zod0.ZodSafeParseSuccess<{
+}> | zod302.ZodSafeParseSuccess<{
   environmentId: string;
   configId: string;
   configVariantId: string;
@@ -598,7 +598,7 @@ declare function validateTableData<T extends TableName>(table: T, data: unknown)
   createdAt: Date;
   updatedAt: Date;
   variantVersionId?: string | null | undefined;
-}> | zod0.ZodSafeParseError<{
+}> | zod302.ZodSafeParseError<{
   environmentId: string;
   configId: string;
   configVariantId: string;
@@ -614,17 +614,17 @@ declare function validateTableData<T extends TableName>(table: T, data: unknown)
 /**
  * Validate partial data (for updates)
  */
-declare function validatePartialTableData<T extends TableName>(table: T, data: unknown): zod0.ZodSafeParseSuccess<{
+declare function validatePartialTableData<T extends TableName>(table: T, data: unknown): zod302.ZodSafeParseSuccess<{
   name?: string | undefined;
   id?: string | undefined;
   createdAt?: Date | undefined;
   updatedAt?: Date | undefined;
-}> | zod0.ZodSafeParseError<{
+}> | zod302.ZodSafeParseError<{
   name?: string | undefined;
   id?: string | undefined;
   createdAt?: Date | undefined;
   updatedAt?: Date | undefined;
-}> | zod0.ZodSafeParseSuccess<{
+}> | zod302.ZodSafeParseSuccess<{
   variantId?: string | undefined;
   version?: number | undefined;
   provider?: string | undefined;
@@ -633,7 +633,7 @@ declare function validatePartialTableData<T extends TableName>(table: T, data: u
   id?: string | undefined;
   createdAt?: Date | undefined;
   updatedAt?: Date | undefined;
-}> | zod0.ZodSafeParseError<{
+}> | zod302.ZodSafeParseError<{
   variantId?: string | undefined;
   version?: number | undefined;
   provider?: string | undefined;
@@ -642,33 +642,33 @@ declare function validatePartialTableData<T extends TableName>(table: T, data: u
   id?: string | undefined;
   createdAt?: Date | undefined;
   updatedAt?: Date | undefined;
-}> | zod0.ZodSafeParseSuccess<{
+}> | zod302.ZodSafeParseSuccess<{
   environmentId?: string | undefined;
   keyName?: string | undefined;
   keyValue?: string | undefined;
   id?: string | undefined;
   createdAt?: Date | undefined;
   updatedAt?: Date | undefined;
-}> | zod0.ZodSafeParseError<{
+}> | zod302.ZodSafeParseError<{
   environmentId?: string | undefined;
   keyName?: string | undefined;
   keyValue?: string | undefined;
   id?: string | undefined;
   createdAt?: Date | undefined;
   updatedAt?: Date | undefined;
-}> | zod0.ZodSafeParseSuccess<{
+}> | zod302.ZodSafeParseSuccess<{
   configId?: string | undefined;
   variantId?: string | undefined;
   id?: string | undefined;
   createdAt?: Date | undefined;
   updatedAt?: Date | undefined;
-}> | zod0.ZodSafeParseError<{
+}> | zod302.ZodSafeParseError<{
   configId?: string | undefined;
   variantId?: string | undefined;
   id?: string | undefined;
   createdAt?: Date | undefined;
   updatedAt?: Date | undefined;
-}> | zod0.ZodSafeParseSuccess<{
+}> | zod302.ZodSafeParseSuccess<{
   environmentId?: string | undefined;
   configId?: string | undefined;
   configVariantId?: string | undefined;
@@ -680,7 +680,7 @@ declare function validatePartialTableData<T extends TableName>(table: T, data: u
   id?: string | undefined;
   createdAt?: Date | undefined;
   updatedAt?: Date | undefined;
-}> | zod0.ZodSafeParseError<{
+}> | zod302.ZodSafeParseError<{
   environmentId?: string | undefined;
   configId?: string | undefined;
   configVariantId?: string | undefined;
@@ -788,6 +788,16 @@ declare function parsePartialTableData<T extends TableName>(table: T, data: unkn
 //#endregion
 //#region src/db/migrations.d.ts
 type DatabaseType$1 = 'postgres' | 'mysql' | 'sqlite' | 'mssql';
+/**
+ * Options for migration operations
+ */
+interface MigrationOptions {
+  /**
+   * PostgreSQL schema name to use.
+   * If provided, the schema will be created if it doesn't exist.
+   */
+  schema?: string;
+}
 declare function matchType(columnDataType: string, fieldType: string, dbType: DatabaseType$1): boolean;
 interface MigrationResult {
   toBeCreated: Array<{
@@ -805,15 +815,16 @@ interface MigrationResult {
   migrations: any[];
   needsMigration: boolean;
 }
-declare function getMigrations(db: Kysely<Database>, dbType: DatabaseType$1): Promise<MigrationResult>;
+declare function getMigrations(db: Kysely<Database>, dbType: DatabaseType$1, options?: MigrationOptions): Promise<MigrationResult>;
 /**
  * Run migrations if needed based on autoMigrate config
  * @param db - Kysely database instance
  * @param dbType - Database type
  * @param autoMigrate - Auto-migrate configuration
+ * @param options - Migration options (schema, etc.)
  * @returns true if migrations were run, false otherwise
  */
-declare function runAutoMigrations(db: Kysely<Database>, dbType: DatabaseType$1, autoMigrate: boolean | 'development'): Promise<{
+declare function runAutoMigrations(db: Kysely<Database>, dbType: DatabaseType$1, autoMigrate: boolean | 'development', options?: MigrationOptions): Promise<{
   ran: boolean;
   tables: string[];
   fields: string[];
@@ -824,6 +835,16 @@ declare function runAutoMigrations(db: Kysely<Database>, dbType: DatabaseType$1,
  * Supported database types
  */
 type DatabaseType = 'postgres' | 'mysql' | 'sqlite' | 'mssql';
+/**
+ * Options for creating a database connection
+ */
+interface DatabaseOptions {
+  /**
+   * PostgreSQL schema name (sets search_path).
+   * Defaults to 'llmops'.
+   */
+  schema?: string;
+}
 /**
  * Database connection options
  */
@@ -853,7 +874,10 @@ declare function createDatabase(connection: DatabaseConnection): Kysely<Database
 declare function detectDatabaseType(db: unknown): DatabaseType | null;
 /**
  * Create database from raw connection
+ *
+ * @param rawConnection - The raw database connection (pg Pool, sqlite Database, etc.)
+ * @param options - Optional configuration (schema for PostgreSQL)
  */
-declare function createDatabaseFromConnection(rawConnection: any): Promise<Kysely<Database> | null>;
+declare function createDatabaseFromConnection(rawConnection: any, options?: DatabaseOptions): Promise<Kysely<Database> | null>;
 //#endregion
-export { Variant as A, variantVersionsSchema as B, Insertable as C, TargetingRule as D, TableName as E, configsSchema as F, environmentSecretsSchema as I, environmentsSchema as L, VariantVersionsTable as M, VariantsTable as N, TargetingRulesTable as O, configVariantsSchema as P, schemas as R, EnvironmentsTable as S, Selectable as T, variantsSchema as V, ConfigsTable as _, detectDatabaseType as a, EnvironmentSecret as b, matchType as c, parseTableData as d, validatePartialTableData as f, ConfigVariantsTable as g, ConfigVariant as h, createDatabaseFromConnection as i, VariantVersion as j, Updateable as k, runAutoMigrations as l, Config as m, DatabaseType as n, MigrationResult as o, validateTableData as p, createDatabase as r, getMigrations as s, DatabaseConnection as t, parsePartialTableData as u, Database as v, SCHEMA_METADATA as w, EnvironmentSecretsTable as x, Environment as y, targetingRulesSchema as z };
+export { TargetingRulesTable as A, schemas as B, EnvironmentSecretsTable as C, Selectable as D, SCHEMA_METADATA as E, VariantsTable as F, variantVersionsSchema as H, configVariantsSchema as I, configsSchema as L, Variant as M, VariantVersion as N, TableName as O, VariantVersionsTable as P, environmentSecretsSchema as R, EnvironmentSecret as S, Insertable as T, variantsSchema as U, targetingRulesSchema as V, ConfigVariant as _, createDatabaseFromConnection as a, Database as b, MigrationResult as c, runAutoMigrations as d, parsePartialTableData as f, Config as g, validateTableData as h, createDatabase as i, Updateable as j, TargetingRule as k, getMigrations as l, validatePartialTableData as m, DatabaseOptions as n, detectDatabaseType as o, parseTableData as p, DatabaseType as r, MigrationOptions as s, DatabaseConnection as t, matchType as u, ConfigVariantsTable as v, EnvironmentsTable as w, Environment as x, ConfigsTable as y, environmentsSchema as z };

package/dist/index.cjs

@@ -1,4 +1,4 @@
-const require_db = require('./db-16I7_mus.cjs');
+const require_db = require('./db-gMDwCuHR.cjs');
 let __llmops_gateway = require("@llmops/gateway");
 __llmops_gateway = require_db.__toESM(__llmops_gateway);
 let __better_auth_utils_random = require("@better-auth/utils/random");
@@ -449,7 +449,8 @@ const llmopsConfigSchema = require_db.object({
 	auth: authSchema,
 	basePath: require_db.string().min(1, "Base path is required and cannot be empty").refine((path) => path.startsWith("/"), "Base path must start with a forward slash"),
 	providers: providersSchema,
-	autoMigrate: require_db.union([require_db.boolean(), require_db.literal("development")]).optional().default(false)
+	autoMigrate: require_db.union([require_db.boolean(), require_db.literal("development")]).optional().default(false),
+	schema: require_db.string().optional().default("llmops")
 });
 function validateLLMOpsConfig(config) {
 	const result = llmopsConfigSchema.safeParse(config);