@postxl/generator 0.13.0 → 0.15.0

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

@@ -41,14 +41,16 @@ function generateRepository({ model, meta }) {
         };
     };
     const indexes = model.attributes.index ? [getIndexDefinition(model.attributes.index)] : [];
-    const defaultValueInitFn = `
+    const defaultValueInitFn = model.defaultField
+        ? `
 		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!')
@@ -58,14 +60,16 @@ function generateRepository({ model, meta }) {
     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],
+        items: [model.typeName, model.brandedIdType, ...(isGenerated ? [meta.types.toBrandedIdTypeFnName] : [])],
         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'),
     });
+    if (!model.attributes.inMemoryOnly) {
+        imports.addImport({ items: [meta.types.zodDecoderFnName], from: meta.types.importPath });
+    }
     relations.forEach((r) => {
         imports.addImport({
             items: [r.meta.types.brandedIdType],
@@ -74,8 +78,12 @@ function generateRepository({ model, meta }) {
     });
     return `
 import { Injectable, Logger } from '@nestjs/common'
+${model.attributes.inMemoryOnly
+        ? ''
+        : `
 import { DbService, ${model.sourceName} as DbType } from '@${model.schemaConfig.project}/db'
 import { format, pluralize ${indexes.length === 0 ? '' : ', NestedMap'} } from '@pxl/common'
+`}
 
 ${imports.generate()}
 
@@ -235,6 +243,11 @@ export class ${meta.data.repositoryClassName} implements Repository<
       ${[...model.fields.values()].map((f) => `${f.sourceName}: item.${f.name}`).join(',\n')}
     }
   }
+  ${model.attributes.inMemoryOnly
+        ? `
+  // Non-mocked version is async - so we keep type-compatible signatures for create() and createWithId() 
+  // eslint-disable-next-line @typescript-eslint/require-await, @typescript-eslint/no-unused-vars`
+        : ''}
   public async createWithId(item: Omit<${model.typeName}, '${idField.name}'> & { 
 		id: ${model.brandedIdType}
 	}): Promise<${model.typeName}> {    
@@ -254,6 +267,11 @@ export class ${meta.data.repositoryClassName} implements Repository<
     return newItem
   }
 
+  ${model.attributes.inMemoryOnly
+        ? `
+  // Non-mocked version is async - so we keep type-compatible signatures for create() and createWithId() 
+  // eslint-disable-next-line @typescript-eslint/require-await, @typescript-eslint/no-unused-vars`
+        : ''}
   public async create(
 		item: Omit<${model.typeName}, 'id'>
 	): Promise<${model.typeName}> {
@@ -405,17 +423,22 @@ export class ${meta.data.repositoryClassName} implements Repository<
     }
   `)
         .join('\n')}
-  ${maxLengthStringFields.map((f) => {
-        return `
-  /**
-   * Utility function that ensures that the ${f.name} field has a max length of ${f.attributes.maxLength}
-   */      
-  private ${getEnsureMaxLengthFnName(f)}(item: { ${f.name}?: string }) {
-    if (!item.${f.name}) return
-    if (item.${f.name}.length <= ${f.attributes.maxLength}) return
-    item.${f.name} = item.${f.name}.substring(0, ${f.attributes.maxLength - 4}) + \`...\`
-  }`;
-    })}
+
+  ${maxLengthStringFields
+        .map((f) => `
+      /**
+       * Utility function that ensures that the ${f.name} field has a max length of ${f.attributes.maxLength}
+       */      
+      private ${getEnsureMaxLengthFnName(f)}(item: { ${f.name}?: string }) {
+        if (!item.${f.name}) {
+          return
+        }
+        if (item.${f.name}.length <= ${f.attributes.maxLength}) {
+          return
+        }
+        item.${f.name} = item.${f.name}.substring(0, ${f.attributes.maxLength - 4}) + \`...\`
+      }`)
+        .join('\n')}
 
   ${uniqueStringFields
         .map((f) => {

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

@@ -11,7 +11,7 @@ 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),
+    getDefault: procedure.query(({ ctx }) => ctx.data.${meta.data.dataServiceName}.defaultValue),
   `;
     const createMethod = getCreateMethod({ model, meta });
     const updateMethod = getUpdateMethod({ model, meta });
@@ -38,8 +38,8 @@ export const ${meta.trpc.routerName} = router({
   
   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()),
+    .query(({ input, ctx }) => ctx.data.${meta.data.dataServiceName}.get(input)),
+  getMap: procedure.query(({ ctx }) => ctx.data.${meta.data.dataServiceName}.getAll()),
 
   ${omit(createMethod, model.attributes.skipCreate)}
   ${omit(updateMethod, model.attributes.skipUpdate)}
@@ -66,7 +66,7 @@ function getCreateMethod({ model: { fields }, meta }) {
     create: procedure.input(z.object({ 
       ${parameters}
     }))
-      .mutation(({ input, ctx }) => ctx.dataService.${meta.data.dataServiceName}.create(input)),
+      .mutation(({ input, ctx }) => ctx.data.${meta.data.dataServiceName}.create(input)),
 `;
 }
 function getUpdateMethod({ model: { fields }, meta }) {
@@ -79,14 +79,14 @@ function getUpdateMethod({ model: { fields }, meta }) {
       ${parameters}
       })
     )
