@lssm/app.cli-database 0.0.0-canary-20251206160926

package/README.md

@@ -0,0 +1,52 @@
+# @lssm/app.cli-database
+
+Prisma wrapper and CLI tools for managing database schemas, migrations, and seeding within the LSSM monorepo.
+
+## Purpose
+
+To abstract and standardize Prisma usage across multiple services and verticals. It provides a unified CLI (`database`) to handle common database tasks like migrations (`dbs:migrate`), client generation (`dbs:generate`), and seeding (`dbs:seed`).
+
+## Installation
+
+```bash
+npm install @lssm/app.cli-database
+# or
+bun add @lssm/app.cli-database
+```
+
+## Key Concepts
+
+- **Unified Config**: Centralizes Prisma configuration.
+- **CLI Wrapper**: Wraps standard Prisma commands for consistent execution in the monorepo environment.
+- **Seeding**: Standardized seeding entry point.
+
+## Exports
+
+- `cli`: The command-line interface.
+- `prisma`: Re-exports `@prisma/client`.
+
+## Usage
+
+### CLI Commands
+
+Run via package scripts:
+
+```bash
+# Generate Prisma Client
+bun database generate
+
+# Run migrations
+bun database migrate:dev
+
+# Seed database
+bun database seed
+```
+
+### In Code
+
+```ts
+import { PrismaClient } from '@lssm/app.cli-database';
+
+const prisma = new PrismaClient();
+const users = await prisma.user.findMany();
+```

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.d.mts

@@ -0,0 +1 @@
+export { };

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("../libs/schema/dist/index.mjs");
+	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("../libs/schema/dist/index.mjs");
+	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.d.mts

@@ -0,0 +1,5 @@
+import { createPrismaClientFromEnv, getSingletonClient } from "./lib/client.mjs";
+import { ImportLock, ImportLockEntry } from "./lib/types.mjs";
+import { MergedPrismaConfig, defineMergedPrismaConfig } from "./lib/config.mjs";
+import { ModuleSchemaContribution, SchemaConfig, defineSchemaConfig, loadSchemaConfig } from "./lib/schema-config.mjs";
+export { ImportLock, ImportLockEntry, MergedPrismaConfig, ModuleSchemaContribution, SchemaConfig, createPrismaClientFromEnv, defineMergedPrismaConfig, defineSchemaConfig, getSingletonClient, loadSchemaConfig };

package/dist/index.mjs

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

package/dist/lib/client.d.mts

@@ -0,0 +1,7 @@
+import { PrismaClient } from "@prisma/client";
+
+//#region src/lib/client.d.ts
+declare function createPrismaClientFromEnv(envVar: string, fallback?: string): PrismaClient;
+declare function getSingletonClient(envVar?: string): PrismaClient;
+//#endregion
+export { createPrismaClientFromEnv, getSingletonClient };

package/dist/lib/client.mjs

@@ -0,0 +1,17 @@
+import { PrismaClient } from "@prisma/client";
+import { PrismaPg } from "@prisma/adapter-pg";
+
+//#region src/lib/client.ts
+const g = global;
+function createPrismaClientFromEnv(envVar, fallback) {
+	const raw = process.env[envVar] || (fallback ? process.env[fallback] : void 0);
+	if (!raw) throw new Error(`Missing database URL env: ${envVar}${fallback ? ` (or ${fallback})` : ""}`);
+	return new PrismaClient({ adapter: new PrismaPg({ connectionString: `${raw}`.replaceAll("sslmode=require", "sslmode=disable") }) });
+}
+function getSingletonClient(envVar = "DATABASE_URL") {
+	if (!g.__lssm_db) g.__lssm_db = createPrismaClientFromEnv(envVar);
+	return g.__lssm_db;
+}
+
+//#endregion
+export { createPrismaClientFromEnv, getSingletonClient };

package/dist/lib/config.d.mts

@@ -0,0 +1,7 @@
+//#region src/lib/config.d.ts
+interface MergedPrismaConfig {
+  modules: string[];
+}
+declare function defineMergedPrismaConfig(config: MergedPrismaConfig): MergedPrismaConfig;
+//#endregion
+export { MergedPrismaConfig, defineMergedPrismaConfig };

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.d.mts

