prisma-trpc-generator/lib/prisma-generator.js

Prisma 2+ generator to emit fully implemented tRPC routers

"use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.generate = generate;
const internals_1 = require("@prisma/internals");
const fs_1 = require("fs");
const path_1 = __importDefault(require("path"));
const pluralize_1 = __importDefault(require("pluralize"));
const prisma_generator_1 = require("prisma-trpc-shield-generator/lib/prisma-generator");
const prisma_generator_2 = require("prisma-zod-generator/lib/prisma-generator");
const config_1 = require("./config");
const helpers_1 = require("./helpers");
const project_1 = require("./project");
const removeDir_1 = __importDefault(require("./utils/removeDir"));
async function generate(options) {
    const outputDir = (0, internals_1.parseEnvValue)(options.generator.output);
    const results = config_1.configSchema.safeParse(options.generator.config);
    if (!results.success)
        throw new Error('Invalid options passed');
    const config = results.data;
    await fs_1.promises.mkdir(outputDir, { recursive: true });
    await (0, removeDir_1.default)(outputDir, true);
    if (config.withZod) {
        await (0, prisma_generator_2.generate)(options);
    }
    if (config.withShield === true) {
        const shieldOutputPath = path_1.default.join(outputDir, './shield');
        await (0, prisma_generator_1.generate)({
            ...options,
            generator: {
                ...options.generator,
                output: {
                    ...options.generator.output,
                    value: shieldOutputPath,
                },
                config: {
                    ...options.generator.config,
                    contextPath: config.contextPath,
                },
            },
        });
    }
    const prismaClientProvider = options.otherGenerators.find((it) => {
        const provider = (0, internals_1.parseEnvValue)(it.provider);
        return provider === 'prisma-client-js' || provider === 'prisma-client';
    });
    if (!prismaClientProvider) {
        throw new Error('Prisma tRPC Generator requires a Prisma Client generator. Please add one of the following to your schema:\n\n' +
            'generator client {\n' +
            '  provider = "prisma-client-js"\n' +
            '}\n\n' +
            'OR\n\n' +
            'generator client {\n' +
            '  provider = "prisma-client"\n' +
            '  output   = "./generated/client"\n' +
            '}');
    }
    const prismaClientDmmf = await (0, internals_1.getDMMF)({
        datamodel: options.datamodel,
        previewFeatures: prismaClientProvider.previewFeatures,
    });
    const modelOperations = prismaClientDmmf.mappings.modelOperations;
    const models = prismaClientDmmf.datamodel.models;
    const hiddenModels = [];
    (0, helpers_1.resolveModelsComments)([...models], hiddenModels);
    const createRouter = project_1.project.createSourceFile(path_1.default.resolve(outputDir, 'routers', 'helpers', 'createRouter.ts'), undefined, { overwrite: true });
    (0, helpers_1.generatetRPCImport)(createRouter);
    if (config.withShield) {
        (0, helpers_1.generateShieldImport)(createRouter, options, config.withShield);
    }
    (0, helpers_1.generateBaseRouter)(createRouter, config, options);
    createRouter.formatText({
        indentSize: 2,
    });
    const appRouter = project_1.project.createSourceFile(path_1.default.resolve(outputDir, 'routers', `index.ts`), undefined, { overwrite: true });
    (0, helpers_1.generateCreateRouterImport)({
        sourceFile: appRouter,
    });
    const routerStatements = [];
    for (const modelOperation of modelOperations) {
        const { model, ...operations } = modelOperation;
        if (hiddenModels.includes(model))
            continue;
        const modelActions = Object.keys(operations).filter((opType) => {
            const baseOpType = opType.replace('One', '').replace('OrThrow', '');
            return config.generateModelActions.some(action => action === baseOpType);
        });
        if (!modelActions.length)
            continue;
        const plural = (0, pluralize_1.default)(model.toLowerCase());
        (0, helpers_1.generateRouterImport)(appRouter, plural, model);
        const modelRouter = project_1.project.createSourceFile(path_1.default.resolve(outputDir, 'routers', `${model}.router.ts`), undefined, { overwrite: true });
        (0, helpers_1.generateCreateRouterImport)({
            sourceFile: modelRouter,
            config,
        });
        if (config.withZod) {
            (0, helpers_1.generateRouterSchemaImports)(modelRouter, model, modelActions);
        }
        modelRouter.addStatements(/* ts */ `
      export const ${plural}Router = t.router({`);
        for (const opType of modelActions) {
            const opNameWithModel = operations[opType];
            const baseOpType = opType.replace('OrThrow', '');
            (0, helpers_1.generateProcedure)(modelRouter, opNameWithModel, (0, helpers_1.getInputTypeByOpName)(baseOpType, model), model, opType, baseOpType, config);
        }
        modelRouter.addStatements(/* ts */ `
    })`);
        modelRouter.formatText({ indentSize: 2 });
        routerStatements.push(/* ts */ `
      ${model.toLowerCase()}: ${plural}Router`);
    }
    appRouter.addStatements(/* ts */ `
    export const appRouter = t.router({${routerStatements}})
    `);
    appRouter.formatText({ indentSize: 2 });
    await project_1.project.save();
}
//# sourceMappingURL=prisma-generator.js.map