-    .mutation(({ input, ctx }) => ctx.dataService.${meta.data.dataServiceName}.update(input)),
+    .mutation(({ input, ctx }) => ctx.data.${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)),
+    .mutation(({ input, ctx }) => ctx.data.${meta.data.dataServiceName}.delete(input)),
 `;
 }
 /**

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

@@ -95,39 +95,60 @@ function generateFieldData({ field, model, index, exampleMode, }) {
             throw new types_1.ExhaustiveSwitchCheck(field);
     }
 }
-function generateFieldDataId({ field, model, index }) {
+function generateFieldDataId({ field, index }) {
     const idModelMeta = (0, meta_1.getModelMetadata)({ model: field.model });
     return `${idModelMeta.types.toBrandedIdTypeFnName}(${field.unbrandedTypeName === 'string' ? `'${index}'` : index})`;
 }
 function quoteSingleQuote(str) {
-    return str !== null ? str.replace(/'/g, "\\'") : null;
+    return str.replace(/'/g, "\\'");
 }
 function generateFieldDataScalar({ field, model, index, exampleMode, }) {
     const { hasExample, example } = getFieldExample({ field, model, index, exampleMode });
     switch (field.typeName) {
-        case 'string':
-            const result = hasExample ? example : generateFieldDataString({ field, model, index });
-            if (result === null)
+        case 'string': {
+            if (hasExample && typeof example === 'string') {
+                return `'${quoteSingleQuote(example)}'`;
+            }
+            const result = generateFieldDataString({ field, model, index });
+            if (result === null) {
                 return 'null';
-            if (result === undefined)
+            }
+            if (result === undefined) {
                 return 'undefined';
-            return `'${quoteSingleQuote(result)}'`;
-        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:
+            }
+            return `'${result.replace(/'/g, "\\'")}'`;
+        }
+        case 'number': {
+            if (hasExample) {
+                return `${example}`;
+            }
+            return generateFieldDataNumber();
+        }
+        case 'boolean': {
+            if (hasExample) {
+                return `${example}`;
+            }
+            return generateFieldDataBoolean();
+        }
+        case 'Date': {
+            if (hasExample) {
+                // TODO: Maybe we should parse the date example to correct format?
+                return `${example}`;
+            }
+            return generateFieldDataDate();
+        }
+        default: {
             console.warn(`Unknown scalar type: ${field.typeName}`);
             return '';
+        }
     }
 }
