@postxl/generator 0.38.2 → 0.40.0

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

@@ -14,8 +14,8 @@ const string_1 = require("../../lib/utils/string");
 function generateRepository({ model, meta }) {
     const { idField } = model;
     const schemaMeta = (0, meta_1.getSchemaMetadata)({ config: model.schemaConfig });
-    const imports = imports_1.ImportsGenerator.from(meta.data.repoFilePath).addImports({
-        [schemaMeta.data.repositoryTypeFilePath]: schemaMeta.data.repositoryTypeName,
+    const imports = imports_1.ImportsGenerator.from(meta.data.repository.filePath).addImports({
+        [schemaMeta.data.repository.typeFilePath]: schemaMeta.data.repository.typeName,
         [meta.types.importPath]: [
             model.typeName,
             model.brandedIdType,
@@ -24,7 +24,7 @@ function generateRepository({ model, meta }) {
             meta.types.dto.update,
             meta.types.dto.upsert,
         ],
-        [schemaMeta.actions.importPath]: [schemaMeta.actions.actionExecutionInterface],
+        [schemaMeta.actions.importPath]: [schemaMeta.actions.actionExecution.interface],
     });
     // NOTE: We first generate different parts of the code responsible for a particular task
     //   and then we combine them into the final code block.
@@ -37,7 +37,7 @@ function generateRepository({ model, meta }) {
     //      and allow being called with an id,
     //  3.) unique string fields are ensured to be unique,
     //  4.) max length string fields are ensured to not exceed their max length,
-    //  5.) index for fields marked with index attribute,
+    //  5.) index for fields marked with index or unique attribute,
     //  6.) relations are indexed by the foreign key.
     //
     // The repository is generated differently based on whether the model is stored in the database or in memory.
@@ -47,6 +47,7 @@ function generateRepository({ model, meta }) {
     const defaultValueBlocks = generateDefaultBlocks({ model, meta });
     const uniqueStringFieldsBlocks = generateUniqueFieldsBlocks({ model, meta });
     const maxLengthBlocks = generateMaxLengthBlocks({ model, meta });
+    const validationBlocks = generateValidationBlocks({ model, meta });
     const indexBlocks = generateIndexBlocks({ model, meta, imports });
     const relationsBlocks = generateRelationsBlocks({ model, meta, imports });
     let mainBlocks;
@@ -55,12 +56,14 @@ function generateRepository({ model, meta }) {
             model,
             meta,
             schemaMeta,
+            imports,
             blocks: {
                 uniqueStringFieldsBlocks,
                 defaultValueBlocks,
                 idBlocks,
                 indexBlocks,
                 maxLengthBlocks,
+                validationBlocks,
             },
         });
     }
@@ -76,6 +79,7 @@ function generateRepository({ model, meta }) {
                 idBlocks,
                 indexBlocks,
                 maxLengthBlocks,
+                validationBlocks,
             },
         });
     }
@@ -85,9 +89,9 @@ ${idBlocks.libraryImports}
 ${imports.generate()}
 
 @Injectable()
-export class ${meta.data.repositoryClassName} implements Repository<${model.typeName}, ${idField.unbrandedTypeName}> {
+export class ${meta.data.repository.className} implements Repository<${model.typeName}, ${idField.unbrandedTypeName}> {
   protected data: Map<${model.brandedIdType}, ${model.typeName}> = new Map()
-  protected logger = new Logger(${meta.data.repositoryClassName}.name)
+  protected logger = new Logger(${meta.data.repository.className}.name)
 
   ${relationsBlocks.mapDeclarations.join('\n')}
   
@@ -96,11 +100,15 @@ export class ${meta.data.repositoryClassName} implements Repository<${model.type
   ${idBlocks.generateNextIdFunctionName}
 
   protected uniqueIds = { 
-    ${uniqueStringFieldsBlocks.mapDeclarations.join(',\n')} 
+    ${uniqueStringFieldsBlocks.mapDeclarations.join(',\n')}   
   }
-		
+  
   ${indexBlocks.nestedMapDeclarations.join('\n')}
 
+  ${mainBlocks.userRepositorySpecificBlocks.rootUserNameConst}
+
+  ${mainBlocks.userRepositorySpecificBlocks.getterBlock}
+
   ${mainBlocks.constructorCode}
   
   ${mainBlocks.initCode}
@@ -109,6 +117,8 @@ export class ${meta.data.repositoryClassName} implements Repository<${model.type
 
   ${mainBlocks.deleteAllCode}
 
+  ${mainBlocks.userRepositorySpecificBlocks.rootUserInitializeBlock}
+
   public async get(id: ${model.brandedIdType} | null): Promise<${model.typeName} | null> {
     if (id === null) { 
       return Promise.resolve(null)
@@ -126,6 +136,8 @@ export class ${meta.data.repositoryClassName} implements Repository<${model.type
 
   ${indexBlocks.getterFunctions.join('\n')}
   
+  ${uniqueStringFieldsBlocks.getByFunctions.join('\n')} 
+		
   public async filter(predicate: (item: ${model.typeName}) => boolean): Promise<${model.typeName}[]> {
     return (await this.getAllAsArray()).filter(predicate)
   }
@@ -197,7 +209,7 @@ exports.generateRepository = generateRepository;
  */
 function generateMockRepository({ model: modelSource, meta: metaSource, }) {
     // We re-use the repository block, but we change the meta data to use the mock repository name and the model to be in memory only
-    const meta = Object.assign(Object.assign({}, metaSource), { data: Object.assign(Object.assign({}, metaSource.data), { repositoryClassName: metaSource.data.mockRepositoryClassName, repoFilePath: metaSource.data.mockRepoFilePath }) });
+    const meta = Object.assign(Object.assign({}, metaSource), { data: Object.assign(Object.assign({}, metaSource.data), { repository: Object.assign(Object.assign({}, metaSource.data.repository), { className: metaSource.data.mockRepository.className, filePath: metaSource.data.mockRepository.filePath }) }) });
     const model = Object.assign(Object.assign({}, modelSource), { attributes: Object.assign(Object.assign({}, modelSource.attributes), { inMemoryOnly: true }) });
     return generateRepository({ model, meta });
 }
@@ -205,10 +217,12 @@ exports.generateMockRepository = generateMockRepository;
 /**
  * Generates the main building blocks of the repository for in-memory model.
  */
-function _generateMainBuildingBlocks_InMemoryOnly({ model, meta, blocks, }) {
+function _generateMainBuildingBlocks_InMemoryOnly({ model, meta, imports, blocks, }) {
     const methodTypeSignatures = getRepositoryMethodsTypeSignatures({ model, meta });
+    const userRepositorySpecificBlocks = generateUserRepositorySpecificBlocks_InMemoryOnly({ model, meta, imports });
     return {
         constructorCode: '',
+        userRepositorySpecificBlocks,
         initCode: `
       public async init() {
         this.data.clear()
@@ -218,6 +232,8 @@ function _generateMainBuildingBlocks_InMemoryOnly({ model, meta, blocks, }) {
     
         ${blocks.indexBlocks.initCode.join('\n')}
     
+        ${userRepositorySpecificBlocks.initCall}
+
         return Promise.resolve()
       }`,
         reInitCode: `
@@ -245,6 +261,8 @@ function _generateMainBuildingBlocks_InMemoryOnly({ model, meta, blocks, }) {
     
         ${blocks.uniqueStringFieldsBlocks.verifyCode.join('\n')}
     
+        ${blocks.validationBlocks.verifyCode.join('\n')}
+
         return {
           ${model.idField.name},
           ${model.fields
@@ -446,8 +464,10 @@ function generateMainBuildingBlocks_InDatabase({ model, meta, imports, blocks, }
         .map((part) => `"${part}"`)
         .join('.');
     const methodTypeSignatures = getRepositoryMethodsTypeSignatures({ model, meta });
+    const userRepositorySpecificBlocks = generateUserRepositorySpecificBlocks_InDatabase({ model, meta, imports });
     return {
         constructorCode: `constructor(protected db: DbService) {}`,
+        userRepositorySpecificBlocks,
         initCode: `
       public async init() {
         this.data.clear()
@@ -471,6 +491,8 @@ function generateMainBuildingBlocks_InDatabase({ model, meta, imports, blocks, }
 
         ${blocks.defaultValueBlocks.init.checkCode}
 
+        ${userRepositorySpecificBlocks.initCall}
+
         this.logger.log(\`\${format(this.data.size)} \${pluralize('${model.typeName}', this.data.size)} loaded\`)
         ${blocks.indexBlocks.initLogCode.join('\n')}
       }`,
@@ -512,6 +534,8 @@ function generateMainBuildingBlocks_InDatabase({ model, meta, imports, blocks, }
         ${blocks.maxLengthBlocks.verifyCode.join('\n')}
     
         ${blocks.uniqueStringFieldsBlocks.verifyCode.join('\n')}
+
+        ${blocks.validationBlocks.verifyCode.join('\n')}
     
         return {
           ${idField.name},
@@ -741,6 +765,100 @@ function generateMainBuildingBlocks_InDatabase({ model, meta, imports, blocks, }
       }`,
     };
 }
+function generateUserRepositorySpecificBlocks_InDatabase({ model, meta, imports, }) {
+    if (model.name !== 'User') {
+        return {
+            rootUserNameConst: '',
+            getterBlock: '',
+            initCall: '',
+            rootUserInitializeBlock: '',
+        };
+    }
+    imports.addImport({
+        from: meta.types.importPath,
+        items: [(0, types_1.toTypeName)('UserRole')],
+    });
+    return {
+        rootUserNameConst: `public static ROOT_USER_ID = ${meta.types.toBrandedIdTypeFnName}('root')`,
+        getterBlock: `
+      // We initialize the root user in the init() function
+      private _rootUser!: ${meta.types.typeName}
+      public get rootUser(): ${meta.types.typeName} {
+        return this._rootUser
+      }`,
+        initCall: `await this.initializeRootUser()`,
+        rootUserInitializeBlock: `
+      private async initializeRootUser(): Promise<void> {
+        const existingRootUser = await this.get(${meta.data.repository.className}.ROOT_USER_ID)
+        if (existingRootUser) {
+          this._rootUser = existingRootUser
+          return
+        }
+    
+        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,
+          },
+        })
+        const newRootUser = this.toUser(rawUser)
+        this.set(newRootUser)
+        this._rootUser = newRootUser
+      }`,
+    };
+}
+function generateUserRepositorySpecificBlocks_InMemoryOnly({ model, meta, imports, }) {
+    if (model.name !== 'User') {
+        return {
+            rootUserNameConst: '',
+            getterBlock: '',
+            initCall: '',
+            rootUserInitializeBlock: '',
+        };
+    }
+    imports.addImport({
+        from: meta.types.importPath,
+        items: [(0, types_1.toTypeName)('UserRole')],
+    });
+    return {
+        rootUserNameConst: `public static ROOT_USER_ID = ${meta.types.toBrandedIdTypeFnName}('root')`,
+        getterBlock: `
+      // We initialize the root user in the init() function
+      private _rootUser!: ${meta.types.typeName}
+      public get rootUser(): ${meta.types.typeName} {
+        return this._rootUser
+      }`,
+        initCall: `await this.initializeRootUser()`,
+        rootUserInitializeBlock: `
+      private async initializeRootUser(): Promise<void> {
+        const existingRootUser = await this.get(${meta.data.repository.className}.ROOT_USER_ID)
+        if (existingRootUser) {
+          this._rootUser = existingRootUser
+          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 newRootUser = this.verifyItem (rawUser)
+        this.set(newRootUser)
+        this._rootUser = newRootUser
+      }`,
+    };
+}
 /**
  * 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.
@@ -768,42 +886,42 @@ function getRepositoryMethodsTypeSignatures({ model, meta }) {
     return {
         create: {
             jsDoc: [`Creates a new ${meta.userFriendlyName} and returns it.`],
-            parameters: [`{item: ${meta.types.dto.create}, execution: ${schemaMeta.actions.actionExecutionInterface}}`],
+            parameters: [`{item: ${meta.types.dto.create}, execution: ${schemaMeta.actions.actionExecution.interface}}`],
             returnType: `Promise<${model.typeName}>`,
         },
         createMany: {
             jsDoc: [`Creates multiple new ${meta.userFriendlyNamePlural} and returns them.`],
-            parameters: [`{items: ${meta.types.dto.create}[], execution: ${schemaMeta.actions.actionExecutionInterface}}`],
+            parameters: [`{items: ${meta.types.dto.create}[], execution: ${schemaMeta.actions.actionExecution.interface}}`],
             returnType: `Promise<${model.typeName}[]>`,
         },
         update: {
             jsDoc: [`Updates a ${meta.userFriendlyName} and returns it.`],
-            parameters: [`{item: ${meta.types.dto.update}, execution: ${schemaMeta.actions.actionExecutionInterface}}`],
+            parameters: [`{item: ${meta.types.dto.update}, execution: ${schemaMeta.actions.actionExecution.interface}}`],
             returnType: `Promise<${model.typeName}>`,
         },
         updateMany: {
             jsDoc: [`Updates multiple ${meta.userFriendlyNamePlural} and returns them.`],
-            parameters: [`{items: ${meta.types.dto.update}[], execution: ${schemaMeta.actions.actionExecutionInterface}}`],
+            parameters: [`{items: ${meta.types.dto.update}[], execution: ${schemaMeta.actions.actionExecution.interface}}`],
             returnType: `Promise<${model.typeName}[]>`,
         },
         upsert: {
             jsDoc: [`Creates or updates a ${meta.userFriendlyName} and returns it.`],
-            parameters: [`{item: ${meta.types.dto.upsert}, execution: ${schemaMeta.actions.actionExecutionInterface}}`],
+            parameters: [`{item: ${meta.types.dto.upsert}, execution: ${schemaMeta.actions.actionExecution.interface}}`],
             returnType: `Promise<${model.typeName}>`,
         },
         upsertMany: {
             jsDoc: [`Creates or updates multiple ${meta.userFriendlyNamePlural} and returns them.`],
-            parameters: [`{items: ${meta.types.dto.upsert}[], execution: ${schemaMeta.actions.actionExecutionInterface}}`],
+            parameters: [`{items: ${meta.types.dto.upsert}[], execution: ${schemaMeta.actions.actionExecution.interface}}`],
             returnType: `Promise<${model.typeName}[]>`,
         },
         delete: {
             jsDoc: [`Deletes a ${meta.userFriendlyName} and returns its id.`],
-            parameters: [`{id: ${model.brandedIdType}, execution: ${schemaMeta.actions.actionExecutionInterface}}`],
+            parameters: [`{id: ${model.brandedIdType}, execution: ${schemaMeta.actions.actionExecution.interface}}`],
             returnType: `Promise<${model.brandedIdType}>`,
         },
         deleteMany: {
             jsDoc: [`Deletes multiple ${meta.userFriendlyNamePlural} and returns their ids.`],
-            parameters: [`{ids: ${model.brandedIdType}[], execution: ${schemaMeta.actions.actionExecutionInterface}}`],
+            parameters: [`{ids: ${model.brandedIdType}[], execution: ${schemaMeta.actions.actionExecution.interface}}`],
             returnType: `Promise<${model.brandedIdType}[]>`,
         },
     };
@@ -929,6 +1047,7 @@ function generateUniqueFieldsBlocks({ model }) {
     const fields = model.fields.filter(fields_1.isUniqueStringField);
     const result = {
         mapDeclarations: [],
+        getByFunctions: [],
         clearCode: [],
         verifyFunctionComment: '',
         verifyCode: [],
@@ -939,6 +1058,10 @@ function generateUniqueFieldsBlocks({ model }) {
     };
     for (const f of fields) {
         result.mapDeclarations.push(`'${f.name}': new Map<string, ${model.typeName}>()`);
+        result.getByFunctions.push(`
+      public async getBy${(0, string_1.toPascalCase)(f.name)}(${f.name}: string): Promise<${model.typeName} | undefined> { 
+        return Promise.resolve(this.uniqueIds.${f.name}.get(${(0, string_1.toCamelCase)(f.name)}))
+      }`);
         result.clearCode.push(`this.uniqueIds.${f.name}.clear()`);
         result.verifyCode.push(`this.${getEnsureUniqueFnName(f)}(item)`);
         result.updateCode.push(`
@@ -1025,6 +1148,21 @@ function generateMaxLengthBlocks({ model }) {
 function getEnsureMaxLengthFnName(field) {
     return `ensureMaxLength${(0, string_1.toPascalCase)(field.name)}`;
 }
+function generateValidationBlocks({ model }) {
+    const fields = model.fields.filter((f) => f.kind === 'scalar' && f.validation && f.validation.type === 'int');
+    const result = {
+        verifyCode: [],
+    };
+    for (const f of fields) {
+        const itemExists = f.isRequired ? '' : `item.${f.name} !== null && `;
+        result.verifyCode.push(`
+    // ensure that ${f.name} is an integer
+    if (${itemExists}item.${f.name} !== Math.floor(item.${f.name})) {
+      throw new Error(\`Invalid value for field ${f.name}: \${item.${f.name}}. Value must be an integer.\`)
+    }`);
+    }
+    return result;
+}
 function generateIndexBlocks({ model, imports, }) {
     const indexes = model.attributes.index ? [getIndexDefinition({ fieldNames: model.attributes.index, model })] : [];
     if (indexes.length > 0) {

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

@@ -31,7 +31,7 @@ function generateRoute({ model, meta }) {
             meta.businessLogic.update.createActionFunctionNameDeleteMany,
         ],
     });
-    return `
+    return /* ts */ `
 import { z } from 'zod'
 import { procedure, router } from '../trpc'
 
@@ -107,7 +107,7 @@ function generateRoutesIndex({ models, meta }) {
     for (const { meta } of mm) {
         imports.addImport({ items: [meta.trpc.routerName], from: meta.trpc.routerFilePath });
     }
-    return `
+    return /* ts */ `
     ${imports.generate()}
 
     /**

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

@@ -20,7 +20,7 @@ function generateStub({ model, meta }) {
         modelName: model.name,
         imports,
     });
-    return `
+    return /* ts */ `
 ${imports.generate()}
 
 /**

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

@@ -40,7 +40,7 @@ function generateModelTypes({ model, meta }) {
         from: schemaMeta.types.dto.path,
     });
     const decoderNames = meta.types.zodDecoderFnNames;
-    return `
+    return /* ts */ `
 import { z } from 'zod'
 
 ${imports.generate()}

package/dist/lib/id-collector.d.ts

@@ -0,0 +1,43 @@
+type ElementId = string & {
+    __brand: 'ElementId';
+};
+/**
+ * The SelectorCollector is used to generate and track HTML element IDs.
+ * The idea is that it is instantiated once and then used to generate IDs throughout the generators.
+ * After the files are generated, all generated IDs can be serialized to a file.
+ *
+ * An ID can for instance be something like `post-create-name, `${model.name}-${componentType}-${fieldName}`.
+ *
+ * Each code generator can instantiate an SelectorCollector - the constructor will require the current model & component type.
+ * All generated Ids will be stored in a global static Set so we can serialize them later.
+ */
+export declare class SelectorCollector {
+    private _prefix;
+    /**
+     * We store all generated IDs in a global static Set so we can serialize them later.
+     */
+    private static _ids;
+    constructor(_prefix: string);
+    /**
+     * Creates a new instance of the SelectorCollector.
+     */
+    static from(prefix: string): SelectorCollector;
+    /**
+     * Generates a new ID for an element and stores it in the collector
+     */
+    idFor(
+    /**
+     * The name of the element, e.g. `age`, `submit`.
+     */
+    elementName: string, options?: {
+        /**
+         * Optional prefix for the type of the element, e.g. `field` or `button`.
+         */
+        typePrefix?: string;
+    }): string;
+    /**
+     * Returns all generated IDs and resets the stored IDs.
+     */
+    static flush(): ElementId[];
+}
+export {};

package/dist/lib/id-collector.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SelectorCollector = void 0;
+/**
+ * The SelectorCollector is used to generate and track HTML element IDs.
+ * The idea is that it is instantiated once and then used to generate IDs throughout the generators.
+ * After the files are generated, all generated IDs can be serialized to a file.
+ *
+ * An ID can for instance be something like `post-create-name, `${model.name}-${componentType}-${fieldName}`.
+ *
+ * Each code generator can instantiate an SelectorCollector - the constructor will require the current model & component type.
+ * All generated Ids will be stored in a global static Set so we can serialize them later.
+ */
+class SelectorCollector {
+    constructor(_prefix) {
+        this._prefix = _prefix;
+    }
+    /**
+     * Creates a new instance of the SelectorCollector.
+     */
+    static from(prefix) {
+        return new SelectorCollector(prefix);
+    }
+    /**
+     * Generates a new ID for an element and stores it in the collector
+     */
+    idFor(
+    /**
+     * The name of the element, e.g. `age`, `submit`.
+     */
+    elementName, options) {
+        const { typePrefix } = options !== null && options !== void 0 ? options : {};
+        const id = [this._prefix, typePrefix, elementName].filter((x) => x !== undefined && x !== '').join('-');
+        if (SelectorCollector._ids.has(id)) {
+            throw new Error(`ID ${id} already exists.`);
+        }
+        SelectorCollector._ids.add(id);
+        return id;
+    }
+    /**
+     * Returns all generated IDs and resets the stored IDs.
+     */
+    static flush() {
+        const result = [...SelectorCollector._ids.values()];
+        SelectorCollector._ids.clear();
+        return result;
+    }
+}
+exports.SelectorCollector = SelectorCollector;
+/**
+ * We store all generated IDs in a global static Set so we can serialize them later.
+ */
+SelectorCollector._ids = new Set();

package/dist/lib/imports.d.ts

@@ -6,7 +6,7 @@ import * as Types from './schema/types';
  * Example:
  * ```
  * {
- *   [meta.data.importPath]: meta.data.repositoryClassName,
+ *   [meta.data.importPath]: meta.data.repository.className,
  *   [meta.types.importPath]: [model.brandedIdType, meta.types.typeName],
  * }
  * ```