@lssm/app.cli-database 1.41.0 → 1.41.1

package/dist/_virtual/rolldown_runtime.mjs

@@ -0,0 +1,7 @@
+import { createRequire } from "node:module";
+
+//#region rolldown:runtime
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+//#endregion
+export { __require };

package/dist/cli.mjs

@@ -0,0 +1,81 @@
+#!/usr/bin/env node
+import { runImport } from "./commands/import.mjs";
+import { runCheck } from "./commands/check.mjs";
+import { runGenerate } from "./commands/generate.mjs";
+import { runMigrate } from "./commands/migrate.mjs";
+import { runSeed } from "./commands/seed.mjs";
+import { runSchemaGenerate } from "./commands/schema-generate.mjs";
+import { runSchemaCompose } from "./commands/schema-compose.mjs";
+import mri from "minimist";
+
+//#region src/cli.ts
+async function main() {
+	const argv = mri(process.argv.slice(2));
+	const [cmd] = argv._;
+	switch (cmd) {
+		case "import":
+			await runImport(argv);
+			break;
+		case "check":
+			await runCheck(argv);
+			break;
+		case "generate":
+			await runGenerate(argv);
+			break;
+		case "migrate:dev":
+		case "migrate:deploy":
+		case "migrate:status":
+			await runMigrate(cmd, argv);
+			break;
+		case "seed":
+			await runSeed(argv);
+			break;
+		case "schema:generate":
+			await runSchemaGenerate(argv);
+			break;
+		case "schema:compose":
+			await runSchemaCompose(argv);
+			break;
+		default:
+			printUsage();
+			process.exit(1);
+	}
+}
+function printUsage() {
+	console.log(`
+Usage: database <command> [options]
+
+Commands:
+  import              Import schema from external sources
+  check               Check Prisma schema validity
+  generate            Generate Prisma client
+  migrate:dev         Run migrations in development
+  migrate:deploy      Deploy migrations to production
+  migrate:status      Check migration status
+  seed                Seed the database
+
+Schema Generation (spec-first):
+  schema:generate     Generate Prisma schema from entity specs
+                      --config <path>   Schema config file (default: ./schema.config.ts)
+                      --output <path>   Output path (default: ./prisma/schema/generated.prisma)
+                      --module <id>     Generate only a specific module
+
+  schema:compose      Compose multiple module schemas
+                      --config <path>   Schema config file (default: ./schema.config.ts)
+                      --output <path>   Output path (default: ./prisma/schema/composed.prisma)
+                      --modules <list>  Comma-separated module IDs to include
+
+Examples:
+  database schema:generate --config ./schema.config.ts
+  database schema:compose --modules "@lssm/lib.identity-rbac,@lssm/module.audit-trail"
+  database generate
+  database migrate:dev --name add_users_table
+`);
+}
+main().catch((err) => {
+	console.error(err);
+	process.exit(1);
+});
+
+//#endregion
+export {  };

package/dist/commands/check.mjs

@@ -0,0 +1,34 @@
+import fs from "node:fs";
+import path from "node:path";
+import crypto from "node:crypto";
+
+//#region src/commands/check.ts
+function sha256(content) {
+	return crypto.createHash("sha256").update(content).digest("hex");
+}
+async function runCheck(argv) {
+	const target = argv.target || process.cwd();
+	const lockPath = path.join(target, "prisma", "schema", "imported", "imported.lock.json");
+	if (!fs.existsSync(lockPath)) {
+		console.error("No imported.lock.json found. Run: database import");
+		process.exit(1);
+	}
+	const lock = JSON.parse(fs.readFileSync(lockPath, "utf8"));
+	let ok = true;
+	for (const e of lock.entries) {
+		if (!fs.existsSync(e.sourcePath)) {
+			console.error(`Missing source: ${e.sourcePath}`);
+			ok = false;
+			continue;
+		}
+		if (sha256(fs.readFileSync(e.sourcePath, "utf8")) !== e.sha256) {
+			console.error(`Drift detected for ${e.moduleName} (${e.sourcePath})`);
+			ok = false;
+		}
+	}
+	if (!ok) process.exit(2);
+	console.log("Imported schemas are in sync with lock.");
+}
+
+//#endregion
+export { runCheck };

package/dist/commands/generate.mjs

@@ -0,0 +1,9 @@
+import { execa } from "execa";
+
+//#region src/commands/generate.ts
+async function runGenerate(argv) {
+	await execa("prisma", ["generate"], { stdio: "inherit" });
+}
+
+//#endregion
+export { runGenerate };

package/dist/commands/import.mjs

