pecunia-cli 0.2.7 → 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-Cb42XRwg.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-Cb42XRwg.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 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 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;
 }
 /**
-* 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.
+* 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 migrationsDir - Path to the drizzle migrations directory
+* @param projectRoot - The project root directory
+* @param tag - The migration tag (filename base without .sql)
+*/
+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);
+}
+/**
+* Find existing invariants migration tag in the journal.
+* 
+* @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
 	};
 }
 
@@ -796,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-Cb42XRwg.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.7",
+  "version": "0.2.8",
   "type": "module",
   "module": "dist/index.mjs",
   "main": "./dist/index.mjs",