prisma-zod-generator
Version:
Prisma 2+ generator to emit Zod schemas from your Prisma schema
226 lines • 10.2 kB
JavaScript
;
var __importDefault = (this && this.__importDefault) || function (mod) {
return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.addMissingInputObjectTypesForSelect = addMissingInputObjectTypesForSelect;
const transformer_1 = __importDefault(require("../transformer"));
const include_helpers_1 = require("./include-helpers");
const model_helpers_1 = require("./model-helpers");
function addMissingInputObjectTypesForSelect(inputObjectTypes, outputObjectTypes, models) {
// In minimal mode, do not generate Select types at all
const cfg = transformer_1.default.getGeneratorConfig();
if ((cfg === null || cfg === void 0 ? void 0 : cfg.mode) === 'minimal') {
return;
}
// Filter models to only include enabled ones
const enabledModels = (0, model_helpers_1.getEnabledModels)(models);
// generate input object types necessary to support ModelSelect._count
const modelCountOutputTypes = getFilteredModelCountOutputTypes(outputObjectTypes);
const modelCountOutputTypeSelectInputObjectTypes = generateModelCountOutputTypeSelectInputObjectTypes(modelCountOutputTypes, models);
const modelCountOutputTypeArgsInputObjectTypes = generateModelCountOutputTypeArgsInputObjectTypes(modelCountOutputTypes, models);
const modelSelectInputObjectTypes = generateModelSelectInputObjectTypes(enabledModels);
const generatedInputObjectTypes = [
modelCountOutputTypeSelectInputObjectTypes,
modelCountOutputTypeArgsInputObjectTypes,
modelSelectInputObjectTypes,
].flat();
for (const inputObjectType of generatedInputObjectTypes) {
inputObjectTypes.push(inputObjectType);
}
}
function getModelCountOutputTypes(outputObjectTypes) {
return outputObjectTypes.filter(({ name }) => name.includes('CountOutputType'));
}
function getFilteredModelCountOutputTypes(outputObjectTypes) {
const modelCountOutputTypes = getModelCountOutputTypes(outputObjectTypes);
return modelCountOutputTypes.filter(({ name }) => {
// Extract model name from count output type (e.g., "UserCountOutputType" -> "User")
const modelName = name.replace('CountOutputType', '');
return (0, include_helpers_1.shouldGenerateIncludeForModel)(modelName);
});
}
function generateModelCountOutputTypeSelectInputObjectTypes(modelCountOutputTypes, models) {
const modelMap = new Map(models.map((model) => [model.name, model]));
const modelCountOutputTypeSelectInputObjectTypes = [];
for (const modelCountOutputType of modelCountOutputTypes) {
const { name: modelCountOutputTypeName, fields: modelCountOutputTypeFields } = modelCountOutputType;
const modelName = modelCountOutputTypeName.replace('CountOutputType', '');
const model = modelMap.get(modelName);
const modelCountOutputTypeSelectInputObjectType = {
name: `${modelCountOutputTypeName}Select`,
constraints: {
maxNumFields: null,
minNumFields: null,
},
fields: modelCountOutputTypeFields.map(({ name }) => {
const inputTypes = [
{
isList: false,
type: `Boolean`,
location: 'scalar',
},
];
if (model) {
const relationField = model.fields.find((field) => field.name === name && field.kind === 'object');
if (relationField) {
inputTypes.push({
isList: false,
type: `${modelCountOutputTypeName}Count${toPascalCase(name)}Args`,
location: 'inputObjectTypes',
namespace: 'prisma',
});
}
}
return {
name,
isRequired: false,
isNullable: false,
inputTypes,
};
}),
};
modelCountOutputTypeSelectInputObjectTypes.push(modelCountOutputTypeSelectInputObjectType);
}
return modelCountOutputTypeSelectInputObjectTypes;
}
function generateModelCountOutputTypeArgsInputObjectTypes(modelCountOutputTypes, models) {
const modelMap = new Map(models.map((model) => [model.name, model]));
const modelCountOutputTypeArgsInputObjectTypes = [];
for (const modelCountOutputType of modelCountOutputTypes) {
const { name: modelCountOutputTypeName, fields: modelCountOutputTypeFields } = modelCountOutputType;
const modelName = modelCountOutputTypeName.replace('CountOutputType', '');
const model = modelMap.get(modelName);
const modelCountOutputTypeArgsInputObjectType = {
name: `${modelCountOutputTypeName}Args`,
constraints: {
maxNumFields: null,
minNumFields: null,
},
fields: [
{
name: 'select',
isRequired: false,
isNullable: false,
inputTypes: [
{
isList: false,
type: `${modelCountOutputTypeName}Select`,
location: 'inputObjectTypes',
namespace: 'prisma',
},
],
},
],
};
modelCountOutputTypeArgsInputObjectTypes.push(modelCountOutputTypeArgsInputObjectType);
if (!model)
continue;
for (const field of modelCountOutputTypeFields) {
const relationField = model.fields.find((modelField) => modelField.name === field.name && modelField.kind === 'object');
if (!relationField) {
continue;
}
const relationModelName = relationField.type;
const whereInputType = `${relationModelName}WhereInput`;
const relationArgsInputObjectType = {
name: `${modelCountOutputTypeName}Count${toPascalCase(field.name)}Args`,
constraints: {
maxNumFields: null,
minNumFields: null,
},
fields: [
{
name: 'where',
isRequired: false,
isNullable: false,
inputTypes: [
{
isList: false,
type: whereInputType,
location: 'inputObjectTypes',
namespace: 'prisma',
},
],
},
],
};
modelCountOutputTypeArgsInputObjectTypes.push(relationArgsInputObjectType);
}
}
return modelCountOutputTypeArgsInputObjectTypes;
}
function generateModelSelectInputObjectTypes(models) {
const modelSelectInputObjectTypes = [];
for (const model of models) {
const { name: modelName } = model;
// Skip if model doesn't support select operations
if (!(0, include_helpers_1.shouldGenerateIncludeForModel)(modelName)) {
continue;
}
const fields = [];
// Get filtered fields for the 'result' variant (what can be selected)
const filteredFields = (0, model_helpers_1.getFilteredModelFields)(model, 'result');
for (const modelField of filteredFields) {
const { name: modelFieldName, isList, type } = modelField;
const isRelationField = (0, model_helpers_1.checkIsModelRelationField)(modelField);
const field = {
name: modelFieldName,
isRequired: false,
isNullable: false,
inputTypes: [{ isList: false, type: 'Boolean', location: 'scalar' }],
};
if (isRelationField) {
// Only add relation selection if the related model is enabled
if (transformer_1.default.isModelEnabled(type)) {
const schemaArgInputType = {
isList: false,
type: isList ? `${type}FindManyArgs` : `${type}Args`,
location: 'inputObjectTypes',
namespace: 'prisma',
};
field.inputTypes.push(schemaArgInputType);
}
}
fields.push(field);
}
const hasEnabledManyRelationToAnotherModel = (0, model_helpers_1.checkModelHasEnabledManyModelRelation)(model);
const shouldAddCountField = hasEnabledManyRelationToAnotherModel;
if (shouldAddCountField) {
const _countField = {
name: '_count',
isRequired: false,
isNullable: false,
inputTypes: [
{ isList: false, type: 'Boolean', location: 'scalar' },
{
isList: false,
type: `${modelName.charAt(0).toUpperCase() + modelName.slice(1)}CountOutputTypeArgs`,
location: 'inputObjectTypes',
namespace: 'prisma',
},
],
};
fields.push(_countField);
}
const modelSelectInputObjectType = {
name: `${modelName}Select`,
constraints: {
maxNumFields: null,
minNumFields: null,
},
fields,
};
modelSelectInputObjectTypes.push(modelSelectInputObjectType);
}
return modelSelectInputObjectTypes;
}
function toPascalCase(name) {
return name
.replace(/[_\s-]+/g, ' ')
.split(' ')
.filter(Boolean)
.map((part) => part.charAt(0).toUpperCase() + part.slice(1))
.join('');
}
//# sourceMappingURL=select-helpers.js.map