@llmops/core 0.4.8-beta.8 → 0.5.0-beta.1

package/dist/{db-BFaJfeYI.mjs → db-DdV835WT.mjs}

@@ -13915,247 +13915,6 @@ const schemas = {
 	llm_requests: llmRequestsSchema
 };
 
-//#endregion
-//#region src/db/schema-sql.ts
-/**
-* Idempotent SQL Schema Generator
-*
-* Generates fully idempotent PostgreSQL schema SQL that can be run on every
-* server restart. Works in edge environments (no file system access needed).
-*
-* This is the programmatic version of the generate-schema-sql.ts script.
-*/
-function toSnakeCase(str) {
-	return str.replace(/[A-Z]/g, (letter) => `_${letter.toLowerCase()}`);
-}
-function getDefaultValue(fieldType, defaultValue) {
-	if (defaultValue === void 0) return null;
-	if (defaultValue === "now()") return "NOW()";
-	if (typeof defaultValue === "boolean") return defaultValue ? "TRUE" : "FALSE";
-	if (typeof defaultValue === "number") return String(defaultValue);
-	if (typeof defaultValue === "string") {
-		if (defaultValue === "{}") return "'{}'::jsonb";
-		return `'${defaultValue}'`;
-	}
-	return null;
-}
-const TYPE_MAPPINGS = {
-	uuid: "UUID",
-	text: "TEXT",
-	integer: "INTEGER",
-	boolean: "BOOLEAN",
-	timestamp: "TIMESTAMP WITH TIME ZONE",
-	jsonb: "JSONB"
-};
-/**
-* Generate idempotent PostgreSQL schema SQL
-*
-* @param schemaName - Optional PostgreSQL schema name (e.g., 'llmops').
-*                     If not provided, tables are created in the current search_path.
-* @returns SQL string that can be executed to create/update the schema
-*/
-function generatePostgresSchemaSQL(schemaName) {
-	const lines = [];
-	const schemaPrefix = schemaName ? `"${schemaName}".` : "";
-	lines.push(`-- LLMOps Database Schema (PostgreSQL)`);
-	lines.push(`-- This SQL is fully idempotent and safe to run on every server restart.`);
-	lines.push("");
-	if (schemaName) {
-		lines.push(`-- Create schema if not exists`);
-		lines.push(`CREATE SCHEMA IF NOT EXISTS "${schemaName}";`);
-		lines.push("");
-	}
-	lines.push(`-- Enable UUID extension`);
-	lines.push(`CREATE EXTENSION IF NOT EXISTS "pgcrypto" SCHEMA public;`);
-	lines.push("");
-	const sortedTables = Object.entries(SCHEMA_METADATA.tables).map(([name, meta$2]) => ({
-		name,
-		meta: meta$2
-	})).sort((a, b) => a.meta.order - b.meta.order);
-	lines.push(`-- STEP 1: Create tables (if not exist)`);
-	for (const { name, meta: meta$2 } of sortedTables) {
-		const fullTableName = schemaPrefix + toSnakeCase(name);
-		if (!Object.entries(meta$2.fields).find(([_, f]) => f.primaryKey)) continue;
-		lines.push(`CREATE TABLE IF NOT EXISTS ${fullTableName} (`);
-		lines.push(`  id UUID PRIMARY KEY DEFAULT gen_random_uuid()`);
-		lines.push(`);`);
-	}
-	lines.push("");
-	lines.push(`-- STEP 2: Add columns (if not exist)`);
-	for (const { name, meta: meta$2 } of sortedTables) {
-		const fullTableName = schemaPrefix + toSnakeCase(name);
-		for (const [columnName, field] of Object.entries(meta$2.fields)) {
-			if (field.primaryKey) continue;
-			const snakeColumn = toSnakeCase(columnName);
-			const sqlType = TYPE_MAPPINGS[field.type] || "TEXT";
-			const defaultVal = getDefaultValue(field.type, field.default);
-			let colDef = `${snakeColumn} ${sqlType}`;
-			if (defaultVal) colDef += ` DEFAULT ${defaultVal}`;
-			lines.push(`ALTER TABLE ${fullTableName} ADD COLUMN IF NOT EXISTS ${colDef};`);
-		}
-	}
-	lines.push("");
-	lines.push(`-- STEP 3: Add unique constraints (if not exist)`);
-	for (const { name, meta: meta$2 } of sortedTables) {
-		const snakeTable = toSnakeCase(name);
-		const fullTableName = schemaPrefix + snakeTable;
-		for (const [columnName, field] of Object.entries(meta$2.fields)) if (field.unique) {
-			const snakeColumn = toSnakeCase(columnName);
-			const constraintName = `uq_${snakeTable}_${snakeColumn}`;
-			lines.push(`DO $$`);
-			lines.push(`BEGIN`);
-			lines.push(`  IF NOT EXISTS (`);
-			lines.push(`    SELECT 1 FROM pg_constraint WHERE conname = '${constraintName}'`);
-			lines.push(`  ) THEN`);
-			lines.push(`    ALTER TABLE ${fullTableName} ADD CONSTRAINT ${constraintName} UNIQUE (${snakeColumn});`);
-			lines.push(`  END IF;`);
-			lines.push(`END $$;`);
-		}
-		if (meta$2.uniqueConstraints) for (const constraint of meta$2.uniqueConstraints) {
-			const cols = constraint.columns.map(toSnakeCase).join(", ");
-			const constraintName = `uq_${snakeTable}_${constraint.columns.map(toSnakeCase).join("_")}`;
-			lines.push(`DO $$`);
-			lines.push(`BEGIN`);
-			lines.push(`  IF NOT EXISTS (`);
-			lines.push(`    SELECT 1 FROM pg_constraint WHERE conname = '${constraintName}'`);
-			lines.push(`  ) THEN`);
-			lines.push(`    ALTER TABLE ${fullTableName} ADD CONSTRAINT ${constraintName} UNIQUE (${cols});`);
-			lines.push(`  END IF;`);
-			lines.push(`END $$;`);
-		}
-	}
-	lines.push("");
-	lines.push(`-- STEP 4: Add foreign keys (if not exist)`);
-	for (const { name, meta: meta$2 } of sortedTables) {
-		const snakeTable = toSnakeCase(name);
-		const fullTableName = schemaPrefix + snakeTable;
-		for (const [columnName, field] of Object.entries(meta$2.fields)) if (field.references) {
-			const snakeColumn = toSnakeCase(columnName);
-			const refTable = schemaPrefix + toSnakeCase(field.references.table);
-			const refColumn = toSnakeCase(field.references.column);
-			const constraintName = `fk_${snakeTable}_${snakeColumn}`;
-			lines.push(`DO $$`);
-			lines.push(`BEGIN`);
-			lines.push(`  IF NOT EXISTS (`);
-			lines.push(`    SELECT 1 FROM pg_constraint WHERE conname = '${constraintName}'`);
-			lines.push(`  ) THEN`);
-			lines.push(`    ALTER TABLE ${fullTableName} ADD CONSTRAINT ${constraintName}`);
-			lines.push(`      FOREIGN KEY (${snakeColumn}) REFERENCES ${refTable}(${refColumn}) ON DELETE CASCADE;`);
-			lines.push(`  END IF;`);
-			lines.push(`END $$;`);
-		}
-	}
-	lines.push("");
-	lines.push(`-- STEP 5: Create indexes (if not exist)`);
-	for (const { name, meta: meta$2 } of sortedTables) {
-		const snakeTable = toSnakeCase(name);
-		const fullTableName = schemaPrefix + snakeTable;
-		for (const [columnName, field] of Object.entries(meta$2.fields)) if (field.references) {
-			const snakeColumn = toSnakeCase(columnName);
-			lines.push(`CREATE INDEX IF NOT EXISTS idx_${snakeTable}_${snakeColumn} ON ${fullTableName}(${snakeColumn});`);
-		}
-	}
-	lines.push("");
-	lines.push(`-- STEP 6: Create updated_at triggers`);
-	const functionName = `${schemaName ? `"${schemaName}".` : "public."}update_updated_at_column`;
-	lines.push(`CREATE OR REPLACE FUNCTION ${functionName}()`);
-	lines.push(`RETURNS TRIGGER AS $$`);
-	lines.push(`BEGIN`);
-	lines.push(`  NEW.updated_at = NOW();`);
-	lines.push(`  RETURN NEW;`);
-	lines.push(`END;`);
-	lines.push(`$$ language 'plpgsql';`);
-	for (const { name } of sortedTables) {
-		const snakeTable = toSnakeCase(name);
-		const fullTableName = schemaPrefix + snakeTable;
-		lines.push(`DROP TRIGGER IF EXISTS update_${snakeTable}_updated_at ON ${fullTableName};`);
-		lines.push(`CREATE TRIGGER update_${snakeTable}_updated_at BEFORE UPDATE ON ${fullTableName} FOR EACH ROW EXECUTE FUNCTION ${functionName}();`);
-	}
-	lines.push("");
-	return lines.join("\n");
-}
-/**
-* Execute the schema SQL using a Neon SQL function
-*
-* @param sql - Neon sql function (from `neon()` or passed connection)
-* @param schemaName - Optional PostgreSQL schema name
-*/
-async function runSchemaSQL(sql$1, schemaName) {
-	const statements = splitSQLStatements(generatePostgresSchemaSQL(schemaName));
-	for (let i = 0; i < statements.length; i++) {
-		const trimmed = statements[i].trim();
-		if (trimmed && !trimmed.startsWith("--")) try {
-			await sql$1(trimmed);
-		} catch (error$47) {
-			console.error(`[Schema] Failed at statement ${i + 1}/${statements.length}:`);
-			console.error(`[Schema] Statement preview: ${trimmed.slice(0, 100)}...`);
-			throw error$47;
-		}
-	}
-}
-/**
-* Split SQL into individual statements, keeping $$ blocks together
-* Handles both DO $$ blocks and CREATE FUNCTION ... AS $$ blocks
-*/
-function splitSQLStatements(sql$1) {
-	const statements = [];
-	let current = "";
-	let inDollarBlock = false;
-	const lines = sql$1.split("\n");
-	for (const line of lines) {
-		const trimmed = line.trim();
-		if (!trimmed || trimmed.startsWith("--")) continue;
-		if (!inDollarBlock && (trimmed === "DO $$" || trimmed.endsWith("AS $$"))) {
-			inDollarBlock = true;
-			current += line + "\n";
-			continue;
-		}
-		if (inDollarBlock) {
-			current += line + "\n";
-			if (trimmed.startsWith("$$") && trimmed.endsWith(";")) {
-				statements.push(current.trim());
-				current = "";
-				inDollarBlock = false;
-			}
-			continue;
-		}
-		current += line + "\n";
-		if (trimmed.endsWith(";")) {
-			statements.push(current.trim());
-			current = "";
-		}
-	}
-	if (current.trim()) statements.push(current.trim());
-	return statements;
-}
-/**
-* Create a Neon SQL function from various connection types
-*
-* The Neon serverless library returns a tagged template function from neon(),
-* but for conventional string queries we need to use sql.query() instead.
-* This helper wraps the neon instance to provide a simple query function.
-*
-* @param rawConnection - neon() function, connection string, or undefined (uses env vars)
-* @returns SQL function that can be used with runSchemaSQL, or null if unable to create
-*/
-async function createNeonSqlFunction(rawConnection) {
-	const wrapNeonSql = (sql$1) => {
-		return (query) => sql$1.query(query);
-	};
-	if (typeof rawConnection === "function") {
-		if ("query" in rawConnection && typeof rawConnection.query === "function") return wrapNeonSql(rawConnection);
-		return rawConnection;
-	}
-	if (typeof rawConnection === "string" && rawConnection) {
-		const { neon: neon$1 } = await import("@neondatabase/serverless");
-		return wrapNeonSql(neon$1(rawConnection));
-	}
-	const connectionString = process.env.NEON_CONNECTION_STRING || process.env.NEON_PG_URL || process.env.DATABASE_URL || process.env.POSTGRES_URL || "";
-	if (!connectionString) return null;
-	const { neon } = await import("@neondatabase/serverless");
-	return wrapNeonSql(neon(connectionString));
-}
-
 //#endregion
 //#region src/db/validation.ts
 /**
@@ -14569,21 +14328,9 @@ function createDatabase(connection) {
 	return new Kysely({ dialect: connection.dialect });
 }
 /**
-* Check if a string looks like a Neon connection string
-*/
-function isNeonConnectionString(str) {
-	return str.includes(".neon.tech") || str.includes("neon.tech") || str.includes("@neon-");
-}
-/**
-* Auto-detect database type from connection object or string
+* Auto-detect database type from connection object
 */
 function detectDatabaseType(db) {
-	if (typeof db === "string") {
-		if (isNeonConnectionString(db)) return "neon";
-		if (db.startsWith("postgres://") || db.startsWith("postgresql://")) return "postgres";
-		if (db.startsWith("mysql://")) return "mysql";
-		return null;
-	}
 	if (!db || typeof db !== "object" && typeof db !== "function") return null;
 	if ("createDriver" in db) {
 		if (db instanceof SqliteDialect) return "sqlite";
@@ -14635,20 +14382,23 @@ async function createDatabaseFromConnection(rawConnection, options) {
 				}
 			});
 			break;
