pecunia-cli 0.2.6 → 0.2.8

package/dist/api.mjs

@@ -1,3 +1,3 @@
-import { a as generateKyselySchema, n as generateSchema, o as generateDrizzleSchema, r as generatePrismaSchema, t as adapters } from "./generators-BVZYl7Wb.mjs";
+import { a as generateKyselySchema, n as generateSchema, o as generateDrizzleSchema, r as generatePrismaSchema, t as adapters } from "./generators-BXA4y5O8.mjs";
 
 export { adapters, generateDrizzleSchema, generateKyselySchema, generatePrismaSchema, generateSchema };

package/dist/{generators-BVZYl7Wb.mjs → generators-BXA4y5O8.mjs}

@@ -325,29 +325,115 @@ async function getDrizzleMigrationsDir(projectRoot) {
 	return drizzleDir;
 }
 /**
-* Find existing invariants migration file if it exists.
+* Get the path to the Drizzle meta directory.
+*/
+function getDrizzleMetaDir(projectRoot) {
+	return path.resolve(projectRoot, "drizzle", "meta");
+}
+/**
+* Get the path to the Drizzle journal file.
+*/
+function getJournalPath(projectRoot) {
+	return path.resolve(projectRoot, "drizzle", "meta", "_journal.json");
+}
+/**
+* Read the Drizzle journal file, or return null if it doesn't exist.
+*/
+async function readJournal(projectRoot) {
+	const journalPath = getJournalPath(projectRoot);
+	if (!existsSync(journalPath)) return null;
+	const content = await fs$1.readFile(journalPath, "utf-8");
+	return JSON.parse(content);
+}
+/**
+* Write the Drizzle journal file with stable JSON formatting (2-space indent).
+*/
+async function writeJournal(projectRoot, journal) {
+	const journalPath = getJournalPath(projectRoot);
+	await fs$1.writeFile(journalPath, JSON.stringify(journal, null, 2) + "\n", "utf-8");
+}
+/**
+* Ensure the Drizzle journal exists. If it doesn't exist, create it with a baseline init migration.
 * 
-* @param migrationsDir - Path to the drizzle migrations directory
-* @returns The migration number if found, or null
+* @param projectRoot - The project root directory
+* @returns true if journal was created, false if it already existed
+*/
+async function ensureDrizzleJournal(projectRoot) {
+	if (existsSync(getJournalPath(projectRoot))) return false;
+	const metaDir = getDrizzleMetaDir(projectRoot);
+	await fs$1.mkdir(metaDir, { recursive: true });
+	await writeJournal(projectRoot, {
+		version: "7",
+		dialect: "postgresql",
+		entries: []
+	});
+	const migrationsDir = await getDrizzleMigrationsDir(projectRoot);
+	const initMigrationPath = path.join(migrationsDir, "0000_pecunia_init.sql");
+	await fs$1.writeFile(initMigrationPath, "-- Initial no-op migration created by pecunia-cli\n", "utf-8");
+	await upsertJournalEntry(projectRoot, "0000_pecunia_init");
+	return true;
+}
+/**
+* Upsert a journal entry. If an entry with the same tag exists, do nothing.
+* Otherwise, append a new entry with the next available idx.
+* 
+* @param projectRoot - The project root directory
+* @param tag - The migration tag (filename base without .sql)
 */
