@postxl/generator 0.8.0 → 0.9.0

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

@@ -9,7 +9,7 @@ function generateEmptyDatabaseStoredProcedure({ models, meta, }) {
         .map((model) => `\t${model.sourceSchemaName !== undefined ? `"${model.sourceSchemaName}".` : ''}"${model.sourceName}"`)
         .join(',\n');
     return `
-  CREATE OR REPLACE PROCEDURE "emptyDatabase"() AS $BODY$ BEGIN IF EXISTS (
+CREATE OR REPLACE PROCEDURE "emptyDatabase"() AS $BODY$ BEGIN IF EXISTS (
     SELECT
     FROM "Configuration"."Config"
     WHERE NOT "isTest"

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

@@ -3,6 +3,8 @@ 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 schema_1 = require("../../lib/schema/schema");
+const meta_1 = require("../../lib/meta");
 const imports_1 = require("../../lib/imports");
 /**
  * Generates repository data structure for a given model.
@@ -13,6 +15,9 @@ function generateRepository({ model, meta }) {
     const decoder = meta.data.repository.decoderFnName;
     const uniqueStringFields = fields.filter(fields_1.isUniqueStringField);
     const maxLengthStringFields = fields.filter(fields_1.isMaxLengthStringField);
+    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 defaultValueInitFn = `
 		if (item.${(_a = model.defaultField) === null || _a === void 0 ? void 0 : _a.name}) {
 			if (this.defaultValue) {
@@ -34,6 +39,12 @@ function generateRepository({ model, meta }) {
         from: meta.types.importPath,
     })
         .addImport({ items: [meta.types.zodDecoderFnName], from: meta.types.importPath });
+    relations.forEach((r) => {
+        imports.addImport({
+            items: [r.meta.types.brandedIdType],
+            from: r.meta.types.importPath,
+        });
+    });
     return `
 import { Injectable, Logger } from '@nestjs/common'
 import { DbService, ${model.sourceName} as DbType } from '@${model.schemaConfig.project}/db'
@@ -51,6 +62,12 @@ export class ${meta.data.repositoryClassName} implements Repository<
   protected data: Map<${model.brandedIdType}, ${model.typeName}> = new Map()
   protected logger = new Logger(${meta.data.repositoryClassName}.name)
 
+  ${relations
+        .map((r) => `
+    protected ${r.name}Map: Map<${r.meta.types.brandedIdType}, Set<${model.brandedIdType}>> = new Map()
+  `)
+        .join('\n')}
+  
   ${model.defaultField ? `public defaultValue!: ${model.typeName}` : ''}
 
   ${isGenerated
@@ -169,9 +186,7 @@ export class ${meta.data.repositoryClassName} implements Repository<
       }),
     )`}
 
-    ${uniqueStringFields.map((f) => `this.uniqueIds.${f.name}.set(newItem.${f.name}, newItem)`).join('\n')}
-
-    this.data.set(newItem.id, newItem)
+    this.set(newItem)
     return newItem
   }
 
@@ -205,9 +220,7 @@ export class ${meta.data.repositoryClassName} implements Repository<
       }),
     )`}
 
-    ${uniqueStringFields.map((f) => `this.uniqueIds.${f.name}.set(newItem.${f.name}, newItem)`).join('\n')}
-
-    this.data.set(newItem.id, newItem)
+    this.set(newItem)
     return newItem`}
   }
 
@@ -228,9 +241,7 @@ export class ${meta.data.repositoryClassName} implements Repository<
     })`}
     
     for (const item of items) {
-      this.data.set(item.id, item)
-      ${isGenerated ? `if (item.id > this.currentMaxId) { this.currentMaxId = item.id }` : ''}
-      ${uniqueStringFields.map((f) => `this.uniqueIds.${f.name}.set(item.${f.name}, item)`).join('\n')} 
+      this.set(item)
     }
     
     return items
@@ -286,20 +297,9 @@ export class ${meta.data.repositoryClassName} implements Repository<
       }),
     )`}
 
