@postxl/generator 0.45.0 → 0.46.0

package/dist/generators/models/repository.generator.js

@@ -785,10 +785,6 @@ function generateUserRepositorySpecificBlocks_InDatabase({ model, meta, imports,
             rootUserInitializeBlock: '',
         };
     }
-    imports.addImport({
-        from: meta.types.importPath,
-        items: [(0, types_1.toVariableName)('UserRole')],
-    });
     const { rootUserId, rootUserValue } = generateSharedRootUserBlocks({ model, meta, imports });
     return {
         rootUserNameConst: `public static ROOT_USER_ID = ${meta.types.toBrandedIdTypeFnName}(${rootUserId})`,
@@ -868,7 +864,7 @@ function generateSharedRootUserBlocks({ model, meta, imports, }) {
         }
         else if (field.kind === 'id') {
             if (field.unbrandedTypeName === 'string') {
-                value = "rootId";
+                value = 'rootId';
             }
             else if (field.unbrandedTypeName === 'number') {
                 value = -1;

package/dist/lib/utils/error.d.ts

@@ -3,3 +3,7 @@
  * By showing the error via console.log and throwing it again, we ensure that the error message is shown.
  */
 export declare function throwError(message: string): never;
+/**
+ * Extracts the error message from an error object or any other object.
+ */
+export declare function extractError(error: unknown): string;

package/dist/lib/utils/error.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.throwError = void 0;
+exports.extractError = exports.throwError = void 0;
 /**
  * Prisma generator often overwrites any error message because of some concurrency issues.
  * By showing the error via console.log and throwing it again, we ensure that the error message is shown.
@@ -11,3 +11,13 @@ function throwError(message) {
     throw new Error(m);
 }
 exports.throwError = throwError;
+/**
+ * Extracts the error message from an error object or any other object.
+ */
+function extractError(error) {
+    if (error instanceof Error) {
+        return error.message;
+    }
+    return JSON.stringify(error);
+}
+exports.extractError = extractError;

package/dist/prisma/parse.js

@@ -37,6 +37,7 @@ const REQUIRED_MODELS = ['User', 'Config', 'File', 'Action', 'Mutation'];
  */
 function parsePrismaSchema({ datamodel: { enums: enumsRaw, models: modelsRaw }, config, }) {
     ensureRequiredModelsExists(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 }));
@@ -49,10 +50,60 @@ exports.parsePrismaSchema = parsePrismaSchema;
 function ensureRequiredModelsExists(models) {
     for (const requiredModel of REQUIRED_MODELS) {
         if (!models.find((m) => m.name === requiredModel)) {
-            (0, error_1.throwError)(`Required model ${requiredModel} not found in schema!`);
+            (0, error_1.throwError)(`Required model ${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 ${highlight(model.name)} is plural. Please use singular names for models.`);
+        }
+        try {
+            (0, attributes_1.getModelAttributes)(model);
+        }
+        catch (e) {
+            errors.push(`Model ${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 ${highlight(model.name)} has invalid attributes for field ${highlight(field.name)}: 
+            ${(0, error_1.extractError)(e)}`);
+            }
+        }
+    }
+    for (const enumDef of enums) {
+        try {
+            (0, attributes_1.getEnumAttributes)(enumDef);
+        }
+        catch (e) {
+            errors.push(`Enum ${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;
 }
@@ -98,14 +149,14 @@ function parseModel({ dmmfModel, enums, models, config, }) {
             continue;
         }
         if (dmmfField.relationFromFields.length > 1) {
-            throw new Error(`❌❌❌ Relation ${dmmfField.relationName} has more than one from field`);
+            (0, error_1.throwError)(`Field ${highlight(`${dmmfModel.name}.${dmmfField.relationName}`)} has more than one "from" field`);
         }
         const referencedModel = models.find((m) => m.sourceName === dmmfField.type);
         if (!referencedModel) {
-            (0, error_1.throwError)(`Investigate: Field references unknown model ${dmmfField.type}.`);
+            (0, error_1.throwError)(`Field ${highlight(`${dmmfModel.name}.${dmmfField.name}`)} references unknown model ${highlight(dmmfField.type)}.`);
         }
         if (dmmfField.relationOnDelete && dmmfField.relationOnDelete !== 'NoAction') {
-            (0, error_1.throwError)(`Investigate: "onDelete" attribute for relationship ${dmmfField.relationName} must be "NoAction": any deletes must be handled in the application layer, e.g. to update repository and search caches!`);
+            (0, error_1.throwError)(`Investigate model ${highlight(dmmfModel.name)}: "onDelete" attribute for relationship ${highlight(dmmfField.relationName)} must be "NoAction": any deletes must be handled in the application layer, e.g. to update repository and search caches!`);
         }
         relations[dmmfField.relationFromFields[0]] = referencedModel;
     }
@@ -123,6 +174,7 @@ function parseModel({ dmmfModel, enums, models, config, }) {
     dmmfField.kind !== 'object')
         .map((dmmfField) => {
         const attributes = (0, attributes_1.getFieldAttributes)(dmmfField);
+        const fieldName = highlight(`${dmmfModel.name}.${dmmfField.name}`);
         const shared = {
             name: Types.toFieldName((0, string_1.toCamelCase)(dmmfField.name)),
             description: attributes.description,
@@ -137,7 +189,7 @@ function parseModel({ dmmfModel, enums, models, config, }) {
             const refModel = relations[dmmfField.name];
             const refField = relationFields[dmmfField.name];
             if (!refField) {
-                (0, error_1.throwError)(`Investigate: Relation field ${dmmfField.name} not found.`);
+                (0, error_1.throwError)(`${fieldName}: Relation field ${highlight(dmmfField.name)} not found.`);
             }
             return Object.assign(Object.assign({ kind: 'relation' }, shared), { relatedModelBacklinkFieldName: Types.toFieldName(refField.name), typeName: Types.toTypeName(dmmfField.type), unbrandedTypeName: getTsTypeForId(dmmfField), relationToModel: refModel });
         }
@@ -148,7 +200,7 @@ function parseModel({ dmmfModel, enums, models, config, }) {
         if (dmmfField.kind === 'scalar') {
             let validation = undefined;
             if (dmmfField.isList) {
-                (0, error_1.throwError)(`Array fields with scalars (e.g. String[]) aren't supported! Use a relation instead. Field: ${dmmfModel.name}.${dmmfField.name}`);
+                (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' };
@@ -161,11 +213,11 @@ function parseModel({ dmmfModel, enums, models, config, }) {
         if (dmmfField.kind === 'enum') {
             const fieldEnumDef = enums.find((e) => e.sourceName === dmmfField.type);
             if (!fieldEnumDef) {
-                (0, error_1.throwError)(`Investigate: Field references unknown enum ${dmmfField.type}.`);
+                (0, error_1.throwError)(`${fieldName}: Field references unknown enum ${highlight(dmmfField.type)}.`);
             }
             return Object.assign(Object.assign({ kind: 'enum' }, shared), { typeName: getTsTypeForEnum(dmmfField), enumerator: fieldEnumDef });
         }
-        (0, error_1.throwError)(`Investigate: Field ${shared.sourceName}.${shared.sourceName} is not scalar, enum nor relation.`);
+        (0, error_1.throwError)(`${fieldName} is not scalar, enum nor relation.`);
     })
         .filter((field) => !isFieldIgnored({ field }));
     const { idField, defaultField, nameField, createdAtField, updatedAtField } = validateFields({ fields, model: core });
@@ -188,6 +240,7 @@ function validateFields({ fields, model: { name } }) {
     let nameField = undefined;
     let defaultField = undefined;
     for (const field of fields) {
+        const fieldName = highlight(`${name}.${field.name}`);
         switch (field.kind) {
             case 'scalar':
                 if (field.name === 'name') {
@@ -195,20 +248,20 @@ function validateFields({ fields, model: { name } }) {
                 }
                 if (field.attributes.isCreatedAt) {
                     if (createdAtField) {
-                        throw new Error(`❌❌❌ Model ${name} has multiple createdAt fields`);
+                        (0, error_1.throwError)(`${fieldName} has multiple createdAt fields`);
                     }
                     createdAtField = field;
                 }
                 if (field.attributes.isUpdatedAt) {
                     if (updatedAtField) {
-                        throw new Error(`❌❌❌ Model ${name} has multiple updatedAt fields`);
+                        (0, error_1.throwError)(`${fieldName} has multiple updatedAt fields`);
                     }
                     updatedAtField = field;
                 }
                 break;
             case 'id':
                 if (idField) {
-                    throw new Error(`❌❌❌ Model ${name} has multiple id fields`);
+                    (0, error_1.throwError)(`${fieldName} has multiple id fields`);
                 }
                 idField = field;
                 break;
@@ -220,20 +273,20 @@ function validateFields({ fields, model: { name } }) {
         //handle default case
         if (field.attributes.isDefaultField && field.kind === 'scalar') {
             if (defaultField !== undefined) {
-                throw new Error(`❌❌❌ Model ${name} has multiple default fields`);
+                (0, error_1.throwError)(`${fieldName} has multiple default fields`);
             }
             defaultField = field;
         }
         //handle name field
         if (field.attributes.isLabel) {
             if (labelField !== undefined) {
-                throw new Error(`❌❌❌ Model ${name} has multiple name fields`);
+                (0, error_1.throwError)(`${fieldName} has multiple name fields`);
             }
             labelField = field;
         }
     }
     if (!idField) {
-        throw new Error(`❌❌❌ Model ${name} does not have an id field`);
+        (0, error_1.throwError)(`Model ${highlight(name)} does not have an id field`);
     }
     return { idField, defaultField, nameField: (_a = labelField !== null && labelField !== void 0 ? labelField : nameField) !== null && _a !== void 0 ? _a : idField, createdAtField, updatedAtField };
 }
@@ -309,12 +362,12 @@ function getTsTypeForScalar(field) {
             return Types.toTypeName('number');
         case 'Json':
         case 'Bytes':
-            (0, error_1.throwError)('Not implemented yet');
+            (0, error_1.throwError)(`Field ${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 ${field.name} of type ${field.type}`);
+            (0, error_1.throwError)(`Investigate: 'default' case in getTsTypeForScalar for field ${highlight(field.name)} of type ${field.type}`);
     }
 }
 /**
@@ -332,7 +385,7 @@ function getTsTypeForId(field) {
         case 'Int':
             return Types.toTypeName('number');
         default:
-            (0, error_1.throwError)(`The id field ${field.name}  is of type ${field.type} - but only BigInt, Boolean, Decimal, Float, Int and String are supported for Ids.`);
+            (0, error_1.throwError)(`The id field ${highlight(field.name)} is of type ${field.type} - but only BigInt, Boolean, Decimal, Float, Int and String are supported for Ids.`);
     }
 }
 /**
@@ -347,9 +400,17 @@ function getTsTypeForEnum(field) {
         case 'Decimal':
         case 'Float':
         case 'Int':
-            (0, error_1.throwError)(`The enum field ${field.name}  is of type ${field.type} - but only String fields are supported for enums so far.`);
+            (0, error_1.throwError)(`The enum field ${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);
     }
 }
+/**
+ * Highlights a string cyan
+ *
+ * NOTE: We would normally use `chalk.cyan` here, but this causes an error in the generator, so we use this workaround.
+ */
+function highlight(str) {
+    return `\u001B[36m${str}\u001B[39m`;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@postxl/generator",
-  "version": "0.45.0",
+  "version": "0.46.0",
   "main": "./dist/generator.js",
   "typings": "./dist/generator.d.ts",
   "bin": {