pecunia-cli 0.1.9 → 0.2.0

package/dist/api.d.mts

@@ -20,6 +20,7 @@ declare const adapters: {
   prisma: SchemaGenerator;
   drizzle: SchemaGenerator;
   kysely: SchemaGenerator;
+  mongodb: SchemaGenerator;
 };
 declare const generateSchema: (opts: {
   adapter: DBAdapter$1;

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-D5zLfxo1.mjs";
+import { a as generateKyselySchema, n as generateSchema, o as generateDrizzleSchema, r as generatePrismaSchema, t as adapters } from "./generators-DjXYs9VN.mjs";
 
 export { adapters, generateDrizzleSchema, generateKyselySchema, generatePrismaSchema, generateSchema };

package/dist/{generators-D5zLfxo1.mjs → generators-DjXYs9VN.mjs}

@@ -1,18 +1,319 @@
 import fs, { existsSync } from "node:fs";
 import fs$1 from "node:fs/promises";
 import path from "node:path";
-import { getMigrations } from "pecunia-root";
-import { capitalizeFirstLetter, getPaymentTables, initGetFieldName, initGetModelName } from "pecunia-core";
+import { getMigrations, getPaymentTables } from "pecunia-root";
+import { capitalizeFirstLetter, getPaymentTables as getPaymentTables$1, initGetFieldName, initGetModelName } from "pecunia-core";
 import prettier from "prettier";
 import { produceSchema } from "@mrleebo/prisma-ast";
 
+//#region src/generators/invariants.ts
+/**
+* Normalize invariants from schema into IR format.
+* This parses invariant descriptions and extracts structured logic.
+*/
+function normalizeInvariants(schema, options) {
+	const invariants = [];
+	for (const [tableKey, table] of Object.entries(schema)) {
+		if (!table.invariants) continue;
+		const modelName = options.getModelName(tableKey);
+		const tableName = table.modelName;
+		for (const invariant of table.invariants) {
+			const logic = parseInvariantLogic(invariant.description, tableKey, table, schema, options);
+			invariants.push({
+				id: invariant.id,
+				description: invariant.description,
+				modelName,
+				tableName,
+				appliesTo: invariant.appliesTo,
+				enforcement: invariant.enforcement || {},
+				logic
+			});
+		}
+	}
+	return invariants;
+}
+/**
+* Parse invariant description into structured logic.
+* This is a heuristic parser that extracts common patterns.
+*/
+function parseInvariantLogic(description, tableKey, table, schema, options) {
+	const desc = description.toLowerCase();
+	if (desc.includes("determines") && desc.includes("presence")) {
+		const modeMatch = description.match(/(\w+)\.(\w+)\s+determines/);
+		const subMatch = description.match(/(\w+)\s+must be (present|null\/absent)/);
+		const enumMatches = description.matchAll(/(\w+)\s*=>\s*(\w+)\s+must be (present|null\/absent)/g);
+		if (modeMatch && subMatch) {
+			const [, modelName, fieldName] = modeMatch;
+			const [, conditionalField] = subMatch;
+			const field = Object.keys(table.fields).find((k) => k.toLowerCase() === fieldName.toLowerCase());
+			const conditional = Object.keys(table.fields).find((k) => k.toLowerCase() === conditionalField.toLowerCase());
+			if (field && conditional) {
+				const fieldAttr = table.fields[field];
+				let allowedValues = [];
+				if (typeof fieldAttr.type !== "string" && Array.isArray(fieldAttr.type) && fieldAttr.type.every((x) => typeof x === "string")) allowedValues = fieldAttr.type;
+				else {
+					const enumValues = /* @__PURE__ */ new Set();
+					for (const match of enumMatches) {
+						const val = match[1]?.trim();
+						if (val) enumValues.add(val);
+					}
+					if (enumValues.size > 0) allowedValues = Array.from(enumValues);
+					else allowedValues = ["PAYMENT", "SUBSCRIPTION"].filter((e) => desc.includes(e.toLowerCase()));
+				}
+				let whenPresent = false;
+				for (const match of enumMatches) {
+					const enumVal = match[1];
+					const requirement = match[3];
+					if (enumVal && requirement === "present") {
+						whenPresent = true;
+						break;
+					}
+				}
+				if (!whenPresent && desc.includes("subscription") && desc.includes("must be present")) whenPresent = true;
+				return {
+					type: "field_enum_constraint",
+					field,
+					fieldName: options.getFieldName({
+						model: tableKey,
+						field
+					}),
+					allowedValues: allowedValues.length > 0 ? allowedValues : ["PAYMENT", "SUBSCRIPTION"],
+					conditionalField: {
+						field: conditional,
+						fieldName: options.getFieldName({
+							model: tableKey,
+							field: conditional
+						}),
+						whenPresent
+					}
+				};
+			}
+		}
+	}
+	if (desc.includes("must belong to same") || desc.includes("must equal") && desc.includes("when")) {
+		const fieldMatch = description.match(/(\w+)\.(\w+)\s+must/);
+		const refMatch = description.match(/(\w+)\.(\w+)\s+must equal\s+(\w+)\.(\w+)/);
+		description.match(/(\w+)\.(\w+)\s+must equal/);
+		if (fieldMatch && refMatch) {
+			const [, modelName, fieldName] = fieldMatch;
+			const [, refTable, refField, ownerTable, ownerField] = refMatch;
+			const field = Object.keys(table.fields).find((k) => k.toLowerCase() === fieldName.toLowerCase());
+			if (field && table.fields[field]?.references) {
+				table.fields[field].references;
+				const refTableKey = Object.keys(schema).find((k) => schema[k]?.modelName === refTable || k === refTable);
+				const ownerTableKey = Object.keys(schema).find((k) => schema[k]?.modelName === ownerTable || k === ownerTable);
+				if (refTableKey && ownerTableKey) {
+					const ownershipField = Object.keys(table.fields).find((k) => k.toLowerCase() === ownerField.toLowerCase());
+					if (ownershipField) return {
+						type: "cross_table_ownership",
+						field,
+						fieldName: options.getFieldName({
+							model: tableKey,
+							field
+						}),
+						referencedTable: options.getModelName(refTableKey),
+						referencedField: options.getFieldName({
+							model: refTableKey,
+							field: refField
+						}),
+						ownershipField,
+						ownershipFieldName: options.getFieldName({
+							model: tableKey,
+							field: ownershipField
+						})
+					};
+				}
+			}
+		}
+	}
+	if (desc.includes("must match") && desc.includes("of its")) {
+		const fieldMatch = description.match(/(\w+)\.(\w+)\s+must match/);
+		const refMatch = description.match(/of its\s+(\w+)/);
+		const equalityMatch = description.match(/(\w+)\.(\w+)\s+must equal\s+(\w+)\.(\w+)/);
+		if (fieldMatch && refMatch && equalityMatch) {
+			const [, , equalityFieldName] = fieldMatch;
+			const [, refFieldName] = refMatch;
+			const [, refTable, refEqualityField, , sourceEqualityField] = equalityMatch;
+			const equalityField = Object.keys(table.fields).find((k) => k.toLowerCase() === equalityFieldName.toLowerCase());
+			const refField = Object.keys(table.fields).find((k) => k.toLowerCase() === refFieldName.toLowerCase());
+			if (equalityField && refField && table.fields[refField]?.references) {
+				const ref = table.fields[refField].references;
+				const refTableKey = Object.keys(schema).find((k) => schema[k]?.modelName === refTable || k === refTable);
+				if (refTableKey) {
+					const refEquality = Object.keys(schema[refTableKey].fields).find((k) => k.toLowerCase() === refEqualityField.toLowerCase());
+					if (refEquality) return {
+						type: "cross_table_equality",
+						field: refField,
+						fieldName: options.getFieldName({
+							model: tableKey,
+							field: refField
+						}),
+						referencedTable: options.getModelName(refTableKey),
+						referencedField: options.getFieldName({
+							model: refTableKey,
+							field: ref.field
+						}),
+						equalityField,
+						equalityFieldName: options.getFieldName({
+							model: tableKey,
+							field: equalityField
+						}),
+						referencedEqualityField: refEquality,
+						referencedEqualityFieldName: options.getFieldName({
+							model: refTableKey,
+							field: refEquality
+						})
+					};
+				}
+			}
+		}
+	}
+	return {
+		type: "raw",
+		description
+	};
+}
+
+//#endregion
+//#region src/generators/invariants-sql.ts
+/**
+* Generate SQL for enforcing invariants in Postgres (and compatible databases).
+* Returns SQL statements for CHECK constraints and triggers.
+*/
+function emitPostgresInvariantSql(invariants, schemaName = "public") {
+	const statements = [];
+	const checkInvariants = invariants.filter((inv) => inv.enforcement.postgres === "check" && inv.appliesTo.includes("postgres"));
+	const triggerInvariants = invariants.filter((inv) => inv.enforcement.postgres === "trigger" && inv.appliesTo.includes("postgres"));
+	for (const inv of checkInvariants) {
+		const sql = generateCheckConstraint(inv, schemaName);
+		if (sql) statements.push(sql);
+	}
+	for (const inv of triggerInvariants) {
+		const sql = generateTrigger(inv, schemaName);
+		if (sql) statements.push(...sql);
+	}
+	if (statements.length === 0) return "-- No invariant enforcement SQL generated\n";
+	return `-- Invariant enforcement SQL
+-- Generated from schema invariants
+-- DO NOT EDIT MANUALLY - This file is auto-generated
+
+${statements.join("\n\n")}
+`;
+}
+/**
+* Generate CHECK constraint SQL for an invariant.
+*/
+function generateCheckConstraint(inv, schemaName) {
+	const { logic, tableName, id } = inv;
+	switch (logic.type) {
+		case "field_enum_constraint": {
+			const { fieldName, allowedValues, conditionalField } = logic;
+			if (conditionalField) {
+				const constraintName$1 = `${tableName}_${id}_check`;
+				const enumCheck$1 = allowedValues.map((val) => `'${val}'`).join(", ");
+				const subscriptionValue = allowedValues.find((v) => v === "SUBSCRIPTION") || allowedValues.find((v) => v !== "PAYMENT") || allowedValues[0];
+				const paymentValue = allowedValues.find((v) => v === "PAYMENT") || allowedValues[0];
+				const conditionalCheck = `(
+  (${fieldName} = '${subscriptionValue}') = (${conditionalField.fieldName} IS NOT NULL) AND
+  (${fieldName} = '${paymentValue}') = (${conditionalField.fieldName} IS NULL)
+)`;
+				return `-- ${inv.description}
+ALTER TABLE ${schemaName}.${tableName}
+ADD CONSTRAINT ${constraintName$1}
+CHECK (
+  ${fieldName} IN (${enumCheck$1}) AND
+  ${conditionalCheck}
+);`;
+			}
+			const constraintName = `${tableName}_${id}_check`;
+			const enumCheck = allowedValues.map((val) => `'${val}'`).join(", ");
+			return `-- ${inv.description}
+ALTER TABLE ${schemaName}.${tableName}
+ADD CONSTRAINT ${constraintName}
+CHECK (${fieldName} IN (${enumCheck}));`;
+		}
+		default: return null;
+	}
+}
+/**
+* Generate trigger SQL for an invariant.
+* Returns array of SQL statements (function + trigger).
+*/
+function generateTrigger(inv, schemaName) {
+	const { logic, tableName, id } = inv;
+	switch (logic.type) {
+		case "cross_table_ownership": {
+			const { fieldName, referencedTable, referencedField, ownershipFieldName } = logic;
+			const functionName = `${tableName}_${id}_fn`;
+			const triggerName = `${tableName}_${id}_trigger`;
+			return [`-- Function to enforce: ${inv.description}
+CREATE OR REPLACE FUNCTION ${schemaName}.${functionName}()
+RETURNS TRIGGER AS $$
+BEGIN
+  IF NEW.${fieldName} IS NOT NULL THEN
+    IF NOT EXISTS (
+      SELECT 1
+      FROM ${schemaName}.${referencedTable}
+      WHERE ${referencedTable}.${referencedField} = NEW.${fieldName}
+        AND ${referencedTable}.${ownershipFieldName} = NEW.${ownershipFieldName}
+    ) THEN
+      RAISE EXCEPTION 'Invariant violation: % must belong to the same % as the record', '${fieldName}', '${ownershipFieldName}';
+    END IF;
+  END IF;
+  RETURN NEW;
+END;
+$$ LANGUAGE plpgsql;`, `-- Trigger to enforce: ${inv.description}
+DROP TRIGGER IF EXISTS ${triggerName} ON ${schemaName}.${tableName};
+CREATE TRIGGER ${triggerName}
+  BEFORE INSERT OR UPDATE ON ${schemaName}.${tableName}
+  FOR EACH ROW
+  EXECUTE FUNCTION ${schemaName}.${functionName}();`];
+		}
+		case "cross_table_equality": {
+			const { fieldName, referencedTable, referencedField, equalityFieldName, referencedEqualityFieldName } = logic;
+			const functionName = `${tableName}_${id}_fn`;
+			const triggerName = `${tableName}_${id}_trigger`;
+			return [`-- Function to enforce: ${inv.description}
+CREATE OR REPLACE FUNCTION ${schemaName}.${functionName}()
+RETURNS TRIGGER AS $$
+DECLARE
+  ref_${referencedEqualityFieldName} TEXT;
+BEGIN
+  IF NEW.${fieldName} IS NOT NULL THEN
+    SELECT ${referencedEqualityFieldName} INTO ref_${referencedEqualityFieldName}
+    FROM ${schemaName}.${referencedTable}
+    WHERE ${referencedTable}.${referencedField} = NEW.${fieldName}
+    LIMIT 1;
+
+    IF ref_${referencedEqualityFieldName} IS NULL THEN
+      RAISE EXCEPTION 'Invariant violation: Referenced record not found in ${referencedTable}';
+    END IF;
+
+    IF NEW.${equalityFieldName} != ref_${referencedEqualityFieldName} THEN
+      RAISE EXCEPTION 'Invariant violation: % must equal %.%', '${equalityFieldName}', '${referencedTable}', '${referencedEqualityFieldName}';
+    END IF;
+  END IF;
+  RETURN NEW;
+END;
+$$ LANGUAGE plpgsql;`, `-- Trigger to enforce: ${inv.description}
+DROP TRIGGER IF EXISTS ${triggerName} ON ${schemaName}.${tableName};
+CREATE TRIGGER ${triggerName}
+  BEFORE INSERT OR UPDATE ON ${schemaName}.${tableName}
+  FOR EACH ROW
+  EXECUTE FUNCTION ${schemaName}.${functionName}();`];
+		}
+		default: return null;
+	}
+}
+
+//#endregion
 //#region src/generators/drizzle.ts
 function convertToSnakeCase(str, camelCase) {
 	if (camelCase) return str;
 	return str.replace(/([A-Z]+)([A-Z][a-z])/g, "$1_$2").replace(/([a-z\d])([A-Z])/g, "$1_$2").toLowerCase();
 }
 const generateDrizzleSchema = async ({ options, file, adapter }) => {
-	const tables = getPaymentTables(options);
+	const tables = getPaymentTables$1(options);
 	const filePath = file || "./payment-schema.ts";
 	const databaseType = adapter.options?.provider;
 	if (!databaseType) throw new Error("Database provider type is undefined during Drizzle schema generation. Please define a `provider` in the Drizzle adapter config.");
@@ -325,12 +626,55 @@ const generateDrizzleSchema = async ({ options, file, adapter }) => {
 		}
 	}
 	code += `\n${relationsString}`;
+	const typeHints = generateInvariantTypeHints(tables, getModelName, getFieldName);
+	if (typeHints) code += `\n\n${typeHints}`;
+	const formattedCode = await prettier.format(code, { parser: "typescript" });
+	if (databaseType === "pg") {
+		const sql = emitPostgresInvariantSql(normalizeInvariants(tables, {
+			getModelName,
+			getFieldName
+		}), "public");
+		const sqlFilePath = filePath.replace(/\.ts$/, "-invariants.sql");
+		const sqlDir = path.dirname(path.resolve(process.cwd(), sqlFilePath));
+		await fs$1.mkdir(sqlDir, { recursive: true });
+		await fs$1.writeFile(path.resolve(process.cwd(), sqlFilePath), sql);
+		console.log(`📝 Generated invariant SQL: ${sqlFilePath}`);
+	}
 	return {
-		code: await prettier.format(code, { parser: "typescript" }),
+		code: formattedCode,
 		fileName: filePath,
 		overwrite: fileExist
 	};
 };
+/**
+* Generate TypeScript type hints for invariants (e.g., enum unions).
+*/
+function generateInvariantTypeHints(tables, getModelName, getFieldName) {
+	const hints = [];
+	for (const [tableKey, table] of Object.entries(tables)) {
+		if (!table.invariants) continue;
+		for (const invariant of table.invariants) {
+			const desc = invariant.description.toLowerCase();
+			if (desc.includes("determines") && desc.includes("presence")) {
+				const modeMatch = invariant.description.match(/(\w+)\.(\w+)\s+determines/);
+				if (modeMatch) {
+					const [, , fieldName] = modeMatch;
+					const field = Object.keys(table.fields).find((k) => k.toLowerCase() === fieldName.toLowerCase());
+					if (field) {
+						const fieldAttr = table.fields[field];
+						if (typeof fieldAttr.type !== "string" && Array.isArray(fieldAttr.type) && fieldAttr.type.every((x) => typeof x === "string")) {
+							const enumName = `${getModelName(tableKey)}${fieldName.charAt(0).toUpperCase() + fieldName.slice(1)}Mode`;
+							const enumValues = fieldAttr.type.map((v) => `"${v}"`).join(" | ");
+							hints.push(`// Type hint for invariant: ${invariant.id}`);
+							hints.push(`export type ${enumName} = ${enumValues};`);
+						}
+					}
+				}
+			}
+		}
+	}
+	return hints.length > 0 ? `\n// Invariant type hints\n${hints.join("\n")}` : "";
+}
 function generateImport({ databaseType, tables }) {
 	const rootImports = ["relations"];
 	const coreImports = [];
@@ -370,12 +714,31 @@ function generateImport({ databaseType, tables }) {
 
 //#endregion
 //#region src/generators/kysely.ts
-const generateKyselySchema = async ({ options, file }) => {
+const generateKyselySchema = async ({ options, file, adapter }) => {
 	const { compileMigrations } = await getMigrations(options);
 	const migrations = await compileMigrations();
+	const migrationFile = file || `./better-auth_migrations/${(/* @__PURE__ */ new Date()).toISOString().replace(/:/g, "-")}.sql`;
+	if ((adapter?.options?.type || "postgres") === "postgres") {
+		const tables = getPaymentTables(options);
+		const sql = emitPostgresInvariantSql(normalizeInvariants(tables, {
+			getModelName: initGetModelName({
+				schema: tables,
+				usePlural: adapter?.options?.adapterConfig?.usePlural
+			}),
+			getFieldName: initGetFieldName({
+				schema: tables,
+				usePlural: false
+			})
+		}), "public");
+		const sqlFilePath = path.join(path.dirname(migrationFile), "invariants.sql");
+		const sqlDir = path.dirname(path.resolve(process.cwd(), sqlFilePath));
+		await fs$1.mkdir(sqlDir, { recursive: true });
+		await fs$1.writeFile(path.resolve(process.cwd(), sqlFilePath), sql);
+		console.log(`📝 Generated invariant SQL: ${sqlFilePath}`);
+	}
 	return {
 		code: migrations.trim() === ";" ? "" : migrations,
-		fileName: file || `./better-auth_migrations/${(/* @__PURE__ */ new Date()).toISOString().replace(/:/g, "-")}.sql`
+		fileName: migrationFile
 	};
 };
 
@@ -401,15 +764,15 @@ function getPrismaVersion(cwd) {
 //#region src/generators/prisma.ts
 const generatePrismaSchema = async ({ adapter, options, file }) => {
 	const provider = adapter.options?.provider || "postgresql";
-	const tables = getPaymentTables(options);
+	const tables = getPaymentTables$1(options);
 	const filePath = file || "./prisma/schema.prisma";
 	const schemaPrismaExist = existsSync(path.join(process.cwd(), filePath));
 	const getModelName = initGetModelName({
-		schema: getPaymentTables(options),
+		schema: getPaymentTables$1(options),
 		usePlural: adapter.options?.adapterConfig?.usePlural
 	});
 	const getFieldName = initGetFieldName({
-		schema: getPaymentTables(options),
+		schema: getPaymentTables$1(options),
 		usePlural: false
 	});
 	let schemaPrisma = "";
@@ -580,6 +943,24 @@ const generatePrismaSchema = async ({ adapter, options, file }) => {
 		}
 	});
 	const schemaChanged = schema.trim() !== schemaPrisma.trim();
+	if (provider === "postgresql") {
+		const tables$1 = getPaymentTables$1(options);
+		const sql = emitPostgresInvariantSql(normalizeInvariants(tables$1, {
+			getModelName: initGetModelName({
+				schema: tables$1,
+				usePlural: adapter.options?.adapterConfig?.usePlural
+			}),
+			getFieldName: initGetFieldName({
+				schema: tables$1,
+				usePlural: false
+			})
+		}), "public");
+		const sqlFilePath = path.join(path.dirname(filePath), "invariants.sql");
+		const sqlDir = path.dirname(path.resolve(process.cwd(), sqlFilePath));
+		await fs$1.mkdir(sqlDir, { recursive: true });
+		await fs$1.writeFile(path.resolve(process.cwd(), sqlFilePath), sql);
+		console.log(`📝 Generated invariant SQL: ${sqlFilePath}`);
+	}
 	return {
 		code: schemaChanged ? schema : "",
 		fileName: filePath,
@@ -598,12 +979,278 @@ const getNewPrisma = (provider, cwd) => {
   }`;
 };
 
+//#endregion
+//#region src/generators/invariants-mongo.ts
+/**
+* Generate MongoDB collection validator JSON schema for invariants.
+*/
+function emitMongoValidators(invariants) {
+	const validators = {};
+	for (const inv of invariants) {
+		if (inv.enforcement.mongo !== "validator" || !inv.appliesTo.includes("mongo")) continue;
+		const collectionName = inv.tableName;
+		if (!validators[collectionName]) validators[collectionName] = { $jsonSchema: {
+			bsonType: "object",
+			required: [],
+			properties: {},
+			additionalProperties: true
+		} };
+		const validator = generateMongoValidator(inv);
+		if (validator) {
+			Object.assign(validators[collectionName].$jsonSchema.properties, validator.properties || {});
+			if (validator.required) validators[collectionName].$jsonSchema.required = [...validators[collectionName].$jsonSchema.required || [], ...validator.required];
+			if (validator.anyOf) {
+				if (!validators[collectionName].$jsonSchema.anyOf) validators[collectionName].$jsonSchema.anyOf = [];
+				validators[collectionName].$jsonSchema.anyOf.push(...validator.anyOf);
+			}
+		}
+	}
+	return validators;
+}
+/**
+* Generate MongoDB validator JSON schema for a single invariant.
+*/
+function generateMongoValidator(inv) {
+	const { logic } = inv;
+	switch (logic.type) {
+		case "field_enum_constraint": {
+			const { fieldName, allowedValues, conditionalField } = logic;
+			if (conditionalField) {
+				const anyOf = [];
+				if (!conditionalField.whenPresent) anyOf.push({ properties: {
+					[fieldName]: { enum: ["PAYMENT"] },
+					[conditionalField.fieldName]: { bsonType: "null" }
+				} });
+				if (conditionalField.whenPresent) anyOf.push({
+					properties: {
+						[fieldName]: { enum: ["SUBSCRIPTION"] },
+						[conditionalField.fieldName]: { bsonType: "string" }
+					},
+					required: [conditionalField.fieldName]
+				});
+				return {
+					properties: { [fieldName]: { enum: allowedValues } },
+					anyOf
+				};
+			}
+			return { properties: { [fieldName]: { enum: allowedValues } } };
+		}
+		default: return null;
+	}
+}
+/**
+* Generate TypeScript guard module for MongoDB "app" enforcement invariants.
+*/
+function emitMongoGuards(invariants) {
+	const guardInvariants = invariants.filter((inv) => inv.enforcement.mongo === "app" && inv.appliesTo.includes("mongo"));
+	if (guardInvariants.length === 0) return `// No MongoDB app-level invariant guards generated
+// This file is auto-generated - DO NOT EDIT MANUALLY
+
+export {};
+`;
+	const guards = [];
+	const imports = [];
+	for (const inv of guardInvariants) {
+		const guard = generateMongoGuard(inv);
+		if (guard) {
+			guards.push(guard);
+			if (guard.imports) imports.push(...guard.imports);
+		}
+	}
+	const uniqueImports = Array.from(new Set(imports));
+	return `// MongoDB invariant guards
+// Generated from schema invariants
+// DO NOT EDIT MANUALLY - This file is auto-generated
+// 
+// These guards should be called before write operations to enforce invariants
+// at the application level.
+
+${uniqueImports.length > 0 ? uniqueImports.join("\n") + "\n" : ""}
+
+${guards.join("\n\n")}
+`;
+}
+/**
+* Generate TypeScript guard function for a single invariant.
+*/
+function generateMongoGuard(inv) {
+	const { logic, tableName, id, description } = inv;
+	switch (logic.type) {
+		case "cross_table_ownership": {
+			const { fieldName, referencedTable, referencedField, ownershipFieldName } = logic;
+			return { code: `/**
+ * Guard: ${description}
+ * 
+ * @param data - The record being created/updated (use camelCase field names)
+ * @param db - MongoDB database instance
+ * @returns true if invariant is satisfied, throws error otherwise
+ */
+export async function ${id}Guard(
+  data: { ${fieldName}?: string | null; ${ownershipFieldName}: string },
+  db: { collection(name: string): { findOne(filter: any): Promise<any | null> } }
+): Promise<boolean> {
+  if (!data.${fieldName}) {
+    return true; // Field is optional/nullable
+  }
+
+  const referenced = await db.collection("${referencedTable}").findOne({
+    ${referencedField}: data.${fieldName}
+  });
+
+  if (!referenced) {
+    throw new Error(\`Invariant violation: \${data.${fieldName}} not found in ${referencedTable}\`);
+  }
+
+  // Compare ownership field (use database field name for referenced record)
+  const dataOwnerValue = data.${ownershipFieldName};
+  const refOwnerValue = referenced.${ownershipFieldName};
+  
+  if (refOwnerValue !== dataOwnerValue) {
+    throw new Error(
+      \`Invariant violation: ${fieldName} must belong to the same ${ownershipFieldName} as the record. \` +
+      \`Expected \${dataOwnerValue}, got \${refOwnerValue}\`
+    );
+  }
+
+  return true;
+}` };
+		}
+		case "cross_table_equality": {
+			const { fieldName, referencedTable, referencedField, equalityFieldName, referencedEqualityFieldName } = logic;
+			return { code: `/**
+ * Guard: ${description}
+ * 
+ * @param data - The record being created/updated
+ * @param db - MongoDB database instance
+ * @returns true if invariant is satisfied, throws error otherwise
+ */
+export async function ${id}Guard(
+  data: { ${fieldName}: string; ${equalityFieldName}: string },
+  db: { collection(name: string): { findOne(filter: any): Promise<any | null> } }
+): Promise<boolean> {
+  if (!data.${fieldName}) {
+    throw new Error(\`Invariant violation: ${fieldName} is required\`);
+  }
+
+  const referenced = await db.collection("${referencedTable}").findOne({
+    ${referencedField}: data.${fieldName}
+  });
+
+  if (!referenced) {
+    throw new Error(\`Invariant violation: Referenced record not found in ${referencedTable}\`);
+  }
+
+  if (referenced.${referencedEqualityFieldName} !== data.${equalityFieldName}) {
+    throw new Error(
+      \`Invariant violation: ${equalityFieldName} must equal ${referencedTable}.${referencedEqualityFieldName}. \` +
+      \`Expected \${referenced.${referencedEqualityFieldName}}, got \${data.${equalityFieldName}}\`
+    );
+  }
+
+  return true;
+}` };
+		}
+		case "raw": return { code: `/**
+ * Guard: ${description}
+ * 
+ * TODO: Implement this guard based on the invariant description.
+ * This is a placeholder - you must implement the actual validation logic.
+ * 
+ * @param data - The record being created/updated
+ * @param db - MongoDB database instance
+ * @returns true if invariant is satisfied, throws error otherwise
+ */
+export async function ${id}Guard(
+  data: any,
+  db: { collection(name: string): { findOne(filter: any): Promise<any | null> } }
+): Promise<boolean> {
+  // TODO: Implement invariant: ${description}
+  console.warn("Guard ${id}Guard is not yet implemented");
+  return true;
+}` };
+		default: return null;
+	}
+}
+
+//#endregion
+//#region src/generators/mongodb.ts
+const generateMongoDBSchema = async ({ options, file, adapter }) => {
+	const tables = getPaymentTables$1(options);
+	const filePath = file || "./mongodb-schema.ts";
+	const invariants = normalizeInvariants(tables, {
+		getModelName: initGetModelName({
+			schema: tables,
+			usePlural: adapter?.options?.adapterConfig?.usePlural
+		}),
+		getFieldName: initGetFieldName({
+			schema: tables,
+			usePlural: false
+		})
+	});
+	const validators = emitMongoValidators(invariants);
+	const validatorsJson = JSON.stringify(validators, null, 2);
+	const guards = emitMongoGuards(invariants);
+	const validatorsPath = filePath.replace(/\.ts$/, "-validators.json");
+	const validatorsDir = path.dirname(path.resolve(process.cwd(), validatorsPath));
+	await fs$1.mkdir(validatorsDir, { recursive: true });
+	await fs$1.writeFile(path.resolve(process.cwd(), validatorsPath), validatorsJson);
+	console.log(`📝 Generated MongoDB validators: ${validatorsPath}`);
+	const guardsPath = filePath.replace(/\.ts$/, "-guards.ts");
+	const guardsDir = path.dirname(path.resolve(process.cwd(), guardsPath));
+	await fs$1.mkdir(guardsDir, { recursive: true });
+	const formattedGuards = await prettier.format(guards, { parser: "typescript" });
+	await fs$1.writeFile(path.resolve(process.cwd(), guardsPath), formattedGuards);
+	console.log(`📝 Generated MongoDB guards: ${guardsPath}`);
+	const validatorsBaseName = path.basename(validatorsPath, ".json");
+	const guardsBaseName = path.basename(guardsPath, ".ts");
+	const schemaCode = `// MongoDB schema setup
+// Generated from schema definitions
+// DO NOT EDIT MANUALLY - This file is auto-generated
+
+import validators from "./${validatorsBaseName}.json";
+import * as guards from "./${guardsBaseName}";
+
+/**
+ * MongoDB collection validators.
+ * Apply these using db.createCollection() or db.command({ collMod: ... })
+ * 
+ * Example:
+ * \`\`\`
+ * await db.createCollection("checkout_session", {
+ *   validator: validators.checkout_session
+ * });
+ * \`\`\`
+ */
+export { validators };
+
+/**
+ * MongoDB invariant guards.
+ * Call these before write operations to enforce invariants at the application level.
+ * 
+ * Example:
+ * \`\`\`
+ * import { customer_payment_method_ownershipGuard } from "./${guardsBaseName}";
+ * 
+ * await customer_payment_method_ownershipGuard(data, db);
+ * await db.collection("customer").insertOne(data);
+ * \`\`\`
+ */
+export { guards };
+`;
+	return {
+		code: await prettier.format(schemaCode, { parser: "typescript" }),
+		fileName: filePath,
+		overwrite: true
+	};
+};
+
 //#endregion
 //#region src/generators/index.ts
 const adapters = {
 	prisma: generatePrismaSchema,
 	drizzle: generateDrizzleSchema,
-	kysely: generateKyselySchema
+	kysely: generateKyselySchema,
+	mongodb: generateMongoDBSchema
 };
 const generateSchema = async (opts) => {
 	const adapter = opts.adapter;

package/dist/index.mjs

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { i as getPackageInfo, n as generateSchema } from "./generators-D5zLfxo1.mjs";
+import { i as getPackageInfo, n as generateSchema } from "./generators-DjXYs9VN.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.1.9",
+  "version": "0.2.0",
   "type": "module",
   "module": "dist/index.mjs",
   "main": "./dist/index.mjs",