@postxl/generator 0.14.0 → 0.15.1

package/dist/generators/models/react.generator/modals.generator.js

@@ -24,12 +24,12 @@ var __importStar = (this && this.__importStar) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateDeleteModalModelComponent = exports.generateEditModalModelComponent = exports.generateModelCreateModalComponent = void 0;
-const serializer_1 = require("../../../lib/serializer");
-const StringUtils = __importStar(require("../../../lib/utils/string"));
+const imports_1 = require("../../../lib/imports");
 const meta_1 = require("../../../lib/meta");
 const fields_1 = require("../../../lib/schema/fields");
-const imports_1 = require("../../../lib/imports");
+const serializer_1 = require("../../../lib/serializer");
 const types_1 = require("../../../lib/types");
+const StringUtils = __importStar(require("../../../lib/utils/string"));
 /**
  * Utility generator that creates a create modal component for a given model.
  */
@@ -37,10 +37,11 @@ function generateModelCreateModalComponent({ model, meta }) {
     const { fields } = model;
     const { react: { components: { modals }, }, trpc, } = meta;
     return `
+/* eslint-disable @typescript-eslint/no-unused-vars */
 ${getFormImports({ model, meta })}
 
 type CreateInputData = {
-  ${getFormInputFields({ model, nullable: true })}
+  ${getCreateFormInputFields({ model })}
 }
 
 /**
@@ -62,7 +63,7 @@ export const ${modals.createComponentName} = ({ show, onHide }: { show: boolean;
         validate={(values) => {
           const errors: FormikErrors<CreateInputData> = {}
 
-					${getFormikValidationCases({ model, includeId: false })}
+					${getFormikValidationCases({ model })}
 
           return errors
         }}
@@ -72,7 +73,7 @@ export const ${modals.createComponentName} = ({ show, onHide }: { show: boolean;
             const res = await toast.promise(
               mutation.mutateAsync(
                 {									
-                  ${getFormikMutationData({ model, includeId: false })}
+                  ${getFormikCreateMutationData({ model })}
                 },
                 {
                   async onSuccess() {
@@ -95,15 +96,14 @@ export const ${modals.createComponentName} = ({ show, onHide }: { show: boolean;
           }
         }}
       >
-        {({ isSubmitting, handleSubmit, isValid }) => (
+        {({ isSubmitting, submitForm, isValid }) => (
           <ModalWithActions actions={
             <ConfirmButton
               color="primary"
               label="Create"
               fill="fill"
-              onClick={handleSubmit}
+              onClick={submitForm}
               loading={isSubmitting}
-              disabled={!isValid}
             />
 					}>
 						${getFormFieldComponents({ model })}
@@ -124,12 +124,13 @@ function generateEditModalModelComponent({ model, meta }) {
     const { fields } = model;
     const { react: { components }, trpc, } = meta;
     return `
+/* eslint-disable @typescript-eslint/no-unused-vars */
 ${getFormImports({ model, meta })}
 
 
 type EditInputData = {
   ${getFormikFieldName(model.idField.name)}: ${model.brandedIdType}
-	${getFormInputFields({ model, nullable: false })}
+	${getEditFormInputFields({ model })}
 }
 
 /**
@@ -168,7 +169,7 @@ export const ${components.modals.editComponentName} = ({
         validate={(values) => {
           const errors: { [K in keyof EditInputData]?: string } = {}
 
-					${getFormikValidationCases({ model, includeId: true })}
+					${getFormikValidationCases({ model })}
 
           return errors
         }}
@@ -177,7 +178,7 @@ export const ${components.modals.editComponentName} = ({
             await toast.promise(
               mutation.mutateAsync(
                 {
-                  ${getFormikMutationData({ model, includeId: true })}
+                  ${getEditFormikMutationData({ model })}
                 },
                 {
                   async onSuccess() {
@@ -198,15 +199,14 @@ export const ${components.modals.editComponentName} = ({
           }
         }}
       >
-        {({ isSubmitting, isValid, handleSubmit }) => (
+        {({ isSubmitting, submitForm }) => (
           <ModalWithActions
             actions={
               <ConfirmButton
                 label="Save"
                 color="primary"
-                onClick={handleSubmit}
+                onClick={submitForm}
                 loading={isSubmitting}
-                disabled={!isValid}
               />
             }
           >
@@ -230,6 +230,7 @@ function generateDeleteModalModelComponent({ model, meta }) {
         from: meta.types.importPath,
     });
     return `
+/* eslint-disable @typescript-eslint/no-unused-vars */
 import { Formik, FormikErrors } from 'formik'
 import React, { useCallback } from 'react'
 import { toast } from 'react-hot-toast'
@@ -335,17 +336,86 @@ function getFormImports({ model, meta }) {
     ${imports.generate()}
   `;
 }
+/**
+ * Returns a string containing TypeScript type definition for the input data of the create mutation.
+ *
+ * NOTE: This function assumes that fields might also be null because we have no data yet.
+ */
+function getCreateFormInputFields({ model }) {
+    const form = new serializer_1.Serializer();
+    for (const field of model.fields.values()) {
+        switch (field.kind) {
+            case 'id':
+                continue;
+            case 'relation':
+                form.append(`${getFormikFieldName(field.name)}: { id: ${field.relationToModel.brandedIdType} } | null`);
+                break;
+            case 'scalar':
+                form.append(`${getFormikFieldName(field.name)}: ${field.typeName} | null`);
+                break;
+            case 'enum':
+                form.append(`${getFormikFieldName(field.name)}: { id: ${field.typeName} } | null`);
+                break;
+            default:
+                throw new types_1.ExhaustiveSwitchCheck(field);
+        }
+    }
+    return form.print();
+}
+function getFormikCreateMutationData({ model: { fields } }) {
+    return fields
+        .map((field) => {
+        const formikFieldName = getFormikFieldName(field.name);
+        switch (field.kind) {
+            case 'id':
+            case 'scalar':
+                // NOTE: Create methods generate the ID field upon submision.
+                if (field.kind === 'id') {
+                    return '';
+                }
+                if (field.isRequired) {
+                    return `
+            // NOTE: We force unwrap values, because we validate values using Formik.
+            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+            ${field.name}: values.${formikFieldName}!,
+            `;
+                }
+                return `${field.name}: values.${formikFieldName},`;
+            case 'relation':
+                if (field.isRequired) {
+                    return `
+              // NOTE: We force unwrap values, because we validate values using Formik.
+              // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+              ${field.name}: values.${formikFieldName}!.id,
+            `;
+                }
+                return `${field.name}: values.${formikFieldName}?.id ? values.${formikFieldName}!.id : null,`;
+            case 'enum':
+                if (field.isRequired) {
+                    return `
+            // NOTE: We force unwrap values, because we validate values using Formik.
+            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+            ${field.name}: values.${formikFieldName}!.id,
+            `;
+                }
+                return `${field.name}: values.${formikFieldName}?.id ? values.${formikFieldName}!.id : null,`;
+            default:
+                throw new types_1.ExhaustiveSwitchCheck(field);
+        }
+    })
+        .join('\n');
+}
 /**
  * Returns a string containing the fields of the input data without the ID field.
  */
-function getFormInputFields({ model, nullable }) {
+function getEditFormInputFields({ model }) {
     const form = new serializer_1.Serializer();
     for (const field of model.fields.values()) {
         switch (field.kind) {
             case 'id':
                 continue;
             case 'relation':
-                if (field.isRequired && nullable !== true) {
+                if (field.isRequired) {
                     form.append(`${getFormikFieldName(field.name)}: { id: ${field.relationToModel.brandedIdType} }`);
                 }
                 else {
@@ -353,7 +423,7 @@ function getFormInputFields({ model, nullable }) {
                 }
                 break;
             case 'scalar':
-                if (field.isRequired && nullable !== true) {
+                if (field.isRequired) {
                     form.append(`${getFormikFieldName(field.name)}: ${field.typeName}`);
                 }
                 else {
@@ -361,7 +431,7 @@ function getFormInputFields({ model, nullable }) {
                 }
                 break;
             case 'enum':
-                if (field.isRequired && nullable !== true) {
+                if (field.isRequired) {
                     form.append(`${getFormikFieldName(field.name)}: { id: ${field.typeName} }`);
                 }
                 else {
@@ -374,6 +444,32 @@ function getFormInputFields({ model, nullable }) {
     }
     return form.print();
 }
+function getEditFormikMutationData({ model: { fields } }) {
+    return fields
+        .map((field) => {
+        const formikFieldName = getFormikFieldName(field.name);
+        switch (field.kind) {
+            case 'id':
+            // NOTE: Edit mutation expects the ID field to identify the object.
+            // eslint-disable-next-line no-fallthrough
+            case 'scalar':
+                return `${field.name}: values.${formikFieldName},`;
+            case 'relation':
+                if (field.isRequired) {
+                    return `${field.name}: values.${formikFieldName}.id,`;
+                }
+                return `${field.name}: values.${formikFieldName}?.id ? values.${formikFieldName}!.id : null,`;
+            case 'enum':
+                if (field.isRequired) {
+                    return `${field.name}: values.${formikFieldName}.id,`;
+                }
+                return `${field.name}: values.${formikFieldName}?.id ? values.${formikFieldName}!.id : null,`;
+            default:
+                throw new types_1.ExhaustiveSwitchCheck(field);
+        }
+    })
+        .join('\n');
+}
 /**
  * Returns a string containing all the components that should appear in the Formik form for this model.
  */
@@ -462,11 +558,12 @@ function getFormFieldComponents({ model }) {
 /**
  * Returns a string containing a list of checks for Formik validation function.
  */
-function getFormikValidationCases({ model, includeId }) {
+function getFormikValidationCases({ model }) {
     const form = new serializer_1.Serializer();
     for (const field of model.fields.values()) {
-        if (!includeId && field.kind === 'id')
+        if (field.kind === 'id') {
             continue;
+        }
         const formikFieldName = getFormikFieldName(field.name);
         if (field.isRequired) {
             form.append(`
@@ -478,45 +575,6 @@ function getFormikValidationCases({ model, includeId }) {
     }
     return form.print();
 }
-function getFormikMutationData({ model: { fields }, includeId }) {
-    return fields
-        .map((field) => {
-        const formikFieldName = getFormikFieldName(field.name);
-        switch (field.kind) {
-            case 'id':
-            case 'scalar':
-                if (field.kind === 'id' && !includeId) {
-                    return '';
-                }
-                if (field.isRequired) {
-                    return `
-            // NOTE: We force unwrap values, because we validate values using Formik.
-            ${field.name}: values.${formikFieldName}!,
-            `;
-                }
-                return `${field.name}: values.${formikFieldName},`;
-            case 'relation':
-                if (field.isRequired) {
-                    return `
-              // NOTE: We force unwrap values, because we validate values using Formik.
-              ${field.name}: values.${formikFieldName}!.id,
-            `;
-                }
-                return `${field.name}: values.${formikFieldName}?.id ? values.${formikFieldName}!.id : null,`;
-            case 'enum':
-                if (field.isRequired) {
-                    return `
-            // NOTE: We force unwrap values, because we validate values using Formik.
-            ${field.name}: values.${formikFieldName}!.id,
-            `;
-                }
-                return `${field.name}: values.${formikFieldName}?.id ? values.${formikFieldName}!.id : null,`;
-            default:
-                throw new types_1.ExhaustiveSwitchCheck(field);
-        }
-    })
-        .join('\n');
-}
 // NOTE: This function is separated because many parts rely on the name of the field.
 function getFormikFieldName(name) {
     return `formik${StringUtils.toPascalCase(name)}`;

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

@@ -60,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],
@@ -76,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()}
 
@@ -237,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}> {    
@@ -256,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}> {

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

@@ -99,12 +99,15 @@ 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.replace(/'/g, "\\'");
+}
 function generateFieldDataScalar({ field, model, index, exampleMode, }) {
     const { hasExample, example } = getFieldExample({ field, model, index, exampleMode });
     switch (field.typeName) {
         case 'string': {
-            if (hasExample) {
-                return `${example}`;
+            if (hasExample && typeof example === 'string') {
+                return `'${quoteSingleQuote(example)}'`;
             }
             const result = generateFieldDataString({ field, model, index });
             if (result === null) {

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,7 +40,7 @@ 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) {
@@ -58,10 +52,18 @@ function getAssigmentStatementModel({ fields }) {
             }
             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': {
                 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': {

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.
  */
@@ -112,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/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;