-function getFieldExample({ field, model, index, exampleMode, }) {
-    if (exampleMode.mode === 'NoExamples')
-        return { hasExample: false, example: undefined };
+function getFieldExample({ field, index, exampleMode, }) {
+    if (exampleMode.mode === 'NoExamples') {
+        return { hasExample: false };
+    }
     if (!field.attributes.examples || field.attributes.examples.length === 0) {
-        return { hasExample: false, example: undefined };
+        return { hasExample: false };
     }
     switch (exampleMode.mode) {
         case 'Permutations': {
@@ -138,30 +159,33 @@ function getFieldExample({ field, model, index, exampleMode, }) {
             const example = field.attributes.examples[(index - 1) % field.attributes.examples.length];
             return { hasExample: true, example };
         }
-        default:
+        default: {
             throw new types_1.ExhaustiveSwitchCheck(exampleMode);
+        }
     }
 }
 function generateFieldDataString({ field, model, index }) {
-    if (field.name === 'name')
+    if (field.name === 'name') {
         return `${(0, string_1.toPascalCase)(model.name)} ${index}`;
-    if (field.name === 'email')
+    }
+    if (field.name === 'email') {
         return faker_1.faker.internet.email();
+    }
     return faker_1.faker.lorem.words(3);
 }
-function generateFieldDataNumber({}) {
+function generateFieldDataNumber() {
     return faker_1.faker.datatype.float({ precision: 0.1, min: 0, max: 1 }).toString();
 }
-function generateFieldDataBoolean({}) {
+function generateFieldDataBoolean() {
     return faker_1.faker.datatype.boolean().toString();
 }
-function generateFieldDataDate({ field, model, index }) {
+function generateFieldDataDate() {
     const d = faker_1.faker.date.past(3, '2023-04-01T00:00:00.000Z');
     //set time to midnight UTC
     d.setUTCHours(0, 0, 0, 0);
     return `new Date('${d.toISOString()}')`;
 }
-function generateFieldDataRelation({ field, model, index, itemCount, }) {
+function generateFieldDataRelation({ field, 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;

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

@@ -14,13 +14,7 @@ function generateStub({ model, meta }) {
         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: [relation.relationToModel.typeName, depMeta.types.toBrandedIdTypeFnName],
-            from: meta.types.importPath,
-        });
-    }
+    const assignments = getAssignmentStatementModel({ fields, imports });
     return `
 ${imports.generate()}
 
@@ -28,7 +22,7 @@ ${imports.generate()}
  * Utility object containing default values for all fields in a model.
  */
 export const ${meta.data.defaultStubConstantName}: ${model.typeName} = {
-	${getAssigmentStatementModel({ fields })}
+	${assignments}
 }
 
 /**
@@ -46,25 +40,38 @@ exports.generateStub = generateStub;
 /**
  * Return an assignment statement for a model where each field is assigned null or its type's default value.
  */
-function getAssigmentStatementModel({ fields }) {
+function getAssignmentStatementModel({ fields, imports }) {
     return fields
         .map((f) => {
         if (!f.isRequired) {
             return `${f.name}: null`;
         }
         switch (f.kind) {
-            case 'scalar':
+            case 'scalar': {
                 return `${f.name}: ${(0, fields_1.getDefaultValueForType)(f.typeName)}`;
-            case 'id':
+            }
+            case 'id': {
                 const idRefMeta = (0, meta_1.getModelMetadata)({ model: f.model });
+                imports.addImport({
+                    items: [idRefMeta.types.toBrandedIdTypeFnName],
+                    from: idRefMeta.types.importPath,
+                });
                 return `${f.name}: ${idRefMeta.types.toBrandedIdTypeFnName}(${(0, fields_1.getDefaultValueForType)(f.unbrandedTypeName)})`;
-            case 'relation':
+            }
+            case 'relation': {
                 const refModelMeta = (0, meta_1.getModelMetadata)({ model: f.relationToModel });
+                imports.addImport({
+                    items: [refModelMeta.types.toBrandedIdTypeFnName],
+                    from: refModelMeta.types.importPath,
+                });
                 return `${f.name}: ${refModelMeta.types.toBrandedIdTypeFnName}(${(0, fields_1.getDefaultValueForType)(f.unbrandedTypeName)})`;
-            case 'enum':
+            }
+            case 'enum': {
                 return `${f.name}: "${f.enumerator.values[0]}"`;
-            default:
+            }
+            default: {
                 throw new types_1.ExhaustiveSwitchCheck(f);
+            }
         }
     })
         .join(',\n');

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

@@ -12,6 +12,7 @@ const types_1 = require("../../lib/types");
 function generateModelTypes({ model, meta }) {
     const idField = model.idField;
     const imports = imports_1.ImportsGenerator.from(meta.types.filePath);
+    let hasLinkedItems = false;
     for (const relation of (0, fields_1.getRelationFields)(model)) {
         if (relation.relationToModel.typeName === model.typeName) {
             continue;
@@ -19,9 +20,10 @@ function generateModelTypes({ model, meta }) {
         const refModel = relation.relationToModel;
         const refMeta = (0, meta_1.getModelMetadata)({ model: refModel });
         imports.addImport({
-            items: [refMeta.types.toBrandedIdTypeFnName, refModel.brandedIdType],
+            items: [refMeta.types.toBrandedIdTypeFnName, refModel.brandedIdType, refMeta.types.typeName],
             from: refMeta.types.filePath,
         });
+        hasLinkedItems = true;
     }
     for (const f of (0, fields_1.getEnumFields)(model)) {
         const refEnumMeta = (0, meta_1.getEnumMetadata)({ enumerator: f.enumerator });
@@ -42,7 +44,7 @@ ${model.description
  * ${model.description.split('\n').join('\n * ')} 
  */`
         : ''}
-export type ${model.typeName} = { 
+export type ${meta.types.typeName} = { 
   ${model.fields
         .map((f) => `
 ${getFieldComment(f)}
@@ -50,6 +52,17 @@ ${f.name}: ${getFieldType(f)}${f.isRequired ? '' : ' | null'}`)
         .join('\n')}
 }
 
+${!hasLinkedItems
+        ? ``
+        : `
+export type ${meta.types.linkedTypeName} = { 
+  ${model.fields
+            .map((f) => `
+${getFieldComment(f)}
+${getLinkedFieldType(f)}${f.isRequired ? '' : ' | null'}`)
+            .join('\n')}
+}`}
+
 /**
  * Branded Id type that should be used to identify an instance of this model.
  */
@@ -90,8 +103,9 @@ function getFieldComment(f) {
 ${comment}*/`;
 }
 function getFieldExamples(f) {
-    if (!f.attributes.examples)
+    if (!f.attributes.examples) {
         return undefined;
+    }
     return `Examples: ${f.attributes.examples.map((e) => `"${e}"`).join(', ')}`;
 }
 /**
@@ -111,3 +125,20 @@ function getFieldType(f) {
             throw new types_1.ExhaustiveSwitchCheck(f);
     }
 }
+/**
+ * Converts a field to a TypeScript type definition with linked fields.
+ */
+function getLinkedFieldType(f) {
+    switch (f.kind) {
+        case 'enum':
+            return `${f.name}: ${f.typeName}`;
+        case 'relation':
+            return `${f.relatedModelBacklinkFieldName}: ${f.relationToModel.typeName}`;
+        case 'id':
+            return `${f.name}: ${f.model.brandedIdType}`;
+        case 'scalar':
+            return `${f.name}: ${f.typeName}`;
+        default:
+            throw new types_1.ExhaustiveSwitchCheck(f);
+    }
+}

package/dist/lib/attributes.d.ts

@@ -51,7 +51,7 @@ export type FieldAttributes = {
     /**
      * Schema tag: ´@@Examples("Example1", "Example2")`
      */
-    examples?: unknown[];
+    examples?: (string | number | boolean)[];
     /**
      * Schema tag: ´@@DefaultField()`
      * The property of the model that identifies the default row.

package/dist/lib/imports.d.ts

@@ -25,7 +25,7 @@ export declare class ImportsGenerator {
      * NOTE: You should never add no items from a given path.
      */
     addImport({ items, from, }: {
-        items: (Types.Function | Types.ClassName | Types.TypeName | Types.VariableName)[];
+        items: (Types.Fnction | Types.ClassName | Types.TypeName | Types.VariableName)[];
         from: Types.Path;
     }): ImportsGenerator;
     /**

package/dist/lib/imports.js

@@ -41,15 +41,24 @@ class ImportsGenerator {
      * Returns the TypeScript import statement.
      */
     generate() {
-        const stetements = Object.entries(this._imports)
-            .sort(([a], [b]) => a.localeCompare(b))
+        const statements = Object.entries(this._imports)
+            .sort(([a], [b]) => {
+            // //in case a or b start with "@", they will be sorted first
+            // if (a.startsWith('@') && !b.startsWith('@')) {
+            //   return -1
+            // }
+            // if (!a.startsWith('@') && b.startsWith('@')) {
+            //   return 1
+            // }
+            return a.localeCompare(b);
+        })
             .map(([path, items]) => {
             const alphabeticallySortedItems = Array.from(items).sort((a, b) => a.localeCompare(b));
             // NOTE: You cannot remove imports and we check that there's at least one imported item for every path.
             return `import { ${alphabeticallySortedItems.join(', ')} } from '${path}'`;
         })
             .join('\n');
-        return stetements;
+        return statements;
     }
 }
 exports.ImportsGenerator = ImportsGenerator;