@postxl/generator 0.44.5 → 0.45.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,
@@ -788,8 +789,9 @@ function generateUserRepositorySpecificBlocks_InDatabase({ model, meta, imports,
         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 +808,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 +825,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 +843,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/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/package.json

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