@llmops/cli 0.1.0-beta.8 → 0.1.1-beta.1

package/dist/index.mjs

@@ -1,14 +1,13 @@
 #!/usr/bin/env node
 import { command, run, string } from "@drizzle-team/brocli";
 import { logger } from "@llmops/core";
-import { createDatabaseFromConnection, detectDatabaseType } from "@llmops/core/db";
+import { createDatabaseFromConnection, detectDatabaseType, getMigrations } from "@llmops/core/db";
 import { existsSync } from "node:fs";
 import yoctoSpinner from "yocto-spinner";
 import chalk from "chalk";
 import prompts from "prompts";
 import { loadConfig } from "c12";
 import path from "node:path";
-import { sql } from "kysely";
 
 //#region src/lib/get-config.ts
 const getConfig = async ({ cwd, configPath }) => {
@@ -20,225 +19,6 @@ const getConfig = async ({ cwd, configPath }) => {
 	}
 };
 
-//#endregion
-//#region src/lib/get-migration.ts
-const typeMap = {
-	postgres: {
-		uuid: [
-			"character varying",
-			"varchar",
-			"text",
-			"uuid"
-		],
-		text: [
-			"character varying",
-			"varchar",
-			"text"
-		],
-		timestamp: [
-			"timestamptz",
-			"timestamp",
-			"date"
-		],
-		jsonb: ["json", "jsonb"]
-	},
-	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) {
-		logger.warn("Could not filter tables by schema. Using all discovered tables.");
-	}
-	const schema = (await import("@llmops/core/db")).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
-	};
-}
-
 //#endregion
 //#region src/commands/migrate.ts
 /**
@@ -283,7 +63,8 @@ const migrateCommand = command({
 			logger.error("No database configuration found.");
 			process.exit(1);
 		}
-		const db = await createDatabaseFromConnection(config.database);
+		const schema = config.schema ?? "llmops";
+		const db = await createDatabaseFromConnection(config.database, { schema });
 		if (!db) {
 			logger.error("Failed to create database connection.");
 			process.exit(1);
@@ -294,7 +75,7 @@ const migrateCommand = command({
 			process.exit(1);
 		}
 		const spinner = yoctoSpinner({ text: "preparing migration..." }).start();
-		const { toBeAdded, toBeCreated, runMigrations } = await getMigrations(db, dbType);
+		const { toBeAdded, toBeCreated, runMigrations } = await getMigrations(db, dbType, { schema });
 		if (!toBeAdded.length && !toBeCreated.length) {
 			spinner.stop();
 			console.log("🚀 No migrations needed.");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@llmops/cli",
-  "version": "0.1.0-beta.8",
+  "version": "0.1.1-beta.1",
   "type": "module",
   "description": "LLMOps CLI - A pluggable LLMOps toolkit for TypeScript teams",
   "license": "Apache-2.0",
@@ -45,8 +45,8 @@
     "kysely": "^0.28.8",
     "prompts": "^2.4.2",
     "yocto-spinner": "^1.0.0",
-    "@llmops/core": "0.1.0-beta.8",
-    "@llmops/sdk": "0.1.0-beta.8"
+    "@llmops/sdk": "^0.1.1-beta.1",
+    "@llmops/core": "^0.1.1-beta.1"
   },
   "devDependencies": {
     "@types/pg": "^8.15.6",