@postxl/generator 0.69.0 → 0.69.1

package/dist/generators/models/update/service.generator.js

@@ -0,0 +1,252 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateModelBusinessLogicUpdate = void 0;
+const assert_1 = __importDefault(require("assert"));
+const imports_1 = require("../../../lib/imports");
+const meta_1 = require("../../../lib/meta");
+const fields_1 = require("../../../lib/schema/fields");
+const types_1 = require("../../../lib/schema/types");
+const types_2 = require("../../../lib/types");
+const typescript_1 = require("../../../lib/typescript");
+const jsdoc_1 = require("../../../lib/utils/jsdoc");
+const zod_1 = require("../../../lib/zod");
+/**
+ * Generates update business logic for a given model.
+ * The update logic handles all Create/Update/Delete/Upsert operations. See template's readme for more info.
+ */
+function generateModelBusinessLogicUpdate({ model, meta }) {
+    const schemaMeta = (0, meta_1.getSchemaMetadata)({ config: model.schemaConfig });
+    const { view, update, types, data } = meta;
+    const imports = imports_1.ImportsGenerator.from(meta.update.serviceClassLocation.path).addImports({
+        [data.repository.location.import]: data.repository.className,
+        [types.importPath]: [model.brandedIdType, types.typeName, types.toBrandedIdTypeFnName],
+        [view.serviceLocation.import]: [view.serviceClassName],
+        [schemaMeta.actions.execution.interfaceLocation.import]: [schemaMeta.actions.execution.interface],
+        [schemaMeta.actions.dispatcher.definitionLocation.import]: [schemaMeta.actions.dispatcher.definition],
+        [schemaMeta.update.serviceLocation.path]: schemaMeta.update.serviceClassName,
+        [schemaMeta.view.serviceLocation.import]: schemaMeta.view.serviceClassName,
+    });
+    for (const field of (0, fields_1.getRelationFields)(model)) {
+        // NOTE: We add `toBrandedType` functions for foreign models for decoders.
+        if (field.relationToModel.typeName === model.typeName) {
+            continue;
+        }
+        const refModelMeta = (0, meta_1.getModelMetadata)({ model: field.relationToModel });
+        imports.addImport({
+            from: refModelMeta.types.importPath,
+            items: [refModelMeta.types.toBrandedIdTypeFnName],
+        });
+    }
+    const cloneFn = generateCloneFn({ model, meta, imports });
+    return /* ts */ `
+    import { Inject, Injectable, forwardRef } from '@nestjs/common'
+    import { z } from 'zod'
+
+    ${imports.generate()}
+
+    export type Scope = "${meta.actions.actionScopeConstType}"
+
+    export type Actions = {
+      ${(0, jsdoc_1.toJsDocComment)([`Creates a new ${meta.userFriendlyName} and returns it.`])}
+      create: {
+        payload: CreatePayload
+        result: ${types.typeName}
+      }
+
+      ${(0, jsdoc_1.toJsDocComment)([`Updates a ${meta.userFriendlyName} and returns it.`])}
+      update: {
+        payload: UpdatePayload
+        result: ${types.typeName}
+      }
+
+      ${(0, jsdoc_1.toJsDocComment)([`Creates or updates a ${meta.userFriendlyName} and returns it.`])}
+      upsert: {
+        payload: UpsertPayload
+        result: ${types.typeName}
+      }
+
+      ${(0, jsdoc_1.toJsDocComment)([`Deletes a ${meta.userFriendlyName} and returns its id.`])}
+      delete: {
+        payload: ${model.brandedIdType}
+        result: ${model.brandedIdType}
+      }
+    }
+
+    /**
+     * Zod decoder for validating the create input of a ${meta.userFriendlyName}.
+     */
+    export const ${meta.update.createInputDecoder} = z.object({
+      ${model.fields
+        .filter((f) => !f.attributes.isReadonly)
+        .map((f) => `${f.name}: z.${(0, zod_1.getZodDecoderDefinition)({ field: f })}`)
+        .join(',')}
+    })
+
+    type CreatePayload = z.infer<typeof ${meta.update.createInputDecoder}>
+
+    /**
+     * Zod decoder for validating the update input of a ${meta.userFriendlyName} .
+     */
+    export const ${meta.update.updateInputDecoder} = z.object({
+      ${model.fields
+        .filter((f) => !f.attributes.isReadonly || f.kind === 'id')
+        .map((f) => `${f.name}: z.${(0, zod_1.getZodDecoderDefinition)({ field: f, allowAnyOptionalField: f.kind !== 'id' })}`)
+        .join(',')}
+    })
+
+    type UpdatePayload = z.infer<typeof ${meta.update.updateInputDecoder}>
+
+    /**
+     * Zod decoder for validating the upsert input of a ${meta.userFriendlyName} .
+     */
+    export const ${meta.update.upsertInputDecoder} = z.union([
+      ${meta.update.updateInputDecoder}, 
+      ${meta.update.createInputDecoder}
+    ])
+    
+    type UpsertPayload = z.infer<typeof ${meta.update.upsertInputDecoder}>
+
+    export type ${update.serviceInterfaceName} = ${schemaMeta.actions.dispatcher.definition}<Actions>
+
+    @Injectable()
+    export class ${update.serviceClassName} implements ${update.serviceInterfaceName} {
+
+      /**
+       * Instance of the ${meta.userFriendlyName} view service for convenience.
+       */
+      private view: ${view.serviceClassName}
+
+      constructor(
+        private readonly data: ${data.repository.className},
+        
+        @Inject(forwardRef(() => ${schemaMeta.update.serviceClassName})) 
+          private readonly updateService: ${schemaMeta.update.serviceClassName},
+
+        @Inject(forwardRef(() => ${schemaMeta.view.serviceClassName})) 
+          private readonly viewService: ${schemaMeta.view.serviceClassName}
+      ) {
+        this.view = this.viewService.${view.serviceVariableName}
+      }
+
+      ${(0, jsdoc_1.toJsDocComment)([`Creates a new ${meta.userFriendlyName} and returns it.`])}
+      public async create({ data, execution }: { 
+        data: CreatePayload; 
+        execution: ${schemaMeta.actions.execution.interface}
+      }): Promise<${types.typeName}> {
+        return this.data.create({ item: data, execution })
+      }
+
+      ${(0, jsdoc_1.toJsDocComment)([`Updates a ${meta.userFriendlyName} and returns it.`])}
+      public async update({ data, execution }: { 
+        data: UpdatePayload; 
+        execution: ${schemaMeta.actions.execution.interface}
+      }): Promise<${types.typeName}> {
+        return this.data.update({ item: data, execution })
+      }
+
+      ${(0, jsdoc_1.toJsDocComment)([`Creates or updates a ${meta.userFriendlyName} and returns it.`])}
+      public async upsert({ data, execution }: {
+        data: UpsertPayload;
+        execution: ${schemaMeta.actions.execution.interface}
+      }): Promise<${types.typeName}> {
+        return this.data.upsert({ item: data, execution })
+      }
+
+      ${(0, jsdoc_1.toJsDocComment)([`Deletes a ${meta.userFriendlyName} instance and returns its id.`])}
+      public async delete({ data, execution }: { 
+        data: ${model.brandedIdType}; 
+        execution: ${schemaMeta.actions.execution.interface}
+      }): Promise<${model.brandedIdType}> {
+        return this.data.delete({ id: data, execution })
+      }
+
+      ${cloneFn}
+    }
+ `;
+}
+exports.generateModelBusinessLogicUpdate = generateModelBusinessLogicUpdate;
+function generateCloneFn({ model, meta, imports }) {
+    const schemaMeta = (0, meta_1.getSchemaMetadata)({ config: model.schemaConfig });
+    for (const enumField of (0, fields_1.getEnumFields)(model)) {
+        const enumMeta = (0, meta_1.getEnumMetadata)(enumField);
+        imports.addTypeImport({
+            from: enumMeta.types.importPath,
+            items: [enumField.typeName],
+        });
+    }
+    const fnInputFields = model.fields
+        .filter((f) => {
+        switch (f.kind) {
+            case 'id':
+            case 'scalar':
+            case 'enum':
+                return true;
+            case 'relation':
+                return false;
+            default:
+                throw new types_2.ExhaustiveSwitchCheck(f);
+        }
+    })
+        .map((f) => {
+        const type = (0, typescript_1.getFieldType)(f);
+        switch (f.kind) {
+            case 'id':
+                return `${f.name}: ${type}`;
+            case 'scalar':
+            case 'enum':
+                if (f.isUnique) {
+                    // NOTE: `unique` fields require a new value.
+                    if (f.isRequired) {
+                        return `${f.name}: ${type}`;
+                    }
+                    return `${f.name}: ${type} | null`;
+                }
+                // NOTE: Non-unique fields can be copied from the source.
+                if (f.isRequired) {
+                    return `${f.name}?: ${type}`;
+                }
+                return `${f.name}?: ${type} | null`;
+            case 'relation':
+                (0, assert_1.default)(false);
+                break;
+            default:
+                throw new types_2.ExhaustiveSwitchCheck(f);
+        }
+    });
+    const foreignKeyMappings = (0, fields_1.getRelationFields)(model).map((f) => {
+        if (f.isRequired) {
+            return `${f.name}: mappings.get({ model: '${f.relationToModel.typeName}', id: item.${f.name} })`;
+        }
+        return `${f.name}: item.${f.name} ? mappings.get({ model: '${f.relationToModel.typeName}', id: item.${f.name} }) : null`;
+    });
+    if (foreignKeyMappings.length > 0) {
+        imports.addImports({
+            [schemaMeta.types.importPath]: [schemaMeta.types.idTypesIndex],
+            [(0, types_1.toPackageName)('@postxl/runtime')]: [(0, types_1.toClassName)('TypedMapping')],
+        });
+    }
+    return `
+  ${(0, jsdoc_1.toJsDocComment)([`Clones a ${meta.userFriendlyName} with mapped foreign ids.`])}
+  public async clone(
+    { data, execution }: {
+      data: { ${fnInputFields.join('; ')} },
+      execution: ${schemaMeta.actions.execution.interface}
+    },
+    ${foreignKeyMappings.length > 0 ? `mappings = new TypedMapping<${schemaMeta.types.idTypesIndex}>()` : ''}
+  ): Promise<${meta.types.typeName}> {
+    const clone = await this.data.clone({
+      id: data.id,
+      item: (${foreignKeyMappings.length > 0 ? 'item' : ''}) => ({
+        ...data,
+        ${foreignKeyMappings.join(',\n')}
+      }),
+      execution
+    })
+
+    return clone
+  }
+  `;
+}

