@postxl/generator 0.9.1 → 0.10.0

package/dist/generator.js

@@ -151,6 +151,7 @@ const generate = ({ models, enums, config, prismaClientPath, logger, }) => __awa
         if (!config.disableGenerators.data) {
             generated.write(`/${meta.data.stubFilePath}.ts`, (0, stub_generator_1.generateStub)({ model, meta }));
             generated.write(`/${meta.data.repoFilePath}.ts`, (0, repository_generator_1.generateRepository)({ model, meta }));
+            generated.write(`/${meta.data.mockRepoFilePath}.ts`, (0, repository_generator_1.generateMockRepository)({ model, meta }));
         }
         // Routes
         if (!config.disableGenerators.trpc) {

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

@@ -47,22 +47,25 @@ function generateDataMockModule({ models, meta }) {
     });
     for (const { model, meta } of mm) {
         imports.addImport({ items: [model.typeName], from: meta.types.importPath });
-        imports.addImport({ items: [meta.data.repositoryClassName], from: meta.data.importPath });
-        imports.addImport({ items: [meta.seed.constantName], from: meta.seed.importPath });
+        imports.addImport({ items: [meta.data.repositoryClassName], from: meta.data.repoFilePath });
+        imports.addImport({ items: [meta.data.mockRepositoryClassName], from: meta.data.mockRepoFilePath });
     }
     const providers = mm
