@postxl/generator 0.44.5 → 0.46.0

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

@@ -6,6 +6,7 @@ const meta_1 = require("../../lib/meta");
 const fields_1 = require("../../lib/schema/fields");
 const schema_1 = require("../../lib/schema/schema");
 const types_1 = require("../../lib/schema/types");
+const types_2 = require("../../lib/types");
 const jsdoc_1 = require("../../lib/utils/jsdoc");
 const string_1 = require("../../lib/utils/string");
 /**
@@ -341,7 +342,7 @@ function _generateMainBuildingBlocks_InMemoryOnly({ model, meta, schemaMeta, imp
           throw new Error(\`Could not update ${meta.userFriendlyName} with id \${item.id}. Not found!\`)
         }
         const mutationId = await execution.startUpdateMutation({
-          model: 'post',
+          model: '${meta.actions.actionScopeConstType}',
           entityId: item.id,
           sourceObject: existingItem,
           updateObject: item,
@@ -639,7 +640,7 @@ function generateMainBuildingBlocks_InDatabase({ model, meta, schemaMeta, import
         }
         
         const mutationId = await execution.startUpdateMutation({
-          model: 'post',
+          model: '${meta.actions.actionScopeConstType}',
           entityId: item.id,
           sourceObject: existingItem,
           updateObject: item,
@@ -784,12 +785,9 @@ 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}('root')`,
+        rootUserNameConst: `public static ROOT_USER_ID = ${meta.types.toBrandedIdTypeFnName}(${rootUserId})`,
         getterBlock: `
       // We initialize the root user in the init() function
       private _rootUser!: ${meta.types.typeName}
@@ -806,16 +804,7 @@ function generateUserRepositorySpecificBlocks_InDatabase({ model, meta, imports,
         }
     
         const rawUser = await this.db.user.create({
-          data: {
-            id: ${meta.data.repository.className}.ROOT_USER_ID,
-            name: 'System',
-            email: 'system@postxl.com',
-            role: UserRole.Admin,
-            login: 'not-set',
-            familyName: 'System user',
-            age: 0,
-            countryId: null,
-          },
+          data: { ${rootUserValue} },
         })
         const newRootUser = this.toUser(rawUser)
         this.set(newRootUser)
@@ -832,12 +821,9 @@ function generateUserRepositorySpecificBlocks_InMemoryOnly({ model, meta, import
             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}('root')`,
+        rootUserNameConst: `public static ROOT_USER_ID = ${meta.types.toBrandedIdTypeFnName}(${rootUserId})`,
         getterBlock: `
       // We initialize the root user in the init() function
       private _rootUser!: ${meta.types.typeName}
@@ -853,22 +839,126 @@ function generateUserRepositorySpecificBlocks_InMemoryOnly({ model, meta, import
           return
         }
     
-        const rawUser = {
-          id: ${meta.data.repository.className}.ROOT_USER_ID,
-          name: 'System',
-          email: 'system@postxl.com',
-          role: UserRole.Admin,
-          login: 'not-set',
-          familyName: 'System user',
-          age: 0,
-          countryId: null, 
-        }
+        const rawUser = { ${rootUserValue} }
         const newRootUser = this.verifyItem (rawUser)
         this.set(newRootUser)
         this._rootUser = newRootUser
       }`,
     };
 }
+function generateSharedRootUserBlocks({ model, meta, imports, }) {
+    var _a;
+    const providedDefault = model.attributes.systemUser;
+    const assignments = [];
+    let rootUserId = '';
+    for (const field of model.fields) {
+        let value = undefined;
+        if (providedDefault && field.name in providedDefault) {
+            value = providedDefault[field.name];
+        }
+        else if ((_a = field.attributes.examples) === null || _a === void 0 ? void 0 : _a.length) {
+            value = field.attributes.examples[0];
+        }
+        else if (!field.isRequired) {
+            value = null;
+        }
+        else if (field.kind === 'id') {
+            if (field.unbrandedTypeName === 'string') {
+                value = 'rootId';
+            }
+            else if (field.unbrandedTypeName === 'number') {
+                value = -1;
+            }
+            else {
+                throw new Error(`Could not generate root user: Unsupported id type ${field.unbrandedTypeName}!`);
+            }
+        }
+        else {
+            if (field.isRequired && !field.attributes.isCreatedAt && !field.attributes.isUpdatedAt) {
+                throw new Error(`Could not generate root user: No value for field ${field.name} provided!`);
+            }
+            else {
+                continue;
+            }
+        }
+        switch (field.kind) {
+            case 'id': {
+                if (field.unbrandedTypeName === 'string') {
+                    value = `'${value}'`;
+                }
+                else if (field.unbrandedTypeName === 'number') {
+                    value = `${value}`;
+                }
+                else {
+                    throw new Error(`Could not generate root user: Unsupported id type ${field.unbrandedTypeName}!`);
+                }
+                rootUserId = value;
+                break;
+            }
+            case 'scalar': {
+                if (value === null) {
+                    break;
+                }
+                switch (field.tsTypeName) {
+                    case 'string': {
+                        value = `'${value}'`;
+                        break;
+                    }
+                    case 'number': {
+                        value = `${value}`;
+                        break;
+                    }
+                    case 'boolean': {
+                        value = value ? 'true' : 'false';
+                        break;
+                    }
+                    case 'Date': {
+                        value = `${value}`;
+                        break;
+                    }
+                    default: {
+                        throw new Error(`Could not generate root user: Unsupported scalar type ${field.tsTypeName}!`);
+                    }
+                }
+                break;
+            }
+            case 'relation': {
+                if (value === null) {
+                    break;
+                }
+                if (field.unbrandedTypeName === 'string') {
+                    value = `'${value}'`;
+                }
+                else if (field.unbrandedTypeName === 'number') {
+                    value = `${value}`;
+                }
+                else {
+                    throw new Error(`Could not generate root user: Unsupported relation type ${field.unbrandedTypeName}!`);
+                }
+                break;
+            }
+            case 'enum': {
+                if (value === null) {
+                    break;
+                }
+                imports.addImport({
+                    from: meta.types.importPath,
+                    items: [field.enumerator.name],
+                });
+                value = `${field.enumerator.name}.${value}`;
+                break;
+            }
+            default: {
+                throw new types_2.ExhaustiveSwitchCheck(field);
+            }
+        }
+        assignments.push(`${field.name}: ${value}`);
+    }
+    return {
+        rootUserId,
+        rootUserValue: assignments.join(', '),
+    };
+}
 /**
  * Generates code chunks responsible for verifying the ID validity of a model instance and generating the id
  * value of a model with auto-generated id.

package/dist/lib/attributes.d.ts

@@ -31,6 +31,11 @@ export type ModelAttributes = {
      * Seed to use for random generation.
      */
     randomSeed?: number;