@@ -0,0 +1,31 @@
+import { ModuleSchemaContribution } from "@lssm/lib.schema";
+
+//#region src/lib/schema-config.d.ts
+
+/**
+ * Configuration for schema generation and composition.
+ */
+interface SchemaConfig {
+  /** Module schema contributions to include */
+  modules: ModuleSchemaContribution[];
+  /** Prisma datasource provider (default: 'postgresql') */
+  provider?: 'postgresql' | 'mysql' | 'sqlite' | 'mongodb' | 'sqlserver';
+  /** Output path for generated Prisma schema */
+  outputPath?: string;
+  /** Prisma client output directory */
+  clientOutput?: string;
+  /** Include Pothos generator (default: true) */
+  includePothos?: boolean;
+  /** Pothos output path */
+  pothosOutput?: string;
+}
+/**
+ * Define a schema configuration.
+ */
+declare function defineSchemaConfig(config: SchemaConfig): SchemaConfig;
+/**
+ * Load schema configuration from a file.
+ */
+declare function loadSchemaConfig(configPath: string): Promise<SchemaConfig | null>;
+//#endregion
+export { type ModuleSchemaContribution, SchemaConfig, defineSchemaConfig, loadSchemaConfig };

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/dist/lib/types.d.mts

@@ -0,0 +1,13 @@
+//#region src/lib/types.d.ts
+interface ImportLockEntry {
+  moduleName: string;
+  version: string;
+  sourcePath: string;
+  sha256: string;
+}
+interface ImportLock {
+  updatedAt: string;
+  entries: ImportLockEntry[];
+}
+//#endregion
+export { ImportLock, ImportLockEntry };

package/dist/libs/schema/dist/EnumType.mjs

@@ -0,0 +1,4 @@
+import "zod";
+import "graphql";
+
+export {  };

package/dist/libs/schema/dist/FieldType.mjs

@@ -0,0 +1,4 @@
+import "zod";
+import "graphql";
+
+export {  };

package/dist/libs/schema/dist/ScalarTypeEnum.mjs

@@ -0,0 +1,5 @@
+import "./FieldType.mjs";
+import "zod";
+import "graphql";
+
+export {  };

package/dist/libs/schema/dist/SchemaModel.mjs

@@ -0,0 +1,5 @@
+import "./EnumType.mjs";
+import "./FieldType.mjs";
+import "zod";
+
+export {  };

package/dist/libs/schema/dist/entity/defineEntity.mjs

@@ -0,0 +1,3 @@
+import "zod";
+
+export {  };

package/dist/libs/schema/dist/entity/generator.mjs

