prisma-zod-generator/lib/helpers/aggregate-helpers.js

Prisma 2+ generator to emit Zod schemas from your Prisma schema

"use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.isAggregateInputType = void 0;
exports.addMissingInputObjectTypesForAggregate = addMissingInputObjectTypesForAggregate;
exports.shouldGenerateAggregateForModel = shouldGenerateAggregateForModel;
exports.filterAggregateInputTypes = filterAggregateInputTypes;
const transformer_1 = __importDefault(require("../transformer"));
const model_helpers_1 = require("./model-helpers");
const isAggregateOutputType = (name) => /(?:Count|Avg|Sum|Min|Max)AggregateOutputType$/.test(name);
const isAggregateInputType = (name) => name.endsWith('CountAggregateInput') ||
    name.endsWith('SumAggregateInput') ||
    name.endsWith('AvgAggregateInput') ||
    name.endsWith('MinAggregateInput') ||
    name.endsWith('MaxAggregateInput');
exports.isAggregateInputType = isAggregateInputType;
/**
 * Extract model name from aggregate type name
 * Examples: UserCountAggregateOutputType -> User, PostAvgAggregateOutputType -> Post
 */
function extractModelNameFromAggregateType(typeName) {
    return typeName.replace(/(Count|Avg|Sum|Min|Max)Aggregate(?:Input|Output|OutputType)?$/, '');
}
function addMissingInputObjectTypesForAggregate(inputObjectTypes, outputObjectTypes) {
    const aggregateOutputTypes = outputObjectTypes.filter(({ name }) => isAggregateOutputType(name));
    for (const aggregateOutputType of aggregateOutputTypes) {
        const name = aggregateOutputType.name.replace(/(?:OutputType|Output)$/, '');
        // Extract model name from aggregate type name
        const modelName = extractModelNameFromAggregateType(name);
        // Skip if model is disabled or aggregate operation is not enabled
        if (!transformer_1.default.isModelEnabled(modelName) ||
            !(0, model_helpers_1.isOperationEnabledForModel)(modelName, 'aggregate')) {
            continue;
        }
        // Filter fields based on field-level filtering for result variant
        const filteredFields = aggregateOutputType.fields.filter((field) => {
            return transformer_1.default.isFieldEnabled(field.name, modelName, 'result');
        });
        // Only add the input type if there are enabled fields
        if (filteredFields.length > 0) {
            inputObjectTypes.push({
                constraints: { maxNumFields: null, minNumFields: null },
                name: `${name}Input`,
                fields: filteredFields.map((field) => ({
                    name: field.name,
                    isNullable: false,
                    isRequired: false,
                    inputTypes: [
                        {
                            isList: false,
                            type: 'True',
                            location: 'scalar',
                        },
                    ],
                })),
            });
        }
    }
}
// Aggregate support detection - recognizes Count, Min, Max, Sum, and Avg aggregate types
/**
 * Check if aggregate operations should be generated for a model
 */
function shouldGenerateAggregateForModel(modelName) {
    return (transformer_1.default.isModelEnabled(modelName) && (0, model_helpers_1.isOperationEnabledForModel)(modelName, 'aggregate'));
}
/**
 * Filter aggregate input types based on model and operation filtering
 */
function filterAggregateInputTypes(inputTypes) {
    return inputTypes.filter((inputType) => {
        if (!(0, exports.isAggregateInputType)(inputType.name)) {
            return true; // Keep non-aggregate input types
        }
        const modelName = extractModelNameFromAggregateType(inputType.name);
        return shouldGenerateAggregateForModel(modelName);
    });
}
//# sourceMappingURL=aggregate-helpers.js.map