-		case "neon": {
-			if (typeof rawConnection === "function") {
-				const { createNeonDialect: createNeonDialect$1 } = await import("./neon-dialect-Hmo08nUq.mjs");
-				dialect = createNeonDialect$1(rawConnection);
-				break;
+		case "neon":
+			if (schema && schema !== "public") {
+				const { Pool, neonConfig } = await import("@neondatabase/serverless");
+				const { default: ws } = await import("ws");
+				neonConfig.webSocketConstructor = ws;
+				const connectionString = typeof rawConnection === "string" ? rawConnection : process.env.NEON_PG_URL || "";
+				dialect = new PostgresDialect({
+					pool: new Pool({ connectionString: connectionString.includes("currentSchema") ? connectionString.split("currentSchema=")[1].split("&")[0] === "public" ? connectionString.replace(/currentSchema=[^&]*&?/, "") : connectionString : connectionString }),
+					onCreateConnection: async (connection) => {
+						await connection.executeQuery(CompiledQuery.raw(`SET search_path TO "${schema}"`));
+					}
+				});
+			} else {
+				const { createNeonDialect } = await import("./neon-dialect-Hmo08nUq.mjs");
+				dialect = createNeonDialect(rawConnection);
 			}
-			const connectionString = typeof rawConnection === "string" && rawConnection || process.env.NEON_CONNECTION_STRING || process.env.NEON_PG_URL || process.env.DATABASE_URL || process.env.POSTGRES_URL || "";
-			if (!connectionString) throw new Error("Neon connection string is required. Pass it directly as the database option or set one of: NEON_CONNECTION_STRING, NEON_PG_URL, DATABASE_URL, POSTGRES_URL");
-			const { neon } = await import("@neondatabase/serverless");
-			const sql$1 = neon(connectionString);
-			const { createNeonDialect } = await import("./neon-dialect-Hmo08nUq.mjs");
-			dialect = createNeonDialect(sql$1);
 			break;
-		}
 		case "mssql":
 			if ("createDriver" in rawConnection) dialect = rawConnection;
 			break;
@@ -14657,4 +14407,4 @@ async function createDatabaseFromConnection(rawConnection, options) {
 }
 
 //#endregion
-export { playgroundsSchema as A, any as B, environmentSecretsSchema as C, playgroundColumnSchema as D, llmRequestsSchema as E, variantVersionsSchema as F, object as G, boolean$1 as H, variantsSchema as I, union as J, record as K, workspaceSettingsSchema as L, providerGuardrailOverridesSchema as M, schemas as N, playgroundResultsSchema as O, targetingRulesSchema as P, zod_default as R, datasetsSchema as S, guardrailConfigsSchema as T, literal as U, array as V, number$1 as W, unknown as Y, configVariantsSchema as _, matchType as a, datasetVersionRecordsSchema as b, logger as c, validatePartialTableData as d, validateTableData as f, SCHEMA_METADATA as g, runSchemaSQL as h, getMigrations$1 as i, providerConfigsSchema as j, playgroundRunsSchema as k, parsePartialTableData as l, generatePostgresSchemaSQL as m, createDatabaseFromConnection as n, runAutoMigrations as o, createNeonSqlFunction as p, string$1 as q, detectDatabaseType as r, getAuthClientOptions as s, createDatabase as t, parseTableData as u, configsSchema as v, environmentsSchema as w, datasetVersionsSchema as x, datasetRecordsSchema as y, _enum as z };
+export { schemas as A, literal as B, llmRequestsSchema as C, playgroundsSchema as D, playgroundRunsSchema as E, zod_default as F, union as G, object as H, _enum as I, unknown as K, any as L, variantVersionsSchema as M, variantsSchema as N, providerConfigsSchema as O, workspaceSettingsSchema as P, array as R, guardrailConfigsSchema as S, playgroundResultsSchema as T, record as U, number$1 as V, string$1 as W, datasetVersionRecordsSchema as _, matchType as a, environmentSecretsSchema as b, logger as c, validatePartialTableData as d, validateTableData as f, datasetRecordsSchema as g, configsSchema as h, getMigrations$1 as i, targetingRulesSchema as j, providerGuardrailOverridesSchema as k, parsePartialTableData as l, configVariantsSchema as m, createDatabaseFromConnection as n, runAutoMigrations as o, SCHEMA_METADATA as p, detectDatabaseType as r, getAuthClientOptions as s, createDatabase as t, parseTableData as u, datasetVersionsSchema as v, playgroundColumnSchema as w, environmentsSchema as x, datasetsSchema as y, boolean$1 as z };

package/dist/{index-BvU4Gv3C.d.mts → index-BtZBaB4H.d.cts}

@@ -1,7 +1,7 @@
 import { ColumnType, Dialect, Generated, Kysely, MssqlDialect, MysqlDialect, PostgresDialect, SqliteDialect } from "kysely";
-import { NeonQueryFunction } from "@neondatabase/serverless";
 import * as zod0 from "zod";
 import { z } from "zod";
+import { NeonQueryFunction } from "@neondatabase/serverless";
 
 //#region src/db/schema.d.ts
 declare const configsSchema: z.ZodObject<{
@@ -1900,42 +1900,6 @@ declare const schemas: {
   }, z.core.$strip>;
 };
 //#endregion
-//#region src/db/schema-sql.d.ts
-/**
- * Idempotent SQL Schema Generator
- *
- * Generates fully idempotent PostgreSQL schema SQL that can be run on every
- * server restart. Works in edge environments (no file system access needed).
- *
- * This is the programmatic version of the generate-schema-sql.ts script.
- */
-/**
- * Generate idempotent PostgreSQL schema SQL
- *
- * @param schemaName - Optional PostgreSQL schema name (e.g., 'llmops').
- *                     If not provided, tables are created in the current search_path.
- * @returns SQL string that can be executed to create/update the schema
- */
-declare function generatePostgresSchemaSQL(schemaName?: string): string;
-/**
- * Execute the schema SQL using a Neon SQL function
- *
- * @param sql - Neon sql function (from `neon()` or passed connection)
- * @param schemaName - Optional PostgreSQL schema name
- */
-declare function runSchemaSQL(sql: (query: string) => Promise<unknown>, schemaName?: string): Promise<void>;
-/**
- * Create a Neon SQL function from various connection types
- *
- * The Neon serverless library returns a tagged template function from neon(),
- * but for conventional string queries we need to use sql.query() instead.
- * This helper wraps the neon instance to provide a simple query function.
- *
- * @param rawConnection - neon() function, connection string, or undefined (uses env vars)
- * @returns SQL function that can be used with runSchemaSQL, or null if unable to create
- */
-declare function createNeonSqlFunction(rawConnection: unknown): Promise<((query: string) => Promise<unknown>) | null>;
-//#endregion
 //#region src/db/validation.d.ts
 /**
  * Validate data against table schema
@@ -2982,7 +2946,7 @@ type DatabaseConnection = {
  */
 declare function createDatabase(connection: DatabaseConnection): Kysely<Database>;
 /**
- * Auto-detect database type from connection object or string
+ * Auto-detect database type from connection object
  */
 declare function detectDatabaseType(db: unknown): DatabaseType | null;
 /**
@@ -2993,4 +2957,4 @@ declare function detectDatabaseType(db: unknown): DatabaseType | null;
  */
 declare function createDatabaseFromConnection(rawConnection: any, options?: DatabaseOptions): Promise<Kysely<Database> | null>;
 //#endregion
-export { ProviderConfigsTable as $, DatasetVersionRecord as A, schemas as At, GuardrailResult as B, ConfigVariantsTable as C, llmRequestsSchema as Ct, DatasetRecord as D, playgroundsSchema as Dt, Dataset as E, playgroundRunsSchema as Et, EnvironmentSecret as F, Playground as G, Insertable as H, EnvironmentSecretsTable as I, PlaygroundResultsTable as J, PlaygroundColumn as K, EnvironmentsTable as L, DatasetVersionsTable as M, variantVersionsSchema as Mt, DatasetsTable as N, variantsSchema as Nt, DatasetRecordsTable as O, providerConfigsSchema as Ot, Environment as P, workspaceSettingsSchema as Pt, ProviderConfig as Q, GuardrailConfig as R, ConfigVariant as S, guardrailConfigsSchema as St, Database as T, playgroundResultsSchema as Tt, LLMRequest as U, GuardrailResults as V, LLMRequestsTable as W, PlaygroundRunsTable as X, PlaygroundRun as Y, PlaygroundsTable as Z, validateTableData as _, datasetVersionRecordsSchema as _t, createDatabaseFromConnection as a, TargetingRule as at, runSchemaSQL as b, environmentSecretsSchema as bt, executeWithSchema as c, Variant as ct, getMigrations as d, VariantsTable as dt, ProviderGuardrailOverride as et, matchType as f, WorkspaceSettings as ft, validatePartialTableData as g, datasetRecordsSchema as gt, parseTableData as h, configsSchema as ht, createDatabase as i, TableName as it, DatasetVersionRecordsTable as j, targetingRulesSchema as jt, DatasetVersion as k, providerGuardrailOverridesSchema as kt, MigrationOptions as l, VariantVersion as lt, parsePartialTableData as m, configVariantsSchema as mt, DatabaseOptions as n, SCHEMA_METADATA as nt, detectDatabaseType as o, TargetingRulesTable as ot, runAutoMigrations as p, WorkspaceSettingsTable as pt, PlaygroundResult as q, DatabaseType as r, Selectable as rt, createNeonDialect as s, Updateable as st, DatabaseConnection as t, ProviderGuardrailOverridesTable as tt, MigrationResult as u, VariantVersionsTable as ut, createNeonSqlFunction as v, datasetVersionsSchema as vt, ConfigsTable as w, playgroundColumnSchema as wt, Config as x, environmentsSchema as xt, generatePostgresSchemaSQL as y, datasetsSchema as yt, GuardrailConfigsTable as z };
+export { SCHEMA_METADATA as $, DatasetsTable as A, variantsSchema as At, LLMRequest as B, Dataset as C, playgroundRunsSchema as Ct, DatasetVersionRecord as D, schemas as Dt, DatasetVersion as E, providerGuardrailOverridesSchema as Et, GuardrailConfig as F, PlaygroundResultsTable as G, Playground as H, GuardrailConfigsTable as I, PlaygroundsTable as J, PlaygroundRun as K, GuardrailResult as L, EnvironmentSecret as M, EnvironmentSecretsTable as N, DatasetVersionRecordsTable as O, targetingRulesSchema as Ot, EnvironmentsTable as P, ProviderGuardrailOverridesTable as Q, GuardrailResults as R, Database as S, playgroundResultsSchema as St, DatasetRecordsTable as T, providerConfigsSchema as Tt, PlaygroundColumn as U, LLMRequestsTable as V, PlaygroundResult as W, ProviderConfigsTable as X, ProviderConfig as Y, ProviderGuardrailOverride as Z, validateTableData as _, environmentSecretsSchema as _t, createDatabaseFromConnection as a, Variant as at, ConfigVariantsTable as b, llmRequestsSchema as bt, executeWithSchema as c, VariantsTable as ct, getMigrations as d, configVariantsSchema as dt, Selectable as et, matchType as f, configsSchema as ft, validatePartialTableData as g, datasetsSchema as gt, parseTableData as h, datasetVersionsSchema as ht, createDatabase as i, Updateable as it, Environment as j, workspaceSettingsSchema as jt, DatasetVersionsTable as k, variantVersionsSchema as kt, MigrationOptions as l, WorkspaceSettings as lt, parsePartialTableData as m, datasetVersionRecordsSchema as mt, DatabaseOptions as n, TargetingRule as nt, detectDatabaseType as o, VariantVersion as ot, runAutoMigrations as p, datasetRecordsSchema as pt, PlaygroundRunsTable as q, DatabaseType as r, TargetingRulesTable as rt, createNeonDialect as s, VariantVersionsTable as st, DatabaseConnection as t, TableName as tt, MigrationResult as u, WorkspaceSettingsTable as ut, Config as v, environmentsSchema as vt, DatasetRecord as w, playgroundsSchema as wt, ConfigsTable as x, playgroundColumnSchema as xt, ConfigVariant as y, guardrailConfigsSchema as yt, Insertable as z };

package/dist/{index-BYhMgUES.d.cts → index-DkZvY6Q3.d.mts}

@@ -1,7 +1,7 @@
 import { ColumnType, Dialect, Generated, Kysely, MssqlDialect, MysqlDialect, PostgresDialect, SqliteDialect } from "kysely";
+import { NeonQueryFunction } from "@neondatabase/serverless";
 import * as zod0 from "zod";
 import { z } from "zod";
-import { NeonQueryFunction } from "@neondatabase/serverless";
 
 //#region src/db/schema.d.ts
 declare const configsSchema: z.ZodObject<{
@@ -1900,42 +1900,6 @@ declare const schemas: {
   }, z.core.$strip>;
 };
 //#endregion
-//#region src/db/schema-sql.d.ts
-/**
- * Idempotent SQL Schema Generator
- *
- * Generates fully idempotent PostgreSQL schema SQL that can be run on every
- * server restart. Works in edge environments (no file system access needed).
- *
- * This is the programmatic version of the generate-schema-sql.ts script.
- */
-/**
- * Generate idempotent PostgreSQL schema SQL
- *
- * @param schemaName - Optional PostgreSQL schema name (e.g., 'llmops').
- *                     If not provided, tables are created in the current search_path.
- * @returns SQL string that can be executed to create/update the schema
- */
-declare function generatePostgresSchemaSQL(schemaName?: string): string;
-/**
- * Execute the schema SQL using a Neon SQL function
- *
- * @param sql - Neon sql function (from `neon()` or passed connection)
- * @param schemaName - Optional PostgreSQL schema name
- */
-declare function runSchemaSQL(sql: (query: string) => Promise<unknown>, schemaName?: string): Promise<void>;
-/**
- * Create a Neon SQL function from various connection types
- *
- * The Neon serverless library returns a tagged template function from neon(),
- * but for conventional string queries we need to use sql.query() instead.
- * This helper wraps the neon instance to provide a simple query function.
- *
- * @param rawConnection - neon() function, connection string, or undefined (uses env vars)
- * @returns SQL function that can be used with runSchemaSQL, or null if unable to create
- */
-declare function createNeonSqlFunction(rawConnection: unknown): Promise<((query: string) => Promise<unknown>) | null>;
-//#endregion
 //#region src/db/validation.d.ts
 /**
  * Validate data against table schema
@@ -2982,7 +2946,7 @@ type DatabaseConnection = {
  */
 declare function createDatabase(connection: DatabaseConnection): Kysely<Database>;
 /**
- * Auto-detect database type from connection object or string
+ * Auto-detect database type from connection object
  */
 declare function detectDatabaseType(db: unknown): DatabaseType | null;
 /**
@@ -2993,4 +2957,4 @@ declare function detectDatabaseType(db: unknown): DatabaseType | null;
  */
 declare function createDatabaseFromConnection(rawConnection: any, options?: DatabaseOptions): Promise<Kysely<Database> | null>;
 //#endregion
-export { ProviderConfigsTable as $, DatasetVersionRecord as A, schemas as At, GuardrailResult as B, ConfigVariantsTable as C, llmRequestsSchema as Ct, DatasetRecord as D, playgroundsSchema as Dt, Dataset as E, playgroundRunsSchema as Et, EnvironmentSecret as F, Playground as G, Insertable as H, EnvironmentSecretsTable as I, PlaygroundResultsTable as J, PlaygroundColumn as K, EnvironmentsTable as L, DatasetVersionsTable as M, variantVersionsSchema as Mt, DatasetsTable as N, variantsSchema as Nt, DatasetRecordsTable as O, providerConfigsSchema as Ot, Environment as P, workspaceSettingsSchema as Pt, ProviderConfig as Q, GuardrailConfig as R, ConfigVariant as S, guardrailConfigsSchema as St, Database as T, playgroundResultsSchema as Tt, LLMRequest as U, GuardrailResults as V, LLMRequestsTable as W, PlaygroundRunsTable as X, PlaygroundRun as Y, PlaygroundsTable as Z, validateTableData as _, datasetVersionRecordsSchema as _t, createDatabaseFromConnection as a, TargetingRule as at, runSchemaSQL as b, environmentSecretsSchema as bt, executeWithSchema as c, Variant as ct, getMigrations as d, VariantsTable as dt, ProviderGuardrailOverride as et, matchType as f, WorkspaceSettings as ft, validatePartialTableData as g, datasetRecordsSchema as gt, parseTableData as h, configsSchema as ht, createDatabase as i, TableName as it, DatasetVersionRecordsTable as j, targetingRulesSchema as jt, DatasetVersion as k, providerGuardrailOverridesSchema as kt, MigrationOptions as l, VariantVersion as lt, parsePartialTableData as m, configVariantsSchema as mt, DatabaseOptions as n, SCHEMA_METADATA as nt, detectDatabaseType as o, TargetingRulesTable as ot, runAutoMigrations as p, WorkspaceSettingsTable as pt, PlaygroundResult as q, DatabaseType as r, Selectable as rt, createNeonDialect as s, Updateable as st, DatabaseConnection as t, ProviderGuardrailOverridesTable as tt, MigrationResult as u, VariantVersionsTable as ut, createNeonSqlFunction as v, datasetVersionsSchema as vt, ConfigsTable as w, playgroundColumnSchema as wt, Config as x, environmentsSchema as xt, generatePostgresSchemaSQL as y, datasetsSchema as yt, GuardrailConfigsTable as z };
+export { SCHEMA_METADATA as $, DatasetsTable as A, variantsSchema as At, LLMRequest as B, Dataset as C, playgroundRunsSchema as Ct, DatasetVersionRecord as D, schemas as Dt, DatasetVersion as E, providerGuardrailOverridesSchema as Et, GuardrailConfig as F, PlaygroundResultsTable as G, Playground as H, GuardrailConfigsTable as I, PlaygroundsTable as J, PlaygroundRun as K, GuardrailResult as L, EnvironmentSecret as M, EnvironmentSecretsTable as N, DatasetVersionRecordsTable as O, targetingRulesSchema as Ot, EnvironmentsTable as P, ProviderGuardrailOverridesTable as Q, GuardrailResults as R, Database as S, playgroundResultsSchema as St, DatasetRecordsTable as T, providerConfigsSchema as Tt, PlaygroundColumn as U, LLMRequestsTable as V, PlaygroundResult as W, ProviderConfigsTable as X, ProviderConfig as Y, ProviderGuardrailOverride as Z, validateTableData as _, environmentSecretsSchema as _t, createDatabaseFromConnection as a, Variant as at, ConfigVariantsTable as b, llmRequestsSchema as bt, executeWithSchema as c, VariantsTable as ct, getMigrations as d, configVariantsSchema as dt, Selectable as et, matchType as f, configsSchema as ft, validatePartialTableData as g, datasetsSchema as gt, parseTableData as h, datasetVersionsSchema as ht, createDatabase as i, Updateable as it, Environment as j, workspaceSettingsSchema as jt, DatasetVersionsTable as k, variantVersionsSchema as kt, MigrationOptions as l, WorkspaceSettings as lt, parsePartialTableData as m, datasetVersionRecordsSchema as mt, DatabaseOptions as n, TargetingRule as nt, detectDatabaseType as o, VariantVersion as ot, runAutoMigrations as p, datasetRecordsSchema as pt, PlaygroundRunsTable as q, DatabaseType as r, TargetingRulesTable as rt, createNeonDialect as s, VariantVersionsTable as st, DatabaseConnection as t, TableName as tt, MigrationResult as u, WorkspaceSettingsTable as ut, Config as v, environmentsSchema as vt, DatasetRecord as w, playgroundsSchema as wt, ConfigsTable as x, playgroundColumnSchema as xt, ConfigVariant as y, guardrailConfigsSchema as yt, Insertable as z };

package/dist/index.cjs

@@ -1,5 +1,5 @@
-const require_db = require('./db-Bsofxq5N.cjs');
-const require_neon_dialect = require('./neon-dialect-E2P4iCXQ.cjs');
+const require_db = require('./db-B6s2Fj5e.cjs');
+const require_neon_dialect = require('./neon-dialect-fjqFddrY.cjs');
 let __llmops_gateway = require("@llmops/gateway");
 __llmops_gateway = require_db.__toESM(__llmops_gateway);
 let kysely = require("kysely");
@@ -436,10 +436,26 @@ const variantJsonDataSchema = require_db.object({
 
 //#endregion
 //#region src/schemas/config.ts
+/**
+* Schema for inline provider configuration
+*/
+const inlineProviderConfigSchema = require_db.object({
+	provider: require_db.string().min(1, "Provider is required"),
+	slug: require_db.string().min(1, "Slug is required"),
+	apiKey: require_db.string().optional(),
+	customHost: require_db.string().optional(),
+	requestTimeout: require_db.number().optional(),
+	forwardHeaders: require_db.array(require_db.string()).optional()
+}).passthrough();
+/**
+* Schema for providers array
+*/
+const providersConfigSchema = require_db.array(inlineProviderConfigSchema).optional();
 const llmopsConfigSchema = require_db.object({
 	database: require_db.any(),
 	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"),
-	schema: require_db.string().optional().default("llmops")
+	schema: require_db.string().optional().default("llmops"),
+	providers: providersConfigSchema
 });
 function validateLLMOpsConfig(config) {
 	const result = llmopsConfigSchema.safeParse(config);
@@ -3764,7 +3780,6 @@ exports.createEnvironmentSecretDataLayer = createEnvironmentSecretDataLayer;
 exports.createGuardrailConfigsDataLayer = createGuardrailConfigsDataLayer;
 exports.createLLMRequestsDataLayer = createLLMRequestsDataLayer;
 exports.createNeonDialect = require_neon_dialect.createNeonDialect;
-exports.createNeonSqlFunction = require_db.createNeonSqlFunction;
 exports.createPlaygroundDataLayer = createPlaygroundDataLayer;
 exports.createPlaygroundResultsDataLayer = createPlaygroundResultsDataLayer;
 exports.createPlaygroundRunsDataLayer = createPlaygroundRunsDataLayer;
@@ -3791,7 +3806,6 @@ Object.defineProperty(exports, 'gateway', {
   }
 });
 exports.generateId = generateId;
-exports.generatePostgresSchemaSQL = require_db.generatePostgresSchemaSQL;
 exports.getAuthClientOptions = require_db.getAuthClientOptions;
 exports.getDefaultPricingProvider = getDefaultPricingProvider;
 exports.getMigrations = require_db.getMigrations;
@@ -3810,7 +3824,6 @@ exports.playgroundsSchema = require_db.playgroundsSchema;
 exports.providerConfigsSchema = require_db.providerConfigsSchema;
 exports.providerGuardrailOverridesSchema = require_db.providerGuardrailOverridesSchema;
 exports.runAutoMigrations = require_db.runAutoMigrations;
-exports.runSchemaSQL = require_db.runSchemaSQL;
 exports.schemas = require_db.schemas;
 exports.targetingRulesSchema = require_db.targetingRulesSchema;
 exports.validateLLMOpsConfig = validateLLMOpsConfig;