@postxl/generator 0.0.20 → 0.0.21

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

@@ -12,18 +12,18 @@ function generateRepository({ model, meta }) {
     const { idField, fields } = model;
     const decoder = meta.data.repository.decoderFnName;
     const uniqueStringFields = fields.filter(fields_1.isUniqueStringField);
-    const defaultValueInitFn = `
-		if (item.${(_a = model.defaultField) === null || _a === void 0 ? void 0 : _a.name}) {
-			if (this.defaultValue) {
-				console.warn(\`More than one default ${meta.userFriendlyName} found! \${this.defaultValue.id} and \${item.id}\`)
-			}
-			this.defaultValue = item
-		}
+    const defaultValueInitFn = `
+		if (item.${(_a = model.defaultField) === null || _a === void 0 ? void 0 : _a.name}) {
+			if (this.defaultValue) {
+				console.warn(\`More than one default ${meta.userFriendlyName} found! \${this.defaultValue.id} and \${item.id}\`)
+			}
+			this.defaultValue = item
+		}
 	`;
-    const defaultValueInitCheckFn = `
-		if (!this.db.isCLI && !this.defaultValue) {
-      throw new Error('No default ${meta.userFriendlyName} found!')
-    }
+    const defaultValueInitCheckFn = `
+		if (!this.db.isCLI && !this.defaultValue) {
+      throw new Error('No default ${meta.userFriendlyName} found!')
+    }
 	`;
     const { isGenerated } = idField;
     const idIntInitFn = `this.currentMaxId = (await this.db.${meta.data.repository.getMethodFnName}.aggregate({ _max: { ${idField.sourceName}: true } }))._max.${idField.sourceName} ?? 0`;
@@ -33,256 +33,256 @@ function generateRepository({ model, meta }) {
         from: meta.types.importPath,
     })
         .addImport({ items: [meta.types.zodDecoderFnName], from: meta.types.importPath });
-    return `
-import { Injectable, Logger } from '@nestjs/common'
-import { DbService } from '@${model.schemaConfig.project}/db'
-
-import { Repository } from '../repository.type'
-
-${imports.generate()}
-
-@Injectable()
-export class ${meta.data.repositoryClassName} implements Repository<
-	${model.typeName}, 
-	${idField.unbrandedTypeName}, 
-	Omit<${model.typeName}, 'id'>
-> {
-  protected data: Map<${model.brandedIdType}, ${model.typeName}> = new Map()
-  protected logger = new Logger(${meta.data.repositoryClassName}.name)
-
-  ${model.defaultField ? `public defaultValue!: ${model.typeName}` : ''}
-
-  ${isGenerated ? `protected currentMaxId = 0\n` : ''}
-
-  protected uniqueIds = {
-		${uniqueStringFields.map((f) => `'${f.name}': new Map<string, ${model.typeName}>()`).join(',\n')}
-	}
-
-  constructor(protected db: DbService) {}
-
-  public async init() {
-    this.data.clear()
-    
-    ${uniqueStringFields.map((f) => `this.uniqueIds.${f.name}.clear()\n`)}
-    
-		this.logger.log(\`Loading ${model.typeName} instances into repository...\`)
-
-    const data = await this.db.${meta.data.repository.getMethodFnName}.findMany({})
-
-    for (const rawItem of data) {
-      const item = this.${decoder}(rawItem)
-      this.data.set(item.id, item)
-
-      ${model.defaultField ? defaultValueInitFn : ''}
-      ${uniqueStringFields.map((f) => `this.uniqueIds.${f.name}.set(item.${f.name}, item)`).join('\n')}
-    }
-
-    ${isGenerated ? idIntInitFn : ''}
-
-    ${model.defaultField ? defaultValueInitCheckFn : ''}
-
-    this.logger.log(\`Loaded \${this.data.size} instances of ${model.typeName} into repository!\`)
-  }
-
-  public async reInit(data: ${model.typeName}[]): Promise<void> {
-    if (!this.db.useE2ETestDB) {
-      const errorMsg =
-        'ReInit() shall only be called in tests using MockRepositories or in DB configured for E2E tests!'
-      this.logger.error(errorMsg)
-      throw new Error(errorMsg)
-    }
-    await this.db.runOnlyOnTestDb(() => this.db.${meta.data.repository.getMethodFnName}.createMany({ data: data.map((i) => this.toCreateItem(i)) }))
-    return this.init()
-  }
-
-  public get(id: ${model.brandedIdType} | null): ${model.typeName} | null {
-    if (id === null) return null
-    return this.data.get(${meta.types.toBrandedIdTypeFnName}(id)) ?? null
-  }
-
-  public getAll(): Map<${model.brandedIdType}, ${model.typeName}> {
-    return this.data
-  }
-
-  public getAllAsArray(): ${model.typeName}[] {
-    return Array.from(this.data.values())
-  }
-
-  public filter(predicate: (item: ${model.typeName}) => boolean): ${model.typeName}[] {
-    return this.getAllAsArray().filter(predicate)
-  }
-
-  public findFirst(predicate: (item: ${model.typeName}) => boolean): ${model.typeName} | null {
-    return this.getAllAsArray().find(predicate) ?? null
-  }
-
-  public count(): number {
-    return this.data.size
-  }
-
-  private toCreateItem(item: ${model.typeName}) {
+    return `
+import { Injectable, Logger } from '@nestjs/common'
+import { DbService } from '@${model.schemaConfig.project}/db'
+
+import { Repository } from '../repository.type'
+
+${imports.generate()}
+
+@Injectable()
+export class ${meta.data.repositoryClassName} implements Repository<
+	${model.typeName}, 
+	${idField.unbrandedTypeName}, 
+	Omit<${model.typeName}, 'id'>
+> {
+  protected data: Map<${model.brandedIdType}, ${model.typeName}> = new Map()
+  protected logger = new Logger(${meta.data.repositoryClassName}.name)
+
+  ${model.defaultField ? `public defaultValue!: ${model.typeName}` : ''}
+
+  ${isGenerated ? `protected currentMaxId = 0\n` : ''}
+
+  protected uniqueIds = {
+		${uniqueStringFields.map((f) => `'${f.name}': new Map<string, ${model.typeName}>()`).join(',\n')}
+	}
+
+  constructor(protected db: DbService) {}
+
+  public async init() {
+    this.data.clear()
+    
+    ${uniqueStringFields.map((f) => `this.uniqueIds.${f.name}.clear()\n`)}
+    
+		this.logger.log(\`Loading ${model.typeName} instances into repository...\`)
+
+    const data = await this.db.${meta.data.repository.getMethodFnName}.findMany({})
+
+    for (const rawItem of data) {
+      const item = this.${decoder}(rawItem)
+      this.data.set(item.id, item)
+
+      ${model.defaultField ? defaultValueInitFn : ''}
+      ${uniqueStringFields.map((f) => `this.uniqueIds.${f.name}.set(item.${f.name}, item)`).join('\n')}
+    }
+
+    ${isGenerated ? idIntInitFn : ''}
+
+    ${model.defaultField ? defaultValueInitCheckFn : ''}
+
+    this.logger.log(\`Loaded \${this.data.size} instances of ${model.typeName} into repository!\`)
+  }
+
+  public async reInit(data: ${model.typeName}[]): Promise<void> {
+    if (!this.db.useE2ETestDB) {
+      const errorMsg =
+        'ReInit() shall only be called in tests using MockRepositories or in DB configured for E2E tests!'
+      this.logger.error(errorMsg)
+      throw new Error(errorMsg)
+    }
+    await this.db.runOnlyOnTestDb(() => this.db.${meta.data.repository.getMethodFnName}.createMany({ data: data.map((i) => this.toCreateItem(i)) }))
+    return this.init()
+  }
+
+  public get(id: ${model.brandedIdType} | null): ${model.typeName} | null {
+    if (id === null) return null
+    return this.data.get(${meta.types.toBrandedIdTypeFnName}(id)) ?? null
+  }
+
+  public getAll(): Map<${model.brandedIdType}, ${model.typeName}> {
+    return this.data
+  }
+
+  public getAllAsArray(): ${model.typeName}[] {
+    return Array.from(this.data.values())
+  }
+
+  public filter(predicate: (item: ${model.typeName}) => boolean): ${model.typeName}[] {
+    return this.getAllAsArray().filter(predicate)
+  }
+
+  public findFirst(predicate: (item: ${model.typeName}) => boolean): ${model.typeName} | null {
+    return this.getAllAsArray().find(predicate) ?? null
+  }
+
+  public count(): number {
+    return this.data.size
+  }
+
+  private toCreateItem(item: ${model.typeName}) {
     ${isGenerated
-        ? `if (item.${idField.name} > ++this.currentMaxId) {
-      this.currentMaxId = item.${idField.name}
-    } else { 
-      item.${idField.name} = this.currentMaxId as ${model.brandedIdType}
+        ? `if (item.${idField.name} > ++this.currentMaxId) {
+      this.currentMaxId = item.${idField.name}
+    } else { 
+      item.${idField.name} = this.currentMaxId as ${model.brandedIdType}
     }`
-        : ''}
-
-    ${uniqueStringFields.map((f) => `this.${getEnsureUniqueFnName(f)}(item)`).join('\n')}
-
-    return {
-      ${[...model.fields.values()].map((f) => `${f.sourceName}: item.${f.name}`).join(',\n')}
-    }
-  }
-  public async createWithId(item: Omit<${model.typeName}, '${idField.name}'> & { 
-		id: ${model.brandedIdType}
-	}): Promise<${model.typeName}> {    
-    const newItem = this.${decoder}(
-      await this.db.${meta.data.repository.getMethodFnName}.create({
-        data: this.toCreateItem(item as ${model.typeName}),
-      }),
-    )
-
-    ${uniqueStringFields.map((f) => `this.uniqueIds.${f.name}.set(newItem.${f.name}, newItem)`).join('\n')}
-
-    this.data.set(newItem.id, newItem)
-    return newItem
-  }
-
-  public async create(
-		item: Omit<${model.typeName}, 'id'>
-	): Promise<${model.typeName}> {
-    ${isGenerated ? `const id = ++this.currentMaxId\n` : ''}
-
-    ${uniqueStringFields.map((f) => `this.${getEnsureUniqueFnName(f)}(item)`).join('\n')}
-
-    const newItem = this.${decoder}(
-      await this.db.${meta.data.repository.getMethodFnName}.create({
-        data: {
-          ${isGenerated ? `${idField.sourceName}: id,` : ''}
+        : ''}
+
+    ${uniqueStringFields.map((f) => `this.${getEnsureUniqueFnName(f)}(item)`).join('\n')}
+
+    return {
+      ${[...model.fields.values()].map((f) => `${f.sourceName}: item.${f.name}`).join(',\n')}
+    }
+  }
+  public async createWithId(item: Omit<${model.typeName}, '${idField.name}'> & { 
+		id: ${model.brandedIdType}
+	}): Promise<${model.typeName}> {    
+    const newItem = this.${decoder}(
+      await this.db.${meta.data.repository.getMethodFnName}.create({
+        data: this.toCreateItem(item as ${model.typeName}),
+      }),
+    )
+
+    ${uniqueStringFields.map((f) => `this.uniqueIds.${f.name}.set(newItem.${f.name}, newItem)`).join('\n')}
+
+    this.data.set(newItem.id, newItem)
+    return newItem
+  }
+
+  public async create(
+		item: Omit<${model.typeName}, 'id'>
+	): Promise<${model.typeName}> {
+    ${isGenerated ? `const id = ++this.currentMaxId\n` : ''}
+
+    ${uniqueStringFields.map((f) => `this.${getEnsureUniqueFnName(f)}(item)`).join('\n')}
+
+    const newItem = this.${decoder}(
+      await this.db.${meta.data.repository.getMethodFnName}.create({
+        data: {
+          ${isGenerated ? `${idField.sourceName}: id,` : ''}
           ${[...model.fields.values()]
         .filter((f) => f.kind !== 'id')
         .map((f) => `${f.sourceName}: item.${f.name}`)
-        .join(',\n')}
-        },
-      }),
-    )
-
-    ${uniqueStringFields.map((f) => `this.uniqueIds.${f.name}.set(newItem.${f.name}, newItem)`).join('\n')}
-
-    this.data.set(newItem.id, newItem)
-    return newItem
-  }
-
-  public async createMany(items: Omit<${model.typeName}, 'id' | 'createdAt' | 'updatedAt'>[]): Promise<${model.typeName}[]> {
-    const result: ${model.typeName}[] = []
-    for (const item of items) {
-      const i = await this.create(item)
-      result.push(i)
-    }
-    return result
-  }
-  
-  public async update(item: Partial<${model.typeName}> & { 
-		id: ${model.brandedIdType}
-	}): Promise<${model.typeName}> {
-    const existingItem = this.get(item.id)
-
-    if (!existingItem) {
-      throw new Error(\`Could not update ${meta.userFriendlyName} with id \${item.id}. Not found!\`)
-    }
-
+        .join(',\n')}
+        },
+      }),
+    )
+
+    ${uniqueStringFields.map((f) => `this.uniqueIds.${f.name}.set(newItem.${f.name}, newItem)`).join('\n')}
+
+    this.data.set(newItem.id, newItem)
+    return newItem
+  }
+
+  public async createMany(items: Omit<${model.typeName}, 'id' | 'createdAt' | 'updatedAt'>[]): Promise<${model.typeName}[]> {
+    const result: ${model.typeName}[] = []
+    for (const item of items) {
+      const i = await this.create(item)
+      result.push(i)
+    }
+    return result
+  }
+  
+  public async update(item: Partial<${model.typeName}> & { 
+		id: ${model.brandedIdType}
+	}): Promise<${model.typeName}> {
+    const existingItem = this.get(item.id)
+
+    if (!existingItem) {
+      throw new Error(\`Could not update ${meta.userFriendlyName} with id \${item.id}. Not found!\`)
+    }
+
     ${uniqueStringFields
         .map((f) => {
-        return `
-					if (item.${f.name} !== undefined && existingItem.${f.name} !== item.${f.name}) {
-						this.${getEnsureUniqueFnName(f)}(item)
-					}
+        return `
+					if (item.${f.name} !== undefined && existingItem.${f.name} !== item.${f.name}) {
+						this.${getEnsureUniqueFnName(f)}(item)
+					}
 				`;
     })
-        .join('\n')}
-
-    const newItem = this.${decoder}(
-      await this.db.${meta.data.repository.getMethodFnName}.update({
-        where: { 
-					${idField.sourceName}: item.${idField.name},
-				},
-        data: {
+        .join('\n')}
+
+    const newItem = this.${decoder}(
+      await this.db.${meta.data.repository.getMethodFnName}.update({
+        where: { 
+					${idField.sourceName}: item.${idField.name},
+				},
+        data: {
 					${[...model.fields.values()]
         .filter((f) => f.kind !== 'id')
         .map((f) => f.isRequired
         ? `${f.sourceName}: item.${f.name} ?? existingItem.${f.name}`
         : `${f.sourceName}: item.${f.name}`)
-        .join(',\n')}
-
-       
-        },
-      }),
-    )
-
+        .join(',\n')}
+
+       
+        },
+      }),
+    )
+
     ${uniqueStringFields
         .map((f) => {
-        return `
-          if (item.${f.name} !== undefined && existingItem.${f.name} !== item.${f.name}) {
-            this.uniqueIds.${f.name}.delete(existingItem.${f.name})
-            if (item.${f.name} !== null) {
-              this.uniqueIds.${f.name}.set(newItem.${f.name}, newItem)
-            }
-          }
+        return `
+          if (item.${f.name} !== undefined && existingItem.${f.name} !== item.${f.name}) {
+            this.uniqueIds.${f.name}.delete(existingItem.${f.name})
+            if (item.${f.name} !== null) {
+              this.uniqueIds.${f.name}.set(newItem.${f.name}, newItem)
+            }
+          }
 				`;
     })
-        .join('\n')}
-
-    this.data.set(newItem.id, newItem)
-    return newItem
-  }
-
-  public async delete(id: ${model.brandedIdType}): Promise<void> {
-    const existingItem = this.get(id)
-    if (!existingItem) {
-      throw new Error(\`Could not delete ${model.typeName} with id \${id}. Not found!\`)
-    }
-
-    await this.db.${meta.data.repository.getMethodFnName}.delete({ where: { ${idField.sourceName}:id } })
-
-    ${uniqueStringFields.map((f) => `this.uniqueIds.${f.name}.delete(existingItem.${f.name})`).join('\n')}
-
-    this.data.delete(${meta.types.toBrandedIdTypeFnName}(id))
-  }
-
+        .join('\n')}
+
+    this.data.set(newItem.id, newItem)
+    return newItem
+  }
+
+  public async delete(id: ${model.brandedIdType}): Promise<void> {
+    const existingItem = this.get(id)
+    if (!existingItem) {
+      throw new Error(\`Could not delete ${model.typeName} with id \${id}. Not found!\`)
+    }
+
+    await this.db.${meta.data.repository.getMethodFnName}.delete({ where: { ${idField.sourceName}:id } })
+
+    ${uniqueStringFields.map((f) => `this.uniqueIds.${f.name}.delete(existingItem.${f.name})`).join('\n')}
+
+    this.data.delete(${meta.types.toBrandedIdTypeFnName}(id))
+  }
+
   ${uniqueStringFields
         .map((f) => {
-        return `
-  /**
-   * Utility function that ensures that the ${f.name} field is unique
-   */      
-  private ${getEnsureUniqueFnName(f)}(item: { ${f.name}?: string }) {
-      if (!item.${f.name}) return
-      if (!this.uniqueIds.${f.name}.has(item.${f.name})) return
-      let counter = 1
-
-      let ${f.name}: string
-      const source${f.name} =${!f.attributes.maxLength ? `item.${f.name}` : `item.${f.name}.substring(0, ${f.attributes.maxLength - 5})`}
-
-      do {
-        ${f.name} = \`\${source${f.name}} (\${++counter})\`
-      } while (this.uniqueIds.${f.name}.has(${f.name}))
-
-      this.logger.log(\`${model.typeName} ${f.name} "\${item.${f.name}}" already exists. Renaming to "\${${f.name}}")\`)
-      item.${f.name} = ${f.name}
-    }
+        return `
+  /**
+   * Utility function that ensures that the ${f.name} field is unique
+   */      
+  private ${getEnsureUniqueFnName(f)}(item: { ${f.name}?: string }) {
+      if (!item.${f.name}) return
+      if (!this.uniqueIds.${f.name}.has(item.${f.name})) return
+      let counter = 1
+
+      let ${f.name}: string
+      const source${f.name} =${!f.attributes.maxLength ? `item.${f.name}` : `item.${f.name}.substring(0, ${f.attributes.maxLength - 5})`}
+
+      do {
+        ${f.name} = \`\${source${f.name}} (\${++counter})\`
+      } while (this.uniqueIds.${f.name}.has(${f.name}))
+
+      this.logger.log(\`${model.typeName} ${f.name} "\${item.${f.name}}" already exists. Renaming to "\${${f.name}}")\`)
+      item.${f.name} = ${f.name}
+    }
 			`;
     })
-        .join('\n\n')}
-
-    /**
-     * Utility function that converts a given Database object to a TypeScript model instance
-     */
-    private ${decoder}(item: unknown): ${model.typeName} {
-      return ${meta.types.zodDecoderFnName}.parse(item)
-    }
-}
+        .join('\n\n')}
+
+    /**
+     * Utility function that converts a given Database object to a TypeScript model instance
+     */
+    private ${decoder}(item: unknown): ${model.typeName} {
+      return ${meta.types.zodDecoderFnName}.parse(item)
+    }
+}
 `;
 }
 exports.generateRepository = generateRepository;

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

@@ -10,8 +10,8 @@ const imports_1 = require("../../lib/imports");
  */
 function generateRoute({ model, meta }) {
     const { idField, defaultField } = model;
-    const defaultValueMethod = `
-    getDefault: procedure.query(({ ctx }) => ctx.dataService.${meta.data.dataServiceName}.defaultValue),
+    const defaultValueMethod = `
+    getDefault: procedure.query(({ ctx }) => ctx.dataService.${meta.data.dataServiceName}.defaultValue),
   `;
     const createMethod = getCreateMethod({ model, meta });
     const updateMethod = getUpdateMethod({ model, meta });
@@ -27,24 +27,24 @@ function generateRoute({ model, meta }) {
             from: depMeta.types.importPath,
         });
     }
-    return `
-import { z } from 'zod'
-import { procedure, router, undefinedToNull } from '../helper'
-
-${imports.generate()}
-
-export const ${meta.trpc.routerName} = router({
-  ${defaultField ? defaultValueMethod : ''}
-  
-  get: procedure
-    .input(z.${idField.unbrandedTypeName}().transform(${meta.types.toBrandedIdTypeFnName}))
-    .query(async ({ input, ctx }) => await ctx.dataService.${meta.data.dataServiceName}.get(input)),
-  getMap: procedure.query(({ ctx }) => ctx.dataService.${meta.data.dataServiceName}.getAll()),
-
-  ${omit(createMethod, model.attributes.skipCreate)}
-  ${omit(updateMethod, model.attributes.skipUpdate)}
-  ${omit(deleteMethod, model.attributes.skipDelete)}
-})
+    return `
+import { z } from 'zod'
+import { procedure, router, undefinedToNull } from '../helper'
+
+${imports.generate()}
+
+export const ${meta.trpc.routerName} = router({
+  ${defaultField ? defaultValueMethod : ''}
+  
+  get: procedure
+    .input(z.${idField.unbrandedTypeName}().transform(${meta.types.toBrandedIdTypeFnName}))
+    .query(async ({ input, ctx }) => await ctx.dataService.${meta.data.dataServiceName}.get(input)),
+  getMap: procedure.query(({ ctx }) => ctx.dataService.${meta.data.dataServiceName}.getAll()),
+
+  ${omit(createMethod, model.attributes.skipCreate)}
+  ${omit(updateMethod, model.attributes.skipUpdate)}
+  ${omit(deleteMethod, model.attributes.skipDelete)}
+})
 `;
 }
 exports.generateRoute = generateRoute;
@@ -62,31 +62,31 @@ function getCreateMethod({ model: { fields }, meta }) {
         .filter((f) => f.kind !== 'id')
         .map((field) => `${field.name}: z.${(0, zod_1.getZodDecoderDefinition)({ field })}`)
         .join(',');
-    return `
-    create: procedure.input(z.object({ 
-      ${parameters}
-    }))
-      .mutation(({ input, ctx }) => ctx.dataService.${meta.data.dataServiceName}.create(input)),
+    return `
+    create: procedure.input(z.object({ 
+      ${parameters}
+    }))
+      .mutation(({ input, ctx }) => ctx.dataService.${meta.data.dataServiceName}.create(input)),
 `;
 }
 function getUpdateMethod({ model: { fields }, meta }) {
     const parameters = fields
         .map((field) => `${field.name}: z.${(0, zod_1.getZodDecoderDefinition)({ field, allowAnyOptionalField: field.kind !== 'id' })}`)
         .join(',');
-    return `update: procedure
-    .input(
-      z.object({ 
-      ${parameters}
-      })
-    )
-    .mutation(({ input, ctx }) => ctx.dataService.${meta.data.dataServiceName}.update(input)),
+    return `update: procedure
+    .input(
+      z.object({ 
+      ${parameters}
+      })
+    )
+    .mutation(({ input, ctx }) => ctx.dataService.${meta.data.dataServiceName}.update(input)),
   `;
 }
 function getDeleteMethod({ idField, meta }) {
-    return `
-  delete: procedure
-    .input(z.${idField.unbrandedTypeName}().transform(${meta.types.toBrandedIdTypeFnName}))
-    .mutation(({ input, ctx }) => ctx.dataService.${meta.data.dataServiceName}.delete(input)),
+    return `
+  delete: procedure
+    .input(z.${idField.unbrandedTypeName}().transform(${meta.types.toBrandedIdTypeFnName}))
+    .mutation(({ input, ctx }) => ctx.dataService.${meta.data.dataServiceName}.delete(input)),
 `;
 }
 /**
@@ -98,15 +98,15 @@ function generateRoutesIndex({ models, meta }) {
     for (const { meta } of mm) {
         imports.addImport({ items: [meta.trpc.routerName], from: meta.trpc.routerFilePath });
     }
-    return `
-    ${imports.generate()}
-
-    /**
-     * Object with all generated routes.
-     */
-    export const routes = {
-      ${mm.map(({ meta }) => `${meta.trpc.routerName}`).join(',\n')}
-    }
+    return `
+    ${imports.generate()}
+
+    /**
+     * Object with all generated routes.
+     */
+    export const routes = {
+      ${mm.map(({ meta }) => `${meta.trpc.routerName}`).join(',\n')}
+    }
   `;
 }
 exports.generateRoutesIndex = generateRoutesIndex;