-        .map(({ meta, model }) => `provideMockRepository<
-        ${model.typeName}, 
-        ${model.idField.unbrandedTypeName}, 
-        ${model.typeName}
-      >(${meta.data.repositoryClassName}, ${meta.seed.constantName})`)
+        .map(({ meta, model }) => `{ 
+          provide: ${meta.data.repositoryClassName},
+          useFactory: async () => {
+            const repository = new ${meta.data.mockRepositoryClassName}()
+            if (!!seed && !!seed.${meta.seed.constantName}) {
+              await repository.reInit(seed.${meta.seed.constantName})
+            }
+            return repository
+          }
+        }`)
         .join(', ');
     return `
 import { DynamicModule } from '@nestjs/common'
 import { DbModule } from '@${meta.config.project}/db'
 
-import { provideMockRepository } from './mock.repository'
-
 ${imports.generate()}
 
 export class DataMockModule {
@@ -77,7 +80,7 @@ export class DataMockModule {
   }
 
   // eslint-disable-next-line @typescript-eslint/require-await, @typescript-eslint/no-unused-vars
-  static async mock(): Promise<DynamicModule> {
+  static async mock(seed?: MockData): Promise<DynamicModule> {
     const providers = [
       DataService, 
       TestDataService, 

package/dist/generators/models/repository.generator.d.ts

@@ -7,3 +7,10 @@ export declare function generateRepository({ model, meta }: {
     model: Model;
     meta: ModelMetaData;
 }): string;
+/**
+ * Generates a mock repository data structure for a given model: same a repository, but in memory only
+ */
+export declare function generateMockRepository({ model: modelSource, meta: metaSource, }: {
+    model: Model;
+    meta: ModelMetaData;
+}): string;

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

@@ -1,11 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.generateRepository = void 0;
+exports.generateMockRepository = exports.generateRepository = void 0;
 const fields_1 = require("../../lib/schema/fields");
 const string_1 = require("../../lib/utils/string");
 const schema_1 = require("../../lib/schema/schema");
 const meta_1 = require("../../lib/meta");
 const imports_1 = require("../../lib/imports");
+const types_1 = require("../../lib/schema/types");
 /**
  * Generates repository data structure for a given model.
  */
@@ -18,6 +19,28 @@ function generateRepository({ model, meta }) {
     const relations = fields
         .filter(schema_1.isFieldRelation)
         .map((field) => (Object.assign(Object.assign({}, field), { meta: (0, meta_1.getModelMetadata)({ model: field.relationToModel }), fieldMeta: (0, meta_1.getFieldMetadata)({ field }) })));
+    const getIndexDefinition = (fieldNames) => {
+        const fields = fieldNames.map((f) => {
+            const result = model.fields.find((field) => field.name === f);
+            if (!result) {
+                throw new Error(`Index field ${f} not found in model ${model.name}`);
+            }
+            if (result.kind !== 'relation') {
+                throw new Error(`Index field ${f} is not a relation in model ${model.name}`);
+            }
+            const meta = (0, meta_1.getModelMetadata)({ model: result.relationToModel });
+            return Object.assign(Object.assign({}, result), { meta });
+        });
+        const [firstField, ...restFields] = fields;
+        if (!restFields || restFields.length === 0) {
+            throw new Error(`Index for model ${model.name} must have at least 2 fields!`);
+        }
+        return {
+            fields,
+            name: (0, string_1.toCamelCase)(`${firstField.name}${restFields.map((f) => (0, string_1.toPascalCase)(f.name)).join('')}Index`),
+        };
+    };
+    const indexes = model.attributes.index ? [getIndexDefinition(model.attributes.index)] : [];
     const defaultValueInitFn = `
 		if (item.${(_a = model.defaultField) === null || _a === void 0 ? void 0 : _a.name}) {
 			if (this.defaultValue) {
@@ -38,7 +61,11 @@ function generateRepository({ model, meta }) {
         items: [model.typeName, model.brandedIdType, meta.types.toBrandedIdTypeFnName],
         from: meta.types.importPath,
     })
-        .addImport({ items: [meta.types.zodDecoderFnName], from: meta.types.importPath });
+        .addImport({ items: [meta.types.zodDecoderFnName], from: meta.types.importPath })
+        .addImport({
+        items: [(0, types_1.toClassName)('Repository')],
+        from: (0, types_1.toFileName)(model.schemaConfig.paths.dataLibPath + 'repository.type'),
+    });
     relations.forEach((r) => {
         imports.addImport({
             items: [r.meta.types.brandedIdType],
@@ -48,9 +75,7 @@ function generateRepository({ model, meta }) {
     return `
 import { Injectable, Logger } from '@nestjs/common'
 import { DbService, ${model.sourceName} as DbType } from '@${model.schemaConfig.project}/db'
-import { format, pluralize } from '@pxl/common'
-
-import { Repository } from '../repository.type'
+import { format, pluralize, NestedMap } from '@pxl/common'
 
 ${imports.generate()}
 
@@ -84,13 +109,26 @@ export class ${meta.data.repositoryClassName} implements Repository<
 		${uniqueStringFields.map((f) => `'${f.name}': new Map<string, ${model.typeName}>()`).join(',\n')}
 	}
 
+  ${indexes
+        .map((i) => `
+  protected ${i.name} = new NestedMap<${i.fields.map((f) => f.meta.types.brandedIdType).join(',')}, ${model.typeName}>(
+    ${i.fields.map((f) => `(x) => x.${f.name}`).join(',')}
+  )
+  `)
+        .join('\n')}
+  ${model.attributes.inMemoryOnly
+        ? ''
+        : `
   constructor(${model.attributes.inMemoryOnly ? '' : 'protected '}db: DbService) {}
-
+  `}	
+  
   public async init() {
     this.data.clear()
     
-    ${uniqueStringFields.map((f) => `this.uniqueIds.${f.name}.clear()\n`)}
+    ${uniqueStringFields.map((f) => `this.uniqueIds.${f.name}.clear()`).join('\n')}
     
+    ${indexes.map((i) => `this.${i.name}.clear()`).join('\n')}
+
     ${model.attributes.inMemoryOnly
         ? 'return Promise.resolve()'
         : `
@@ -99,10 +137,11 @@ export class ${meta.data.repositoryClassName} implements Repository<
 
     for (const rawItem of data) {
       const item = this.${decoder}(rawItem)
-      this.data.set(item.id, item)
+      this.set(item)
 
       ${model.defaultField ? defaultValueInitFn : ''}
       ${uniqueStringFields.map((f) => `this.uniqueIds.${f.name}.set(item.${f.name}, item)`).join('\n')}
+      ${indexes.map((i) => `this.${i.name}.set(item)`).join('\n')}
     }
 
     ${isGenerated ? idIntInitFn : ''}
@@ -110,12 +149,18 @@ export class ${meta.data.repositoryClassName} implements Repository<
     ${model.defaultField ? defaultValueInitCheckFn : ''}
 
     this.logger.log(\`\${format(this.data.size)} \${pluralize('${model.typeName}', this.data.size)} loaded\`)
+    ${indexes
+            .map((i) => `this.logger.log(\`\${this.${i.name}.size} ${model.typeName} loaded into index ${i.name}\`)`)
+            .join('\n')}
     `}
   }
 
   public async reInit(data: ${model.typeName}[]): Promise<void> {
     ${model.attributes.inMemoryOnly
-        ? 'return Promise.resolve()'
+        ? `
+        await this.init()
+        await this.createMany(data)
+        `
         : `
     if (!this.db.useE2ETestDB) {
       const errorMsg =
@@ -123,8 +168,9 @@ export class ${meta.data.repositoryClassName} implements Repository<
       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)) }))`}
+    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 {
@@ -142,6 +188,17 @@ export class ${meta.data.repositoryClassName} implements Repository<
     return Array.from(this.data.values())
   }
 
+  ${indexes
+        .map((i) => `
+  public getFrom${indexes.length === 1 ? 'Index' : (0, string_1.toPascalCase)(i.name)}
+  ({ ${i.fields.map((f) => f.name).join(',')} }: { ${i.fields
+        .map((f) => `${f.name} : ${f.meta.types.brandedIdType}`)
+        .join(';')} }): ${model.typeName} | null {
+    return this.${i.name}.get(${i.fields.map((f) => f.name).join(',')}) ?? null
+  }
+  `)
+        .join('\n')}
+  
   public filter(predicate: (item: ${model.typeName}) => boolean): ${model.typeName}[] {
     return this.getAllAsArray().filter(predicate)
   }
@@ -205,7 +262,7 @@ export class ${meta.data.repositoryClassName} implements Repository<
 
     ${model.attributes.inMemoryOnly
             ? `
-    const newItem = await Promise.resolve({ item, id })
+    const newItem = await Promise.resolve({ ...item, id: ${meta.types.toBrandedIdTypeFnName}(id) })
     `
             : `
     const newItem = this.${decoder}(
@@ -398,6 +455,8 @@ export class ${meta.data.repositoryClassName} implements Repository<
         ${!r.isRequired ? `}` : ''}
       `)
         .join('\n')}
+
+      ${indexes.map((i) => `this.${i.name}.set(item)`).join('\n')}
     }
 
     /**
@@ -420,22 +479,38 @@ export class ${meta.data.repositoryClassName} implements Repository<
         ${!r.isRequired ? '}' : ''}
       `)
         .join('\n')}
+        
+        ${indexes.map((i) => `this.${i.name}.delete(item)`).join('\n')}
     }
 
