@nonsoo/prisma-mermaid 0.1.0

package/build/index.js

@@ -0,0 +1,345 @@
+// src/lib/MermaidClass/prismaMermaidClass.ts
+import pkg from "@prisma/internals";
+import { readFileSync, writeFileSync, mkdirSync } from "fs";
+import path from "path";
+
+// src/constants/mermaid.ts
+var mermaidERDiagramConfig = {
+  theme: "neutral",
+  themeVariables: {
+    fontSize: "20px",
+    fontFamily: "Arial",
+    padding: "12px",
+    lineHeight: "1.4"
+  },
+  flowchart: {
+    nodeSpacing: 80,
+    rankSpacing: 120,
+    htmlLabels: true
+  }
+};
+var mermaidClassDiagramConfig = {
+  theme: "neutral",
+  themeVariables: {
+    fontFamily: "Arial",
+    lineHeight: "1.4"
+  },
+  flowchart: {
+    nodeSpacing: 300,
+    rankSpacing: 120,
+    htmlLabels: true
+  },
+  class: {
+    hideEmptyMembersBox: true
+  }
+};
+var DEFAULT_BASE_NODE_SPACING = 100;
+var DEFAULT_BASE_EDGE_SPACING = 150;
+
+// src/utils/mermaid.ts
+var generateDiagramSpacing = ({
+  baseEdge,
+  baseNode,
+  models
+}) => {
+  const totalFields = models.reduce((sum, m) => sum + m.fields.length, 0);
+  const totalRelations = models.reduce(
+    (sum, m) => sum + m.fields.filter((f) => f.relationName && f.relationFromFields?.length).length,
+    0
+  );
+  return {
+    nodeSpacing: baseNode + models.length * 6 + totalFields * 2,
+    edgeSpacing: baseEdge + models.length * 4 + totalRelations * 4
+  };
+};
+var generateMermaidConfig = (config, models) => {
+  if (config["themeVariables"]) {
+    const { edgeSpacing, nodeSpacing } = generateDiagramSpacing({
+      baseEdge: DEFAULT_BASE_EDGE_SPACING,
+      baseNode: DEFAULT_BASE_NODE_SPACING,
+      models
+    });
+    config["themeVariables"] = {
+      ...config["themeVariables"],
+      edgeSpacing,
+      nodeSpacing
+    };
+  }
+  const json = JSON.stringify(config, null, 2);
+  return `%%{init: ${json}}%%
+`;
+};
+
+// src/lib/MermaidClass/utils.ts
+var generateCardinality = ({
+  isList,
+  isRequired
+}) => {
+  if (isList) return '"*"';
+  return isRequired ? '"1"' : '"0..1"';
+};
+var generateRelationships = ({
+  relationships
+}) => {
+  const lines = [];
+  for (const relName in relationships) {
+    const sides = relationships[relName];
+    if (!sides) continue;
+    if (sides.length === 1) {
+      const a = sides[0];
+      if (!a) continue;
+      lines.push(
+        `${a.model} ${generateCardinality({
+          isList: a.isList,
+          isRequired: a.isRequired
+        })} --> "1" ${a.fieldType} : ${relName}`
+      );
+    } else if (sides.length === 2) {
+      const a = sides[0];
+      const b = sides[1];
+      if (!a || !b) continue;
+      lines.push(
+        `${a.model} ${generateCardinality({
+          isList: a.isList,
+          isRequired: a.isRequired
+        })} --> ${generateCardinality({
+          isList: b.isList,
+          isRequired: b.isRequired
+        })} ${b.model} : ${relName}`
+      );
+    } else {
+      for (let i = 1; i < sides.length; i++) {
+        const a = sides[0];
+        const b = sides[i];
+        if (!a || !b) continue;
+        lines.push(
+          `${a.model} ${generateCardinality({
+            isList: a.isList,
+            isRequired: a.isRequired
+          })} --> ${generateCardinality({
+            isList: b.isList,
+            isRequired: b.isRequired
+          })} ${b.model} : ${relName}`
+        );
+      }
+    }
+  }
+  return lines;
+};
+
+// src/lib/MermaidClass/prismaMermaidClass.ts
+var { getDMMF } = pkg;
+var generateDiagram = async ({
+  outputPath,
+  schemaPath,
+  generatorPrismaDocument
+}) => {
+  const outputDir = outputPath ? path.resolve(outputPath) : path.join(`${process.cwd()}/src/generated/diagrams`);
+  try {
+    const prismaDocument = generatorPrismaDocument ?? await getDMMF({
+      datamodel: readFileSync(schemaPath, "utf-8")
+    });
+    const models = prismaDocument.datamodel.models;
+    const enums = prismaDocument.datamodel.enums;
+    const mermaidLines = [
+      "%% --------------------------------------------",
+      "%% Auto-generated Mermaid Class Diagram.  Do Not Edit Directly.",
+      "%% --------------------------------------------\n",
+      generateMermaidConfig(mermaidClassDiagramConfig, models),
+      "classDiagram"
+    ];
+    const relationships = {};
+    models.forEach((model) => {
+      mermaidLines.push(`class ${model.name} {`);
+      model.fields.forEach((field) => {
+        mermaidLines.push(`  ${field.type} ${field.name}`);
+        if (field.relationName) {
+          if (!relationships[field.relationName]) {
+            relationships[field.relationName] = [];
+          }
+          relationships[field.relationName].push({
+            model: model.name,
+            fieldType: field.type,
+            isList: field.isList ?? false,
+            isRequired: field.isRequired ?? false
+          });
+        }
+      });
+      mermaidLines.push("}");
+    });
+    enums.forEach((enumDef) => {
+      mermaidLines.push(`class ${enumDef.name} {`);
+      enumDef.values.forEach((val) => {
+        mermaidLines.push(`  <<enumeration>> ${val.name}`);
+      });
+      mermaidLines.push("}");
+    });
+    const relationLines = generateRelationships({ relationships });
+    const output = mermaidLines.concat(relationLines).join("\n");
+    mkdirSync(outputDir, { recursive: true });
+    const outFile = path.join(outputDir, "mermaidClassDiagram.mmd");
+    writeFileSync(outFile, output, "utf-8");
+    console.log(`Mermaid Class Diagram written to: ${outFile}`);
+    return outFile;
+  } catch (e) {
+    console.error("Failed to generate Mermaid Class Diagram.", e);
+    return "";
+  }
+};
+
+// src/lib/MermaidERD/prismaMermaidErd.ts
+import pkg2 from "@prisma/internals";
+import { readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "fs";
+import { mkdirSync as mkdirSync2 } from "fs";
+import path2 from "path";
+
+// src/lib/MermaidERD/utils.ts
+var generateCardinality2 = ({
+  isList,
+  isRequired
+}) => {
+  if (isList) {
+    return "}|";
+  }
+  return isRequired ? "||" : "o|";
+};
+var getKeyConstraints = (isId, fieldName, foreignKeys, nativeTypes) => {
+  if (isId) return "PK";
+  if (nativeTypes) {
+    const allNativeTypes = nativeTypes.flatMap((nativeType) => nativeType);
+    if (!isId && allNativeTypes.includes("UniqueIdentifier")) {
+      return "FK";
+    }
+  }
+  if (!isId && foreignKeys.has(fieldName)) return "FK";
+  return "";
+};
+var getOptionalitySymbol = (isRequired) => {
+  return isRequired ? "" : `"?"`;
+};
+var generateRelationships2 = ({
+  relationships
+}) => {
+  const relationLines = [];
+  for (const relName in relationships) {
+    const sides = relationships[relName];
+    if (!sides) continue;
+    if (sides.length === 1) {
+      const a = sides[0];
+      if (!a) continue;
+      relationLines.push(
+        `	${a.model} ${generateCardinality2({
+          isList: a.isList,
+          isRequired: a.isRequired
+        })}--${generateCardinality2({ isList: false, isRequired: true })} ${a.fieldType} : ${relName}`
+      );
+    } else if (sides.length === 2) {
+      const a = sides[0];
+      const b = sides[1];
+      if (!a || !b) continue;
+      relationLines.push(
+        `	${a.model} ${generateCardinality2({
+          isList: a.isList,
+          isRequired: a.isRequired
+        })}--${generateCardinality2({
+          isList: b.isList,
+          isRequired: b.isRequired
+        })} ${b.model} : ${relName}`
+      );
+    } else {
+      for (let i = 1; i < sides.length; i++) {
+        const a = sides[0];
+        const b = sides[i];
+        if (!a || !b) continue;
+        relationLines.push(
+          `	${a.model} ${generateCardinality2({
+            isList: a.isList,
+            isRequired: a.isRequired
+          })}--${generateCardinality2({
+            isList: b.isList,
+            isRequired: b.isRequired
+          })} ${b.model} : ${relName}`
+        );
+      }
+    }
+  }
+  return relationLines;
+};
+
+// src/lib/MermaidERD/prismaMermaidErd.ts
+var { getDMMF: getDMMF2 } = pkg2;
+var generateDiagram2 = async ({
+  outputPath,
+  schemaPath,
+  generatorPrismaDocument
+}) => {
+  const outputDir = outputPath ? path2.resolve(outputPath) : path2.join(`${process.cwd()}/src/generated/diagrams`);
+  try {
+    const prismaDocument = generatorPrismaDocument ?? await getDMMF2({
+      datamodel: readFileSync2(schemaPath, "utf-8")
+    });
+    const schemaModels = prismaDocument.datamodel.models;
+    const schemaEnums = prismaDocument.datamodel.enums;
+    console.dir(schemaEnums, { depth: null });
+    const mermaidLines = [
+      "%% --------------------------------------------",
+      "%% Auto-generated Mermaid ER Diagram. Do Not Edit Directly.",
+      "%% --------------------------------------------\n",
+      generateMermaidConfig(mermaidERDiagramConfig, schemaModels),
+      "erDiagram"
+    ];
+    const relationships = {};
+    schemaModels.forEach((model) => {
+      mermaidLines.push(`	${model.name} {`);
+      const foreignKeys = /* @__PURE__ */ new Set();
+      model.fields.forEach((field) => {
+        if (field.relationFromFields && field.relationFromFields.length > 0) {
+          field.relationFromFields.forEach((fk) => {
+            foreignKeys.add(fk);
+          });
+        }
+        mermaidLines.push(
+          `		${field.type} ${field.name} ${getKeyConstraints(
+            field.isId,
+            field.name,
+            foreignKeys,
+            field.nativeType
+          )} ${getOptionalitySymbol(field.isRequired)}`
+        );
+        if (field.relationName) {
+          if (!relationships[field.relationName]) {
+            relationships[field.relationName] = [];
+          }
+          relationships[field.relationName].push({
+            model: model.name,
+            fieldType: field.type,
+            isList: field.isList ?? false,
+            isRequired: field.isRequired ?? false
+          });
+        }
+      });
+      mermaidLines.push(`	}`);
+    });
+    schemaEnums.forEach((enumDef) => {
+      mermaidLines.push(`	${enumDef.name} {`);
+      enumDef.values.forEach((enumValue) => {
+        mermaidLines.push(`		${enumValue.name}`);
+      });
+      mermaidLines.push(`	}`);
+    });
+    const relationLines = generateRelationships2({ relationships });
+    const output = mermaidLines.concat(relationLines);
+    mkdirSync2(outputDir, { recursive: true });
+    const outFile = path2.join(outputDir, "mermaidErdDiagram.mmd");
+    writeFileSync2(outFile, output.join("\n"));
+    console.log(`Mermaid ERD generated at: ${outFile}`);
+    return outFile;
+  } catch {
+    console.error("Failed to generate Mermaid ER Diagram.");
+    return "";
+  }
+};
+export {
+  generateDiagram as generateMermaidClass,
+  generateDiagram2 as generateMermaidERD
+};