@postxl/generator 0.74.2 → 1.0.1

package/dist/prisma/parse.js

@@ -1,452 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.parsePrismaSchema = void 0;
-const Types = __importStar(require("../lib/schema/types"));
-const error_1 = require("../lib/utils/error");
-const logger_1 = require("../lib/utils/logger");
-const string_1 = require("../lib/utils/string");
-const attributes_1 = require("./attributes");
-/**
- * Converts a Prisma schema (DMMF) document to a Schema that's passed around generators.
- */
-function parsePrismaSchema({ datamodel: { enums: enumsRaw, models: modelsRaw }, config, }) {
-    ensurePXLSystemModelsExist(modelsRaw);
-    ensureConsistency({ models: modelsRaw, enums: enumsRaw });
-    // NOTE: We preprocess models and enums so that we can populate relationships.
-    const models = modelsRaw.map((dmmfModel) => parseModelCore({ dmmfModel, config }));
-    const enums = enumsRaw.map((dmmfEnum) => parseEnum({ dmmfEnum, config }));
-    // NOTE: Then we parse the fields of the models.
-    const modelsWithFields = modelsRaw
-        .map((dmmfModel) => parseModel({ dmmfModel, models, enums, config }))
-        .filter(isModelNotIgnored);
-    // NOTE: Lastly we link back-relations to models.
-    for (const mwf of modelsWithFields) {
-        for (const field of mwf.fields) {
-            if (field.kind !== 'relation') {
-                continue;
-            }
-            const referencedModel = modelsWithFields.find((m) => m.sourceName === field.relationToModel.sourceName);
-            if (!referencedModel) {
-                // NOTE: This should never happen because Prisma should validate the validity of the relation.
-                (0, error_1.throwError)(`Model ${(0, logger_1.highlight)(mwf.name)} not found!`);
-            }
-            referencedModel.references.push({
-                referencingModel: mwf,
-                referencingField: field,
-            });
-        }
-    }
-    return { models: modelsWithFields, enums };
-}
-exports.parsePrismaSchema = parsePrismaSchema;
-/**
- * These models are required for the generators/backend to work.
- */
-const SYSTEM_MODELS = ['User', 'File', 'Action', 'Mutation'];
-function ensurePXLSystemModelsExist(models) {
-    for (const requiredModel of SYSTEM_MODELS) {
-        if (!models.find((m) => m.name === requiredModel)) {
-            (0, error_1.throwError)(`Required model ${(0, logger_1.highlight)(requiredModel)} not found in schema!`);
-        }
-    }
-}
-/**
- * Validates:
- * - That there are no duplicate model names
- * - That model names are singular
- * - That model attributes are valid
- * - That field attributes are valid
- * - That enum attributes are valid
- */
-function ensureConsistency({ models, enums }) {
-    const errors = [];
-    const modelNames = models.map((m) => m.name);
-    const duplicateModelName = modelNames.find((name, i) => modelNames.indexOf(name) !== i);
-    if (duplicateModelName) {
-        errors.push(`Model ${duplicateModelName} is defined more than once.`);
-    }
-    for (const model of models) {
-        if ((0, string_1.isPlural)(model.name)) {
-            errors.push(`Model ${(0, logger_1.highlight)(model.name)} is plural. Please use singular names for models.`);
-        }
-        try {
-            (0, attributes_1.getModelAttributes)(model);
-        }
-        catch (e) {
-            errors.push(`Model ${(0, logger_1.highlight)(model.name)} has invalid model attributes: ${(0, error_1.extractError)(e)}`);
-        }
-    }
-    for (const model of models) {
-        for (const field of model.fields) {
-            try {
-                (0, attributes_1.getFieldAttributes)(field);
-            }
-            catch (e) {
-                errors.push(`Model ${(0, logger_1.highlight)(model.name)} has invalid attributes for field ${(0, logger_1.highlight)(field.name)}: 
-            ${(0, error_1.extractError)(e)}`);
-            }
-        }
-    }
-    for (const enumDef of enums) {
-        try {
-            (0, attributes_1.getEnumAttributes)(enumDef);
-        }
-        catch (e) {
-            errors.push(`Enum ${(0, logger_1.highlight)(enumDef.name)} has invalid attributes: 
-        ${(0, error_1.extractError)(e)}`);
-        }
-    }
-    if (errors.length > 0) {
-        (0, error_1.throwError)(`${errors.length} ${(0, string_1.pluralize)('issue', errors.length)} detected in schema:\n   * ${errors.join('\n   * ')}`);
-    }
-}
-function isModelNotIgnored(model) {
-    return model !== undefined && !model.attributes.ignore;
-}
-/**
- * Parses the core properties of a model without fields.
- */
-function parseModelCore({ dmmfModel, config, }) {
-    if ((0, string_1.isPlural)(dmmfModel.name)) {
-        (0, error_1.throwError)(`Model ${dmmfModel.name} is plural. Please use singular names for models.`);
-    }
-    const attributes = (0, attributes_1.getModelAttributes)(dmmfModel);
-    return {
-        name: Types.toModelName((0, string_1.toPascalCase)(dmmfModel.name)),
-        description: attributes.description,
-        typeName: Types.toTypeName((0, string_1.toPascalCase)(dmmfModel.name)),
-        sourceName: dmmfModel.name,
-        sourceSchemaName: attributes.databaseSchema,
-        brandedIdType: Types.toTypeName(`${(0, string_1.toPascalCase)(dmmfModel.name)}Id`),
-        attributes,
-        schemaConfig: config,
-    };
-}
-/**
- * Converts a preprocessed model (with DMMF model) to a complete Schema.Model
- * by extracting/converting fields from DMMF and attaching them to the model
- */
-function parseModel({ dmmfModel, enums, models, config, }) {
-    const core = parseModelCore({ dmmfModel, config });
-    // NOTE: We ignore models which are marked as ignored.
-    if (core.attributes.ignore) {
-        return undefined;
-    }
-    // NOTE: We assume that each relation may only reference one field.
-    //       Because of this, we can "relate" a given relation to a scalar field
-    //       used as a foreign key.
-    //
-    //       Since Prisma doesn't mark foreign-key fields as relations,
-    //       we need to preprocess relations and then figure out which scalar
-    //       fields are actually foreign-keys.
-    const referencedModels = {};
-    for (const dmmfField of dmmfModel.fields) {
-        if (dmmfField.kind !== 'object' || !dmmfField.relationName) {
-            continue;
-        }
-        const referencedModel = models.find((m) => m.sourceName === dmmfField.type);
-        if (!referencedModel) {
-            (0, error_1.throwError)(`Field ${(0, logger_1.highlight)(`${dmmfModel.name}.${dmmfField.name}`)} references unknown model ${(0, logger_1.highlight)(dmmfField.type)}.`);
-        }
-        if (!dmmfField.relationFromFields || dmmfField.relationFromFields.length === 0) {
-            // NOTE: This field has no foreign-key values in this model so it must be a back-relation.
-            continue;
-        }
-        if (dmmfField.relationFromFields.length > 1) {
-            (0, error_1.throwError)(`Field ${(0, logger_1.highlight)(`${dmmfModel.name}.${dmmfField.relationName}`)} has more than one "from" field`);
-        }
-        if (dmmfField.relationOnDelete && dmmfField.relationOnDelete !== 'NoAction') {
-            (0, error_1.throwError)(`Investigate model ${(0, logger_1.highlight)(dmmfModel.name)}: "onDelete" attribute for relationship ${(0, logger_1.highlight)(dmmfField.relationName)} must be "NoAction": any deletes must be handled in the application layer, e.g. to update repository and search caches!`);
-        }
-        // NOTE: At this point, we only have the `ModelCore`. After all models are parsed, we need to updated
-        //       the relations with the full `Model`. This is done in the `linkModels` function.
-        referencedModels[dmmfField.relationFromFields[0]] = referencedModel;
-    }
-    const relationFields = dmmfModel.fields
-        .filter((f) => { var _a, _b; return f.kind === 'object' && ((_a = f.relationToFields) === null || _a === void 0 ? void 0 : _a.length) === 1 && ((_b = f.relationFromFields) === null || _b === void 0 ? void 0 : _b.length) === 1; })
-        .reduce((acc, f) => {
-        // NOTE: It's safe to assume that `relationFromFields` and `relationToFields` are defined because of the filter above.
-        acc[f.relationFromFields[0]] = f;
-        return acc;
-    }, {});
-    const fields = dmmfModel.fields
-        .filter((dmmfField) => {
-        // NOTE: This is a relation field that we'll handle when we process its foreign-key. If it's a back relation
-        //       then it won't have a foreign-key and we simply ignore it.
-        if (dmmfField.kind === 'object') {
-            return false;
-        }
-        return true;
-    })
-        .map((dmmfField) => {
-        const attributes = (0, attributes_1.getFieldAttributes)(dmmfField);
-        const fieldName = (0, logger_1.highlight)(`${dmmfModel.name}.${dmmfField.name}`);
-        const shared = {
-            name: Types.toFieldName((0, string_1.toCamelCase)(dmmfField.name)),
-            description: attributes.description,
-            sourceName: dmmfField.name,
-            isRequired: dmmfField.isRequired,
-            isUnique: dmmfField.isUnique,
-            attributes,
-            schemaConfig: config,
-            schemaType: dmmfField.type,
-        };
-        // NOTE: We mark scalar fields which are used in relations as relation fields by Purple Schema standards.
-        if (dmmfField.name in referencedModels) {
-            const refModel = referencedModels[dmmfField.name];
-            const refField = relationFields[dmmfField.name];
-            if (!refField) {
-                (0, error_1.throwError)(`${fieldName}: Relation field ${(0, logger_1.highlight)(dmmfField.name)} not found.`);
-            }
-            const _field = Object.assign(Object.assign({ kind: 'relation' }, shared), { relationFieldName: Types.toFieldName(refField.name), unbrandedTypeName: getTsTypeForId(dmmfField), relationToModel: refModel });
-            return _field;
-        }
-        if (dmmfField.isId) {
-            const isGeneratedField = isAutoIncrementField(dmmfField) || isUUIDField(dmmfField);
-            const _field = Object.assign(Object.assign({ kind: 'id' }, shared), { name: Types.ID_FIELD_NAME, isUnique: isUniqueField(dmmfField), isGenerated: isGeneratedField, unbrandedTypeName: getTsTypeForId(dmmfField), model: core });
-            return _field;
-        }
-        if (dmmfField.kind === 'scalar') {
-            let validation = undefined;
-            if (dmmfField.isList) {
-                (0, error_1.throwError)(`${fieldName}: Array fields with scalars (e.g. String[]) aren't supported! Use a relation instead. `);
-            }
-            if (dmmfField.type === 'Int') {
-                validation = { type: 'int' };
-            }
-            if (dmmfField.type === 'Float') {
-                validation = { type: 'float' };
-            }
-            const _field = Object.assign(Object.assign({ kind: 'scalar', validation }, shared), { isUnique: isUniqueField(dmmfField), isGenerated: isAutoIncrementField(dmmfField), tsTypeName: getTsTypeForScalar(dmmfField) });
-            if (_field.tsTypeName === 'boolean' && !_field.isRequired) {
-                (0, error_1.throwError)(`${(0, logger_1.highlight)(`${dmmfModel.name}.${fieldName}`)}: Boolean fields cannot be nullable!`);
-            }
-            return _field;
-        }
-        if (dmmfField.kind === 'enum') {
-            const fieldEnumDef = enums.find((e) => e.sourceName === dmmfField.type);
-            if (!fieldEnumDef) {
-                (0, error_1.throwError)(`${fieldName}: Field references unknown enum ${(0, logger_1.highlight)(dmmfField.type)}.`);
-            }
-            const _field = Object.assign(Object.assign({ kind: 'enum' }, shared), { typeName: getTsTypeForEnum(dmmfField), enumerator: fieldEnumDef });
-            return _field;
-        }
-        (0, error_1.throwError)(`${fieldName} is not scalar, enum nor relation.`);
-    })
-        .filter((field) => !isFieldIgnored({ field }));
-    const { idField, defaultField, nameField, createdAtField, updatedAtField } = getTaggedFields({ fields, model: core });
-    return Object.assign(Object.assign({}, core), { idField,
-        defaultField,
-        nameField,
-        fields,
-        createdAtField,
-        updatedAtField, 
-        // NOTE: This is only a stub because we link references after all models were parsed above.
-        references: [] });
-}
-/**
- * Returns special fields that are tagged with special attributes.
- */
-function getTaggedFields({ fields, model: { name }, }) {
-    var _a;
-    let idField = undefined;
-    let createdAtField = undefined;
-    let updatedAtField = undefined;
-    let nameField = undefined;
-    let isNameField = undefined;
-    let defaultField = undefined;
-    for (const field of fields) {
-        const fieldName = (0, logger_1.highlight)(`${name}.${field.name}`);
-        switch (field.kind) {
-            case 'id': {
-                if (idField) {
-                    (0, error_1.throwError)(`${fieldName} has multiple id fields - ${idField.name} and ${field.name}`);
-                }
-                idField = field;
-                break;
-            }
-            case 'scalar':
-                if (field.name === 'name') {
-                    nameField = field;
-                }
-                if (field.attributes.isNameField) {
-                    if (isNameField != null) {
-                        (0, error_1.throwError)(`${fieldName} has multiple name fields - ${isNameField.name} and ${field.name}`);
-                    }
-                    isNameField = field;
-                }
-                if (field.attributes.isCreatedAt) {
-                    if (createdAtField != null) {
-                        (0, error_1.throwError)(`${fieldName} has multiple createdAt fields - ${createdAtField.name} and ${field.name}`);
-                    }
-                    createdAtField = field;
-                }
-                if (field.attributes.isUpdatedAt) {
-                    if (updatedAtField != null) {
-                        (0, error_1.throwError)(`${fieldName} has multiple updatedAt fields - ${updatedAtField.name} and ${field.name}`);
-                    }
-                    updatedAtField = field;
-                }
-                if (field.attributes.isDefaultField) {
-                    if (defaultField != null) {
-                        (0, error_1.throwError)(`${fieldName} has multiple default fields - ${defaultField.name} and ${field.name}`);
-                    }
-                    defaultField = field;
-                }
-                break;
-            case 'relation':
-                break;
-            case 'enum':
-                break;
-        }
-    }
-    if (!idField) {
-        (0, error_1.throwError)(`Model ${(0, logger_1.highlight)(name)} does not have an id field`);
-    }
-    return {
-        idField,
-        defaultField,
-        nameField: (_a = isNameField !== null && isNameField !== void 0 ? isNameField : nameField) !== null && _a !== void 0 ? _a : idField,
-        createdAtField,
-        updatedAtField,
-    };
-}
-function isAutoIncrementField(fieldDmmf) {
-    if (fieldDmmf.default === undefined) {
-        return false;
-    }
-    if (Array.isArray(fieldDmmf.default)) {
-        return false;
-    }
-    if (typeof fieldDmmf.default === 'object') {
-        return fieldDmmf.default.name === 'autoincrement';
-    }
-    return false;
-}
-function isUUIDField(fieldDmmf) {
-    if (fieldDmmf.default === undefined) {
-        return false;
-    }
-    if (Array.isArray(fieldDmmf.default)) {
-        return false;
-    }
-    if (typeof fieldDmmf.default === 'object') {
-        return fieldDmmf.default.name === 'uuid' || fieldDmmf.default.name === 'cuid';
-    }
-    return false;
-}
-function isUniqueField(fieldRaw) {
-    return fieldRaw.isUnique && fieldRaw.type === 'String';
-}
-/**
- * Tells whether the parsed schema should skip a given field.
- */
-function isFieldIgnored({ field }) {
-    if (Object.hasOwn(field.attributes, 'ignore') && field.attributes.ignore) {
-        return true;
-    }
-    if (field.kind === 'relation' && field.relationToModel.attributes.ignore) {
-        return true;
-    }
-    return false;
-}
-/**
- * Parses a given enumerator type.
- */
-function parseEnum({ dmmfEnum, config }) {
-    const attributes = (0, attributes_1.getEnumAttributes)(dmmfEnum);
-    return {
-        name: Types.toEnumName(dmmfEnum.name),
-        description: attributes.description,
-        attributes,
-        tsTypeName: Types.toTypeName((0, string_1.toPascalCase)(dmmfEnum.name)),
-        sourceName: dmmfEnum.name,
-        values: dmmfEnum.values.map((v) => v.name),
-        schemaConfig: config,
-    };
-}
-/**
- * Returns the TypeScript type of a scalar database field
- */
-function getTsTypeForScalar(field) {
-    switch (field.type) {
-        case 'BigInt':
-        case 'String':
-            return Types.toTypeName('string');
-        case 'Boolean':
-            return Types.toTypeName('boolean');
-        case 'DateTime':
-            return Types.toTypeName('Date');
-        case 'Decimal':
-        case 'Float':
-        case 'Int':
-            return Types.toTypeName('number');
-        case 'Json':
-        case 'Bytes':
-            (0, error_1.throwError)(`Field ${(0, logger_1.highlight)(field.name)}: Type ${field.type} Not implemented yet`);
-        // While TypeScript understands that throwError never returns, eslint doesn't and complains.
-        // Hence we ignore the fallthrough error.
-        // eslint-disable-next-line no-fallthrough
-        default:
-            (0, error_1.throwError)(`Investigate: 'default' case in getTsTypeForScalar for field ${(0, logger_1.highlight)(field.name)} of type ${field.type}`);
-    }
-}
-/**
- * Returns the TypeScript type of a scalar id field.
- */
-function getTsTypeForId(field) {
-    switch (field.type) {
-        case 'BigInt':
-        case 'String':
-            return Types.toTypeName('string');
-        case 'Boolean':
-            return Types.toTypeName('boolean');
-        case 'Decimal':
-        case 'Float':
-        case 'Int':
-            return Types.toTypeName('number');
-        default:
-            (0, error_1.throwError)(`The id field ${(0, logger_1.highlight)(field.name)} is of type ${field.type} - but only BigInt, Boolean, Decimal, Float, Int and String are supported for Ids.`);
-    }
-}
-/**
- * Returns the TypeScript type of an enum field.
- */
-function getTsTypeForEnum(field) {
-    switch (field.type) {
-        case 'String':
-            return Types.toTypeName('string');
-        case 'BigInt':
-        case 'Boolean':
-        case 'Decimal':
-        case 'Float':
-        case 'Int':
-            (0, error_1.throwError)(`The enum field ${(0, logger_1.highlight)(field.name)} is of type ${field.type} - but only String fields are supported for enums so far.`);
-            break;
-        default:
-            return Types.toTypeName(field.type);
-    }
-}