@stryke/prisma-trpc-generator
Version:
A fork of the prisma-trpc-generator code to work in ESM with Prisma v6.
186 lines (183 loc) • 9.79 kB
JavaScript
const require_runtime = require('./_virtual/_rolldown/runtime.cjs');
const require_lower_case_first = require('./string-format/src/lower-case-first.cjs');
const require_config = require('./config.cjs');
const require_project = require('./project.cjs');
const require_get_prisma_internals = require('./utils/get-prisma-internals.cjs');
const require_helpers = require('./helpers.cjs');
const require_write_file_safely = require('./utils/write-file-safely.cjs');
const require_aggregate_helpers = require('./zod/aggregate-helpers.cjs');
const require_comments_helpers = require('./zod/comments-helpers.cjs');
const require_transformer = require('./zod/transformer.cjs');
const require_generator_helpers = require('./zod/generator-helpers.cjs');
const require_helpers$1 = require('./zod/helpers.cjs');
let _stryke_fs_exists = require("@stryke/fs/exists");
let _stryke_fs_helpers = require("@stryke/fs/helpers");
let _stryke_path_join_paths = require("@stryke/path/join-paths");
let node_path = require("node:path");
node_path = require_runtime.__toESM(node_path, 1);
let pluralize = require("pluralize");
pluralize = require_runtime.__toESM(pluralize, 1);
//#region src/prisma-generator.ts
async function generate(options) {
console.log("[STORM]: Running the Storm Software - Prisma tRPC generator \n");
const internals = await require_get_prisma_internals.getPrismaInternals();
console.log(`[STORM]: Validating configuration options \n`);
const outputDir = internals.parseEnvValue(options.generator.output);
const results = await require_config.configSchema.safeParseAsync(options.generator.config);
if (!results.success) throw new Error("Invalid options passed");
const config = results.data;
const consoleLog = (message) => {
if (config.debug) console.log(`[STORM]: ${message} \n`);
};
consoleLog(`Using configuration parameters: \n${JSON.stringify(config)}`);
consoleLog(`Preparing output directory: ${outputDir}`);
await (0, _stryke_fs_helpers.removeDirectory)(outputDir);
await (0, _stryke_fs_helpers.createDirectory)(outputDir);
consoleLog("Finding Prisma Client generator");
const prismaClientProvider = options.otherGenerators.find((it) => internals.parseEnvValue(it.provider) === "prisma-client-js");
if (!prismaClientProvider) throw new Error("No Prisma Client generator found. Please add `prisma-client-js` to your generator list.");
consoleLog("Generating Prisma Client DMMF");
const prismaClientDmmf = await internals.getDMMF({
datamodel: options.datamodel,
previewFeatures: prismaClientProvider?.previewFeatures
});
const modelOperations = prismaClientDmmf.mappings.modelOperations;
const inputObjectTypes = prismaClientDmmf.schema.inputObjectTypes.prisma;
const outputObjectTypes = prismaClientDmmf.schema.outputObjectTypes.prisma;
const enumTypes = prismaClientDmmf.schema.enumTypes;
const models = prismaClientDmmf.datamodel.models;
const hiddenModels = [];
const hiddenFields = [];
if (config.withZod !== false) {
consoleLog("Generating Zod schemas");
const zodOutputPath = internals.parseEnvValue(options.generator.output);
await (0, _stryke_fs_helpers.createDirectory)(zodOutputPath);
require_transformer.default.setOutputPath(zodOutputPath);
if (prismaClientProvider?.isCustomOutput) require_transformer.default.setPrismaClientOutputPath(prismaClientProvider.output?.value);
await require_helpers.constructZodModels(models, (0, _stryke_path_join_paths.joinPaths)(zodOutputPath, "schemas", "models"), config, options);
require_comments_helpers.resolveZodModelsComments(models, modelOperations, enumTypes, hiddenModels, hiddenFields);
await require_generator_helpers.generateZodEnumSchemas(enumTypes.prisma, enumTypes.model);
const dataSource = options.datasources?.[0];
if (!dataSource) throw new Error("No datasource found");
const previewFeatures = prismaClientProvider?.previewFeatures;
require_transformer.default.provider = dataSource.provider;
require_transformer.default.previewFeatures = previewFeatures;
require_helpers$1.addMissingZodInputObjectTypes(inputObjectTypes, outputObjectTypes, models, modelOperations, dataSource.provider, {
isGenerateSelect: true,
isGenerateInclude: true
});
const aggregateOperationSupport = require_aggregate_helpers.resolveZodAggregateOperationSupport(inputObjectTypes);
require_comments_helpers.hideZodInputObjectTypesAndRelatedFields(inputObjectTypes, hiddenModels, hiddenFields);
await require_generator_helpers.generateZodObjectSchemas(inputObjectTypes);
await require_generator_helpers.generateZodModelSchemas(models, modelOperations, aggregateOperationSupport);
await require_generator_helpers.generateZodIndex();
} else consoleLog("Skipping Zod schemas generation");
const queries = [];
const mutations = [];
const subscriptions = [];
prismaClientDmmf.mappings.modelOperations.forEach((modelOperation) => {
const { model: _model, plural: _plural, ...operations } = modelOperation;
for (const [opType, opNameWithModel] of Object.entries(operations)) {
if ([
"findUnique",
"findUniqueOrThrow",
"findFirst",
"findFirstOrThrow",
"findRaw",
"findMany",
"aggregateRaw",
"count",
"aggregate",
"groupBy"
].includes(opType)) queries.push(opNameWithModel);
if ([
"createOne",
"createMany",
"createManyAndReturn",
"deleteOne",
"deleteMany",
"updateOne",
"updateMany",
"updateManyAndReturn",
"upsertOne"
].includes(opType)) mutations.push(opNameWithModel);
}
});
queries.sort();
mutations.sort();
subscriptions.sort();
if (config.withShield && !(typeof config.withShield === "string" && ((0, _stryke_fs_exists.existsSync)((0, _stryke_path_join_paths.joinPaths)(outputDir, config.withShield)) || (0, _stryke_fs_exists.existsSync)((0, _stryke_path_join_paths.joinPaths)(outputDir, `./${config.withShield}.ts`)) || (0, _stryke_fs_exists.existsSync)((0, _stryke_path_join_paths.joinPaths)(outputDir, config.withShield, "./shield.ts"))))) {
consoleLog(`Generating tRPC Shield source file to ${outputDir}`);
await require_write_file_safely.writeFileSafely((0, _stryke_path_join_paths.joinPaths)(outputDir, "./shield.ts"), await require_helpers.constructShield({
queries,
mutations,
subscriptions
}, config, options, outputDir));
} else consoleLog("Skipping tRPC Shield generation");
consoleLog(`Generating tRPC source code for ${models.length} models`);
if (config.trpcOptions && typeof config.trpcOptions === "boolean") {
consoleLog(`Generating tRPC options source file to ${outputDir}`);
await require_write_file_safely.writeFileSafely((0, _stryke_path_join_paths.joinPaths)(outputDir, "./options.ts"), require_helpers.constructDefaultOptions(config, options, outputDir));
}
require_helpers.resolveModelsComments(models, hiddenModels);
consoleLog("Generating tRPC export file");
await require_helpers.generateTRPCExports(require_project.project.createSourceFile(node_path.default.resolve(outputDir, "trpc.ts"), void 0, { overwrite: true }), config, options, outputDir);
consoleLog("Generating tRPC app router");
const appRouter = require_project.project.createSourceFile(node_path.default.resolve(outputDir, "routers", `index.ts`), void 0, { overwrite: true });
consoleLog("Generating tRPC router imports");
require_helpers.generateCreateRouterImport({ sourceFile: appRouter });
const routerStatements = [];
for (const modelOperation of modelOperations) {
const { model, ...operations } = modelOperation;
if (hiddenModels.includes(model)) {
consoleLog(`Skipping model ${model} as it is hidden`);
continue;
}
if (!model) {
consoleLog(`Skipping model ${model} as it is not defined`);
continue;
}
const modelActions = Object.keys(operations).filter((opType) => config.generateModelActions.some((generateModelAction) => generateModelAction === opType.replace("One", "")));
if (!modelActions.length) {
consoleLog(`Skipping model ${model} as it has no actions to generate`);
continue;
}
const plural = (0, pluralize.default)(require_lower_case_first.lowerCaseFirst(model));
consoleLog(`Generating tRPC router for model ${model}`);
require_helpers.generateRouterImport(appRouter, plural, model);
const modelRouter = require_project.project.createSourceFile(node_path.default.resolve(outputDir, "routers", `${require_lower_case_first.lowerCaseFirst(model)}.router.ts`), void 0, { overwrite: true });
require_helpers.generateCreateRouterImport({
sourceFile: modelRouter,
config
});
if (config.withZod) {
consoleLog("Generating Zod schemas imports");
require_helpers.generateRouterSchemaImports(modelRouter, model, modelActions);
}
modelRouter.addStatements(`
export const ${plural}Router = t.router({`);
for (const opType of modelActions) {
const opNameWithModel = operations[opType];
if (opNameWithModel) {
const baseOpType = opType.replace("OrThrow", "");
require_helpers.generateProcedure(modelRouter, opNameWithModel, require_helpers.getInputTypeByOpName(baseOpType, model), model, opType, baseOpType, config);
}
}
modelRouter.addStatements(`
})`);
modelRouter.formatText({ indentSize: 2 });
routerStatements.push(`
${require_lower_case_first.lowerCaseFirst(model)}: ${plural}Router`);
consoleLog(`Generated tRPC router for model ${model} with ${modelActions.length} actions`);
}
consoleLog("Generating tRPC app router");
appRouter.addStatements(`
export const appRouter = t.router({${routerStatements.join()}});
export type AppRouter = typeof appRouter;`);
appRouter.formatText({ indentSize: 2 });
consoleLog("Saving tRPC router source files to disk");
await require_project.project.save();
consoleLog("Storm Software - Prisma tRPC generator completed successfully");
}
//#endregion
exports.generate = generate;