@@ -0,0 +1,95 @@
+import { __require } from "../_virtual/rolldown_runtime.mjs";
+import fs from "node:fs";
+import path from "node:path";
+import crypto from "node:crypto";
+import { pathToFileURL } from "node:url";
+
+//#region src/commands/import.ts
+function sha256(content) {
+	return crypto.createHash("sha256").update(content).digest("hex");
+}
+function stripDatasourceAndGenerators(schema) {
+	return schema.replace(/datasource\s+\w+\s*\{[\s\S]*?\}/g, "").replace(/generator\s+\w+\s*\{[\s\S]*?\}/g, "").trim();
+}
+async function runImport(argv) {
+	const target = argv.target || process.cwd();
+	const modulesArg = argv.modules || "";
+	async function loadModulesFromMergerConfig() {
+		const candidates = [
+			path.join(target, "prisma-merger.config.ts"),
+			path.join(target, "prisma-merger.config.mts"),
+			path.join(target, "prisma-merger.config.js"),
+			path.join(target, "prisma-merger.config.mjs"),
+			path.join(target, "prisma-merger.config.cjs"),
+			path.join(target, "prisma-merger.config.json")
+		];
+		for (const file of candidates) {
+			if (!fs.existsSync(file)) continue;
+			if (file.endsWith(".json")) {
+				const json = JSON.parse(fs.readFileSync(file, "utf8"));
+				if (Array.isArray(json.modules) && json.modules.length > 0) return json.modules;
+			} else if (file.endsWith(".ts") || file.endsWith(".mts")) {
+				const match = fs.readFileSync(file, "utf8").match(/modules\s*:\s*\[([\s\S]*?)\]/m);
+				if (Array.isArray(match) && typeof match[1] === "string") {
+					const arr = match[1] || "";
+					const mods = [];
+					const re = /['\"]([^'\"]+)['\"]/g;
+					let m;
+					while (m = re.exec(arr)) {
+						const val = m[1] ?? "";
+						if (val) mods.push(val);
+					}
+					if (mods.length > 0) return mods;
+				}
+			} else {
+				const mod = await import(pathToFileURL(file).href);
+				const cfg = mod.default || mod;
+				if (Array.isArray(cfg.modules) && cfg.modules.length > 0) return cfg.modules;
+			}
+		}
+		return null;
+	}
+	let modules = modulesArg.split(",").map((s) => s.trim()).filter(Boolean);
+	if (modules.length === 0) {
+		const fromCfg = await loadModulesFromMergerConfig();
+		if (fromCfg) modules = fromCfg;
+	}
+	if (modules.length === 0) {
+		console.error("No modules specified. Provide --modules or define prisma-merger.config.ts { modules: [...] }");
+		process.exit(1);
+	}
+	const importedDir = path.join(target, "prisma", "schema", "imported");
+	fs.mkdirSync(importedDir, { recursive: true });
+	const entries = [];
+	for (const mod of modules) {
+		const pkgPath = __require.resolve(path.join(mod, "package.json"));
+		const modRoot = path.dirname(pkgPath);
+		const schemaPath = path.join(modRoot, "prisma", "schema.prisma");
+		if (!fs.existsSync(schemaPath)) {
+			console.error(`Module ${mod} missing prisma/schema.prisma`);
+			process.exit(1);
+		}
+		const raw = fs.readFileSync(schemaPath, "utf8");
+		const stripped = stripDatasourceAndGenerators(raw);
+		const outDir = path.join(importedDir, path.basename(mod).replace(/^@/, "").replace(/\//g, "_"));
+		fs.mkdirSync(outDir, { recursive: true });
+		const outFile = path.join(outDir, "models.prisma");
+		fs.writeFileSync(outFile, stripped, "utf8");
+		const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf8"));
+		entries.push({
+			moduleName: mod,
+			version: pkg.version || "0.0.0",
+			sourcePath: schemaPath,
+			sha256: sha256(raw)
+		});
+	}
+	const lock = {
+		updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+		entries
+	};
+	fs.writeFileSync(path.join(importedDir, "imported.lock.json"), JSON.stringify(lock, null, 2));
+	console.log(`Imported ${entries.length} modules into ${importedDir}`);
+}
+
+//#endregion
+export { runImport };

package/dist/commands/migrate.mjs

@@ -0,0 +1,20 @@
+import { execa } from "execa";
+
+//#region src/commands/migrate.ts
+async function runMigrate(cmd, argv) {
+	if (cmd === "migrate:dev") {
+		await execa("prisma", ["migrate", "dev"], { stdio: "inherit" });
+		return;
+	}
+	if (cmd === "migrate:deploy") {
+		await execa("prisma", ["migrate", "deploy"], { stdio: "inherit" });
+		return;
+	}
+	if (cmd === "migrate:status") {
+		await execa("prisma", ["migrate", "status"], { stdio: "inherit" });
+		return;
+	}
+}
+
+//#endregion
+export { runMigrate };

package/dist/commands/schema-compose.mjs

@@ -0,0 +1,76 @@
+import { loadSchemaConfig } from "../lib/schema-config.mjs";
+import fs from "node:fs";
+import path from "node:path";
+
+//#region src/commands/schema-compose.ts
+/**
+* Compose multiple module schemas into a single Prisma schema.
+*
+* Usage:
+*   database schema:compose --config ./schema.config.ts
+*   database schema:compose --modules "@lssm/lib.identity-rbac,@lssm/module.audit-trail"
+*/
+async function runSchemaCompose(argv) {
+	console.log("🔗 Composing module schemas...\n");
+	const configPath = argv.config ?? "./schema.config.ts";
+	const config = await loadSchemaConfig(configPath);
+	if (!config) {
+		console.error(`❌ Could not load schema config from ${configPath}`);
+		process.exit(1);
+	}
+	let modules = config.modules;
+	if (argv.modules) {
+		const moduleIds = argv.modules.split(",").map((m) => m.trim());
+		modules = config.modules.filter((m) => moduleIds.includes(m.moduleId));
+	}
+	if (modules.length === 0) {
+		console.error("❌ No modules found to compose");
+		process.exit(1);
+	}
+	console.log(`📦 Composing ${modules.length} module(s):`);
+	modules.forEach((m) => {
+		console.log(`   - ${m.moduleId}`);
+		m.entities.forEach((e) => {
+			console.log(`     • ${e.name} (${Object.keys(e.fields).length} fields)`);
+		});
+	});
+	console.log("");
+	const allEnums = /* @__PURE__ */ new Set();
+	modules.forEach((m) => {
+		m.enums?.forEach((e) => allEnums.add(e.name));
+		m.entities.forEach((entity) => {
+			entity.enums?.forEach((e) => allEnums.add(e.name));
+		});
+	});
+	if (allEnums.size > 0) {
+		console.log(`📋 Enums discovered: ${Array.from(allEnums).join(", ")}`);
+		console.log("");
+	}
+	const { composeModuleSchemas } = await import("@lssm/lib.schema");
+	const prismaSchema = composeModuleSchemas(modules, {
+		provider: config.provider ?? "postgresql",
+		clientOutput: config.clientOutput,
+		includePothos: config.includePothos ?? true,
+		pothosOutput: config.pothosOutput
+	});
+	const outputPath = argv.output ?? config.outputPath ?? "./prisma/schema/composed.prisma";
+	const outputDir = path.dirname(outputPath);
+	if (!fs.existsSync(outputDir)) fs.mkdirSync(outputDir, { recursive: true });
+	fs.writeFileSync(outputPath, prismaSchema, "utf-8");
+	const entityCount = modules.reduce((acc, m) => acc + m.entities.length, 0);
+	const fieldCount = modules.reduce((acc, m) => acc + m.entities.reduce((eAcc, e) => eAcc + Object.keys(e.fields).length, 0), 0);
+	console.log("✅ Schema composition complete!");
+	console.log("");
+	console.log(`   📄 Output: ${outputPath}`);
+	console.log(`   📦 Modules: ${modules.length}`);
+	console.log(`   🏗️  Entities: ${entityCount}`);
+	console.log(`   📝 Fields: ${fieldCount}`);
+	console.log(`   📋 Enums: ${allEnums.size}`);
+	console.log("");
+	console.log("Next steps:");
+	console.log("  1. Run: database generate");
+	console.log("  2. Run: database migrate:dev --name <migration-name>");
+}
+
+//#endregion
+export { runSchemaCompose };

package/dist/commands/schema-generate.mjs

@@ -0,0 +1,51 @@
+import { loadSchemaConfig } from "../lib/schema-config.mjs";
+import fs from "node:fs";
+import path from "node:path";
+
+//#region src/commands/schema-generate.ts
+/**
+* Generate Prisma schema from ContractSpec entity definitions.
+*
+* Usage:
+*   database schema:generate --config ./schema.config.ts --output ./prisma/schema
+*   database schema:generate --module @lssm/lib.identity-rbac
+*/
+async function runSchemaGenerate(argv) {
+	console.log("📝 Generating Prisma schema from entity specs...\n");
+	const configPath = argv.config ?? "./schema.config.ts";
+	const config = await loadSchemaConfig(configPath);
+	if (!config) {
+		console.error(`❌ Could not load schema config from ${configPath}`);
+		process.exit(1);
+	}
+	const modules = argv.module ? config.modules.filter((m) => m.moduleId === argv.module) : config.modules;
+	if (modules.length === 0) {
+		console.error("❌ No modules found to generate");
+		process.exit(1);
+	}
+	console.log(`📦 Processing ${modules.length} module(s):`);
+	modules.forEach((m) => {
+		console.log(`   - ${m.moduleId} (${m.entities.length} entities)`);
+	});
+	console.log("");
+	const { composeModuleSchemas } = await import("@lssm/lib.schema");
+	const prismaSchema = composeModuleSchemas(modules, {
+		provider: config.provider ?? "postgresql",
+		clientOutput: config.clientOutput,
+		includePothos: config.includePothos ?? true,
+		pothosOutput: config.pothosOutput
+	});
+	const outputPath = argv.output ?? config.outputPath ?? "./prisma/schema/generated.prisma";
+	const outputDir = path.dirname(outputPath);
+	if (!fs.existsSync(outputDir)) fs.mkdirSync(outputDir, { recursive: true });
+	fs.writeFileSync(outputPath, prismaSchema, "utf-8");
+	console.log(`✅ Generated Prisma schema: ${outputPath}`);
+	console.log("");
+	console.log("Next steps:");
+	console.log("  1. Review the generated schema");
+	console.log("  2. Run: database generate");
+	console.log("  3. Run: database migrate:dev");
+}
+
+//#endregion
+export { runSchemaGenerate };

package/dist/commands/seed.mjs

@@ -0,0 +1,14 @@
+import { execa } from "execa";
+
+//#region src/commands/seed.ts
+async function runSeed(argv) {
+	try {
+		await execa("prisma", ["db", "seed"], { stdio: "inherit" });
+	} catch (e) {
+		console.warn("No prisma seed configured or seed failed.");
+		throw e;
+	}
+}
+
+//#endregion
+export { runSeed };

package/dist/index.mjs

@@ -0,0 +1,4 @@
+import { defineSchemaConfig, loadSchemaConfig } from "./lib/schema-config.mjs";
+import { defineMergedPrismaConfig } from "./lib/config.mjs";
+
+export { defineMergedPrismaConfig, defineSchemaConfig, loadSchemaConfig };

package/dist/lib/config.mjs

@@ -0,0 +1,7 @@
+//#region src/lib/config.ts
+function defineMergedPrismaConfig(config) {
+	return config;
+}
+
+//#endregion
+export { defineMergedPrismaConfig };

package/dist/lib/schema-config.mjs

@@ -0,0 +1,22 @@
+//#region src/lib/schema-config.ts
+/**
+* Define a schema configuration.
+*/
+function defineSchemaConfig(config) {
+	return config;
+}
+/**
+* Load schema configuration from a file.
+*/
+async function loadSchemaConfig(configPath) {
+	try {
+		const module = await (configPath.startsWith("/") ? import(configPath) : import(`${process.cwd()}/${configPath}`));
+		return module.default ?? module.config ?? module;
+	} catch (error) {
+		console.error(`Failed to load schema config from ${configPath}:`, error);
+		return null;
+	}
+}
+
+//#endregion
+export { defineSchemaConfig, loadSchemaConfig };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lssm/app.cli-database",
-  "version": "1.41.0",
+  "version": "1.41.1",
   "type": "module",
   "bin": {
     "database": "dist/cli.js"
@@ -8,6 +8,7 @@
   "scripts": {
     "clean": "rm -rf dist",
     "publish:pkg": "bun publish --tolerate-republish --ignore-scripts --verbose",
+    "publish:pkg:canary": "bun publish:pkg --tag canary",
     "build": "tsdown",
     "dev": "bun run build --watch",
     "lint": "bun run lint:fix",
@@ -24,7 +25,7 @@
     "schema:compose": "database schema:compose"
   },
   "dependencies": {
-    "@lssm/lib.schema": "workspace:*",
+    "@lssm/lib.schema": "1.41.1",
     "@prisma/adapter-pg": "^7.1.0",
     "@prisma/client": "^7.1.0",
     "prisma": "^7.1.0",
@@ -32,7 +33,7 @@
     "execa": "^9.6.1"
   },
   "devDependencies": {
-    "@lssm/tool.tsdown": "workspace:*",
+    "@lssm/tool.tsdown": "1.41.1",
     "@types/minimist": "^1.2.5",
     "tsdown": "^0.17.4"
   },