pecunia-cli 0.3.0 → 0.3.2

package/dist/api.d.mts

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

package/dist/{generators-DyDUFaYK.mjs → generators-CWgRQHR-.mjs}

@@ -13,14 +13,10 @@ function convertToSnakeCase(str, camelCase) {
 }
 const generateDrizzleSchema = async ({ options, file, adapter }) => {
 	const tables = getPaymentTables(options);
-	const filePath = file || "./src/db/schema.ts";
+	const filePath = file || "./schema.ts";
 	const databaseType = adapter.options?.provider;
-	const projectRoot = process.cwd();
-	if (!databaseType) throw new Error("Database provider type is undefined during Drizzle schema generation. Please define a `provider` in the Drizzle adapter config.");
-	const resolvedSchemaPath = path.isAbsolute(filePath) ? filePath : path.resolve(projectRoot, filePath);
-	const schemaDir = path.dirname(resolvedSchemaPath);
-	if (!existsSync(schemaDir)) await fs$1.mkdir(schemaDir, { recursive: true });
-	const fileExist = existsSync(resolvedSchemaPath);
+	if (!databaseType) throw new Error(`Database provider type is undefined during Drizzle schema generation. Please define a \`provider\` in the Drizzle adapter config. Read more at https://better-auth.com/docs/adapters/drizzle`);
+	const fileExist = existsSync(filePath);
 	let code = generateImport({
 		databaseType,
 		tables,
@@ -34,84 +30,83 @@ const generateDrizzleSchema = async ({ options, file, adapter }) => {
 		schema: tables,
 		usePlural: adapter.options?.adapterConfig?.usePlural
 	});
-	const tableNameMap = /* @__PURE__ */ new Map();
-	for (const tableKey in tables) tableNameMap.set(tableKey, getModelName(tableKey));
-	function getType(name, field, databaseType$1) {
-		name = convertToSnakeCase(name, adapter.options?.camelCase);
-		if (field.references?.field === "id") {
-			if (databaseType$1 === "mysql") return `varchar('${name}', { length: 36 })`;
-			return `text('${name}')`;
-		}
-		const type = field.type;
-		if (typeof type !== "string") {
-			if (Array.isArray(type) && type.every((x) => typeof x === "string")) return {
-				sqlite: `text({ enum: [${type.map((x) => `'${x}'`).join(", ")}] })`,
-				pg: `text('${name}', { enum: [${type.map((x) => `'${x}'`).join(", ")}] })`,
-				mysql: `mysqlEnum([${type.map((x) => `'${x}'`).join(", ")}])`
-			}[databaseType$1];
-			throw new TypeError(`Invalid field type for field ${name}`);
-		}
-		const dbTypeMap = {
-			string: {
-				sqlite: `text('${name}')`,
-				pg: `text('${name}')`,
-				mysql: field.unique ? `varchar('${name}', { length: 255 })` : field.references ? `varchar('${name}', { length: 36 })` : field.sortable ? `varchar('${name}', { length: 255 })` : field.index ? `varchar('${name}', { length: 255 })` : `text('${name}')`
-			},
-			boolean: {
-				sqlite: `integer('${name}', { mode: 'boolean' })`,
-				pg: `boolean('${name}')`,
-				mysql: `boolean('${name}')`
-			},
-			number: {
-				sqlite: `integer('${name}')`,
-				pg: field.bigint ? `bigint('${name}', { mode: 'number' })` : `integer('${name}')`,
-				mysql: field.bigint ? `bigint('${name}', { mode: 'number' })` : `int('${name}')`
-			},
-			date: {
-				sqlite: `integer('${name}', { mode: 'timestamp_ms' })`,
-				pg: `timestamp('${name}')`,
-				mysql: `timestamp('${name}', { fsp: 3 })`
-			},
-			"number[]": {
-				sqlite: `text('${name}', { mode: "json" })`,
-				pg: field.bigint ? `bigint('${name}', { mode: 'number' }).array()` : `integer('${name}').array()`,
-				mysql: `text('${name}', { mode: 'json' })`
-			},
-			"string[]": {
-				sqlite: `text('${name}', { mode: "json" })`,
-				pg: `text('${name}').array()`,
-				mysql: `text('${name}', { mode: "json" })`
-			},
-			json: {
-				sqlite: `text('${name}', { mode: "json" })`,
-				pg: `jsonb('${name}')`,
-				mysql: `json('${name}', { mode: "json" })`
-			},
-			uuid: {
-				sqlite: `text('${name}')`,
-				pg: `uuid('${name}')`,
-				mysql: `varchar('${name}', { length: 36 })`
-			}
-		}[type];
-		if (!dbTypeMap) throw new Error(`Unsupported field type '${field.type}' for field '${name}'.`);
-		return dbTypeMap[databaseType$1];
-	}
-	const tableDefinitions = [];
 	for (const tableKey in tables) {
 		const table = tables[tableKey];
 		const modelName = getModelName(tableKey);
 		const fields = table.fields;
-		const idFieldType = table.fields.id?.type;
-		let id;
-		if (databaseType === "pg" && idFieldType === "uuid") id = `uuid('id').primaryKey()`;
-		else if (databaseType === "mysql") id = `varchar('id', { length: 36 }).primaryKey()`;
-		else id = `text('id').primaryKey()`;
-		const indexes = [];
-		const references = [];
-		for (const field of Object.keys(fields)) {
-			if (field === "id") continue;
+		function getType(name, field) {
+			if (!databaseType) throw new Error(`Database provider type is undefined during Drizzle schema generation. Please define a \`provider\` in the Drizzle adapter config. Read more at https://better-auth.com/docs/adapters/drizzle`);
+			name = convertToSnakeCase(name, adapter.options?.camelCase);
+			if (field.references?.field === "id") {
+				if (databaseType === "pg") return `uuid('${name}')`;
+				if (databaseType === "mysql") return `varchar('${name}', { length: 36 })`;
+				return `text('${name}')`;
+			}
+			const type = field.type;
+			if (typeof type !== "string") if (Array.isArray(type) && type.every((x) => typeof x === "string")) return {
+				sqlite: `text({ enum: [${type.map((x) => `'${x}'`).join(", ")}] })`,
+				pg: `text('${name}', { enum: [${type.map((x) => `'${x}'`).join(", ")}] })`,
+				mysql: `mysqlEnum([${type.map((x) => `'${x}'`).join(", ")}])`
+			}[databaseType];
+			else throw new TypeError(`Invalid field type for field ${name} in model ${modelName}`);
+			const dbTypeMap = {
+				string: {
+					sqlite: `text('${name}')`,
+					pg: `text('${name}')`,
+					mysql: field.unique ? `varchar('${name}', { length: 255 })` : field.references ? `varchar('${name}', { length: 36 })` : field.sortable ? `varchar('${name}', { length: 255 })` : field.index ? `varchar('${name}', { length: 255 })` : `text('${name}')`
+				},
+				boolean: {
+					sqlite: `integer('${name}', { mode: 'boolean' })`,
+					pg: `boolean('${name}')`,
+					mysql: `boolean('${name}')`
+				},
+				number: {
+					sqlite: `integer('${name}')`,
+					pg: field.bigint ? `bigint('${name}', { mode: 'number' })` : `integer('${name}')`,
+					mysql: field.bigint ? `bigint('${name}', { mode: 'number' })` : `int('${name}')`
+				},
+				date: {
+					sqlite: `integer('${name}', { mode: 'timestamp_ms' })`,
+					pg: `timestamp('${name}')`,
+					mysql: `timestamp('${name}', { fsp: 3 })`
+				},
+				"number[]": {
+					sqlite: `text('${name}', { mode: "json" })`,
+					pg: field.bigint ? `bigint('${name}', { mode: 'number' }).array()` : `integer('${name}').array()`,
+					mysql: `text('${name}', { mode: "json" })`
+				},
+				"string[]": {
+					sqlite: `text('${name}', { mode: "json" })`,
+					pg: `text('${name}').array()`,
+					mysql: `text('${name}', { mode: "json" })`
+				},
+				json: {
+					sqlite: `text('${name}', { mode: "json" })`,
+					pg: `jsonb('${name}')`,
+					mysql: `json('${name}', { mode: "json" })`
+				}
+			}[type];
+			if (!dbTypeMap) throw new Error(`Unsupported field type '${field.type}' for field '${name}'.`);
+			return dbTypeMap[databaseType];
+		}
+		let id = "";
+		if (databaseType === "pg") id = `uuid("id").default(sql\`gen_random_uuid()\`).primaryKey()`;
+		else if (databaseType === "mysql") id = `varchar("id", { length: 36 }).primaryKey()`;
+		else id = `text("id").primaryKey()`;
+		let indexes = [];
+		const assignIndexes = (indexes$1) => {
+			if (!indexes$1.length) return "";
+			let code$1 = [`, (table) => [`];
+			for (const index of indexes$1) code$1.push(`  ${index.type}("${index.name}").on(table.${index.on}),`);
+			code$1.push(`]`);
+			return code$1.join("\n");
+		};
+		const schema = `export const ${modelName} = ${databaseType}Table("${convertToSnakeCase(modelName, adapter.options?.camelCase)}", {
+					id: ${id},
+					${Object.keys(fields).map((field) => {
 			const attr = fields[field];
 			const fieldName = attr.fieldName || field;
+			let type = getType(fieldName, attr);
 			if (attr.index && !attr.unique) indexes.push({
 				type: "index",
 				name: `${modelName}_${fieldName}_idx`,
@@ -122,80 +117,6 @@ const generateDrizzleSchema = async ({ options, file, adapter }) => {
 				name: `${modelName}_${fieldName}_uidx`,
 				on: fieldName
 			});
-			if (attr.references) {
-				const referencedModelName = tableNameMap.get(attr.references.model) || getModelName(attr.references.model);
-				const onDelete = attr.references.onDelete || "no action";
-				references.push({
-					fieldName,
-					referencedTable: referencedModelName,
-					referencedField: getFieldName({
-						model: attr.references.model,
-						field: attr.references.field
-					}),
-					onDelete,
-					required: attr.required ?? false,
-					originalModel: attr.references.model
-				});
-			}
-		}
-		tableDefinitions.push({
-			modelName,
-			tableKey,
-			fields,
-			id,
-			indexes,
-			references
-		});
-	}
-	const modelKeyToTableKey = /* @__PURE__ */ new Map();
-	for (const tableKey in tables) {
-		const table = tables[tableKey];
-		const modelName = getModelName(tableKey);
-		modelKeyToTableKey.set(tableKey, tableKey);
-		modelKeyToTableKey.set(modelName, tableKey);
-		modelKeyToTableKey.set(table.modelName, tableKey);
-	}
-	const referenceGraph = /* @__PURE__ */ new Map();
-	for (const tableDef of tableDefinitions) for (const ref of tableDef.references) {
-		const referencedTableKey = modelKeyToTableKey.get(ref.originalModel);
-		if (!referencedTableKey) continue;
-		const key = `${tableDef.tableKey}->${referencedTableKey}`;
-		referenceGraph.set(key, {
-			...ref,
-			sourceTable: tableDef.tableKey,
-			sourceModelName: tableDef.modelName
-		});
-	}
-	const skipReferences = /* @__PURE__ */ new Set();
-	for (const tableDef of tableDefinitions) for (const ref of tableDef.references) {
-		const referencedTableKey = modelKeyToTableKey.get(ref.originalModel);
-		if (!referencedTableKey) continue;
-		const reverseKey = `${referencedTableKey}->${tableDef.tableKey}`;
-		const reverseRef = referenceGraph.get(reverseKey);
-		if (reverseRef) {
-			const thisIsNullableWithSetNull = !ref.required && ref.onDelete === "set null";
-			const reverseIsNullableWithSetNull = !reverseRef.required && reverseRef.onDelete === "set null";
-			if (thisIsNullableWithSetNull) continue;
-			if (reverseIsNullableWithSetNull) continue;
-			if (!ref.required && (reverseRef.required || ref.onDelete !== "cascade" && reverseRef.onDelete === "cascade")) skipReferences.add(`${tableDef.tableKey}.${ref.fieldName}`);
-		}
-	}
-	for (const tableDef of tableDefinitions) {
-		const { modelName, fields, id, indexes, references } = tableDef;
-		const assignIndexes = (indexesToAssign) => {
-			if (!indexesToAssign.length) return "";
-			const parts = [`, (table) => [`];
-			for (const index of indexesToAssign) parts.push(`  ${index.type}("${index.name}").on(table.${index.on}),`);
-			parts.push(`]`);
-			return parts.join("\n");
-		};
-		const referenceMap = /* @__PURE__ */ new Map();
-		for (const ref of references) referenceMap.set(ref.fieldName, ref);
-		const fieldDefinitions = Object.keys(fields).filter((field) => field !== "id").map((field) => {
-			const attr = fields[field];
-			const fieldName = attr.fieldName || field;
-			let type = getType(fieldName, attr, databaseType);
-			let comment = "";
 			if (attr.defaultValue !== null && typeof attr.defaultValue !== "undefined") if (typeof attr.defaultValue === "function") {
 				if (attr.type === "date" && attr.defaultValue.toString().includes("new Date()")) if (databaseType === "sqlite") type += `.default(sql\`(cast(unixepoch('subsecond') * 1000 as integer))\`)`;
 				else type += `.defaultNow()`;
@@ -204,23 +125,11 @@ const generateDrizzleSchema = async ({ options, file, adapter }) => {
 			if (attr.onUpdate && attr.type === "date") {
 				if (typeof attr.onUpdate === "function") type += `.$onUpdate(${attr.onUpdate})`;
 			}
-			const ref = referenceMap.get(fieldName);
-			const shouldSkipReference = skipReferences.has(`${tableDef.tableKey}.${fieldName}`);
-			let referenceChain = "";
-			if (ref && !shouldSkipReference) referenceChain = `.references(() => ${ref.referencedTable}.${ref.referencedField}, { onDelete: '${ref.onDelete}' })`;
-			else if (ref && shouldSkipReference) {
-				const reverseKey = `${ref.originalModel}->${tableDef.tableKey}`;
-				const reverseRef = referenceGraph.get(reverseKey);
-				if (reverseRef) comment = `\n					// FK constraint removed to break circular dependency with ${ref.referencedTable}\n					// Primary FK: ${reverseRef.sourceModelName}.${reverseRef.fieldName} -> ${modelName}.${fieldName}\n					// This field still maintains referential integrity via application logic and Drizzle relations`;
-				else comment = `\n					// FK constraint removed to break circular dependency with ${ref.referencedTable}\n					// This field still maintains referential integrity via application logic and Drizzle relations`;
-			}
-			const isRequired = attr.required === true;
-			const fieldDef = `${fieldName}: ${type}${isRequired ? ".notNull()" : ""}${attr.unique ? ".unique()" : ""}${referenceChain}`;
-			return comment ? `${comment}\n					${fieldDef}` : fieldDef;
-		});
-		const schema = `export const ${modelName} = ${databaseType}Table("${convertToSnakeCase(modelName, adapter.options?.camelCase)}", {
-					id: ${id},
-					${fieldDefinitions.join(",\n ")}
+			return `${fieldName}: ${type}${attr.required ? ".notNull()" : ""}${attr.unique ? ".unique()" : ""}${attr.references ? `.references(()=> ${getModelName(attr.references.model)}.${getFieldName({
+				model: attr.references.model,
+				field: attr.references.field
+			})}, { onDelete: '${attr.references.onDelete || "cascade"}' })` : ""}`;
+		}).join(",\n ")}
 					}${assignIndexes(indexes)});`;
 		code += `\n${schema}\n`;
 	}
@@ -230,118 +139,72 @@ 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];
-				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: 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
-							},
-							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"
-						});
-					}
+		const manyRelationsSet = /* @__PURE__ */ new Set();
+		const foreignFields = Object.entries(table.fields).filter(([_, field]) => field.references);
+		for (const [fieldName, field] of foreignFields) {
+			const referencedModel = field.references.model;
+			const relationKey = getModelName(referencedModel);
+			const fieldRef = `${getModelName(tableKey)}.${getFieldName({
+				model: tableKey,
+				field: fieldName
+			})}`;
+			const referenceRef = `${getModelName(referencedModel)}.${getFieldName({
+				model: referencedModel,
+				field: field.references.field || "id"
+			})}`;
+			oneRelations.push({
+				key: relationKey,
+				model: getModelName(referencedModel),
+				type: "one",
+				reference: {
+					field: fieldRef,
+					references: referenceRef,
+					fieldName
 				}
-			}
-			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 otherModels = Object.entries(tables).filter(([modelName$1]) => modelName$1 !== tableKey);
+		const modelRelationsMap = /* @__PURE__ */ new Map();
+		for (const [modelName$1, otherTable] of otherModels) {
+			const foreignKeysPointingHere = Object.entries(otherTable.fields).filter(([_, field]) => field.references?.model === tableKey || field.references?.model === getModelName(tableKey));
+			if (foreignKeysPointingHere.length === 0) continue;
+			const hasUnique = foreignKeysPointingHere.some(([_, field]) => !!field.unique);
+			const hasMany$1 = foreignKeysPointingHere.some(([_, field]) => !field.unique);
+			modelRelationsMap.set(modelName$1, {
+				modelName: modelName$1,
+				hasUnique,
+				hasMany: hasMany$1
+			});
+		}
+		for (const { modelName: modelName$1, hasMany: hasMany$1 } of modelRelationsMap.values()) {
+			const relationType = hasMany$1 ? "many" : "one";
+			let relationKey = getModelName(modelName$1);
+			if (!adapter.options?.adapterConfig?.usePlural && relationType === "many") relationKey = `${relationKey}s`;
+			if (!manyRelationsSet.has(relationKey)) {
+				manyRelationsSet.add(relationKey);
+				manyRelations.push({
+					key: relationKey,
+					model: getModelName(modelName$1),
+					type: relationType
+				});
 			}
 		}
 		const relationsByModel = /* @__PURE__ */ new Map();
-		for (const relation of oneRelations) {
-			if (!relation.reference) continue;
+		for (const relation of oneRelations) if (relation.reference) {
 			const modelKey = relation.key;
 			if (!relationsByModel.has(modelKey)) relationsByModel.set(modelKey, []);
 			relationsByModel.get(modelKey).push(relation);
 		}
 		const duplicateRelations = [];
 		const singleRelations = [];
-		for (const [_modelKey, rels] of relationsByModel.entries()) if (rels.length > 1) duplicateRelations.push(...rels);
-		else singleRelations.push(rels[0]);
-		for (const relation of duplicateRelations) {
-			if (!relation.reference) continue;
+		for (const [_modelKey, relations] of relationsByModel.entries()) if (relations.length > 1) duplicateRelations.push(...relations);
+		else singleRelations.push(relations[0]);
+		for (const relation of duplicateRelations) if (relation.reference) {
 			const fieldName = relation.reference.fieldName;
-			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 }) => ({
+			const tableRelation = `export const ${`${modelName}${fieldName.charAt(0).toUpperCase() + fieldName.slice(1)}Relations`} = relations(${getModelName(table.modelName)}, ({ one }) => ({
 				${relation.key}: one(${relation.model}, {
 					fields: [${relation.reference.field}],
-					references: [${relation.reference.references}]${relationNameParam}
+					references: [${relation.reference.references}],
 				})
 			}))`;
 			relationsString += `\n${tableRelation}\n`;
@@ -349,37 +212,25 @@ const generateDrizzleSchema = async ({ options, file, adapter }) => {
 		const hasOne = singleRelations.length > 0;
 		const hasMany = manyRelations.length > 0;
 		if (hasOne && hasMany) {
-			const tableRelation = `export const ${modelName}Relations = relations(${modelName}, ({ one, many }) => ({
-				${singleRelations.map((relation) => {
-				if (!relation.reference) return "";
-				const relationNameParam = relation.relationName ? `,\n					relationName: "${relation.relationName}"` : "";
-				return ` ${relation.key}: one(${relation.model}, {
+			const tableRelation = `export const ${modelName}Relations = relations(${getModelName(table.modelName)}, ({ one, many }) => ({
+				${singleRelations.map((relation) => relation.reference ? ` ${relation.key}: one(${relation.model}, {
 					fields: [${relation.reference.field}],
-					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 ")}
+					references: [${relation.reference.references}],
+				})` : "").filter((x) => x !== "").join(",\n ")}${singleRelations.length > 0 && manyRelations.length > 0 ? "," : ""}
+				${manyRelations.map(({ key, model }) => ` ${key}: many(${model})`).join(",\n ")}
 			}))`;
 			relationsString += `\n${tableRelation}\n`;
 		} else if (hasOne) {
-			const tableRelation = `export const ${modelName}Relations = relations(${modelName}, ({ one }) => ({
-				${singleRelations.map((relation) => {
-				if (!relation.reference) return "";
-				const relationNameParam = relation.relationName ? `,\n					relationName: "${relation.relationName}"` : "";
-				return ` ${relation.key}: one(${relation.model}, {
+			const tableRelation = `export const ${modelName}Relations = relations(${getModelName(table.modelName)}, ({ one }) => ({
+				${singleRelations.map((relation) => relation.reference ? ` ${relation.key}: one(${relation.model}, {
 					fields: [${relation.reference.field}],
-					references: [${relation.reference.references}]${relationNameParam}
-				})`;
-			}).filter((x) => x !== "").join(",\n ")}
+					references: [${relation.reference.references}],
+				})` : "").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, relationName }) => {
-				return ` ${key}: many(${model}${relationName ? `, { relationName: "${relationName}" }` : ""})`;
-			}).join(",\n ")}
+			const tableRelation = `export const ${modelName}Relations = relations(${getModelName(table.modelName)}, ({ many }) => ({
+				${manyRelations.map(({ key, model }) => ` ${key}: many(${model})`).join(",\n ")}
 			}))`;
 			relationsString += `\n${tableRelation}\n`;
 		}
@@ -387,7 +238,7 @@ const generateDrizzleSchema = async ({ options, file, adapter }) => {
 	code += `\n${relationsString}`;
 	return {
 		code: await prettier.format(code, { parser: "typescript" }),
-		fileName: path.relative(projectRoot, resolvedSchemaPath),
+		fileName: filePath,
 		overwrite: fileExist
 	};
 };
@@ -396,14 +247,12 @@ function generateImport({ databaseType, tables }) {
 	const coreImports = [];
 	let hasBigint = false;
 	let hasJson = false;
-	let hasUuid = false;
 	for (const table of Object.values(tables)) {
 		for (const field of Object.values(table.fields)) {
 			if (field.bigint) hasBigint = true;
 			if (field.type === "json") hasJson = true;
-			if (field.type === "uuid") hasUuid = true;
 		}
-		if (hasJson && hasBigint && hasUuid) break;
+		if (hasJson && hasBigint) break;
 	}
 	coreImports.push(`${databaseType}Table`);
 	coreImports.push(databaseType === "mysql" ? "varchar, text" : databaseType === "pg" ? "text" : "text");
@@ -413,8 +262,9 @@ function generateImport({ databaseType, tables }) {
 		if (Object.values(tables).some((table) => Object.values(table.fields).some((field) => (field.type === "number" || field.type === "number[]") && !field.bigint))) coreImports.push("int");
 		if (Object.values(tables).some((table) => Object.values(table.fields).some((field) => typeof field.type !== "string" && Array.isArray(field.type) && field.type.every((x) => typeof x === "string")))) coreImports.push("mysqlEnum");
 	} else if (databaseType === "pg") {
+		rootImports.push("sql");
+		coreImports.push("uuid");
 		if (Object.values(tables).some((table) => Object.values(table.fields).some((field) => (field.type === "number" || field.type === "number[]") && !field.bigint))) coreImports.push("integer");
-		if (hasUuid) coreImports.push("uuid");
 	} else coreImports.push("integer");
 	if (hasJson) {
 		if (databaseType === "pg") coreImports.push("jsonb");
@@ -511,6 +361,7 @@ const generatePrismaSchema = async ({ adapter, options, file }) => {
 			}
 		}
 	}
+	const uuidsAreNative = provider === "postgresql";
 	const schema = produceSchema(schemaPrisma, (builder) => {
 		for (const table in tables) {
 			const originalTableName = table;
@@ -537,7 +388,8 @@ const generatePrismaSchema = async ({ adapter, options, file }) => {
 				}
 			}
 			const prismaModel = builder.findByType("model", { name: modelName });
-			if (!prismaModel) builder.model(modelName).field("id", "String").attribute("id");
+			if (!prismaModel) if (uuidsAreNative) builder.model(modelName).field("id", "String").attribute("id").attribute("default(dbgenerated(\"pg_catalog.gen_random_uuid()\"))").attribute("db.Uuid");
+			else builder.model(modelName).field("id", "String").attribute("id");
 			for (const field in fields) {
 				const attr = fields[field];
 				const fieldName = attr.fieldName || field;
@@ -550,7 +402,7 @@ const generatePrismaSchema = async ({ adapter, options, file }) => {
 				const fieldBuilder = builder.model(modelName).field(fieldName, getType({
 					isBigint: attr?.bigint || false,
 					isOptional: !attr?.required,
-					type: "string"
+					type: attr.references?.field === "id" ? "string" : attr.type
 				}));
 				if (field === "id") fieldBuilder.attribute("id");
 				if (attr.unique) builder.model(modelName).blockAttribute(`unique([${fieldName}])`);
@@ -561,7 +413,7 @@ const generatePrismaSchema = async ({ adapter, options, file }) => {
 								fieldBuilder.attribute(`default("${JSON.stringify(attr.defaultValue).replace(/\\/g, "\\\\").replace(/"/g, "\\\"")}")`);
 								continue;
 							}
-							let jsonArray = [];
+							const jsonArray = [];
 							for (const value of attr.defaultValue) jsonArray.push(value);
 							fieldBuilder.attribute(`default("${JSON.stringify(jsonArray).replace(/"/g, "\\\"")}")`);
 							continue;
@@ -570,11 +422,11 @@ const generatePrismaSchema = async ({ adapter, options, file }) => {
 							fieldBuilder.attribute(`default([])`);
 							continue;
 						} else if (typeof attr.defaultValue[0] === "string" && attr.type === "string[]") {
-							let valueArray = [];
+							const valueArray = [];
 							for (const value of attr.defaultValue) valueArray.push(JSON.stringify(value));
 							fieldBuilder.attribute(`default([${valueArray}])`);
 						} else if (typeof attr.defaultValue[0] === "number") {
-							let valueArray = [];
+							const valueArray = [];
 							for (const value of attr.defaultValue) valueArray.push(`${value}`);
 							fieldBuilder.attribute(`default([${valueArray}])`);
 						}
@@ -593,11 +445,11 @@ const generatePrismaSchema = async ({ adapter, options, file }) => {
 				if (field === "updatedAt" && attr.onUpdate) fieldBuilder.attribute("updatedAt");
 				else if (attr.onUpdate) {}
 				if (attr.references) {
+					if (uuidsAreNative && attr.references?.field === "id") builder.model(modelName).field(fieldName).attribute(`db.Uuid`);
 					const referencedOriginalModelName = getModelName(attr.references.model);
 					const referencedCustomModelName = tables[referencedOriginalModelName]?.modelName || referencedOriginalModelName;
-					let action = "NoAction";
-					if (attr.references.onDelete === "cascade") action = "Cascade";
-					else if (attr.references.onDelete === "no action") action = "NoAction";
+					let action = "Cascade";
+					if (attr.references.onDelete === "no action") action = "NoAction";
 					else if (attr.references.onDelete === "set null") action = "SetNull";
 					else if (attr.references.onDelete === "set default") action = "SetDefault";
 					else if (attr.references.onDelete === "restrict") action = "Restrict";
@@ -630,7 +482,8 @@ const generatePrismaSchema = async ({ adapter, options, file }) => {
 				}
 				const field = Object.entries(fields).find(([key, attr]) => (attr.fieldName || key) === fieldName)?.[1];
 				let indexField = fieldName;
-				if (provider === "mysql" && field && field.type === "string") indexField = `${fieldName}(length: 191)`;
+				if (provider === "mysql" && field && field.type === "string") if (field.references?.field === "id") indexField = `${fieldName}`;
+				else indexField = `${fieldName}(length: 191)`;
 				builder.model(modelName).blockAttribute(`index([${indexField}])`);
 			}
 			const hasAttribute = builder.findByType("attribute", {
@@ -660,39 +513,12 @@ const getNewPrisma = (provider, cwd) => {
   }`;
 };
 
-//#endregion
-//#region src/generators/mongodb.ts
-const generateMongoDBSchema = async ({ options, file, adapter }) => {
-	const tables = getPaymentTables(options);
-	const filePath = file || "./mongodb-schema.ts";
-	initGetModelName({
-		schema: tables,
-		usePlural: adapter?.options?.adapterConfig?.usePlural
-	});
-	initGetFieldName({
-		schema: tables,
-		usePlural: false
-	});
-	return {
-		code: await prettier.format(`// MongoDB schema setup
-// Generated from schema definitions
-// DO NOT EDIT MANUALLY - This file is auto-generated
-
-// Schema definitions for MongoDB collections
-// Use this file to set up your MongoDB collections and indexes
-`, { parser: "typescript" }),
-		fileName: filePath,
-		overwrite: true
-	};
-};
-
 //#endregion
 //#region src/generators/index.ts
 const adapters = {
 	prisma: generatePrismaSchema,
 	drizzle: generateDrizzleSchema,
-	kysely: generateKyselySchema,
-	mongodb: generateMongoDBSchema
+	kysely: generateKyselySchema
 };
 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-DyDUFaYK.mjs";
+import { i as getPackageInfo, n as generateSchema } from "./generators-CWgRQHR-.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.3.0",
+  "version": "0.3.2",
   "type": "module",
   "module": "dist/index.mjs",
   "main": "./dist/index.mjs",
@@ -64,8 +64,8 @@
     "dotenv": "^17.2.2",
     "drizzle-orm": "^0.33.0",
     "open": "^10.2.0",
-    "pecunia-core": "^0.1.4",
-    "pecunia-root": "^0.2.5",
+    "pecunia-core": "^0.1.6",
+    "pecunia-root": "^0.2.7",
     "pg": "^8.16.3",
     "prettier": "^3.6.2",
     "prompts": "^2.4.2",