@@ -0,0 +1,90 @@
+//#region ../../libs/schema/dist/entity/generator.js
+function e(e$1, r$1 = {}) {
+	let { provider: i$1 = `postgresql`, clientOutput: a$1 = `../../src/generated/prisma`, includePothos: o$1 = !0, pothosOutput: s$1 = `../../src/generated/pothos-types.ts` } = r$1, c$1 = [], l = /* @__PURE__ */ new Set();
+	e$1.forEach((e$2) => {
+		e$2.schema && l.add(e$2.schema);
+	});
+	let u = l.size > 0 ? Array.from(l) : [`public`];
+	c$1.push(`datasource db {`), c$1.push(`  provider = "${i$1}"`), l.size > 0 && c$1.push(`  schemas  = [${u.map((e$2) => `"${e$2}"`).join(`, `)}]`), c$1.push(`}`), c$1.push(``), c$1.push(`generator client {`), c$1.push(`  provider = "prisma-client"`), c$1.push(`  output   = "${a$1}"`), c$1.push(``), c$1.push(`  engineType             = "client"`), c$1.push(`  runtime                = "bun"`), c$1.push(`  moduleFormat           = "esm"`), c$1.push(`  generatedFileExtension = "ts"`), c$1.push(`  importFileExtension    = "ts"`), c$1.push(`}`), c$1.push(``), o$1 && (c$1.push(`generator pothos {`), c$1.push(`  provider          = "prisma-pothos-types"`), c$1.push(`  clientOutput      = "./prisma"`), c$1.push(`  output            = "${s$1}"`), c$1.push(`  generateDatamodel = true`), c$1.push(`  documentation     = false`), c$1.push(`}`), c$1.push(``));
+	let d = /* @__PURE__ */ new Map();
+	return e$1.forEach((e$2) => {
+		e$2.enums?.forEach((e$3) => {
+			d.has(e$3.name) || d.set(e$3.name, e$3);
+		}), Object.values(e$2.fields).forEach((t$1) => {
+			t$1.kind === `enum` && t$1.values && !d.has(t$1.enumName) && d.set(t$1.enumName, {
+				name: t$1.enumName,
+				values: t$1.values,
+				schema: e$2.schema
+			});
+		});
+	}), d.forEach((e$2) => {
+		c$1.push(...t(e$2)), c$1.push(``);
+	}), e$1.forEach((e$2) => {
+		c$1.push(...n(e$2)), c$1.push(``);
+	}), c$1.join(`
+`);
+}
+function t(e$1) {
+	let t$1 = [];
+	return e$1.description && t$1.push(`/// ${e$1.description}`), t$1.push(`enum ${e$1.name} {`), e$1.values.forEach((e$2) => {
+		t$1.push(`  ${e$2}`);
+	}), t$1.push(``), e$1.schema && t$1.push(`  @@schema("${e$1.schema}")`), t$1.push(`}`), t$1;
+}
+function n(e$1) {
+	let t$1 = [];
+	return e$1.description && t$1.push(`/// ${e$1.description}`), t$1.push(`model ${e$1.name} {`), Object.entries(e$1.fields).forEach(([e$2, n$1]) => {
+		let i$1 = r(e$2, n$1);
+		n$1.description && t$1.push(`  /// ${n$1.description}`), t$1.push(`  ${i$1}`);
+	}), e$1.indexes && e$1.indexes.length > 0 && (t$1.push(``), e$1.indexes.forEach((e$2) => {
+		t$1.push(`  ${s(e$2)}`);
+	})), e$1.map && t$1.push(`  @@map("${e$1.map}")`), e$1.schema && t$1.push(`  @@schema("${e$1.schema}")`), t$1.push(`}`), t$1;
+}
+function r(e$1, t$1) {
+	if (t$1.kind === `scalar`) return i(e$1, t$1);
+	if (t$1.kind === `enum`) return a(e$1, t$1);
+	if (t$1.kind === `relation`) return o(e$1, t$1);
+	throw Error(`Unknown field kind: ${t$1.kind}`);
+}
+function i(e$1, t$1) {
+	let n$1 = [e$1], r$1 = t$1.type;
+	t$1.isArray && (r$1 += `[]`), t$1.isOptional && (r$1 += `?`), n$1.push(r$1);
+	let i$1 = [];
+	return t$1.isId && i$1.push(`@id`), t$1.default !== void 0 && (typeof t$1.default == `string` && t$1.default.includes(`(`) || typeof t$1.default == `boolean` || typeof t$1.default == `number` ? i$1.push(`@default(${t$1.default})`) : i$1.push(`@default("${t$1.default}")`)), t$1.updatedAt && i$1.push(`@updatedAt`), t$1.isUnique && i$1.push(`@unique`), t$1.map && i$1.push(`@map("${t$1.map}")`), t$1.dbType && i$1.push(`@db.${t$1.dbType}`), i$1.length > 0 && n$1.push(i$1.join(` `)), n$1.join(` `);
+}
+function a(e$1, t$1) {
+	let n$1 = [e$1], r$1 = t$1.enumName;
+	t$1.isArray && (r$1 += `[]`), t$1.isOptional && (r$1 += `?`), n$1.push(r$1);
+	let i$1 = [];
+	return t$1.default !== void 0 && i$1.push(`@default(${t$1.default})`), t$1.isUnique && i$1.push(`@unique`), t$1.map && i$1.push(`@map("${t$1.map}")`), i$1.length > 0 && n$1.push(i$1.join(` `)), n$1.join(` `);
+}
+function o(e$1, t$1) {
+	let n$1 = [e$1], r$1 = t$1.target;
+	t$1.type === `hasMany` && (r$1 += `[]`), t$1.type === `hasOne` && (r$1 += `?`), n$1.push(r$1);
+	let i$1 = [];
+	return t$1.name && i$1.push(`name: "${t$1.name}"`), t$1.fields && t$1.fields.length > 0 && i$1.push(`fields: [${t$1.fields.join(`, `)}]`), t$1.references && t$1.references.length > 0 && i$1.push(`references: [${t$1.references.join(`, `)}]`), t$1.onDelete && i$1.push(`onDelete: ${t$1.onDelete}`), t$1.onUpdate && i$1.push(`onUpdate: ${t$1.onUpdate}`), i$1.length > 0 && n$1.push(`@relation(${i$1.join(`, `)})`), n$1.join(` `);
+}
+function s(e$1) {
+	let t$1 = e$1.fields.join(`, `), n$1 = [];
+	e$1.unique ? n$1.push(`@@unique([${t$1}]`) : n$1.push(`@@index([${t$1}]`);
+	let r$1 = [];
+	return e$1.name && r$1.push(`name: "${e$1.name}"`), e$1.type && r$1.push(`type: ${e$1.type}`), r$1.length > 0 && (n$1[0] += `, ${r$1.join(`, `)}`), n$1[0] += `)`, n$1.join(``);
+}
+function c(t$1, n$1 = {}) {
+	let r$1 = [], i$1 = /* @__PURE__ */ new Map();
+	return t$1.forEach((e$1) => {
+		e$1.entities.forEach((t$2) => {
+			r$1.push({
+				...t$2,
+				module: e$1.moduleId
+			});
+		}), e$1.enums?.forEach((e$2) => {
+			i$1.has(e$2.name) || i$1.set(e$2.name, e$2);
+		});
+	}), r$1.length > 0 && i$1.size > 0 && (r$1[0] = {
+		...r$1[0],
+		enums: [...r$1[0].enums ?? [], ...i$1.values()]
+	}), e(r$1, n$1);
+}
+
+//#endregion
+export { c, e };

