@postxl/generator 0.36.0 → 0.38.0

package/dist/generators/indices/dataservice.generator.js

@@ -20,9 +20,9 @@ function generateDataService({ models, meta }) {
         .join(',\n');
     const initializer = mm.map(({ meta }) => `await this.${meta.data.dataServiceName}.init()`).join('\n');
     const excelExports = mm
-        .map(({ meta }) => `${meta.data.excelExportTableName}: mapValues(this.${meta.data.dataServiceName}.getAll()),`)
+        .map(({ meta }) => `${meta.data.excelExportTableName}: mapValues(await this.${meta.data.dataServiceName}.getAll()),`)
         .join('\n');
-    const isEmptyChecks = mm.map(({ meta }) => `this.${meta.data.dataServiceName}.count() === 0`).join(' &&');
+    const isEmptyChecks = mm.map(({ meta }) => `(await this.${meta.data.dataServiceName}.count()) === 0`).join(' &&');
     return `
 import { Injectable } from '@nestjs/common'
 import { mapValues } from '@pxl/common'
@@ -33,7 +33,7 @@ ${imports.generate()}
 export class DataService {
   constructor(${constructor}) {}
 
-  public prepareExcelExport() {
+  public async prepareExcelExport() {
     return {
       ${excelExports}
     }
@@ -43,7 +43,7 @@ export class DataService {
     ${initializer}
   }
 
-  public isEmpty(): boolean {
+  public async isEmpty(): Promise<boolean> {
     return (
       ${isEmptyChecks}
     )

package/dist/generators/models/businesslogic-view.generator.js

@@ -41,7 +41,7 @@ function generateModelBusinessLogicView({ model, meta }) {
     for (const relation of (0, fields_1.getRelationFields)(model)) {
         const refModel = relation.relationToModel;
         const refMeta = (0, meta_1.getModelMetadata)({ model: refModel });
-        const variableGetter = `this.${viewServiceClassName}.${refMeta.businessLogic.view.serviceVariableName}.get(itemRaw.${relation.name})`;
+        const variableGetter = `await this.${viewServiceClassName}.${refMeta.businessLogic.view.serviceVariableName}.get(itemRaw.${relation.name})`;
         const variablePresenceCheck = `
       if (!${relation.relatedModelBacklinkFieldName}) {
         throw new Error(\`Could not find ${refMeta.types.typeName} with id \${itemRaw.${relation.name}} for ${model.typeName}.${relation.name}!\`)
@@ -66,8 +66,8 @@ function generateModelBusinessLogicView({ model, meta }) {
      * Returns the linked ${meta.userFriendlyName} with the given id or null if it does not exist.
      * Linked: The ${meta.userFriendlyName} contains the linked (raw) items themselves, not only the ids.
      */
-    public getLinkedItem(id: ${model.brandedIdType}): ${meta.types.linkedTypeName} | null {
-      const itemRaw = this.${modelRepositoryVariableName}.get(id)
+    public async getLinkedItem(id: ${model.brandedIdType}): Promise<${meta.types.linkedTypeName} | null> {
+      const itemRaw = await this.${modelRepositoryVariableName}.get(id)
       if (!itemRaw) {
         return null
       }
@@ -107,7 +107,7 @@ export class ${meta.businessLogic.view.serviceClassName} {
    * Returns the raw ${meta.userFriendlyName} with the given id or null if it does not exist.
    * Raw: The ${meta.userFriendlyName} only contains linked Ids, not the linked items themselves.
    */
-  public get(id: ${model.brandedIdType}): ${meta.types.typeName} | null {
+  public async get(id: ${model.brandedIdType}): Promise<${meta.types.typeName} | null> {
     return this.${modelRepositoryVariableName}.get(id)
   }
 
@@ -116,14 +116,14 @@ export class ${meta.businessLogic.view.serviceClassName} {
   /**
    * Returns a map of all ${meta.userFriendlyNamePlural}.
    */
-  public getAll(): Map<${meta.types.brandedIdType}, ${model.typeName}> {
+  public async getAll(): Promise<Map<${meta.types.brandedIdType}, ${model.typeName}>> {
     return this.${modelRepositoryVariableName}.getAll()
   }
 
   /**
    * Returns a list of filtered, sorted and paginated ${meta.userFriendlyNamePlural}.
    */
-  public getList({
+  public async getList({
     filter,
     sort,
     cursor,
@@ -132,7 +132,7 @@ export class ${meta.businessLogic.view.serviceClassName} {
     sort?: { field: keyof ${model.typeName}; ascending: boolean }
     cursor?: { startRow: number; endRow: number }
   }) {
-    const items = this.data.getAllAsArray()
+    const items = await this.data.getAllAsArray()
     const filtered = !filter
       ? items
       : items.filter((item) => filterFn(item, filter.field, filter.operator, filter.value))

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

@@ -109,33 +109,33 @@ export class ${meta.data.repositoryClassName} implements Repository<${model.type
 
   ${mainBlocks.deleteAllCode}
 
-  public get(id: ${model.brandedIdType} | null): ${model.typeName} | null {
+  public async get(id: ${model.brandedIdType} | null): Promise<${model.typeName} | null> {
     if (id === null) { 
-      return null
+      return Promise.resolve(null)
     }
-    return this.data.get(id) ?? null
+    return Promise.resolve(this.data.get(id) ?? null)
   }
 
-  public getAll(): Map<${model.brandedIdType}, ${model.typeName}> {
-    return new Map(this.data)
+  public async getAll(): Promise<Map<${model.brandedIdType}, ${model.typeName}>> {
+    return Promise.resolve(new Map(this.data))
   }
 
-  public getAllAsArray(): ${model.typeName}[] {
-    return Array.from(this.data.values())
+  public async getAllAsArray(): Promise<${model.typeName}[]> {
+    return Promise.resolve(Array.from(this.data.values()))
   }
 
   ${indexBlocks.getterFunctions.join('\n')}
   
-  public filter(predicate: (item: ${model.typeName}) => boolean): ${model.typeName}[] {
-    return this.getAllAsArray().filter(predicate)
+  public async filter(predicate: (item: ${model.typeName}) => boolean): Promise<${model.typeName}[]> {
+    return (await this.getAllAsArray()).filter(predicate)
   }
 
-  public findFirst(predicate: (item: ${model.typeName}) => boolean): ${model.typeName} | null {
-    return this.getAllAsArray().find(predicate) ?? null
+  public async findFirst(predicate: (item: ${model.typeName}) => boolean): Promise<${model.typeName} | null> {
+    return (await this.getAllAsArray()).find(predicate) ?? null
   }
 
-  public count(): number {
-    return this.data.size
+  public async count(): Promise<number> {
+    return Promise.resolve(this.data.size)
   }
   
   ${mainBlocks.createCode}
@@ -313,7 +313,7 @@ function _generateMainBuildingBlocks_InMemoryOnly({ model, meta, blocks, }) {
       public async update(
         { item, execution }: ${methodTypeSignatures.update.parameters[0]}
       ): ${methodTypeSignatures.update.returnType} {
-        const existingItem = this.get(item.id)
+        const existingItem = await this.get(item.id)
     
         if (!existingItem) {
           throw new Error(\`Could not update ${meta.userFriendlyName} with id \${item.id}. Not found!\`)
@@ -363,7 +363,7 @@ function _generateMainBuildingBlocks_InMemoryOnly({ model, meta, blocks, }) {
       public async upsert(
         { item, execution }: ${methodTypeSignatures.upsert.parameters[0]}
       ): ${methodTypeSignatures.upsert.returnType} {
-        const existingItem = item.${model.idField.name} ? this.get(item.${model.idField.name}) : null
+        const existingItem = item.${model.idField.name} ? (await this.get(item.${model.idField.name})) : null
         if (existingItem) {
           return this.update({ item: item as ${meta.types.dto.update}, execution })
         } else {
@@ -391,7 +391,7 @@ function _generateMainBuildingBlocks_InMemoryOnly({ model, meta, blocks, }) {
       public async delete(
         { id, execution }: ${methodTypeSignatures.delete.parameters[0]}
       ): ${methodTypeSignatures.delete.returnType} {
-        const existingItem = this.get(id)
+        const existingItem = await this.get(id)
         if (!existingItem) {
           throw new Error(\`Could not delete ${model.typeName} with id \${id}. Not found!\`)
         }
@@ -599,7 +599,7 @@ function generateMainBuildingBlocks_InDatabase({ model, meta, imports, blocks, }
       public async update(
         { item, execution }: ${methodTypeSignatures.update.parameters[0]}
       ): ${methodTypeSignatures.update.returnType} {
-        const existingItem = this.get(item.${idField.name})
+        const existingItem = await this.get(item.${idField.name})
         if (!existingItem) {
           throw new Error(\`Could not update ${meta.userFriendlyName} with id \${item.id}. Not found!\`)
         }
@@ -662,7 +662,7 @@ function generateMainBuildingBlocks_InDatabase({ model, meta, imports, blocks, }
       public async upsert(
         { item, execution }: ${methodTypeSignatures.upsert.parameters[0]}
       ): ${methodTypeSignatures.upsert.returnType} {
-        const existingItem = item.${model.idField.name} ? this.get(item.${model.idField.name}) : null
+        const existingItem = item.${model.idField.name} ? (await this.get(item.${model.idField.name})) : null
         if (existingItem) {
           return this.update({ item: item as ${meta.types.dto.update}, execution })
         } else {
@@ -690,7 +690,7 @@ function generateMainBuildingBlocks_InDatabase({ model, meta, imports, blocks, }
       public async delete(
         { id, execution }: ${methodTypeSignatures.delete.parameters[0]}
       ): ${methodTypeSignatures.delete.returnType} {
-        const existingItem = this.get(id)
+        const existingItem = await this.get(id)
         if (!existingItem) {
           throw new Error(\`Could not delete ${model.typeName} with id \${id}. Not found!\`)
         }
@@ -1098,28 +1098,28 @@ function generateRelationsBlocks({ model, imports, }) {
       /** 
        * Function to retrieve all ${(0, string_1.pluralize)(model.name)} that are related to a ${r.name}
        */
-      public ${fieldMeta.getByForeignKeyMethodFnName}(
+      public async ${fieldMeta.getByForeignKeyMethodFnName}(
         id: ${relationModelMeta.types.brandedIdType}
-      ): Map<${model.brandedIdType}, ${model.typeName}> {
+      ): Promise<Map<${model.brandedIdType}, ${model.typeName}>> {
         const result = this.${r.name}Map.get(id)
         if (!result) {
-          return new Map()
+          return Promise.resolve(new Map<${model.brandedIdType}, ${model.typeName}>())
         }
-        return new Map(result)
+        return Promise.resolve(new Map(result))
       }
 
       /** 
        * Function to retrieve all ${model.brandedIdType}s that are related to a ${r.name}
        */
-      public ${fieldMeta.getByForeignKeyIdsMethodFnName}(
+      public async ${fieldMeta.getByForeignKeyIdsMethodFnName}(
         id: ${relationModelMeta.types.brandedIdType}
-      ): ${model.brandedIdType}[] {
+      ): Promise<${model.brandedIdType}[]> {
         const s = this.${r.name}Map.get(id)
         if (!s) {
-          return []
+          return Promise.resolve([])
         }
         
-        return Array.from(s.keys())
+        return Promise.resolve(Array.from(s.keys()))
       }`);
         result.setCode.push(`
       ${!r.isRequired ? `if (item.${r.name}) {` : ''}

package/package.json

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