-    ${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.remove(existingItem)
+    this.set(newItem)
 
-    this.data.set(newItem.id, newItem)
     return newItem
   }
 
@@ -317,11 +317,28 @@ export class ${meta.data.repositoryClassName} implements Repository<
     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))
+    this.remove(existingItem)
   }
 
+  ${relations
+        .map((r) => `
+    /** 
+     * Function to retrieve all ${(0, string_1.pluralize)(model.name)} that are related to a ${r.name}
+     */
+    public ${r.fieldMeta.getByForeignKeyMethodFnName}(id: ${r.meta.types.brandedIdType}): ${model.typeName}[] {
+      return this.${r.fieldMeta.getByForeignKeyIdsMethodFnName}(id).map((id) => this.get(id) as ${model.typeName})
+    }
+
+    /** 
+     * Function to retrieve all ${model.brandedIdType}s that are related to a ${r.name}
+     */
+    public ${r.fieldMeta.getByForeignKeyIdsMethodFnName}(id: ${r.meta.types.brandedIdType}): ${model.brandedIdType}[] {
+      const s = this.${r.name}Map.get(id)
+      if (!s) return []
+      return Array.from(s)
+    }
+  `)
+        .join('\n')}
   ${maxLengthStringFields.map((f) => {
         return `
   /**
@@ -359,6 +376,50 @@ export class ${meta.data.repositoryClassName} implements Repository<
     })
         .join('\n\n')}
 
+    /**
+     * Function that adds/updates a given item to the internal data store, indexes, etc.
+     */
+    private set(item: ${model.typeName}): void {
+      ${isGenerated ? `if (item.id > this.currentMaxId) { this.currentMaxId = item.id }` : ''}
+      this.data.set(item.id, item)
+      ${uniqueStringFields.map((f) => `this.uniqueIds.${f.name}.set(item.${f.name}, item)`).join('\n')}
+
+      ${relations
+        .map((r) => `
+        ${!r.isRequired ? `if (item.${r.name}) {` : ''}
+        let ${r.name}Set = this.${r.name}Map.get(item.${r.name})
+        if (!${r.name}Set) {
+          ${r.name}Set = new Set()
+          this.${r.name}Map.set(item.${r.name}, ${r.name}Set)
+        }
+        ${r.name}Set.add(item.id)
+        ${!r.isRequired ? `}` : ''}
+      `)
+        .join('\n')}
+    }
+
+    /**
+     * Function that removes a given item from the internal data store, indexes, etc.
+     */
+    private remove(item: ${model.typeName}): void {
+      this.data.delete(item.id)
+      ${uniqueStringFields.map((f) => `this.uniqueIds.${f.name}.delete(item.${f.name})`).join('\n')}
+      
+      ${relations
+        .map((r) => `
+        ${!r.isRequired ? `if (item.${r.name}) {` : ''}
+        const ${r.name}Set = this.${r.name}Map.get(item.${r.name})
+        if (${r.name}Set) {
+          ${r.name}Set.delete(item.id)
+          if (${r.name}Set.size === 0) {
+            this.${r.name}Map.delete(item.${r.name})
+          }
+        }
+        ${!r.isRequired ? '}' : ''}
+      `)
+        .join('\n')}
+    }
+
     /**
      * Utility function that converts a given Database object to a TypeScript model instance
      */

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

@@ -90,7 +90,7 @@ function generateFieldData({ field, model, index, exampleMode, }) {
         case 'relation':
             return generateFieldDataRelation({ field, model, index, itemCount: exampleMode.itemCount });
         case 'enum':
-            return generateFieldDataEnum({ field });
+            return generateFieldDataEnum({ field, exampleMode, index });
         default:
             throw new types_1.ExhaustiveSwitchCheck(field);
     }
@@ -106,7 +106,12 @@ function generateFieldDataScalar({ field, model, index, exampleMode, }) {
     const { hasExample, example } = getFieldExample({ field, model, index, exampleMode });
     switch (field.typeName) {
         case 'string':
-            return `'${quoteSingleQuote(hasExample ? example : generateFieldDataString({ field, model, index }))}'`;
+            const result = hasExample ? example : generateFieldDataString({ field, model, index });
+            if (result === null)
+                return 'null';
+            if (result === undefined)
+                return 'undefined';
+            return `'${quoteSingleQuote(result)}'`;
         case 'number':
             return hasExample ? example : generateFieldDataNumber({ field, model, index });
         case 'boolean':
@@ -162,7 +167,13 @@ function generateFieldDataRelation({ field, model, index, itemCount, }) {
     const brandingFn = refModelMeta.types.toBrandedIdTypeFnName;
     return `${brandingFn}(${field.unbrandedTypeName === 'string' ? `'${referenceId}'` : referenceId})`;
 }
-function generateFieldDataEnum({ field }) {
+function generateFieldDataEnum({ field, exampleMode, index, }) {
+    if (exampleMode.mode === 'Tuples') {
+        if (field.attributes.examples) {
+            const example = field.attributes.examples[(index - 1) % field.attributes.examples.length];
+            return `'${example}'`;
+        }
+    }
     return `'${faker_1.faker.helpers.arrayElement(field.enumerator.values)}'`;
 }
 /**

package/dist/lib/meta.d.ts

@@ -312,11 +312,19 @@ export type ModelMetaData = {
 export declare function getModelMetadata({ model }: {
     model: Schema.ModelCore;
 }): ModelMetaData;
-type FieldMetaData = {
+export type FieldMetaData = {
     /**
      * Name of the field as it should appear in the "exposed" properties of the generated type.
      */
     tsFieldName: Types.VariableName;
+    /**
+     * The name of the method that should be used to get all child objects for a given item, e.g. `getItemsForAggregation`.
+     */
+    getByForeignKeyMethodFnName: Types.Function;
+    /**
+     * The name of the method that should be used to get all child Ids for a given item, e.g. `getIdsForAggregation`.
+     */
+    getByForeignKeyIdsMethodFnName: Types.Function;
 };
 /**
  * A collection of hardcoded values shared across multiple generators related to the given field in the model.
@@ -372,4 +380,3 @@ export type EnumMetaData = {
 export declare function getEnumMetadata({ enumerator: { name, schemaConfig: config }, }: {
     enumerator: Schema.Enum;
 }): EnumMetaData;
-export {};

package/dist/lib/meta.js

@@ -153,24 +153,30 @@ exports.getModelMetadata = getModelMetadata;
  * A collection of hardcoded values shared across multiple generators related to the given field in the model.
  */
 function getFieldMetadata({ field }) {
-    switch (field.kind) {
-        case 'id':
-            return {
-                tsFieldName: Types.toVariableName((0, string_1.toCamelCase)(field.name)),
-            };
-        case 'enum':
-            return {
-                tsFieldName: Types.toVariableName((0, string_1.toCamelCase)(field.name)),
-            };
-        case 'relation':
-            return {
-                tsFieldName: Types.toVariableName((0, string_1.toCamelCase)(field.name)),
-            };
-        case 'scalar':
-            return {
-                tsFieldName: Types.toVariableName((0, string_1.toCamelCase)(field.name)),
-            };
-    }
+    const PascalCase = (0, string_1.toPascalCase)(field.name);
+    return {
+        tsFieldName: Types.toVariableName((0, string_1.toCamelCase)(field.name)),
+        getByForeignKeyMethodFnName: Types.toFunction(`get${PascalCase}Items`),
+        getByForeignKeyIdsMethodFnName: Types.toFunction(`get${PascalCase}Ids`),
+    };
+    // switch (field.kind) {
+    //   case 'id':
+    //     return {
+    //       tsFieldName: Types.toVariableName(toCamelCase(field.name)),
+    //     }
+    //   case 'enum':
+    //     return {
+    //       tsFieldName: Types.toVariableName(toCamelCase(field.name)),
+    //     }
+    //   case 'relation':
+    //     return {
+    //       tsFieldName: Types.toVariableName(toCamelCase(field.name)),
+    //     }
+    //   case 'scalar':
+    //     return {
+    //       tsFieldName: Types.toVariableName(toCamelCase(field.name)),
+    //     }
+    // }
 }
 exports.getFieldMetadata = getFieldMetadata;
 /**

package/dist/lib/schema/schema.d.ts

@@ -246,6 +246,36 @@ export type FieldId = Prettify<Omit<FieldCore, 'name'> & {
      */
     unbrandedTypeName: Types.TypeName;
 }>;
+/**
+ * Utility function to check if a field is an id field.
+ */
+export declare const isFieldId: (field: Field) => field is Prettify<Omit<FieldCore, "name"> & {
+    kind: 'id';
+    /**
+     * Name of the field and variable (e.g. id)
+     */
+    name: string;
+    /**
+     * Model that this ID field identifies.
+     */
+    model: ModelCore;
+    /**
+     * If true, each element is unique.
+     * Note: This is ensured by the repository/database
+     */
+    isUnique: boolean;
+    /**
+     * True if the id field is an autoIncremented field.
+     */
+    isGenerated: boolean;
+    /**
+     * Name of the unbranded TypeScript type of the id field, e.g. string
+     *
+     * Note: This should only be used in the type generator - all other generators
+     * should use the branded type "typeName"!
+     */
+    unbrandedTypeName: Types.TypeName;
+}>;
 /**
  * A relation field, representing a "to-relation" in the schema.
  */
@@ -269,6 +299,29 @@ export type FieldRelation = Prettify<Omit<FieldCore, 'name'> & {
      */
     relationToModel: ModelCore;
 }>;
+/**
+ * Utility function to check if a field is an relation field.
+ */
+export declare const isFieldRelation: (field: Field) => field is Prettify<Omit<FieldCore, "name"> & {
+    kind: 'relation';
+    /**
+     * Name of the field and variable (e.g. aggregationId)
+     */
+    name: string;
+    /**
+     * Name of the unbranded TypeScript type of the field, e.g. string
+     *
+     * Note: This should only be used in the type generator - all other generators
+     * should use the branded type "typeName"!
+     *
+     * @internal
+     */
+    unbrandedTypeName: Types.TypeName;
+    /**
+     * The referenced model
+     */
+    relationToModel: ModelCore;
+}>;
 /**
  * An enum field, e.g. a field that can only have a value of a specific enum.
  */
@@ -287,6 +340,24 @@ export type FieldEnum = Prettify<Omit<FieldCore, 'name'> & {
      */
     enumerator: Enum;
 }>;
+/**
+ * Utility function to check if a field is an enumid field.
+ */
+export declare const isFieldEnum: (field: Field) => field is Prettify<Omit<FieldCore, "name"> & {
+    kind: 'enum';
+    /**
+     * Name of the field and variable (e.g. language)
+     */
+    name: string;
+    /**
+     * Name of the TypeScript type of the field, e.g. Language
+     */
+    typeName: Types.TypeName;
+    /**
+     * Enum definition of the field.
+     */
+    enumerator: Enum;
+}>;
 /**
  * Definition of an enum, consisting of a name and a list of enum members.
  */

package/dist/lib/schema/schema.js

@@ -1,2 +1,18 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.isFieldEnum = exports.isFieldRelation = exports.isFieldId = void 0;
+/**
+ * Utility function to check if a field is an id field.
+ */
+const isFieldId = (field) => field.kind === 'id';
+exports.isFieldId = isFieldId;
+/**
+ * Utility function to check if a field is an relation field.
+ */
+const isFieldRelation = (field) => field.kind === 'relation';
+exports.isFieldRelation = isFieldRelation;
+/**
+ * Utility function to check if a field is an enumid field.
+ */
+const isFieldEnum = (field) => field.kind === 'enum';
+exports.isFieldEnum = isFieldEnum;

package/package.json

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