package/dist/libs/schema/dist/entity/index.mjs

@@ -0,0 +1,5 @@
+import "./defineEntity.mjs";
+import { c, e } from "./generator.mjs";
+import "./types.mjs";
+
+export {  };

package/dist/libs/schema/dist/entity/types.mjs

@@ -0,0 +1,3 @@
+import "zod";
+
+export {  };

package/dist/libs/schema/dist/index.mjs

@@ -0,0 +1,9 @@
+import "./EnumType.mjs";
+import "./FieldType.mjs";
+import "./ScalarTypeEnum.mjs";
+import "./SchemaModel.mjs";
+import "./entity/defineEntity.mjs";
+import { c, e } from "./entity/generator.mjs";
+import "./entity/index.mjs";
+
+export { c as composeModuleSchemas };

package/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "@lssm/app.cli-database",
+  "version": "0.0.0-canary-20251206160926",
+  "type": "module",
+  "bin": {
+    "database": "dist/cli.js"
+  },
+  "scripts": {
+    "clean": "rm -rf dist",
+    "publish:pkg": "bun publish --tolerate-republish --ignore-scripts --verbose",
+    "build": "tsdown",
+    "dev": "bun run build --watch",
+    "lint": "bun run lint:fix",
+    "lint:fix": "eslint src --fix",
+    "lint:check": "eslint src",
+    "prisma:import": "bun database import",
+    "prisma:check": "bun database check",
+    "dbs:generate": "bun database generate",
+    "dbs:migrate": "bun database migrate:dev",
+    "dbs:deploy": "bun database migrate:deploy",
+    "dbs:status": "bun database migrate:status",
+    "dbs:seed": "bun database seed",
+    "schema:generate": "bun database schema:generate",
+    "schema:compose": "bun database schema:compose"
+  },
+  "dependencies": {
+    "@lssm/lib.schema": "workspace:*",
+    "@prisma/adapter-pg": "^7.1.0",
+    "@prisma/client": "^7.1.0",
+    "prisma": "^7.1.0",
+    "minimist": "^1.2.8",
+    "execa": "^9.6.1"
+  },
+  "devDependencies": {
+    "@lssm/tool.tsdown": "workspace:*",
+    "@types/minimist": "^1.2.5",
+    "tsdown": "^0.17.0"
+  },
+  "main": "./dist/index.mjs",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.mts",
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "exports": {
+    ".": "./dist/index.mjs",
+    "./cli": "./dist/cli.mjs",
+    "./*": "./*"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}