@tsed/prisma/lib/esm/generator/domain/DmmfModel.js

Generate Ts.ED JsonSchema based on Prisma models

import { toMap } from "@tsed/core";
import { pascalCase } from "change-case";
import { StructureKind } from "ts-morph";
import { resolveExtension } from "../utils/resolveExtension.js";
import { DmmfField } from "./DmmfField.js";
export class DmmfModel {
    #imports = new Map();
    constructor({ isInputType, model, modelType }) {
        this.model = model;
        this.modelType = modelType;
        this.isInputType = isInputType;
    }
    get name() {
        return this.model.name;
    }
    get fields() {
        const dataField = toMap(this.modelType.fields, "name");
        return this.model.fields.map((field) => {
            return new DmmfField({
                model: this,
                field,
                schemaArg: dataField.get(field.name)
            });
        });
    }
    get importDeclarations() {
        return [...this.#imports.values()];
    }
    static getModels(dmmf, modelsMap, typesMap) {
        const inputObjectsTypes = dmmf.schema.inputObjectTypes.model || [];
        const outputObjectTypes = dmmf.schema.outputObjectTypes.model || [];
        const factory = (isInputType) => (modelType) => {
            let model = modelsMap.get(modelType.name) || typesMap?.get(modelType.name);
            if (model) {
                return new DmmfModel({
                    modelType,
                    model,
                    isInputType
                });
            }
            return undefined;
        };
        const inputs = inputObjectsTypes.map(factory(true)).filter(Boolean);
        const outputs = outputObjectTypes.map(factory(false)).filter(Boolean);
        return [...inputs, ...outputs];
    }
    static symbolName(name) {
        return pascalCase(`${name}Model`);
    }
    addImportDeclaration(moduleSpecifier, name, isTypeOnly = false) {
        moduleSpecifier = resolveExtension(moduleSpecifier);
        if (!this.#imports.has(moduleSpecifier)) {
            this.#imports.set(moduleSpecifier, {
                kind: StructureKind.ImportDeclaration,
                moduleSpecifier: moduleSpecifier,
                namedImports: [],
                isTypeOnly
            });
        }
        const moduleDeclaration = this.#imports.get(moduleSpecifier);
        const nameImports = moduleDeclaration.namedImports;
        if (!nameImports.includes(name)) {
            nameImports.push(name);
            moduleDeclaration.namedImports = nameImports.sort();
        }
        return this;
    }
    toString() {
        return DmmfModel.symbolName(this.name);
    }
}