hekireki 0.8.1 → 0.8.2

package/README.md

@@ -712,6 +712,25 @@ generator Hekireki-PNG {
 }
 ```
 
+### Logical Relations (without a Foreign Key)
+
+To draw a relation that has **no physical foreign key**, add a `/// @relation <Parent>.<field> <Child>.<field> <cardinality>` doc-comment on the model:
+
+```prisma
+model User {
+  id   String @id @default(uuid())
+  name String
+}
+
+/// @relation User.id Post.userId one-to-many
+model Post {
+  id     String @id @default(uuid())
+  userId String
+}
+```
+
+The relation is drawn in both the Mermaid and DBML output even though `Post.userId` has no `@relation(...)` foreign key. When a physical FK and an annotation describe the same pair, the annotation's cardinality wins in the Mermaid diagram.
+
 ### Docs
 
 The `hekireki-docs` generator creates an HTML documentation page from your Prisma schema. Serve it locally with `hekireki docs serve`:

package/dist/bin/ajv.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { t as registerGenerator } from "../bin-BqlsEIc6.js";
+import { t as registerGenerator } from "../bin-B_9WDdSx.js";
 //#region src/bin/ajv.ts
 registerGenerator("ajv");
 //#endregion

package/dist/bin/arktype.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { t as registerGenerator } from "../bin-BqlsEIc6.js";
+import { t as registerGenerator } from "../bin-B_9WDdSx.js";
 //#region src/bin/arktype.ts
 registerGenerator("arktype");
 //#endregion

package/dist/bin/dbml.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { t as registerGenerator } from "../bin-BqlsEIc6.js";
+import { t as registerGenerator } from "../bin-B_9WDdSx.js";
 //#region src/bin/dbml.ts
 registerGenerator("dbml");
 //#endregion

package/dist/bin/docs.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { t as registerGenerator } from "../bin-BqlsEIc6.js";
+import { t as registerGenerator } from "../bin-B_9WDdSx.js";
 //#region src/bin/docs.ts
 registerGenerator("docs");
 //#endregion

package/dist/bin/drizzle.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { t as registerGenerator } from "../bin-BqlsEIc6.js";
+import { t as registerGenerator } from "../bin-B_9WDdSx.js";
 //#region src/bin/drizzle.ts
 registerGenerator("drizzle");
 //#endregion

package/dist/bin/ecto.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { t as registerGenerator } from "../bin-BqlsEIc6.js";
+import { t as registerGenerator } from "../bin-B_9WDdSx.js";
 //#region src/bin/ecto.ts
 registerGenerator("ecto");
 //#endregion

package/dist/bin/effect.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { t as registerGenerator } from "../bin-BqlsEIc6.js";
+import { t as registerGenerator } from "../bin-B_9WDdSx.js";
 //#region src/bin/effect.ts
 registerGenerator("effect");
 //#endregion

package/dist/bin/gorm.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { t as registerGenerator } from "../bin-BqlsEIc6.js";
+import { t as registerGenerator } from "../bin-B_9WDdSx.js";
 //#region src/bin/gorm.ts
 registerGenerator("gorm");
 //#endregion

package/dist/bin/mermaid-er.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { t as registerGenerator } from "../bin-BqlsEIc6.js";
+import { t as registerGenerator } from "../bin-B_9WDdSx.js";
 //#region src/bin/mermaid-er.ts
 registerGenerator("mermaid-er");
 //#endregion

package/dist/bin/sea-orm.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { t as registerGenerator } from "../bin-BqlsEIc6.js";
+import { t as registerGenerator } from "../bin-B_9WDdSx.js";
 //#region src/bin/sea-orm.ts
 registerGenerator("sea-orm");
 //#endregion

package/dist/bin/sqlalchemy.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { t as registerGenerator } from "../bin-BqlsEIc6.js";
+import { t as registerGenerator } from "../bin-B_9WDdSx.js";
 //#region src/bin/sqlalchemy.ts
 registerGenerator("sqlalchemy");
 //#endregion

package/dist/bin/typebox.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { t as registerGenerator } from "../bin-BqlsEIc6.js";
+import { t as registerGenerator } from "../bin-B_9WDdSx.js";
 //#region src/bin/typebox.ts
 registerGenerator("typebox");
 //#endregion

package/dist/bin/valibot.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { t as registerGenerator } from "../bin-BqlsEIc6.js";
+import { t as registerGenerator } from "../bin-B_9WDdSx.js";
 //#region src/bin/valibot.ts
 registerGenerator("valibot");
 //#endregion

package/dist/bin/zod.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { t as registerGenerator } from "../bin-BqlsEIc6.js";
+import { t as registerGenerator } from "../bin-B_9WDdSx.js";
 //#region src/bin/zod.ts
 registerGenerator("zod");
 //#endregion

