prisma-zod-generator
Version:
Prisma 2+ generator to emit Zod schemas from your Prisma schema
123 lines • 5.85 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));
const rawOpsNames = [
...new Set(enabledModelOperations.reduce((result, current) => {
const keys = Object.keys(current);
keys === null || keys === void 0 ? void 0 : keys.forEach((key) => {
if (key.includes('Raw')) {
result.push(key);
}
});
return result;
}, [])),
];
const modelNames = enabledModelOperations.map((item) => item.model);
rawOpsNames.forEach((opName) => {
modelNames.forEach((modelName) => {
// Check if the specific raw operation is enabled for this model
const operation = opName === 'findRaw' ? 'findRaw' : 'aggregateRaw';
if (!isMongoDbRawOperationEnabledForModel(modelName, operation)) {
return; // Skip this operation if not enabled
}
const isFind = opName === 'findRaw';
const opWithModel = `${opName.replace('Raw', '')}${modelName}Raw`;
rawOpsMap[opWithModel] = isFind ? `${modelName}FindRawArgs` : `${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');
const mongodbRawQueries = (_a = queryOutputTypes === null || queryOutputTypes === void 0 ? void 0 : queryOutputTypes[0].fields.filter((field) => field.name.includes('Raw'))) !== null && _a !== void 0 ? _a : [];
return mongodbRawQueries;
}
function getFilteredMongoDbRawQueries(outputObjectTypes) {
const mongoDbRawQueries = getMongoDbRawQueries(outputObjectTypes);
return mongoDbRawQueries.filter((field) => {
// Extract model name from raw query field name
// Examples: "findUserRaw" -> "User", "aggregatePostRaw" -> "Post"
const modelName = extractModelNameFromRawQuery(field.name);
if (!modelName)
return true; // Keep queries we can't parse
// Check if model is enabled and raw operations are allowed
if (!transformer_1.default.isModelEnabled(modelName)) {
return false;
}
// Check if specific raw operation is enabled for this model
const operation = field.name.includes('find') ? 'findRaw' : 'aggregateRaw';
return isMongoDbRawOperationEnabledForModel(modelName, operation);
});
}
const isMongodbRawOp = (name) => /find([^]*?)Raw/.test(name) || /aggregate([^]*?)Raw/.test(name);
exports.isMongodbRawOp = isMongodbRawOp;
/**
* Extract model name from MongoDB raw query field name
* Examples: "findUserRaw" -> "User", "aggregatePostRaw" -> "Post"
*/
function extractModelNameFromRawQuery(fieldName) {
const findMatch = fieldName.match(/find([A-Z][a-zA-Z]*)Raw/);
if (findMatch) {
return findMatch[1];
}
const aggregateMatch = fieldName.match(/aggregate([A-Z][a-zA-Z]*)Raw/);
if (aggregateMatch) {
return aggregateMatch[1];
}
return null;
}
/**
* 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