@postxl/generator 0.0.1

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

@@ -0,0 +1,282 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateRepository = void 0;
+const fields_1 = require("../../lib/schema/fields");
+const string_1 = require("../../lib/utils/string");
+const imports_1 = require("../../lib/imports");
+/**
+ * Generates repository data structure for a given model.
+ */
+function generateRepository({ model, meta }) {
+    var _a;
+    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 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`;
+    const imports = imports_1.ImportsGenerator.from(meta.data.repoFilePath)
+        .addImport({
+        items: [model.typeName, model.brandedIdType, meta.types.toBrandedIdTypeFnName],
+        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()
+
+		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}.set(item.${f}, 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}| ${idField.unbrandedTypeName} | 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}
+    }`
+        : ''}
+
+    ${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} | ${idField.unbrandedTypeName} | undefined
+	}): Promise<${model.typeName}> {
+    if (item.${idField.name} === undefined) {
+      return this.create(item)
+    }
+    
+    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 update(item: Partial<${model.typeName}> & { 
+		id: ${model.brandedIdType} | ${idField.unbrandedTypeName}
+	}): Promise<${model.typeName}> {
+    const id = ${meta.types.toBrandedIdTypeFnName}(item.id)
+    const existingItem = this.get(id)
+
+    if (!existingItem) {
+      throw new Error(\`Could not update ${meta.userFriendlyName} with id \${id}. Not found!\`)
+    }
+
+    ${uniqueStringFields
+        .map((f) => {
+        return `
+					if (item.${f.name} !== undefined && existingItem.${f} !== item.${f}) {
+						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: {
+					${[...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')}
+
+       
+        },
+      }),
+    )
+
+    ${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)
+            }
+          }
+				`;
+    })
+        .join('\n')}
+
+    this.data.set(newItem.id, newItem)
+    return newItem
+  }
+
+  public async delete(id: ${model.brandedIdType} | ${idField.unbrandedTypeName}): 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) => {
+        const fName = f.name;
+        return `
+				private ${getEnsureUniqueFnName(f)}(item: { ${fName}?: string }) {
+					if (!item.${fName}) return
+					if (!this.uniqueIds.${fName}.has(item.${fName})) return
+					let counter = 1
+					let ${fName}: string
+
+					//TODO: Add attribute for max length of string
+					do {
+						${fName} = \`\${item.${fName}} (\${++counter})\`
+					} while (this.uniqueIds.${fName}.has(${fName}))
+
+					this.logger.log(\`Asset ${fName} \${item.${fName}} already exists. Renaming to \${${fName}})\`)
+					item.${fName} = ${fName}
+				}
+			`;
+    })
+        .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;
+function getEnsureUniqueFnName(field) {
+    return `ensureUnique${(0, string_1.toPascalCase)(field.name)}`;
+}

package/dist/src/generators/models/route.generator.d.ts

@@ -0,0 +1,16 @@
+import { ModelMetaData, SchemaMetaData } from '../../lib/meta';
+import { Model } from '../../lib/schema/schema';
+/**
+ * Generates TRPC route for a given model.
+ */
+export declare function generateRoute({ model, meta }: {
+    model: Model;
+    meta: ModelMetaData;
+}): string;
+/**
+ * Generates the index file for all the routes.
+ */
+export declare function generateRoutesIndex({ models, meta }: {
+    models: Model[];
+    meta: SchemaMetaData;
+}): string;

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

@@ -0,0 +1,112 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateRoutesIndex = exports.generateRoute = void 0;
+const meta_1 = require("../../lib/meta");
+const fields_1 = require("../../lib/schema/fields");
+const zod_1 = require("../../lib/schema/zod");
+const imports_1 = require("../../lib/imports");
+/**
+ * Generates TRPC route for a given model.
+ */
+function generateRoute({ model, meta }) {
+    const { idField, defaultField } = model;
+    const defaultValueMethod = `
+    getDefault: procedure.query(({ ctx }) => ctx.dataService.${meta.data.dataServiceName}.defaultValue),
+  `;
+    const createMethod = getCreateMethod({ model, meta });
+    const updateMethod = getUpdateMethod({ model, meta });
+    const deleteMethod = getDeleteMethod({ idField, meta });
+    const imports = imports_1.ImportsGenerator.from(meta.trpc.routerFilePath).addImport({
+        items: [meta.types.toBrandedIdTypeFnName],
+        from: meta.types.importPath,
+    });
+    for (const relation of (0, fields_1.getRelationFields)(model)) {
+        const depMeta = (0, meta_1.getModelMetadata)({ model: relation.relationToModel });
+        imports.addImport({
+            items: [depMeta.types.toBrandedIdTypeFnName],
+            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)}
+})
+`;
+}
+exports.generateRoute = generateRoute;
+function omit(lines, omitted) {
+    if (!omitted) {
+        return lines;
+    }
+    return lines
+        .split('\n')
+        .map((l) => `// ${l}`)
+        .join('\n');
+}
+function getCreateMethod({ model: { fields }, meta }) {
+    const parameters = fields
+        .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)),
+`;
+}
+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)),
+  `;
+}
+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)),
+`;
+}
+/**
+ * Generates the index file for all the routes.
+ */
+function generateRoutesIndex({ models, meta }) {
+    const mm = models.map((model) => ({ model, meta: (0, meta_1.getModelMetadata)({ model }) }));
+    const imports = imports_1.ImportsGenerator.from(meta.trpc.routesFilePath);
+    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')}
+    }
+  `;
+}
+exports.generateRoutesIndex = generateRoutesIndex;

