@postxl/generator 0.15.4 → 0.15.6

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

@@ -33,119 +33,109 @@ const Types = __importStar(require("../../lib/schema/types"));
  */
 function generateModelBusinessLogic({ model, meta }) {
     const imports = imports_1.ImportsGenerator.from(meta.businessLogic.serviceFilePath);
-    const repos = new Map();
-    imports.addImport({
-        items: [meta.data.repositoryClassName],
-        from: meta.data.importPath,
+    const dependencies = new Map();
+    imports.addImport({ from: meta.data.importPath, items: [meta.data.repositoryClassName] });
+    imports.addImport({ from: meta.types.importPath, items: [model.brandedIdType, meta.types.typeName] });
+    /**
+     * Set of repositories (one for each referenced model) to be injected into the constructor.
+     */
+    const dataRepositoryVariableName = Types.toVariableName('data');
+    dependencies.set(meta.data.repositoryClassName, {
+        repositoryClassName: meta.data.repositoryClassName,
+        localRepositoryVariableName: dataRepositoryVariableName,
     });
-    imports.addImport({
-        items: [model.brandedIdType, meta.types.typeName],
-        from: meta.types.importPath,
-    });
-    const dataRepo = Types.toVariableName('data');
-    repos.set(meta.data.repositoryClassName, { name: dataRepo, repoName: meta.data.repositoryClassName });
-    const linkedItems = new Map();
+    const linkedForeignBacklinkFields = new Map();
+    // Converts each relationship to a variable that is pulled from the referenced model's repository - and validates
+    // that it exists in case the relationship is required.
+    // Variable definition and name of the variable is stored in a Map for each relationship - and is referenced in
+    // the `getLinkedItem` function.
     for (const relation of (0, fields_1.getRelationFields)(model)) {
-        if (relation.relationToModel.typeName === model.typeName) {
-            continue;
-        }
         const refModel = relation.relationToModel;
         const refMeta = (0, meta_1.getModelMetadata)({ model: refModel });
-        imports.addImport({
-            items: [refModel.brandedIdType, refMeta.types.typeName],
-            from: refMeta.types.importPath,
-        });
-        imports.addImport({
-            items: [refMeta.data.repositoryClassName],
-            from: refMeta.data.importPath,
-        });
-        repos.set(refMeta.data.repositoryClassName, {
-            name: refMeta.internalPluralName,
-            repoName: refMeta.data.repositoryClassName,
+        imports.addImport({ from: refMeta.data.importPath, items: [refMeta.data.repositoryClassName] });
+        /**
+         * Internal variable pointing to an instance of a referenced repository.
+         */
+        const repoReferenceName = relation.relationToModel.typeName !== model.typeName ? refMeta.internalPluralName : dataRepositoryVariableName;
+        dependencies.set(refMeta.data.repositoryClassName, {
+            localRepositoryVariableName: repoReferenceName,
+            repositoryClassName: refMeta.data.repositoryClassName,
         });
-        linkedItems.set(relation.name, {
+        const variableDefinition = `
+      const ${relation.relatedModelBacklinkFieldName} = this.${repoReferenceName}.get(itemRaw.${relation.name})
+      ${!relation.isRequired
+            ? ''
+            : `if (!${relation.relatedModelBacklinkFieldName}) {
+              throw new Error(\`Could not find ${refMeta.types.typeName} with id \${itemRaw.${relation.name}} for ${model.typeName}.${relation.name}!\`)
+            }`}      
+      `;
+        linkedForeignBacklinkFields.set(relation.name, {
             fieldName: relation.relatedModelBacklinkFieldName,
-            variableDefinition: `
-    const ${relation.relatedModelBacklinkFieldName} = this.${refMeta.internalPluralName}.get(itemRaw.${relation.name})
-    ${!relation.isRequired
-                ? ''
-                : `
-    if (!${relation.relatedModelBacklinkFieldName}) {
-      throw new Error(\`Could not find ${refMeta.types.typeName} with id \${itemRaw.${relation.name}} for ${model.typeName}.${relation.name}!\`)
-    }`}`,
+            variableDefinition,
         });
     }
-    const hasLinkedItems = linkedItems.size > 0;
+    const hasLinkedItems = linkedForeignBacklinkFields.size > 0;
     if (hasLinkedItems) {
-        imports.addImport({
-            items: [meta.types.linkedTypeName],
-            from: meta.types.importPath,
-        });
+        imports.addImport({ from: meta.types.importPath, items: [meta.types.linkedTypeName] });
     }
-    for (const f of (0, fields_1.getEnumFields)(model)) {
-        const refEnumMeta = (0, meta_1.getEnumMetadata)({ enumerator: f.enumerator });
-        imports.addImport({
-            items: [f.enumerator.typeName],
-            from: refEnumMeta.types.importPath,
-        });
+    const constructorParameters = [...dependencies.values()].map(({ localRepositoryVariableName, repositoryClassName }) => `private readonly ${localRepositoryVariableName}: ${repositoryClassName}`);
+    const linkedItemsGetterFn = `
+    /**
+     * Returns the linked ${meta.userFriendlyName} with the given id or null if it does not exist.
+     * Linked: The ${meta.userFriendlyName} contains the linked (raw) items themselves, not only the ids.
+     */
+    public getLinkedItem(id: ${model.brandedIdType}): ${meta.types.linkedTypeName} | null {
+      const itemRaw = this.${dataRepositoryVariableName}.get(id)
+      if (!itemRaw) return null
+      ${[...linkedForeignBacklinkFields.values()].map(({ variableDefinition }) => variableDefinition).join('\n')}
+      const item: ${meta.types.linkedTypeName} = {
+        ${model.fields
+        .map((f) => {
+        if (f.kind !== 'relation') {
+            return `${f.name}: itemRaw.${f.name}`;
+        }
+        const linked = linkedForeignBacklinkFields.get(f.name);
+        if (!linked) {
+            throw new Error(`Could not find linked item for ${model.typeName}.${f.name}`);
+        }
+        return `${linked.fieldName}`;
+    })
+        .join(',\n')}
+      }
+      return item
     }
+  `;
     return `
 import { Injectable } from '@nestjs/common'
-  ${imports.generate()}
+
+${imports.generate()}
 
 @Injectable()
 export class ${meta.businessLogic.serviceClassName} {
-  constructor(
-    ${[...repos.values()].map(({ name, repoName }) => `private readonly ${name}: ${repoName}`).join(',\n')}
-  ) {}
+  constructor(${constructorParameters.join(',\n')}) {}
 
   /**
    * Returns the raw ${meta.userFriendlyName} with the given id or null if it does not exist.
    * Raw: The ${meta.userFriendlyName} only contains linked Ids, not the linked items themselves.
    */
   public get(id: ${model.brandedIdType}): ${meta.types.typeName} | null {
-    return this.${dataRepo}.get(id)
+    return this.${dataRepositoryVariableName}.get(id)
   }
-  ${!hasLinkedItems
-        ? ''
-        : `
-  /**
-   * Returns the linked ${meta.userFriendlyName} with the given id or null if it does not exist.
-   * Linked: The ${meta.userFriendlyName} contains the linked (raw) items themselves, not only the ids.
-   */
-  public getLinkedItem(id: ${model.brandedIdType}): ${meta.types.linkedTypeName} | null {
-    const itemRaw = this.${dataRepo}.get(id)
-    if (!itemRaw) return null
-    ${[...linkedItems.values()].map(({ variableDefinition }) => variableDefinition).join('\n')}
-    const item: ${meta.types.linkedTypeName} = {
-      ${model.fields
-            .map((f) => {
-            if (f.kind !== 'relation') {
-                return `${f.name}: itemRaw.${f.name}`;
-            }
-            const linked = linkedItems.get(f.name);
-            if (!linked) {
-                throw new Error(`Could not find linked item for ${model.typeName}.${f.name}`);
-            }
-            return `${linked.fieldName}`;
-        })
-            .join(',\n')}
-    }
-    return item
-  }`}
+
+  ${hasLinkedItems ? linkedItemsGetterFn : ''}
 
   /**
    * Returns a map of all ${meta.userFriendlyName}s.
    */
   public getAll(): Map<${meta.types.brandedIdType}, ${model.typeName}> {
-    return this.${dataRepo}.getAll()
+    return this.${dataRepositoryVariableName}.getAll()
   }
 
   /**
    * Creates a new ${meta.userFriendlyName}.
    */
   public async create(item: Omit<${model.typeName}, 'id'>): Promise<${model.typeName}> {
-    return this.${dataRepo}.create(item)
+    return this.${dataRepositoryVariableName}.create(item)
   }
 
   /**
@@ -154,7 +144,7 @@ export class ${meta.businessLogic.serviceClassName} {
   public async update(item: Partial<${model.typeName}> & { 
 		id: ${model.brandedIdType}
 	}): Promise<${model.typeName}> {
-    return this.${dataRepo}.update(item)
+    return this.${dataRepositoryVariableName}.update(item)
   }
 
   /**
@@ -164,7 +154,7 @@ export class ${meta.businessLogic.serviceClassName} {
    * If the items is a dependency of another item, the deletion will fail!
    */
   public async delete(id: ${model.brandedIdType}): Promise<void> {
-    return this.${dataRepo}.delete(id)
+    return this.${dataRepositoryVariableName}.delete(id)
   }
 }
 `;

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

@@ -28,10 +28,11 @@ function generateModelLibraryComponents({ model, meta }) {
             from: refMeta.react.folderPath,
         });
     }
-    const depContexts = (0, fields_1.getRelationFields)(model).map((field) => {
-        const depMeta = (0, meta_1.getModelMetadata)({ model: field.relationToModel });
-        return depMeta.react.context.contextProviderName;
-    });
+    const reactContextProvidersOfDependencies = new Set();
+    for (const relation of (0, fields_1.getRelationFields)(model)) {
+        const refMeta = (0, meta_1.getModelMetadata)({ model: relation.relationToModel });
+        reactContextProvidersOfDependencies.add(refMeta.react.context.contextProviderName);
+    }
     return `
     import React, { useState } from 'react'
 
@@ -56,64 +57,76 @@ function generateModelLibraryComponents({ model, meta }) {
     /**
      * Show a single ${model.name} entry.
      */
-    export const ${components.cardComponentName} = React.forwardRef<HTMLLIElement, { item: ${model.typeName} }>(({ item }, forwardedRef) => {
-      const [isEditModalOpen, setIsEditModalOpen] = useState(false)
-      const [isDeleteModalOpen, setIsDeleteModalOpen] = useState(false)
+    export const ${components.cardComponentName} = React.forwardRef<HTMLLIElement, { item: ${model.typeName} }>(
+      ({ item }, forwardedRef) => {
+        const [isEditModalOpen, setIsEditModalOpen] = useState(false)
+        const [isDeleteModalOpen, setIsDeleteModalOpen] = useState(false)
 
-      return (
-        <>
-          <Card
-            ref={forwardedRef}
-            title={item.name}
-            actions={[
-              {
-                label: 'Edit',
-                icon: 'pencil-on-paper',
-                onClick: () => setIsEditModalOpen(true),
-              },
-              {
-                label: 'Delete',
-                icon: 'trash',
-                onClick: () => setIsDeleteModalOpen(true),
-              },
-            ]}
-          />
-          
-          ${nestInParentComponents({
+        return (
+          <>
+            <Card
+              ref={forwardedRef}
+              title={item.name}
+              actions={[
+                {
+                  label: 'Edit',
+                  icon: 'pencil-on-paper',
+                  onClick: () => setIsEditModalOpen(true),
+                },
+                {
+                  label: 'Delete',
+                  icon: 'trash',
+                  onClick: () => setIsDeleteModalOpen(true),
+                },
+              ]}
+            />
+            
+            ${nestChildrenInComponents({
         child: `
-              <${components.modals.editComponentName} 
-                data={item} 
-                show={isEditModalOpen} 
-                onHide={() => setIsEditModalOpen(false)} 
-              />
-            `,
-        components: depContexts,
+                <${components.modals.editComponentName} 
+                  data={item} 
+                  show={isEditModalOpen} 
+                  onHide={() => setIsEditModalOpen(false)} 
+                />
+              `,
+        components: reactContextProvidersOfDependencies,
     })}
 
-          <${components.modals.deleteComponentName} 
-            id={item.id} 
-            show={isDeleteModalOpen} 
-            onHide={() => setIsDeleteModalOpen(false)} 
-          />
-        </>
-      )
-    })
+            <${components.modals.deleteComponentName} 
+              id={item.id} 
+              show={isDeleteModalOpen} 
+              onHide={() => setIsDeleteModalOpen(false)} 
+            />
+          </>
+        )
+      }
+    )
 
     ${components.cardComponentName}.displayName = '${components.cardComponentName}'
   `;
 }
 exports.generateModelLibraryComponents = generateModelLibraryComponents;
 /**
- * Nests a given React component in an array of parent wrappers.
+ * Deterministifcally nests a given React component in an array of parent wrappers.
+ */
+function nestChildrenInComponents({ child, components }) {
+    if (components.size === 0) {
+        return child;
+    }
+    const sortedComponents = [...components.values()].sort((a, b) => a.localeCompare(b));
+    return _nestInComponents({ child, components: sortedComponents });
+}
+/**
+ * DO NOT USE THIS FUNCTION DIRECTLY. Use `nestChildrenInComponents` instead.
  */
-function nestInParentComponents({ child, components }) {
+function _nestInComponents({ child, components }) {
     if (components.length === 0) {
         return child;
     }
     const [parent, ...rest] = components;
     return `
     <${parent}>
-      ${nestInParentComponents({ child, components: rest })}
+      ${_nestInComponents({ child, components: rest })}
     </${parent}>
   `;
 }

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

@@ -389,7 +389,7 @@ function getFormikCreateMutationData({ model: { fields } }) {
               ${field.name}: values.${formikFieldName}!.id,
             `;
                 }
-                return `${field.name}: values.${formikFieldName}?.id ? values.${formikFieldName}!.id : null,`;
+                return `${field.name}: values.${formikFieldName}?.id ? values.${formikFieldName}.id : null,`;
             case 'enum':
                 if (field.isRequired) {
                     return `
@@ -398,7 +398,7 @@ function getFormikCreateMutationData({ model: { fields } }) {
             ${field.name}: values.${formikFieldName}!.id,
             `;
                 }
-                return `${field.name}: values.${formikFieldName}?.id ? values.${formikFieldName}!.id : null,`;
+                return `${field.name}: values.${formikFieldName}?.id ? values.${formikFieldName}.id : null,`;
             default:
                 throw new types_1.ExhaustiveSwitchCheck(field);
         }
@@ -458,12 +458,12 @@ function getEditFormikMutationData({ model: { fields } }) {
                 if (field.isRequired) {
                     return `${field.name}: values.${formikFieldName}.id,`;
                 }
-                return `${field.name}: values.${formikFieldName}?.id ? values.${formikFieldName}!.id : null,`;
+                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,`;
+                return `${field.name}: values.${formikFieldName}?.id ? values.${formikFieldName}.id : null,`;
             default:
                 throw new types_1.ExhaustiveSwitchCheck(field);
         }

package/package.json

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