prisma-zod-generator
Version:
Prisma 2+ generator to emit Zod schemas from your Prisma schema
88 lines • 4.7 kB
JavaScript
;
var __importDefault = (this && this.__importDefault) || function (mod) {
return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.isMongodbRawOp = void 0;
exports.addMissingInputObjectTypesForMongoDbRawOpsAndQueries = addMissingInputObjectTypesForMongoDbRawOpsAndQueries;
exports.shouldGenerateMongoDbRawOpsForModel = shouldGenerateMongoDbRawOpsForModel;
const transformer_1 = __importDefault(require("../transformer"));
const model_helpers_1 = require("./model-helpers");
function addMissingInputObjectTypesForMongoDbRawOpsAndQueries(modelOperations, outputObjectTypes, inputObjectTypes) {
const rawOpsMap = resolveMongoDbRawOperations(modelOperations);
transformer_1.default.rawOpsMap = rawOpsMap !== null && rawOpsMap !== void 0 ? rawOpsMap : {};
const mongoDbRawQueryInputObjectTypes = resolveMongoDbRawQueryInputObjectTypes(outputObjectTypes);
for (const mongoDbRawQueryInputType of mongoDbRawQueryInputObjectTypes) {
inputObjectTypes.push(mongoDbRawQueryInputType);
}
}
function resolveMongoDbRawOperations(modelOperations) {
const rawOpsMap = {};
// Filter model operations to only include enabled models
const enabledModelOperations = modelOperations.filter((operation) => transformer_1.default.isModelEnabled(operation.model));
// Register the exact operation names Prisma exposes in its model mappings
// (DMMF.ModelMapping.findRaw / aggregateRaw). Reconstructing names from
// substring heuristics false-positives on models whose own name contains
// 'Raw' (e.g. model MaterialRaw: findFirstMaterialRaw is NOT a raw op).
for (const mapping of enabledModelOperations) {
const modelName = mapping.model;
if (mapping.findRaw && isMongoDbRawOperationEnabledForModel(modelName, 'findRaw')) {
rawOpsMap[mapping.findRaw] = `${modelName}FindRawArgs`;
}
if (mapping.aggregateRaw && isMongoDbRawOperationEnabledForModel(modelName, 'aggregateRaw')) {
rawOpsMap[mapping.aggregateRaw] = `${modelName}AggregateRawArgs`;
}
}
return rawOpsMap;
}
function resolveMongoDbRawQueryInputObjectTypes(outputObjectTypes) {
const mongoDbRawQueries = getFilteredMongoDbRawQueries(outputObjectTypes);
const mongoDbRawQueryInputObjectTypes = mongoDbRawQueries.map((item) => ({
name: item.name,
constraints: {
maxNumFields: null,
minNumFields: null,
},
fields: item.args.map((arg) => ({
name: arg.name,
isRequired: arg.isRequired,
isNullable: arg.isNullable,
inputTypes: arg.inputTypes,
})),
}));
return mongoDbRawQueryInputObjectTypes;
}
function getMongoDbRawQueries(outputObjectTypes) {
var _a;
const queryOutputTypes = outputObjectTypes.filter((item) => item.name === 'Query');
// Match Query fields against the exact raw-op names registered in rawOpsMap
// (assigned before this runs). A substring check on 'Raw' would sweep in every
// regular operation of models whose name contains 'Raw'.
const mongodbRawQueries = (_a = queryOutputTypes === null || queryOutputTypes === void 0 ? void 0 : queryOutputTypes[0].fields.filter((field) => (0, exports.isMongodbRawOp)(field.name))) !== null && _a !== void 0 ? _a : [];
return mongodbRawQueries;
}
function getFilteredMongoDbRawQueries(outputObjectTypes) {
// Model and per-operation enablement is already applied while building
// Transformer.rawOpsMap, which getMongoDbRawQueries matches against.
return getMongoDbRawQueries(outputObjectTypes);
}
const isMongodbRawOp = (name) => Object.prototype.hasOwnProperty.call(transformer_1.default.rawOpsMap, name);
exports.isMongodbRawOp = isMongodbRawOp;
/**
* Check if a MongoDB raw operation is enabled for a model
*/
function isMongoDbRawOperationEnabledForModel(modelName, operation) {
// Check if the equivalent standard operation is enabled
// findRaw corresponds to findMany/findFirst, aggregateRaw corresponds to aggregate
const standardOperation = operation === 'findRaw' ? 'findMany' : 'aggregate';
return (0, model_helpers_1.isOperationEnabledForModel)(modelName, standardOperation);
}
/**
* Check if MongoDB raw operations should be generated for a model
*/
function shouldGenerateMongoDbRawOpsForModel(modelName) {
return (transformer_1.default.isModelEnabled(modelName) &&
((0, model_helpers_1.isOperationEnabledForModel)(modelName, 'findMany') ||
(0, model_helpers_1.isOperationEnabledForModel)(modelName, 'aggregate')));
}
//# sourceMappingURL=mongodb-helpers.js.map