package/dist/src/generators/models/seed.generator.d.ts

@@ -0,0 +1,20 @@
+import { Model, SchemaConfig } from '../../lib/schema/schema';
+import { ModelMetaData } from '../../lib/meta';
+/**
+ * Creates a seed file for a given model.
+ */
+export declare function generateSeedModel({ model, itemCount, meta, }: {
+    model: Model;
+    itemCount: number;
+    meta: ModelMetaData;
+}): string;
+/**
+ * Creates the seed file that exposes all seed data as single object.
+ */
+export declare function generateSeeds({ models, config, }: {
+    models: {
+        model: Model;
+        meta: ModelMetaData;
+    }[];
+    config: SchemaConfig;
+}): string;

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

@@ -0,0 +1,185 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateSeeds = exports.generateSeedModel = void 0;
+const faker_1 = require("@faker-js/faker");
+const assert_never_1 = __importDefault(require("assert-never"));
+const serializer_1 = require("../../lib/serializer");
+const string_1 = require("../../lib/utils/string");
+const meta_1 = require("../../lib/meta");
+const fields_1 = require("../../lib/schema/fields");
+const imports_1 = require("../../lib/imports");
+/**
+ * Creates a seed file for a given model.
+ */
+function generateSeedModel({ model, itemCount, meta, }) {
+    const imports = imports_1.ImportsGenerator.from(meta.seed.filePath).addImport({
+        items: [model.typeName, meta.types.toBrandedIdTypeFnName],
+        from: meta.types.importPath,
+    });
+    for (const relation of (0, fields_1.getRelationFields)(model)) {
+        const depMeta = (0, meta_1.getModelMetadata)({ model: relation.relationToModel });
+        imports.addImport({
+            items: [depMeta.types.toBrandedIdTypeFnName],
+            from: depMeta.types.importPath,
+        });
+    }
+    const exampleMode = getExampleMode({ model, maxItemCount: itemCount });
+    const seed = [];
+    for (let i = 1; i <= exampleMode.itemCount; i++) {
+        seed.push(generateSeedData({ model, index: i, exampleMode }));
+    }
+    return `
+    ${imports.generate()}
+
+    export const ${meta.seed.constantName}: ${model.typeName}[] = [
+      ${seed.join(',\n')}
+    ]
+  `;
+}
+exports.generateSeedModel = generateSeedModel;
+/**
+ * In case of a model with examples, there are two options:
+ * 1. the number of examples per field is the same for all fields with examples -> we generate them as tuples
+ * 2. the number of examples per field is different -> we generate them as random permutations
+ * Here we determine which option to use - and the number of tuples/permutations available
+ */
+function getExampleMode({ model, maxItemCount }) {
+    let numberOfExamplesPerField = undefined;
+    let sameNumberOfExamplesPerField = true;
+    let examplePermutations = 0;
+    for (const field of model.fields) {
+        if (field.kind === 'scalar' && field.attributes.examples && field.attributes.examples.length > 0) {
+            if (numberOfExamplesPerField === undefined) {
+                numberOfExamplesPerField = field.attributes.examples.length;
+                examplePermutations = 1;
+            }
+            else if (numberOfExamplesPerField !== field.attributes.examples.length) {
+                sameNumberOfExamplesPerField = false;
+            }
+            examplePermutations *= field.attributes.examples.length;
+        }
+    }
+    if (numberOfExamplesPerField === undefined) {
+        return { mode: 'NoExamples', itemCount: maxItemCount };
+    }
+    else if (sameNumberOfExamplesPerField) {
+        return {
+            mode: 'Tuples',
+            itemCount: numberOfExamplesPerField < maxItemCount ? numberOfExamplesPerField : maxItemCount,
+        };
+    }
+    else {
+        return { mode: 'Permutations', itemCount: examplePermutations < maxItemCount ? examplePermutations : maxItemCount };
+    }
+}
+function generateSeedData({ model, index, exampleMode, }) {
+    const data = new serializer_1.Serializer();
+    data.append('{');
+    for (const field of model.fields.values()) {
+        data.append(`${field.name}: ${generateFieldData({ field, model, index, exampleMode })},`);
+    }
+    data.append('}');
+    return data.print();
+}
+function generateFieldData({ field, model, index, exampleMode, }) {
+    switch (field.kind) {
+        case 'id':
+            return generateFieldDataId({ field, model, index });
+        case 'scalar':
+            return generateFieldDataScalar({ field, model, index, exampleMode });
+        case 'relation':
+            return generateFieldDataRelation({ field, model, index, itemCount: exampleMode.itemCount });
+        case 'enum':
+            return generateFieldDataEnum({ field });
+        default:
+            (0, assert_never_1.default)(field);
+    }
+}
+function generateFieldDataId({ field, model, index }) {
+    const idModelMeta = (0, meta_1.getModelMetadata)({ model: field.model });
+    return `${idModelMeta.types.toBrandedIdTypeFnName}(${field.unbrandedTypeName === 'string' ? `'${index}'` : index})`;
+}
+function generateFieldDataScalar({ field, model, index, exampleMode, }) {
+    const { hasExample, example } = getFieldExample({ field, model, index, exampleMode });
+    switch (field.typeName) {
+        case 'string':
+            return `'${hasExample ? example : generateFieldDataString({ field, model, index })}'`;
+        case 'number':
+            return hasExample ? example : generateFieldDataNumber({ field, model, index });
+        case 'boolean':
+            return hasExample ? example : generateFieldDataBoolean({ field, model, index });
+        case 'Date':
+            return hasExample ? example : generateFieldDataDate({ field, model, index });
+        default:
+            console.warn(`Unknown scalar type: ${field.typeName}`);
+            return '';
+    }
+}
+function getFieldExample({ field, model, index, exampleMode, }) {
+    if (exampleMode.mode === 'NoExamples')
+        return { hasExample: false, example: undefined };
+    if (!field.attributes.examples || field.attributes.examples.length === 0)
+        return { hasExample: false, example: undefined };
+    if (exampleMode.mode === 'Permutations') {
+        const example = faker_1.faker.helpers.arrayElement(field.attributes.examples);
+        return { hasExample: true, example };
+    }
+    else if (exampleMode.mode === 'Tuples') {
+        const example = field.attributes.examples[index % field.attributes.examples.length];
+        return { hasExample: true, example };
+    }
+    else {
+        (0, assert_never_1.default)(exampleMode);
+    }
+}
+function generateFieldDataString({ field, model, index }) {
+    if (field.name === 'name')
+        return `${(0, string_1.toPascalCase)(model.name)} ${index}`;
+    if (field.name === 'email')
+        return faker_1.faker.internet.email();
+    return faker_1.faker.lorem.words(3);
+}
+function generateFieldDataNumber({}) {
+    return faker_1.faker.datatype.float({ precision: 0.1, min: 0, max: 1 }).toString();
+}
+function generateFieldDataBoolean({}) {
+    return faker_1.faker.datatype.boolean().toString();
+}
+function generateFieldDataDate({ field, model, index }) {
+    return `new Date('${faker_1.faker.date.past(3)}')`;
+}
+function generateFieldDataRelation({ field, model, index, itemCount, }) {
+    const referenceId = faker_1.faker.datatype.number({ min: 1, max: itemCount });
+    const refModelMeta = (0, meta_1.getModelMetadata)({ model: field.relationToModel });
+    const brandingFn = refModelMeta.types.toBrandedIdTypeFnName;
+    return `${brandingFn}(${field.unbrandedTypeName === 'string' ? `'${referenceId}'` : referenceId})`;
+}
+function generateFieldDataEnum({ field }) {
+    return `'${faker_1.faker.helpers.arrayElement(field.enumerator.values)}'`;
+}
+/**
+ * Creates the seed file that exposes all seed data as single object.
+ */
+function generateSeeds({ models, config, }) {
+    const imports = imports_1.ImportsGenerator.from(config.paths.seedPath);
+    for (const { meta } of models) {
+        imports.addImport({
+            items: [meta.seed.constantName],
+            from: meta.seed.filePath,
+        });
+    }
+    const seeds = models.map(({ meta }) => `${meta.seed.constantName}`).join(',\n');
+    return `
+  import { MockData } from '${config.paths.seedPath}'
+
+  ${imports.generate()}
+  
+  export const seed: MockData = {
+    ${seeds}
+  }
+  `;
+}
+exports.generateSeeds = generateSeeds;

package/dist/src/generators/models/stub.generator.d.ts

@@ -0,0 +1,9 @@
+import { Model } from '../../lib/schema/schema';
+import { ModelMetaData } from '../../lib/meta';
+/**
+ * Generates a stub definition file for a given model.
+ */
+export declare function generateStub({ model, meta }: {
+    model: Model;
+    meta: ModelMetaData;
+}): string;