package/dist/{bin-BqlsEIc6.js → bin-B_9WDdSx.js}

@@ -124,6 +124,18 @@ async function emitMany(files, dir) {
 }
 //#endregion
 //#region src/utils/index.ts
+function parseRelation(line) {
+	const match = line.trim().match(/^@relation\s+(\w+)\.(\w+)\s+(\w+)\.(\w+)\s+(\w+-to-\w+)$/);
+	if (!match) return null;
+	const [, fromModel, fromField, toModel, toField, type] = match;
+	return {
+		fromModel,
+		fromField,
+		toModel,
+		toField,
+		type
+	};
+}
 function getString(v, fallback) {
 	return typeof v === "string" ? v : Array.isArray(v) ? v[0] ?? fallback : fallback;
 }
@@ -436,6 +448,68 @@ async function arktype(options) {
 	return emit(arktypeCode(options.dmmf, getBool(options.generator.config?.type), getBool(options.generator.config?.comment), getBool(options.generator.config?.relation)), resolved.dir, resolved.file);
 }
 //#endregion
+//#region src/helper/relation.ts
+function isCardinality(value) {
+	return value === "zero-one" || value === "one" || value === "zero-many" || value === "many";
+}
+function erKey(relation) {
+	return `${relation.from.model}.${relation.from.field}->${relation.to.model}.${relation.to.field}`;
+}
+function inferredERRelations(models) {
+	return models.flatMap((model) => model.fields.filter((field) => field.kind === "object" && field.relationFromFields && field.relationFromFields.length > 0).map((field) => {
+		const toModel = model.name;
+		const fromModel = field.type;
+		const toField = field.relationFromFields?.[0] ?? "";
+		const fromField = field.relationToFields?.[0] ?? "id";
+		const toCardinality = (models.find((m) => m.name === fromModel)?.fields.find((f) => f.relationName === field.relationName && f.name !== field.name))?.isList ? field.isRequired ? "many" : "zero-many" : field.isRequired ? "one" : "zero-one";
+		return {
+			from: {
+				model: fromModel,
+				field: fromField,
+				cardinality: "one"
+			},
+			to: {
+				model: toModel,
+				field: toField,
+				cardinality: toCardinality
+			},
+			identifying: true,
+			origin: "inferred"
+		};
+	}));
+}
+function annotatedERRelations(models) {
+	return models.flatMap((model) => (model.documentation ?? "").split("\n").flatMap((line) => {
+		const relation = parseRelation(line);
+		if (relation === null) return [];
+		const [fromCard, toCard] = relation.type.split("-to-");
+		if (!isCardinality(fromCard) || !isCardinality(toCard)) return [];
+		return [{
+			from: {
+				model: relation.fromModel,
+				field: relation.fromField,
+				cardinality: fromCard
+			},
+			to: {
+				model: relation.toModel,
+				field: relation.toField,
+				cardinality: toCard
+			},
+			identifying: true,
+			origin: "annotated"
+		}];
+	}));
+}
+function mergeERRelations(models) {
+	const inferred = inferredERRelations(models);
+	const annotated = annotatedERRelations(models);
+	const inferredKeys = new Set(inferred.map(erKey));
+	return [...new Map([...inferred.map((r) => [erKey(r), r]), ...annotated.map((r) => [erKey(r), inferredKeys.has(erKey(r)) ? {
+		...r,
+		origin: "inferred"
+	} : r])]).values()];
+}
+//#endregion
 //#region src/helper/dbml.ts
 function escapeNote(str) {
 	return str.replace(/'/g, "\\'");
@@ -552,16 +626,36 @@ function makeRelations$1(models, mapToDbSchema = false) {
 		});
 	}));
 }
