prisma-markdown/lib/writers/MermaidWriter.js

Prisma Markdown documents generator including ERD diagrams and comment descriptions

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.MermaidWriter = void 0;
const PrismaUtil_1 = require("../utils/PrismaUtil");
const field_util_1 = require("../utils/field-util");
var MermaidWriter;
(function (MermaidWriter) {
    MermaidWriter.write = (chapter) => [
        "```mermaid",
        "erDiagram",
        ...chapter.map(writeTable),
        ...chapter
            .map((model) => model.fields
            .filter((f) => f.kind === "object")
            .map(writeRelationship({ group: chapter, model })))
            .flat()
            .filter((str) => !!str.length),
        "```",
    ].join("\n");
    const writeTable = (model) => {
        var _a;
        return [
            `${JSON.stringify((_a = model.dbName) !== null && _a !== void 0 ? _a : model.name)} {`,
            ...model.fields
                .filter((f) => f.kind !== "object")
                .map(writeField(model))
                .map((str) => `  ${str}`),
            "}",
        ].join("\n");
    };
    const writeField = (model) => (field) => {
        const isFK = model.fields.some((f) => { var _a; return f.kind === "object" && ((_a = f.relationFromFields) === null || _a === void 0 ? void 0 : _a[0]) === field.name; });
        const targetField = (0, field_util_1.FieldUtil)(field, isFK);
        return [
            targetField.data().size
                ? targetField.format("t(s)")
                : targetField.format("t"),
            targetField.format("n"),
            targetField.format("k"),
            targetField.format("r"),
        ]
            .filter((str) => !!str.length)
            .join(" ");
    };
    const writeRelationship = (props) => (field) => {
        var _a, _b, _c;
        if (!((_a = field.relationFromFields) === null || _a === void 0 ? void 0 : _a.length))
            return "";
        const column = field.relationFromFields[0];
        const scalar = props.model.fields.find((s) => column === s.dbName || column === s.name);
        if (scalar === undefined)
            return "";
        const target = props.group.find((t) => t.name === field.type);
        if (target === undefined)
            return "";
        const oneToOne = scalar.isId || scalar.isUnique;
        const arrow = [
            oneToOne ? "|" : "}",
            oneToOne &&
                props.group.some((m) => m.name === field.type &&
                    m.fields.some((f) => f.relationName === field.relationName && !f.isRequired))
                ? "o"
                : isMandatoryMany({ model: props.model, field, target })
                    ? "|"
                    : "o",
            "--",
            scalar.isRequired ? "|" : "o",
            "|",
        ].join("");
        return [
            JSON.stringify((_b = props.model.dbName) !== null && _b !== void 0 ? _b : props.model.name),
            arrow,
            JSON.stringify((_c = target.dbName) !== null && _c !== void 0 ? _c : target.name),
            ":",
            field.name,
        ].join(" ");
    };
    const isMandatoryMany = (props) => {
        const opposite = props.target.fields.find((f) => f.relationName === props.field.relationName &&
            f.type === props.model.name);
        if (opposite === undefined)
            return false;
        const values = PrismaUtil_1.PrismaUtil.tagValues("minItems")(opposite);
        if (values.length === 0)
            return false;
        const numeric = Number(values[0]);
        return !isNaN(numeric) && numeric >= 1;
    };
})(MermaidWriter || (exports.MermaidWriter = MermaidWriter = {}));
//# sourceMappingURL=MermaidWriter.js.map