+    
+    ${model.attributes.inMemoryOnly
+        ? ''
+        : `
     /**
      * Utility function that converts a given Database object to a TypeScript model instance
      */
     private ${decoder}(item: Pick<DbType, ${[...model.fields.values()]
-        .map((f) => `'${f.sourceName}'`)
-        .join(' | ')}>): ${model.typeName} {
+            .map((f) => `'${f.sourceName}'`)
+            .join(' | ')}>): ${model.typeName} {
       return ${meta.types.zodDecoderFnName}.parse({
         ${[...model.fields.values()].map((f) => `${f.name}: item.${f.sourceName}`).join(',\n')}
       })
-    }
+    }`}
   }
 `;
 }
 exports.generateRepository = generateRepository;
+/**
+ * Generates a mock repository data structure for a given model: same a repository, but in memory only
+ */
+function generateMockRepository({ model: modelSource, meta: metaSource, }) {
+    // We re-use the repository generator, 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 model = Object.assign(Object.assign({}, modelSource), { attributes: Object.assign(Object.assign({}, modelSource.attributes), { inMemoryOnly: true }) });
+    return generateRepository({ model, meta });
+}
+exports.generateMockRepository = generateMockRepository;
 function getEnsureUniqueFnName(field) {
     return `ensureUnique${(0, string_1.toPascalCase)(field.name)}`;
 }

package/dist/lib/attributes.d.ts

@@ -33,6 +33,11 @@ export type ModelAttributes = {
      * Whether the model should be stored in the database or only in memory.
      */
     inMemoryOnly: boolean;
+    /**
+     * Schema tag: ´@@Index()`
+     * Creates an index on the given fields.
+     */
+    index?: string[];
 };
 export type FieldAttributes = {
     /**

package/dist/lib/meta.d.ts

@@ -125,10 +125,22 @@ export type ModelMetaData = {
          * Path to the file containing the repository definition.
          */
         repoFilePath: Types.Path;
+        /**
+         * Name of the file containing the mock repository definition for this model.
+         */
+        mockRepoFileName: Types.FileName;
+        /**
+         * Path to the file containing the mock repository definition.
+         */
+        mockRepoFilePath: Types.Path;
         /**
          * The name of the class for the repository definition of this model (e.g. AggregationRepository).
          */
         repositoryClassName: Types.ClassName;
+        /**
+         * The name of the class for the in-memory mock repository definition of this model (e.g. MockAggregationRepository).
+         */
+        mockRepositoryClassName: Types.ClassName;
         /**
          * The name by which the repository is exposed in the dataService/context. (e.g. aggregations)
          */

package/dist/lib/meta.js

@@ -71,10 +71,13 @@ function getModelMetadata({ model }) {
             defaultStubConstantName: Types.toVariableName(`${camelCase}DefaultStub`),
             repoFileName: Types.toFileName(`${camelCase}.repository`),
             repoFilePath: Types.toPath(`${config.paths.dataLibPath}repositories/${camelCase}.repository`),
+            mockRepoFileName: Types.toFileName(`${camelCase}.mock.repository`),
+            mockRepoFilePath: Types.toPath(`${config.paths.dataLibPath}repositories/mock/${camelCase}.mock.repository`),
             stubFilePath: Types.toPath(`${config.paths.dataLibPath}stubs/${camelCase}.stub`),
             importPath: Types.toPath(`@${config.project}/data`),
             stubGenerationFnName: Types.toFunction(`stub${PascalCase}`),
             repositoryClassName: Types.toClassName(`${PascalCase}Repository`),
+            mockRepositoryClassName: Types.toClassName(`Mock${PascalCase}Repository`),
             dataServiceName: Types.toVariableName(`${uncapitalizedPlural}`),
             excelExportTableName: `${pluralized}`,
             repository: {

package/dist/prisma/attributes.js

@@ -1,8 +1,12 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getFieldAttributes = exports.getModelAttributes = exports.parseArgumentToStringOrStringArray = exports.parseAttributesFromDocumentation = void 0;
 const remeda_1 = require("remeda");
 const string_1 = require("../lib/utils/string");
+const zod_1 = __importDefault(require("zod"));
 /**
  * Parses attributes from a given string using provided prefix.
  */
@@ -43,20 +47,48 @@ function parseArgumentToStringOrStringArray(str) {
     throw new Error(`Could not parse attribute argument: ${str}`);
 }
 exports.parseArgumentToStringOrStringArray = parseArgumentToStringOrStringArray;
+const blankStringBooleanDecoder = zod_1.default
+    .string()
+    .transform((str) => true)
+    .or(zod_1.default.boolean())
+    .optional()
+    .default(false);
 /**
  * Returns attribute information for a given model.
  */
 function getModelAttributes(model) {
     const attributes = parseAttributesFromDocumentation(model);
-    return {
-        ignore: Object.hasOwn(attributes, 'ignore'),
-        skipUpdate: Object.hasOwn(attributes, 'skipUpdate') || Object.hasOwn(attributes, 'customUpdate'),
-        skipCreate: Object.hasOwn(attributes, 'skipCreate') || Object.hasOwn(attributes, 'customCreate'),
-        skipDelete: Object.hasOwn(attributes, 'skipDelete') || Object.hasOwn(attributes, 'customDelete'),
-        inMemoryOnly: Object.hasOwn(attributes, 'inMemoryOnly'),
-        description: attributes.description && (0, remeda_1.isString)(attributes.description) ? attributes.description : undefined,
-        databaseSchema: attributes.schema && (0, remeda_1.isString)(attributes.schema) ? attributes.schema : undefined,
-    };
+    const decoder = zod_1.default
+        .object({
+        ignore: blankStringBooleanDecoder,
+        skipUpdate: blankStringBooleanDecoder,
+        customUpdate: blankStringBooleanDecoder,
+        skipCreate: blankStringBooleanDecoder,
+        customCreate: blankStringBooleanDecoder,
+        skipDelete: blankStringBooleanDecoder,
+        customDelete: blankStringBooleanDecoder,
+        inMemoryOnly: blankStringBooleanDecoder,
+        description: zod_1.default.string().optional(),
+        schema: zod_1.default.string().optional(),
+        index: zod_1.default.array(zod_1.default.string()).optional(),
+    })
+        .transform((obj) => ({
+        ignore: obj.ignore,
+        skipUpdate: obj.skipUpdate || obj.customUpdate,
+        skipCreate: obj.skipCreate || obj.customCreate,
+        skipDelete: obj.skipDelete || obj.customDelete,
+        inMemoryOnly: obj.inMemoryOnly,
+        description: obj.description,
+        schema: obj.schema,
+        index: obj.index,
+    }));
+    const result = decoder.safeParse(attributes);
+    if (!result.success) {
+        throw new Error(`Model ${model.name} has invalid model attributes: ${result.error}`);
+    }
+    if (result.data.description === 'The calculated metric value for a dataset.') {
+    }
+    return result.data;
 }
 exports.getModelAttributes = getModelAttributes;
 /**

package/package.json

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