+function isMany(cardinality) {
+	return cardinality === "many" || cardinality === "zero-many";
+}
+function dbmlOperator(leftMany, rightMany) {
+	if (leftMany && !rightMany) return ">";
+	if (!leftMany && rightMany) return "<";
+	if (leftMany && rightMany) return "<>";
+	return "-";
+}
+function annotatedDbmlRefs(models) {
+	const inferredKeys = new Set(inferredERRelations(models).map(erKey));
+	return annotatedERRelations(models).filter((relation) => !inferredKeys.has(erKey(relation))).map((relation) => {
+		const left = `${relation.to.model}.${relation.to.field}`;
+		const right = `${relation.from.model}.${relation.from.field}`;
+		const operator = dbmlOperator(isMany(relation.to.cardinality), isMany(relation.from.cardinality));
+		return `Ref ${`${relation.to.model}_${relation.to.field}_${relation.from.model}_${relation.from.field}`}: ${left} ${operator} ${right}`;
+	});
+}
 //#endregion
 //#region src/generator/dbml.ts
 function dbmlContent(datamodel, mapToDbSchema = false) {
 	const tables = makeTables(datamodel.models, mapToDbSchema);
 	const enums = makeEnums(datamodel.enums);
 	const refs = makeRelations$1(datamodel.models, mapToDbSchema);
+	const logicalRefs = annotatedDbmlRefs(datamodel.models);
 	return [
 		...enums,
 		...tables,
-		...refs
+		...refs,
+		...logicalRefs
 	].join("\n\n");
 }
 function dbmlToPng(dbml) {
@@ -2235,7 +2329,7 @@ async function ecto(options) {
 //#endregion
 //#region src/helper/effect.ts
 function makeEffectInfer(modelName) {
-	return `export type ${modelName}Encoded = typeof ${modelName}Schema.Encoded`;
+	return `export type ${modelName} = typeof ${modelName}Schema.Type`;
 }
 function makeEffectSchema(modelName, fields) {
 	return `export const ${modelName}Schema = Schema.Struct({\n${fields}\n})`;
@@ -2266,7 +2360,7 @@ function makeEffectRelations(model, relProps, options) {
 	if (relProps.length === 0) return null;
 	const base = `...${model.name}Schema.fields,`;
 	const rels = relProps.map((r) => `${r.key}:${r.isMany ? `Schema.Array(${r.targetModel}Schema)` : `${r.targetModel}Schema`},`).join("");
-	const typeLine = options?.includeType ? `\n\nexport type ${model.name}RelationsEncoded = typeof ${model.name}RelationsSchema.Encoded` : "";
+	const typeLine = options?.includeType ? `\n\nexport type ${model.name}Relations = typeof ${model.name}RelationsSchema.Type` : "";
 	return `export const ${model.name}RelationsSchema = Schema.Struct({${base}${rels}})${typeLine}`;
 }
 function effectSchemaCode(models, type, comment, enums) {
@@ -2623,15 +2717,15 @@ async function gorm(options) {
 }
 //#endregion
 //#region src/helper/mermaid-er.ts
-function removeDuplicateRelations(relations) {
-	return [...new Set(relations)];
-}
 const RELATIONSHIPS = {
 	"zero-one": "|o",
 	one: "||",
 	"zero-many": "}o",
 	many: "}|"
 };
+function erRelationLine(relation) {
+	return `    ${relation.from.model} ${RELATIONSHIPS[relation.from.cardinality]}--${RELATIONSHIPS[relation.to.cardinality]} ${relation.to.model} : "(${relation.from.field}) - (${relation.to.field})"`;
+}
 function modelFields(model) {
 	const fkFields = new Set(model.fields.filter((f) => f.relationFromFields && f.relationFromFields.length > 0).flatMap((f) => f.relationFromFields ?? []));
 	return model.fields.map((field) => {
@@ -2649,26 +2743,16 @@ function modelInfo(model) {
 		"    }"
 	];
 }
-function extractRelationsFromDmmf(models) {
-	return models.flatMap((model) => model.fields.filter((field) => field.kind === "object" && field.relationFromFields && field.relationFromFields.length > 0).map((field) => {
-		const toModel = model.name;
-		const fromModel = field.type;
-		const toField = field.relationFromFields?.[0];
-		const fromField = field.relationToFields?.[0] ?? "id";
-		const toCardinality = (models.find((m) => m.name === fromModel)?.fields.find((f) => f.relationName === field.relationName && f.name !== field.name))?.isList ? field.isRequired ? "many" : "zero-many" : field.isRequired ? "one" : "zero-one";
-		return `    ${fromModel} ${RELATIONSHIPS.one}--${RELATIONSHIPS[toCardinality]} ${toModel} : "(${fromField}) - (${toField})"`;
-	}));
-}
 //#endregion
 //#region src/generator/mermaid-er.ts
 const ER_HEADER = ["```mermaid", "erDiagram"];
 const ER_FOOTER = ["```"];
 function erContent(models) {
-	const uniqueRelations = removeDuplicateRelations(extractRelationsFromDmmf(models));
+	const relations = mergeERRelations(models).map(erRelationLine);
 	const modelInfos = models.flatMap(modelInfo);
 	return [
 		...ER_HEADER,
-		...uniqueRelations,
+		...relations,
 		...modelInfos,
 		...ER_FOOTER
 	];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hekireki",
-  "version": "0.8.1",
+  "version": "0.8.2",
   "description": "Hekireki is a tool that generates validation schemas for Zod, Valibot, ArkType, and Effect Schema, as well as ER diagrams and DBML, from Prisma schemas annotated with comments.",
   "keywords": [
     "ajv",