-async function findExistingInvariantsMigration(migrationsDir) {
-	if (!existsSync(migrationsDir)) return null;
-	const invariantsFile = (await fs$1.readdir(migrationsDir)).find((file) => file.endsWith("_pecunia_invariants.sql") && /^\d{4}_/.test(file));
-	if (!invariantsFile) return null;
-	const match = invariantsFile.match(/^(\d{4})_/);
-	return match ? match[1] : null;
+async function upsertJournalEntry(projectRoot, tag) {
+	const journal = await readJournal(projectRoot);
+	if (!journal) throw new Error("Journal does not exist. Call ensureDrizzleJournal() first.");
+	if (journal.entries.find((entry) => entry.tag === tag)) return;
+	const nextIdx = (journal.entries.length > 0 ? Math.max(...journal.entries.map((e) => e.idx)) : -1) + 1;
+	const hasBreakpoints = journal.entries.some((e) => e.breakpoints === true);
+	const newEntry = {
+		tag,
+		idx: nextIdx,
+		version: journal.version,
+		when: Date.now(),
+		...hasBreakpoints && { breakpoints: true }
+	};
+	journal.entries.push(newEntry);
+	await writeJournal(projectRoot, journal);
 }
 /**
-* Determine the next migration number by scanning existing migration files.
-* Migration files are expected to follow the pattern: `NNNN_description.sql`
-* where NNNN is a 4-digit number.
+* Find existing invariants migration tag in the journal.
 * 
-* @param migrationsDir - Path to the drizzle migrations directory
+* @param projectRoot - The project root directory
+* @returns The tag if found, or null
+*/
+async function findExistingInvariantsTag(projectRoot) {
+	const journal = await readJournal(projectRoot);
+	if (!journal) return null;
+	const invariantsEntry = journal.entries.find((entry) => entry.tag.endsWith("_pecunia_invariants"));
+	return invariantsEntry ? invariantsEntry.tag : null;
+}
+/**
+* Determine the next migration number by checking journal entries and existing files.
+* Prefers checking journal entries first, then falls back to scanning files.
+* 
+* @param projectRoot - The project root directory
 * @returns The next migration number (4-digit string, e.g., "0001")
 */
-async function getNextMigrationNumber(migrationsDir) {
-	const existingInvariantsNumber = await findExistingInvariantsMigration(migrationsDir);
-	if (existingInvariantsNumber) return existingInvariantsNumber;
+async function nextMigrationNumber(projectRoot) {
+	const existingInvariantsTag = await findExistingInvariantsTag(projectRoot);
+	if (existingInvariantsTag) {
+		const match = existingInvariantsTag.match(/^(\d{4})_/);
+		if (match) return match[1];
+	}
+	const journal = await readJournal(projectRoot);
+	if (journal && journal.entries.length > 0) {
+		const numbers$1 = journal.entries.map((entry) => {
+			const match = entry.tag.match(/^(\d{4})_/);
+			return match ? parseInt(match[1], 10) : 0;
+		}).filter((n) => n >= 0);
+		if (numbers$1.length > 0) {
+			const nextNumber$1 = Math.max(...numbers$1) + 1;
+			if (nextNumber$1 >= 9999) return "9999";
+			return String(nextNumber$1).padStart(4, "0");
+		}
+	}
+	const migrationsDir = await getDrizzleMigrationsDir(projectRoot);
 	if (!existsSync(migrationsDir)) return "0001";
 	const migrationFiles = (await fs$1.readdir(migrationsDir)).filter((file) => file.endsWith(".sql") && /^\d{4}_/.test(file));
 	if (migrationFiles.length === 0) return "0001";
@@ -373,31 +459,57 @@ function getInvariantsMigrationPath(migrationsDir, migrationNumber) {
 	return path.join(migrationsDir, `${migrationNumber}_pecunia_invariants.sql`);
 }
 /**
+* Upsert a Drizzle migration file and register it in the journal.
+* 
+* @param projectRoot - The project root directory
+* @param tag - The migration tag (filename base without .sql)
+* @param sql - The SQL content to write
+*/
+async function upsertDrizzleMigration(projectRoot, tag, sql) {
+	const migrationsDir = await getDrizzleMigrationsDir(projectRoot);
+	const migrationPath = path.join(migrationsDir, `${tag}.sql`);
+	if (existsSync(migrationPath)) {
+		if (await fs$1.readFile(migrationPath, "utf-8") === sql) {
+			await upsertJournalEntry(projectRoot, tag);
+			return;
+		}
+	}
+	await fs$1.writeFile(migrationPath, sql, "utf-8");
+	await upsertJournalEntry(projectRoot, tag);
+}
+/**
 * Write the invariants SQL file to the drizzle migrations directory.
-* Handles idempotency by checking if the file exists and has the same content.
+* Ensures journal exists, determines migration number, and registers in journal.
 * 
 * @param projectRoot - The project root directory
 * @param sqlContent - The SQL content to write
-* @returns The path to the written file, or null if no changes were needed
+* @returns The path to the written file and status flags
 */
 async function writeInvariantsMigration(projectRoot, sqlContent) {
-	const migrationsDir = await getDrizzleMigrationsDir(projectRoot);
-	const migrationPath = getInvariantsMigrationPath(migrationsDir, await getNextMigrationNumber(migrationsDir));
+	const journalCreated = await ensureDrizzleJournal(projectRoot);
+	const migrationNumber = await nextMigrationNumber(projectRoot);
+	const tag = `${migrationNumber}_pecunia_invariants`;
+	const migrationPath = getInvariantsMigrationPath(await getDrizzleMigrationsDir(projectRoot), migrationNumber);
 	let created = false;
 	let updated = false;
 	if (existsSync(migrationPath)) {
-		if (await fs$1.readFile(migrationPath, "utf-8") === sqlContent) return {
-			path: migrationPath,
-			created: false,
-			updated: false
-		};
+		if (await fs$1.readFile(migrationPath, "utf-8") === sqlContent) {
+			await upsertJournalEntry(projectRoot, tag);
+			return {
+				path: migrationPath,
+				created: false,
+				updated: false,
+				journalCreated
+			};
+		}
 		updated = true;
 	} else created = true;
-	await fs$1.writeFile(migrationPath, sqlContent, "utf-8");
+	await upsertDrizzleMigration(projectRoot, tag, sqlContent);
 	return {
 		path: migrationPath,
 		created,
-		updated
+		updated,
+		journalCreated
 	};
 }
 
@@ -633,61 +745,97 @@ const generateDrizzleSchema = async ({ options, file, adapter }) => {
 		const modelName = getModelName(tableKey);
 		const oneRelations = [];
 		const manyRelations = [];
-		if (table.relations) for (const [relationName, relationDef] of Object.entries(table.relations)) {
-			const referencedModelName = getModelName(relationDef.model);
-			const foreignKeyField = table.fields[relationDef.foreignKey];
-			if (relationDef.kind === "one") {
-				if (foreignKeyField?.references) {
-					const fieldRef = `${modelName}.${getFieldName({
-						model: tableKey,
-						field: relationDef.foreignKey
-					})}`;
-					const referenceRef = `${referencedModelName}.${getFieldName({
-						model: relationDef.model,
-						field: foreignKeyField.references.field || "id"
-					})}`;
-					oneRelations.push({
-						key: relationName,
-						model: referencedModelName,
-						type: "one",
-						reference: {
-							field: fieldRef,
-							references: referenceRef,
-							fieldName: relationDef.foreignKey
-						}
-					});
-				}
-			} else if (relationDef.kind === "many") {
-				const referencedTable = tables[relationDef.model];
-				if (referencedTable) {
-					const fkField = Object.entries(referencedTable.fields).find(([_, field]) => field.references && (field.references.model === tableKey || field.references.model === getModelName(tableKey)));
-					if (fkField) {
-						const [fkFieldName] = fkField;
-						const fieldRef = `${referencedModelName}.${getFieldName({
-							model: relationDef.model,
-							field: fkFieldName
-						})}`;
-						const referenceRef = `${modelName}.${getFieldName({
+		if (table.relations) {
+			for (const [relationName, relationDef] of Object.entries(table.relations)) {
+				const referencedModelName = getModelName(relationDef.model);
+				const foreignKeyField = table.fields[relationDef.foreignKey];
+				const isSelfReferential = relationDef.model === tableKey || referencedModelName === modelName;
+				const generateRelationName = (fkName) => {
+					let cleaned = convertToSnakeCase(fkName, adapter.options?.camelCase).replace(/_by_id$/, "").replace(/_id$/, "");
+					const participleToNoun = {
+						"reversed": "reversal",
+						"created": "creation",
+						"updated": "update"
+					};
+					if (participleToNoun[cleaned]) cleaned = participleToNoun[cleaned];
+					return `${convertToSnakeCase(modelName, adapter.options?.camelCase)}_${cleaned}`;
+				};
+				if (relationDef.kind === "one") {
+					if (foreignKeyField?.references) {
+						const fieldRef = `${modelName}.${getFieldName({
 							model: tableKey,
-							field: "id"
+							field: relationDef.foreignKey
 						})}`;
-						manyRelations.push({
+						const referenceRef = `${referencedModelName}.${getFieldName({
+							model: relationDef.model,
+							field: foreignKeyField.references.field || "id"
+						})}`;
+						oneRelations.push({
 							key: relationName,
 							model: referencedModelName,
-							type: "many",
+							type: "one",
 							reference: {
 								field: fieldRef,
 								references: referenceRef,
-								fieldName: fkFieldName
+								fieldName: relationDef.foreignKey
+							},
+							relationName: isSelfReferential ? generateRelationName(relationDef.foreignKey) : void 0
+						});
+					}
+				} else if (relationDef.kind === "many") {
+					const referencedTable = tables[relationDef.model];
+					if (referencedTable) {
+						const fkField = Object.entries(referencedTable.fields).find(([_, field]) => field.references && (field.references.model === tableKey || field.references.model === getModelName(tableKey)));
+						if (fkField) {
+							const [fkFieldName] = fkField;
+							const fieldRef = `${referencedModelName}.${getFieldName({
+								model: relationDef.model,
+								field: fkFieldName
+							})}`;
+							const referenceRef = `${modelName}.${getFieldName({
+								model: tableKey,
+								field: "id"
+							})}`;
+							let relationNameForMany;
+							if (isSelfReferential) {
+								const matchingOne = oneRelations.find((rel) => rel.reference?.fieldName === fkFieldName && rel.model === referencedModelName);
+								if (matchingOne?.relationName) relationNameForMany = matchingOne.relationName;
+								else {
+									let cleaned = convertToSnakeCase(fkFieldName, adapter.options?.camelCase).replace(/_by_id$/, "").replace(/_id$/, "");
+									const participleToNoun = {
+										"reversed": "reversal",
+										"created": "creation",
+										"updated": "update"
+									};
+									if (participleToNoun[cleaned]) cleaned = participleToNoun[cleaned];
+									relationNameForMany = `${convertToSnakeCase(modelName, adapter.options?.camelCase)}_${cleaned}`;
+								}
 							}
+							manyRelations.push({
+								key: relationName,
+								model: referencedModelName,
+								type: "many",
+								reference: {
+									field: fieldRef,
+									references: referenceRef,
+									fieldName: fkFieldName
+								},
+								relationName: relationNameForMany
+							});
+						} else manyRelations.push({
+							key: relationName,
+							model: referencedModelName,
+							type: "many"
 						});
-					} else manyRelations.push({
-						key: relationName,
-						model: referencedModelName,
-						type: "many"
-					});
+					}
 				}
 			}
+			for (const oneRel of oneRelations) {
+				if (!oneRel.relationName || !oneRel.reference) continue;
+				const oneRelFieldName = oneRel.reference.fieldName;
+				const matchingMany = manyRelations.find((manyRel) => manyRel.model === oneRel.model && manyRel.reference?.fieldName === oneRelFieldName);
+				if (matchingMany) matchingMany.relationName = oneRel.relationName;
+			}
 		}
 		const relationsByModel = /* @__PURE__ */ new Map();
 		for (const relation of oneRelations) {
@@ -703,10 +851,12 @@ const generateDrizzleSchema = async ({ options, file, adapter }) => {
 		for (const relation of duplicateRelations) {
 			if (!relation.reference) continue;
 			const fieldName = relation.reference.fieldName;
-			const tableRelation = `export const ${`${modelName}${fieldName.charAt(0).toUpperCase() + fieldName.slice(1)}Relations`} = relations(${modelName}, ({ one }) => ({
+			const relationExportName = `${modelName}${fieldName.charAt(0).toUpperCase() + fieldName.slice(1)}Relations`;
+			const relationNameParam = relation.relationName ? `,\n					relationName: "${relation.relationName}"` : "";
+			const tableRelation = `export const ${relationExportName} = relations(${modelName}, ({ one }) => ({
 				${relation.key}: one(${relation.model}, {
 					fields: [${relation.reference.field}],
-					references: [${relation.reference.references}],
+					references: [${relation.reference.references}]${relationNameParam}
 				})
 			}))`;
 			relationsString += `\n${tableRelation}\n`;
@@ -715,24 +865,36 @@ const generateDrizzleSchema = async ({ options, file, adapter }) => {
 		const hasMany = manyRelations.length > 0;
 		if (hasOne && hasMany) {
 			const tableRelation = `export const ${modelName}Relations = relations(${modelName}, ({ one, many }) => ({
-				${singleRelations.map((relation) => relation.reference ? ` ${relation.key}: one(${relation.model}, {
+				${singleRelations.map((relation) => {
+				if (!relation.reference) return "";
+				const relationNameParam = relation.relationName ? `,\n					relationName: "${relation.relationName}"` : "";
+				return ` ${relation.key}: one(${relation.model}, {
 					fields: [${relation.reference.field}],
-					references: [${relation.reference.references}],
-				})` : "").filter((x) => x !== "").join(",\n ")}${singleRelations.length > 0 && manyRelations.length > 0 ? "," : ""}
-				${manyRelations.map(({ key, model }) => ` ${key}: many(${model})`).join(",\n ")}
+					references: [${relation.reference.references}]${relationNameParam}
+				})`;
+			}).filter((x) => x !== "").join(",\n ")}${singleRelations.length > 0 && manyRelations.length > 0 ? "," : ""}
+				${manyRelations.map(({ key, model, relationName }) => {
+				return ` ${key}: many(${model}${relationName ? `, { relationName: "${relationName}" }` : ""})`;
+			}).join(",\n ")}
 			}))`;
 			relationsString += `\n${tableRelation}\n`;
 		} else if (hasOne) {
 			const tableRelation = `export const ${modelName}Relations = relations(${modelName}, ({ one }) => ({
-				${singleRelations.map((relation) => relation.reference ? ` ${relation.key}: one(${relation.model}, {
+				${singleRelations.map((relation) => {
+				if (!relation.reference) return "";
+				const relationNameParam = relation.relationName ? `,\n					relationName: "${relation.relationName}"` : "";
+				return ` ${relation.key}: one(${relation.model}, {
 					fields: [${relation.reference.field}],
-					references: [${relation.reference.references}],
-				})` : "").filter((x) => x !== "").join(",\n ")}
+					references: [${relation.reference.references}]${relationNameParam}
+				})`;
+			}).filter((x) => x !== "").join(",\n ")}
 			}))`;
 			relationsString += `\n${tableRelation}\n`;
 		} else if (hasMany) {
 			const tableRelation = `export const ${modelName}Relations = relations(${modelName}, ({ many }) => ({
-				${manyRelations.map(({ key, model }) => ` ${key}: many(${model})`).join(",\n ")}
+				${manyRelations.map(({ key, model, relationName }) => {
+				return ` ${key}: many(${model}${relationName ? `, { relationName: "${relationName}" }` : ""})`;
+			}).join(",\n ")}
 			}))`;
 			relationsString += `\n${tableRelation}\n`;
 		}
@@ -746,7 +908,8 @@ const generateDrizzleSchema = async ({ options, file, adapter }) => {
 			getModelName,
 			getFieldName
 		}), "public"));
-		if (result.created) console.log(`Generated invariants migration: ${path.relative(projectRoot, result.path)}\nNote: Created ./drizzle directory. Invariants SQL is placed in Drizzle migrations.`);
+		if (result.journalCreated) console.log(`Created Drizzle migration journal and invariants migration; now run \`npx drizzle-kit migrate\`.`);
+		else if (result.created) console.log(`Generated invariants migration: ${path.relative(projectRoot, result.path)}`);
 		else if (result.updated) console.log(`Updated invariants migration: ${path.relative(projectRoot, result.path)}`);
 		else console.log(`Invariants migration up to date: ${path.relative(projectRoot, result.path)}`);
 	}

package/dist/index.mjs

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { i as getPackageInfo, n as generateSchema } from "./generators-BVZYl7Wb.mjs";
+import { i as getPackageInfo, n as generateSchema } from "./generators-BXA4y5O8.mjs";
 import { Command } from "commander";
 import fs, { existsSync, readFileSync } from "node:fs";
 import fs$1 from "node:fs/promises";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pecunia-cli",
-  "version": "0.2.6",
+  "version": "0.2.8",
   "type": "module",
   "module": "dist/index.mjs",
   "main": "./dist/index.mjs",