@postxl/generator 0.39.0 → 0.40.1

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;
@@ -62,6 +63,7 @@ function generateRepository({ model, meta }) {
                 idBlocks,
                 indexBlocks,
                 maxLengthBlocks,
+                validationBlocks,
             },
         });
     }
@@ -77,6 +79,7 @@ function generateRepository({ model, meta }) {
                 idBlocks,
                 indexBlocks,
                 maxLengthBlocks,
+                validationBlocks,
             },
         });
     }
@@ -86,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')}
   
@@ -97,9 +100,9 @@ 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}
@@ -133,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)
   }
@@ -204,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 });
 }
@@ -256,6 +261,8 @@ function _generateMainBuildingBlocks_InMemoryOnly({ model, meta, imports, blocks
     
         ${blocks.uniqueStringFieldsBlocks.verifyCode.join('\n')}
     
+        ${blocks.validationBlocks.verifyCode.join('\n')}
+
         return {
           ${model.idField.name},
           ${model.fields
@@ -527,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},
@@ -780,7 +789,7 @@ function generateUserRepositorySpecificBlocks_InDatabase({ model, meta, imports,
         initCall: `await this.initializeRootUser()`,
         rootUserInitializeBlock: `
       private async initializeRootUser(): Promise<void> {
-        const existingRootUser = await this.get(${meta.data.repositoryClassName}.ROOT_USER_ID)
+        const existingRootUser = await this.get(${meta.data.repository.className}.ROOT_USER_ID)
         if (existingRootUser) {
           this._rootUser = existingRootUser
           return
@@ -788,7 +797,7 @@ function generateUserRepositorySpecificBlocks_InDatabase({ model, meta, imports,
     
         const rawUser = await this.db.user.create({
           data: {
-            id: ${meta.data.repositoryClassName}.ROOT_USER_ID,
+            id: ${meta.data.repository.className}.ROOT_USER_ID,
             name: 'System',
             email: 'system@postxl.com',
             role: UserRole.Admin,
@@ -828,14 +837,14 @@ function generateUserRepositorySpecificBlocks_InMemoryOnly({ model, meta, import
         initCall: `await this.initializeRootUser()`,
         rootUserInitializeBlock: `
       private async initializeRootUser(): Promise<void> {
-        const existingRootUser = await this.get(${meta.data.repositoryClassName}.ROOT_USER_ID)
+        const existingRootUser = await this.get(${meta.data.repository.className}.ROOT_USER_ID)
         if (existingRootUser) {
           this._rootUser = existingRootUser
           return
         }
     
         const rawUser = {
-          id: ${meta.data.repositoryClassName}.ROOT_USER_ID,
+          id: ${meta.data.repository.className}.ROOT_USER_ID,
           name: 'System',
           email: 'system@postxl.com',
           role: UserRole.Admin,
@@ -877,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}[]>`,
         },
     };
@@ -1038,6 +1047,7 @@ function generateUniqueFieldsBlocks({ model }) {
     const fields = model.fields.filter(fields_1.isUniqueStringField);
     const result = {
         mapDeclarations: [],
+        getByFunctions: [],
         clearCode: [],
         verifyFunctionComment: '',
         verifyCode: [],
@@ -1048,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(`
@@ -1134,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/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],
  * }
  * ```