+    /**
+     * Schema tag: ´@@SystemUser()`
+     * The user that is used for system actions.
+     */
+    systemUser?: object;
 };
 export type FieldAttributes = {
     /**

package/dist/lib/schema/types.d.ts

@@ -150,7 +150,7 @@ export declare const toPath: (t: string) => FilePath;
 /**
  * Branded string values that can be used as import statement values in the generators
  */
-export type ImportableTypes = FunctionName | ClassName | AnnotatedTypeName | VariableName;
+export type ImportableTypes = FunctionName | ClassName | AnnotatedTypeName | VariableName | EnumName;
 /**
  * Branded string values that can be used as paths in import statements
  */

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/attributes.js

@@ -74,6 +74,10 @@ function getModelAttributes(model) {
         schema: zod_1.default.string().optional(),
         index: zod_1.default.array(zod_1.default.string()).optional(),
         seed: zod_1.default.string().optional(),
+        systemUser: zod_1.default
+            .string()
+            .transform((t) => JSON.parse(t))
+            .optional(),
     })
         .transform((obj) => ({
         ignore: obj.ignore,
@@ -81,6 +85,7 @@ function getModelAttributes(model) {
         description: obj.description,
         databaseSchema: obj.schema,
         index: obj.index,
+        systemUser: obj.systemUser,
         randomSeed: obj.seed !== undefined ? parseInt(obj.seed, 10) : undefined,
     }));
     const result = decoder.safeParse(attributes);

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.44.5",
+  "version": "0.46.0",
   "main": "./dist/generator.js",
   "typings": "./dist/generator.d.ts",
   "bin": {