prisma-zod-generator/lib/helpers/model-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.checkModelHasModelRelation = checkModelHasModelRelation;
exports.checkModelHasManyModelRelation = checkModelHasManyModelRelation;
exports.checkIsModelRelationField = checkIsModelRelationField;
exports.checkIsManyModelRelationField = checkIsManyModelRelationField;
exports.findModelByName = findModelByName;
exports.checkModelHasEnabledModelRelation = checkModelHasEnabledModelRelation;
exports.checkModelHasEnabledManyModelRelation = checkModelHasEnabledManyModelRelation;
exports.getFilteredModelFields = getFilteredModelFields;
exports.getEnabledModels = getEnabledModels;
exports.getEnabledRelationFields = getEnabledRelationFields;
exports.modelHasEnabledOperations = modelHasEnabledOperations;
exports.getEnabledOperationsForModel = getEnabledOperationsForModel;
exports.isOperationEnabledForModel = isOperationEnabledForModel;
const transformer_1 = __importDefault(require("../transformer"));
function checkModelHasModelRelation(model) {
    const { fields: modelFields } = model;
    for (const modelField of modelFields) {
        const isRelationField = checkIsModelRelationField(modelField);
        if (isRelationField) {
            return true;
        }
    }
    return false;
}
function checkModelHasManyModelRelation(model) {
    const { fields: modelFields } = model;
    for (const modelField of modelFields) {
        const isManyRelationField = checkIsManyModelRelationField(modelField);
        if (isManyRelationField) {
            return true;
        }
    }
    return false;
}
function checkIsModelRelationField(modelField) {
    const { kind, relationName } = modelField;
    return kind === 'object' && !!relationName;
}
function checkIsManyModelRelationField(modelField) {
    return checkIsModelRelationField(modelField) && modelField.isList;
}
function findModelByName(models, modelName) {
    return models.find(({ name }) => name === modelName);
}
/**
 * Filtering-aware helper functions that respect generator configuration
 */
/**
 * Check if model has enabled model relations (filters out disabled models)
 */
function checkModelHasEnabledModelRelation(model) {
    const { fields: modelFields } = model;
    for (const modelField of modelFields) {
        const isRelationField = checkIsModelRelationField(modelField);
        if (isRelationField) {
            // Check if the related model is enabled
            const relatedModelEnabled = transformer_1.default.isModelEnabled(modelField.type);
            if (relatedModelEnabled) {
                return true;
            }
        }
    }
    return false;
}
/**
 * Check if model has enabled many model relations (filters out disabled models)
 */
function checkModelHasEnabledManyModelRelation(model) {
    const { fields: modelFields } = model;
    for (const modelField of modelFields) {
        const isManyRelationField = checkIsManyModelRelationField(modelField);
        if (isManyRelationField) {
            // Check if the related model is enabled
            const relatedModelEnabled = transformer_1.default.isModelEnabled(modelField.type);
            if (relatedModelEnabled) {
                return true;
            }
        }
    }
    return false;
}
/**
 * Get filtered model fields based on field exclusion configuration
 */
function getFilteredModelFields(model, variant) {
    return model.fields.filter((field) => {
        return transformer_1.default.isFieldEnabled(field.name, model.name, variant);
    });
}
/**
 * Get enabled models from a list of models
 */
function getEnabledModels(models) {
    return models.filter((model) => transformer_1.default.isModelEnabled(model.name));
}
/**
 * Get enabled relation fields from a model
 */
function getEnabledRelationFields(model) {
    return model.fields.filter((field) => {
        if (!checkIsModelRelationField(field)) {
            return false;
        }
        // Check if the related model is enabled
        if (!transformer_1.default.isModelEnabled(field.type)) {
            return false;
        }
        // Check if the field itself is enabled according to configuration (not excluded)
        if (!transformer_1.default.isFieldEnabled(field.name, model.name, 'result')) {
            return false;
        }
        return true;
    });
}
/**
 * Check if a model has any enabled operations
 */
function modelHasEnabledOperations(modelName) {
    var _a;
    const config = transformer_1.default.getGeneratorConfig();
    if (!config)
        return true;
    const modelConfig = (_a = config.models) === null || _a === void 0 ? void 0 : _a[modelName];
    if (!(modelConfig === null || modelConfig === void 0 ? void 0 : modelConfig.operations))
        return true;
    return modelConfig.operations.length > 0;
}
/**
 * Get enabled operations for a model
 */
function getEnabledOperationsForModel(modelName) {
    var _a;
    const config = transformer_1.default.getGeneratorConfig();
    if (!config)
        return [];
    const modelConfig = (_a = config.models) === null || _a === void 0 ? void 0 : _a[modelName];
    if (!(modelConfig === null || modelConfig === void 0 ? void 0 : modelConfig.operations))
        return [];
    return modelConfig.operations;
}
/**
 * Check if a specific operation is enabled for a model
 */
function isOperationEnabledForModel(modelName, operation) {
    const enabledOperations = getEnabledOperationsForModel(modelName);
    if (enabledOperations.length === 0)
        return true; // Default to enabled if no restrictions
    return enabledOperations.includes(operation);
}
//# sourceMappingURL=model-helpers.js.map