package/dist/generators/models/{businesslogic-view.generator.d.ts → view/service.generator.d.ts}

@@ -1,5 +1,5 @@
-import { ModelMetaData } from '../../lib/meta';
-import { Model } from '../../lib/schema/schema';
+import { ModelMetaData } from '../../../lib/meta';
+import { Model } from '../../../lib/schema/schema';
 /**
  * Generates view business logic for a given model.
  * The view  logic exposes all information and links of a model. See template's readme for more info.

package/dist/generators/models/{businesslogic-view.generator.js → view/service.generator.js}

@@ -1,13 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateModelBusinessLogicView = void 0;
-const imports_1 = require("../../lib/imports");
-const meta_1 = require("../../lib/meta");
-const fields_1 = require("../../lib/schema/fields");
-const types_1 = require("../../lib/schema/types");
-const types_2 = require("../../lib/types");
-const ast_1 = require("../../lib/utils/ast");
-const jsdoc_1 = require("../../lib/utils/jsdoc");
+const imports_1 = require("../../../lib/imports");
+const meta_1 = require("../../../lib/meta");
+const fields_1 = require("../../../lib/schema/fields");
+const types_1 = require("../../../lib/schema/types");
+const types_2 = require("../../../lib/types");
+const ast_1 = require("../../../lib/utils/ast");
+const jsdoc_1 = require("../../../lib/utils/jsdoc");
 /**
  * Generates view business logic for a given model.
  * The view  logic exposes all information and links of a model. See template's readme for more info.
@@ -20,12 +20,6 @@ function generateModelBusinessLogicView({ model, meta }) {
         [meta.types.importPath]: [(0, types_1.toAnnotatedTypeName)(model.brandedIdType), (0, types_1.toAnnotatedTypeName)(meta.types.typeName)],
         [schemaMeta.view.serviceLocation.path]: schemaMeta.view.serviceClassName,
     });
-    /**
-     * The name of the variable that holds the repository instance for the current model
-     * (e.g. when we generate business logic service for Aggregation, the AggregationRepository
-     * would be referenced using `this.data` variable).
-     */
-    const modelRepositoryVariableName = meta.view.dataRepositoryVariableName;
     /**
      * The name of the variable that holds the central business logic service instance.
      * Instead of injecting a repository instance for each model, we inject this single instance
@@ -33,7 +27,7 @@ function generateModelBusinessLogicView({ model, meta }) {
      */
     const viewServiceClassName = 'viewService';
     const constructorParameters = [
-        `public readonly ${modelRepositoryVariableName}: ${meta.data.repository.className}`,
+        `public readonly data: ${meta.data.repository.className}`,
         `@Inject(forwardRef(() => ${schemaMeta.view.serviceClassName})) private readonly ${viewServiceClassName}: ${schemaMeta.view.serviceClassName}`,
     ];
     /**
@@ -76,7 +70,7 @@ function generateModelBusinessLogicView({ model, meta }) {
      * Linked: The ${meta.userFriendlyName} contains the linked (raw) items themselves, not only the ids.
      */
     public async getLinkedItem(id: ${model.brandedIdType}): Promise<${meta.types.linkedTypeName} | null> {
-      const itemRaw = await this.${modelRepositoryVariableName}.get(id)
+      const itemRaw = await this.data.get(id)
       if (!itemRaw) {
         return null
       }
@@ -157,7 +151,7 @@ export class ${meta.view.serviceClassName} {
    * Raw: The ${meta.userFriendlyName} only contains linked Ids, not the linked items themselves.
    */
   public async get(id: ${model.brandedIdType}): Promise<${meta.types.typeName} | null> {
-    return this.${modelRepositoryVariableName}.get(id)
+    return this.data.get(id)
   }
 
   ${hasLinkedItems ? linkedItemsGetterFn : ''}
@@ -166,7 +160,7 @@ export class ${meta.view.serviceClassName} {
    * Returns a map of all ${meta.userFriendlyNamePlural}.
    */
   public async getAll(): Promise<Map<${meta.types.brandedIdType}, ${model.typeName}>> {
-    return this.${modelRepositoryVariableName}.getAll()
+    return this.data.getAll()
   }
 
   /**
@@ -181,7 +175,7 @@ export class ${meta.view.serviceClassName} {
     sort?: { field: keyof ${model.typeName}; ascending: boolean }
     cursor?: Cursor
   }) {
-    const items = await this.${modelRepositoryVariableName}.getAllAsArray()
+    const items = await this.data.getAllAsArray()
     const filtered = !filter
       ? items
       : items.filter((item) => filterFn(item, filter.field, filter.operator, filter.value))

package/dist/lib/meta.d.ts

@@ -574,6 +574,18 @@ export type SchemaMetaData = {
          * Path that may be used to import the type definitions package.
          */
         importPath: Types.BackendModulePath;
+        /**
+         * Index of all branded ID types associated with the models.
+         *
+         * @example
+         * ```
+         * type SchemaIdTypes = {
+         *   Post: PostId
+         *   Comment: CommentId
+         * }
+         * ```
+         */
+        idTypesIndex: Types.TypeName;
         /**
          * Path and type names for the Data Transfer Objects (DTOs).
          */
@@ -824,10 +836,6 @@ export type ModelMetaData = {
          * Path to the view service for this model.
          */
         serviceLocation: Types.ModuleLocation;
-        /**
-         * The name of the variable that holds the repository instance for the current model
-         */
-        dataRepositoryVariableName: Types.VariableName;
         /**
          * The name of the variable that defines the filter operator decoder for the current model.
          */
@@ -883,10 +891,6 @@ export type ModelMetaData = {
          * The name of the function that decodes an Upsert object to a fully typed object (e.g. `aggregationUpsertDecoder`.)
          */
         upsertInputDecoder: Types.VariableName;
-        /**
-         * Name by which the business logic service exposes the data service.
-         */
-        dataRepositoryVariableName: Types.VariableName;
     };
     /**
      * Properties provided by the `seed` generators.
@@ -1067,6 +1071,10 @@ export type ModelMetaData = {
              * The name of the type that represents a DTO for upserting an existing object (e.g. `AggregationUpsertDTO`.)
              */
             upsert: Types.TypeName;
+            /**
+             * The name of the type that represents a DTO for cloning an existing object (e.g. `AggregationCloneDTO`.)
+             */
+            clone: Types.TypeName;
         };
         /**
          * The name of the file containing type definitions (e.g. `aggregation.type`).

package/dist/lib/meta.js

@@ -237,6 +237,7 @@ function getSchemaMetadata({ config }) {
         types: {
             indexFilePath: Types.toPath(`${config.paths.modelTypeDefinitionsPath}index`),
             importPath: Types.toBackendModulePath(`@backend/types`),
+            idTypesIndex: Types.toTypeName(`SchemaIds`),
             dto: {
                 path: Types.toPath(`${config.paths.modelTypeDefinitionsPath}dto.types`),
                 genericModel: Types.toTypeName(`GenericModel`),
@@ -304,7 +305,6 @@ function getModelMetadata({ model }) {
             serviceClassName: Types.toClassName(`${PascalCase}ViewService`),
             serviceVariableName: Types.toVariableName(`${uncapitalizedPlural}`),
             serviceLocation: Types.toModuleLocation(`view`, `${config.paths.businessViewLogicPath}${camelCase}.view.service`),
-            dataRepositoryVariableName: Types.toVariableName(`data`),
             cursorDecoder: Types.toVariableName(`CURSOR_DECODER`),
             filterOperatorDecoder: Types.toVariableName(`FILTER_OPERATOR_DECODER`),
         },
@@ -319,7 +319,6 @@ function getModelMetadata({ model }) {
             createInputDecoder: Types.toVariableName(`${camelCase}CreateInputDecoder`),
             updateInputDecoder: Types.toVariableName(`${camelCase}UpdateInputDecoder`),
             upsertInputDecoder: Types.toVariableName(`${camelCase}UpsertInputDecoder`),
-            dataRepositoryVariableName: Types.toVariableName(`data`),
         },
         seed: {
             location: Types.toModuleLocation('seed-data', `${config.paths.seedDataPath}001-base-data/${uncapitalizedPlural}.seed`),
@@ -389,6 +388,7 @@ function getModelMetadata({ model }) {
                 create: Types.toTypeName(`${PascalCase}CreateDTO`),
                 update: Types.toTypeName(`${PascalCase}UpdateDTO`),
                 upsert: Types.toTypeName(`${PascalCase}UpsertDTO`),
+                clone: Types.toTypeName(`${PascalCase}CloneDTO`),
             },
             typeName: Types.toTypeName(`${PascalCase}`),
             linkedTypeName: Types.toTypeName(`${PascalCase}Linked`),

package/package.json

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