@postxl/generator 0.66.0 → 0.68.0

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

@@ -45,7 +45,7 @@ function generateDataService({ models, meta }) {
     return /* ts */ `
 import { Injectable, Logger } from '@nestjs/common'
 
-import { format, mapValues, pluralize } from '@backend/common'
+import { format, mapValues, pluralize } from '@postxl/runtime'
 
 ${imports.generate()}
 

package/dist/generators/indices/dispatcher-service.generator.js

@@ -24,7 +24,7 @@ function generateActionsDispatcherService({ models, meta }) {
     return /* ts */ `
   import { Injectable } from '@nestjs/common'
 
-import { ExhaustiveSwitchCheck } from '@backend/common'
+import { ExhaustiveSwitchCheck } from '@postxl/runtime'
 
 ${imports.generate()}
 

package/dist/generators/indices/importexport-convert-import-functions.generator.js

@@ -42,7 +42,7 @@ function generateImportExportConvertImportFunctions({ models, meta, }) {
         // logState({ state, nextStep, lastStep: 'updateModelState' })
     }
     return /* ts */ `
-import { ExhaustiveSwitchCheck } from '@backend/common'
+import { ExhaustiveSwitchCheck } from '@postxl/runtime'
 ${imports.generate()}
 
 /**

package/dist/generators/indices/importexport-exporter-class.generator.js

@@ -95,7 +95,7 @@ function generateImportExportExporterClass({ models, meta }) {
 
 import { Logger } from '@nestjs/common'
 
-import { mapValues } from '@backend/common'
+import { mapValues } from '@postxl/runtime'
 ${imports.generate()}
 
 /**

package/dist/generators/indices/importexport-import-service.generator.js

@@ -46,7 +46,7 @@ function generateImportExportImportService({ models, meta }) {
     }
     return /* ts */ `
 import { Injectable } from '@nestjs/common'
-import { ExhaustiveSwitchCheck } from '@backend/common'
+import { ExhaustiveSwitchCheck } from '@postxl/runtime'
 
 ${imports.generate()}
 

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

@@ -42,12 +42,6 @@ function generateModelBusinessLogicUpdate({ model, meta }) {
         iExecution: schemaMeta.actions.execution.interface,
         typeName: meta.types.typeName,
         brandedId: model.brandedIdType,
-        decoders: {
-            name: meta.update.decoders.name,
-            createType: `Create${meta.internalSingularNameCapitalized}`,
-            updateType: `Update${meta.internalSingularNameCapitalized}`,
-            upsertType: `Upsert${meta.internalSingularNameCapitalized}`,
-        },
     };
     const imports = imports_1.ImportsGenerator.from(meta.update.serviceClassLocation.path);
     imports.addImports({
@@ -96,7 +90,6 @@ function generateModelBusinessLogicUpdate({ model, meta }) {
         `@Inject(forwardRef(() => ${schemaMeta.update.serviceClassName})) private readonly updateService: ${schemaMeta.update.serviceClassName}`,
         `@Inject(forwardRef(() => ${schemaMeta.view.serviceClassName})) private readonly viewService: ${schemaMeta.view.serviceClassName}`,
     ];
-    const decoders = meta.update.decoders;
     const { view, update } = meta;
     const deleteFn = generateDeleteFn({ model, meta, m });
     const deleteManyFn = generateDeleteManyFn({ imports, model, meta, m });
@@ -113,19 +106,19 @@ function generateModelBusinessLogicUpdate({ model, meta }) {
     export type Actions = {
       ${(0, jsdoc_1.toJsDocComment)([`Creates a new ${meta.userFriendlyName} and returns it.`])}
       create: {
-        payload: ${m.decoders.createType}
+        payload: CreatePayload
         result: ${m.typeName}
       }
 
       ${(0, jsdoc_1.toJsDocComment)([`Updates a ${meta.userFriendlyName} and returns it.`])}
       update: {
-        payload: ${m.decoders.updateType}
+        payload: UpdatePayload
         result: ${m.typeName}
       }
 
       ${(0, jsdoc_1.toJsDocComment)([`Creates or updates a ${meta.userFriendlyName} and returns it.`])}
       upsert: {
-        payload: ${m.decoders.upsertType}
+        payload: UpsertPayload
         result: ${m.typeName}
       }
 
@@ -139,40 +132,34 @@ function generateModelBusinessLogicUpdate({ model, meta }) {
     /**
      * Zod decoder for validating the create input of a ${meta.userFriendlyName}.
      */
-    export const ${decoders.create} = z.object({
+    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 ${m.decoders.createType} = z.infer<typeof ${decoders.create}>
+    type CreatePayload = z.infer<typeof ${meta.update.createInputDecoder}>
 
     /**
      * Zod decoder for validating the update input of a ${meta.userFriendlyName} .
      */
-    export const ${decoders.update} = z.object({
+    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 ${m.decoders.updateType} = z.infer<typeof ${decoders.update}>
+    type UpdatePayload = z.infer<typeof ${meta.update.updateInputDecoder}>
 
     /**
      * Zod decoder for validating the upsert input of a ${meta.userFriendlyName} .
      */
-    export const ${decoders.upsert} = z.union([${decoders.update}, ${decoders.create}])
+    export const ${meta.update.upsertInputDecoder} = z.union([${meta.update.updateInputDecoder}, ${meta.update.createInputDecoder}])
     
-    type ${m.decoders.upsertType} = z.infer<typeof ${decoders.upsert}>
+    type UpsertPayload = z.infer<typeof ${meta.update.upsertInputDecoder}>
 
-    export const ${decoders.name} = {
-      create: ${decoders.create},
-      update: ${decoders.update},
-      upsert: ${decoders.upsert},
-    }
-    
     export type ${update.serviceInterfaceName} = ${schemaMeta.actions.dispatcher.definition}<Actions>
 
     @Injectable()
@@ -188,17 +175,17 @@ function generateModelBusinessLogicUpdate({ model, meta }) {
       }
 
       ${(0, jsdoc_1.toJsDocComment)([`Creates a new ${meta.userFriendlyName} and returns it.`])}
-      public async create({ data, execution }: { data: ${m.decoders.createType}; execution: ${m.iExecution} }): Promise<${m.typeName}> {
+      public async create({ data, execution }: { data: CreatePayload; execution: ${m.iExecution} }): Promise<${m.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: ${m.decoders.updateType}; execution: ${m.iExecution} }): Promise<${m.typeName}> {
+      public async update({ data, execution }: { data: UpdatePayload; execution: ${m.iExecution} }): Promise<${m.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: ${m.decoders.upsertType}; execution: ${m.iExecution} }): Promise<${m.typeName}> {
+      public async upsert({ data, execution }: { data: UpsertPayload; execution: ${m.iExecution} }): Promise<${m.typeName}> {
         return this.data.upsert({ item: data, execution })
       }
 
@@ -302,10 +289,22 @@ function generateDeleteManyFn({ imports, model, meta, m, }) {
 function generateCloneFn({ model, meta, m }) {
     const inputFields = model.fields.map((f) => {
         const type = (0, typescript_1.getFieldType)(f);
-        if (f.kind === 'id' || f.isUnique) {
+        // NOTE: ID field is always required to resolve the source.
+        if (f.kind === 'id') {
             return `${f.name}: ${type}`;
         }
-        return `${f.name}?: ${type}`;
+        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`;
     });
     return `
   ${(0, jsdoc_1.toJsDocComment)([`Creates a new ${meta.userFriendlyName} deep clone and returns it.`])}

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

@@ -113,13 +113,41 @@ function generateModelBusinessLogicView({ model, meta }) {
   `;
     return /* ts */ `
 /* eslint-disable @typescript-eslint/no-unused-vars */
+import z from 'zod'
+
 import { Inject, Injectable, forwardRef } from '@nestjs/common'
-import { FilterOperator } from '@backend/common'
 
 ${imports.generate()}
 
 ${hasLinkedItems ? linkedTypeDefinition : ''}
 
+/**
+ * Cursor decoder.
+ */
+export const ${meta.view.cursorDecoder} = z.object({ startRow: z.number(), endRow: z.number() })
+
+type Cursor = z.infer<typeof ${meta.view.cursorDecoder}>
+
+/**
+ * Filter operator decoder.
+ */
+export const ${meta.view.filterOperatorDecoder} = z.enum([
+  'eq',
+  'neq',
+  'gt',
+  'gte',
+  'lt',
+  'lte',
+  'in',
+  'nin',
+  'contains',
+  'ncontains',
+  'starts',
+  'ends',
+])
+
+type FilterOperator = z.infer<typeof ${meta.view.filterOperatorDecoder}>
+
 @Injectable()
 export class ${meta.view.serviceClassName} {
   constructor(${constructorParameters.join(',\n')}) {}
@@ -151,7 +179,7 @@ export class ${meta.view.serviceClassName} {
   }: {
     filter?: { field: keyof ${model.typeName}; operator: FilterOperator; value: string | number }
     sort?: { field: keyof ${model.typeName}; ascending: boolean }
-    cursor?: { startRow: number; endRow: number }
+    cursor?: Cursor
   }) {
     const items = await this.${modelRepositoryVariableName}.getAllAsArray()
     const filtered = !filter

package/dist/generators/models/importexport-decoder.generator.js

@@ -10,19 +10,17 @@ const types_2 = require("../../lib/types");
  */
 function generateModelImportExportDecoder({ model, meta, schemaMeta, }) {
     const { filePath: decoderFilePath, itemEncoderFunctionName: rowExportFunctionName, encodedExcelType: excelType, arrayEncoderFunctionName: tableExportFunctionName, tableDecoder: tableImportDecoder, } = meta.importExport.decoder;
-    const imports = imports_1.ImportsGenerator.from(decoderFilePath);
-    imports.addImports({
-        [schemaMeta.backendModules.common.importPath]: [
-            schemaMeta.backendModules.common.functions.uncapitalizeKeys,
-            schemaMeta.backendModules.common.functions.capitalizeKeys,
-            schemaMeta.backendModules.common.functions.nullOrBlankDecoder,
-        ],
+    const imports = imports_1.ImportsGenerator.from(decoderFilePath).addImports({
+        [schemaMeta.backendModules.common.importPath]: [schemaMeta.backendModules.common.functions.excelNullOrBlankDecoder],
         [meta.types.importPath]: [(0, types_1.toAnnotatedTypeName)(meta.types.typeName)],
     });
     const { userFriendlyName: userFriendly, userFriendlyNamePlural: userFriendlyPlural, internalSingularName: singular, internalSingularNameCapitalized: singularCapitalized, } = meta;
     const { fieldDecoders, blankFieldDecoders } = generateFieldDecoders({ model, meta, schemaMeta, imports });
     return `
 import * as z from 'zod'
+
+import { uncapitalizeKeys, capitalizeKeys } from '@postxl/runtime'
+
 ${imports.generate()}
 
 /**
@@ -80,7 +78,7 @@ function generateFieldDecoders({ model, meta, schemaMeta, imports, }) {
     for (const field of model.fields) {
         const fieldMeta = (0, meta_1.getFieldMetadata)({ field });
         const optionalModifier = field.attributes.isUpdatedAt || field.attributes.isCreatedAt ? '.optional()' : '';
-        blankFieldDecoders.push(`${fieldMeta.excelColumnName}: nullOrBlankDecoder${optionalModifier}`);
+        blankFieldDecoders.push(`${fieldMeta.excelColumnName}: excelNullOrBlankDecoder${optionalModifier}`);
         switch (field.kind) {
             case 'id': {
                 imports.addImport({ items: [meta.types.toBrandedIdTypeFnName], from: meta.types.importPath });
@@ -140,10 +138,7 @@ dbTypeName, nullable, imports, schemaMeta, }) {
     switch (tsTypeName) {
         case 'string': {
             const decoder = schemaMeta.backendModules.common.functions[nullable ? 'excelStringNullableDecoder' : 'excelStringDecoder'];
-            imports.addImport({
-                items: [decoder],
-                from: schemaMeta.backendModules.common.importPath,
-            });
+            imports.addImport({ items: [decoder], from: schemaMeta.backendModules.common.importPath });
             return decoder;
         }
         case 'boolean':
@@ -192,9 +187,6 @@ dbTypeName, nullable, imports, schemaMeta, }) {
 function generateImportExportDecoder({ models, meta }) {
     const { decodedPXLModelDataTypeName, encodedExcelDataTypeName, fullDecoderName, fullEncoderFunctionName } = meta.importExport.decoder;
     const imports = imports_1.ImportsGenerator.from(meta.importExport.decoder.location.path);
-    imports.addImports({
-        [meta.backendModules.common.importPath]: (0, types_1.toFunctionName)('uncapitalizeKeys'),
-    });
     const importTypes = [];
     const decoderEntries = [];
     const exportFields = [];
@@ -217,6 +209,9 @@ function generateImportExportDecoder({ models, meta }) {
     }
     return `
 import * as z from 'zod'
+
+import { uncapitalizeKeys } from '@postxl/runtime'
+
 ${imports.generate()}
 
 export type ${encodedExcelDataTypeName} = {

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

@@ -18,7 +18,7 @@ function generateModelContext({ model, meta }) {
 import React, { useMemo } from 'react'
 
 import { trpc } from '@lib/trpc'
-import { filterMap, mapMap } from '@lib/utils'
+import { filterMap, mapMap } from '@postxl/runtime'
 
 ${imports.generate()}
 

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

@@ -56,7 +56,6 @@ function generateRepository({ model, meta }) {
         mainBlocks = _generateMainBuildingBlocks_InMemoryOnly({
             model,
             meta,
-            schemaMeta,
             imports,
             blocks: {
                 uniqueStringFieldsBlocks,
@@ -88,6 +87,7 @@ function generateRepository({ model, meta }) {
     }
     return `
 import { Injectable, Logger } from '@nestjs/common'
+
 ${idBlocks.libraryImports}
 ${imports.generate()}
 
@@ -228,13 +228,10 @@ exports.generateMockRepository = generateMockRepository;
 /**
  * Generates the main building blocks of the repository for in-memory model.
  */
-function _generateMainBuildingBlocks_InMemoryOnly({ model, meta, schemaMeta, imports, blocks, }) {
+function _generateMainBuildingBlocks_InMemoryOnly({ model, meta, imports, blocks, }) {
     const methodTypeSignatures = getRepositoryMethodsTypeSignatures({ model, meta });
     const userRepositorySpecificBlocks = generateUserRepositorySpecificBlocks_InMemoryOnly({ model, meta, imports });
-    imports.addImport({
-        from: schemaMeta.backendModules.common.importPath,
-        items: ['removeUndefinedProperties'].map(types_1.toFunctionName),
-    });
+    imports.addImport({ from: (0, types_1.toPackageName)('@postxl/runtime'), items: [(0, types_1.toFunctionName)('removeUndefinedProperties')] });
     return {
         constructorCode: '',
         userRepositorySpecificBlocks,
@@ -472,10 +469,7 @@ function generateMainBuildingBlocks_InDatabase({ model, meta, schemaMeta, import
         [meta.types.importPath]: [meta.types.zodDecoderFnNames.fromDatabase],
         [schemaMeta.backendModules.db.databaseService.location.import]: [schemaMeta.backendModules.db.databaseService.name],
         [schemaMeta.backendModules.db.typesImportPath]: [(0, types_1.toAnnotatedTypeName)((0, types_1.toTypeName)(`${model.sourceName} as DbType`))],
-        [schemaMeta.backendModules.common.importPath]: [
-            schemaMeta.backendModules.common.functions.format,
-            schemaMeta.backendModules.common.functions.pluralize,
-        ],
+        [(0, types_1.toPackageName)('@postxl/runtime')]: [(0, types_1.toFunctionName)('format'), (0, types_1.toFunctionName)('pluralize')],
     });
     const dbTableName = [model.sourceSchemaName, model.sourceName]
         .filter((s) => s != null)

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

@@ -12,20 +12,23 @@ function generateRoute({ model, meta }) {
     const defaultValueMethod = `
     getDefault: procedure.query(({ ctx }) => ctx.view.${meta.data.dataServiceName}.${dataRepositoryVariableName}.defaultValue),
   `;
-    const decoders = meta.update.decoders;
     const imports = imports_1.ImportsGenerator.from(meta.trpc.routerFilePath).addImports({
         [meta.types.importPath]: [
             (0, types_1.toAnnotatedTypeName)(model.typeName),
             meta.types.toBrandedIdTypeFnName,
             meta.types.zodDecoderFnNames.id,
         ],
-        [meta.update.serviceClassLocation.import]: [decoders.name],
+        [meta.update.serviceClassLocation.import]: [
+            meta.update.createInputDecoder,
+            meta.update.updateInputDecoder,
+            meta.update.upsertInputDecoder,
+        ],
+        [meta.view.serviceLocation.import]: [meta.view.filterOperatorDecoder, meta.view.cursorDecoder],
     });
     return /* ts */ `
 import { z } from 'zod'
 import { procedure, router } from '../trpc'
 
-import { CURSOR_DECODER, FILTER_OPERATOR_DECODER } from '@backend/common'
 ${imports.generate()}
 
 export const ${meta.trpc.routerName} = router({
@@ -37,7 +40,7 @@ export const ${meta.trpc.routerName} = router({
   getMap: procedure.query(({ ctx }) => ctx.view.${meta.data.dataServiceName}.getAll()),
   getList: procedure
     .input(z.object({
-      cursor: CURSOR_DECODER,
+      cursor: ${meta.view.cursorDecoder}.optional(),
       sort: z.object({
         field: z.enum([
           ${model.fields.map((f) => `'${f.name}'`).join(',\n')}
@@ -51,7 +54,7 @@ export const ${meta.trpc.routerName} = router({
           ${model.fields.map((f) => `'${f.name}'`).join(',\n')}
         ])
         .transform((v): keyof ${model.typeName} => v),
-        operator: FILTER_OPERATOR_DECODER,
+        operator: ${meta.view.filterOperatorDecoder},
         value: z.union([z.string(), z.number()]),
       })
       .optional(),
@@ -61,15 +64,15 @@ export const ${meta.trpc.routerName} = router({
     }),
 
     create: procedure
-      .input(${decoders.name}.create)
+      .input(${meta.update.createInputDecoder})
       .mutation(({ input, ctx }) => ctx.dispatch({scope: "${scopeName}", type: "create", payload: input})),
     
     update: procedure
-      .input(${decoders.name}.update)
+      .input(${meta.update.updateInputDecoder})
       .mutation(({ input, ctx }) => ctx.dispatch({scope: "${scopeName}", type: "update", payload: input})),
 
     upsert: procedure
-      .input(${decoders.name}.upsert)
+      .input(${meta.update.upsertInputDecoder})
       .mutation(({ input, ctx }) => ctx.dispatch({scope: "${scopeName}", type: "upsert", payload: input})),
 
     delete: procedure

package/dist/lib/meta.d.ts

@@ -17,11 +17,7 @@ export type SchemaMetaData = {
              * Names of the functions that are provided by the common backend module.
              */
             functions: {
-                format: Types.FunctionName;
-                pluralize: Types.FunctionName;
-                uncapitalizeKeys: Types.FunctionName;
-                capitalizeKeys: Types.FunctionName;
-                nullOrBlankDecoder: Types.FunctionName;
+                excelNullOrBlankDecoder: Types.FunctionName;
                 excelStringNullableDecoder: Types.FunctionName;
                 excelStringDecoder: Types.FunctionName;
                 excelNumberNullableDecoder: Types.FunctionName;
@@ -878,6 +874,14 @@ export type ModelMetaData = {
          * 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.
+         */
+        filterOperatorDecoder: Types.VariableName;
+        /**
+         * The name of the variable that defines the cursor decoder for the current model.
+         */
+        cursorDecoder: Types.VariableName;
     };
     /**
      * The definitions for the update service of a model
@@ -913,24 +917,18 @@ export type ModelMetaData = {
          * The name of the model used as a discriminant for the action execution. (e.g. `aggregation`)
          */
         actionModelDiscriminantName: Types.VariableName;
-        decoders: {
-            /**
-             * The name of the variable that holds the decoders for the model. (e.g. `aggregationDecoders`)
-             */
-            name: Types.VariableName;
-            /**
-             * The name of the function that decodes a Create object to a fully typed object (e.g. `aggregationCreateDecoder`.)
-             */
-            create: Types.FunctionName;
-            /**
-             * The name of the function that decodes an Update object to a fully typed object (e.g. `aggregationUpdateDecoder`.)
-             */
-            update: Types.FunctionName;
-            /**
-             * The name of the function that decodes an Upsert object to a fully typed object (e.g. `aggregationUpsertDecoder`.)
-             */
-            upsert: Types.FunctionName;
-        };
+        /**
+         * The name of the function that decodes a Create object to a fully typed object (e.g. `aggregationCreateDecoder`.)
+         */
+        createInputDecoder: Types.VariableName;
+        /**
+         * The name of the function that decodes an Update object to a fully typed object (e.g. `aggregationUpdateDecoder`.)
+         */
+        updateInputDecoder: Types.VariableName;
+        /**
+         * 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.
          */

package/dist/lib/meta.js

@@ -35,11 +35,7 @@ function getSchemaMetadata({ config }) {
             common: {
                 importPath: Types.toBackendModulePath(`@backend/common`),
                 functions: {
-                    format: Types.toFunctionName(`format`),
-                    pluralize: Types.toFunctionName(`pluralize`),
-                    uncapitalizeKeys: Types.toFunctionName(`uncapitalizeKeys`),
-                    capitalizeKeys: Types.toFunctionName(`capitalizeKeys`),
-                    nullOrBlankDecoder: Types.toFunctionName(`nullOrBlankDecoder`),
+                    excelNullOrBlankDecoder: Types.toFunctionName(`excelNullOrBlankDecoder`),
                     excelStringNullableDecoder: Types.toFunctionName(`excelStringNullableDecoder`),
                     excelStringDecoder: Types.toFunctionName(`excelStringDecoder`),
                     excelNumberNullableDecoder: Types.toFunctionName(`excelNumberNullableDecoder`),
@@ -325,6 +321,8 @@ function getModelMetadata({ model }) {
             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`),
         },
         update: {
             scopeName: Types.toVariableName(`${camelCase}`),
@@ -334,12 +332,9 @@ function getModelMetadata({ model }) {
             serviceInterfaceName: Types.toTypeName(`I${PascalCase}UpdateService`),
             serviceVariableName: Types.toVariableName(`${uncapitalizedPlural}`),
             actionModelDiscriminantName: Types.toVariableName(`${camelCase}`),
-            decoders: {
-                name: Types.toVariableName(`${camelCase}Decoders`),
-                create: Types.toFunctionName(`${camelCase}CreateDecoder`),
-                update: Types.toFunctionName(`${camelCase}UpdateDecoder`),
-                upsert: Types.toFunctionName(`${camelCase}UpsertDecoder`),
-            },
+            createInputDecoder: Types.toVariableName(`${camelCase}CreateInputDecoder`),
+            updateInputDecoder: Types.toVariableName(`${camelCase}UpdateInputDecoder`),
+            upsertInputDecoder: Types.toVariableName(`${camelCase}UpsertInputDecoder`),
             dataRepositoryVariableName: Types.toVariableName(`data`),
         },
         seed: {

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

@@ -174,6 +174,13 @@ export type BackendModulePath = `@backend/${string}` & {
  * Converts a string to a branded PAth.
  */
 export declare const toPath: (t: string) => FilePath;
+/**
+ * The name of an NPM package (e.g. "@postxl/runtime").
+ */
+export type PackageName = string & {
+    readonly ___type: 'PackageName';
+};
+export declare const toPackageName: (t: string) => PackageName;
 /**
  * Branded string values that can be used as import statement values in the generators
  */
@@ -181,4 +188,4 @@ export type ImportableTypes = FunctionName | ClassName | TypeName | AnnotatedTyp
 /**
  * Branded string values that can be used as paths in import statements
  */
-export type ImportPaths = BackendModulePath | FilePath;
+export type ImportPaths = BackendModulePath | FilePath | PackageName;

package/dist/lib/schema/types.js

@@ -1,7 +1,7 @@
 "use strict";
 // MARK: - Generated content related types
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.toPath = exports.toBackendModulePath = exports.toModuleLocation = exports.toFolderName = exports.toFileName = exports.toVariableName = exports.toFunctionName = exports.toEnumName = exports.toFieldName = exports.isAnnotatedTypeName = exports.toAnnotatedTypeName = exports.toTypeName = exports.toModelName = exports.toDiscriminantName = exports.toClassName = void 0;
+exports.toPackageName = exports.toPath = exports.toBackendModulePath = exports.toModuleLocation = exports.toFolderName = exports.toFileName = exports.toVariableName = exports.toFunctionName = exports.toEnumName = exports.toFieldName = exports.isAnnotatedTypeName = exports.toAnnotatedTypeName = exports.toTypeName = exports.toModelName = exports.toDiscriminantName = exports.toClassName = void 0;
 /**
  * Converts a raw string to a branded ClassName.
  */
@@ -104,3 +104,5 @@ exports.toBackendModulePath = toBackendModulePath;
  */
 const toPath = (t) => t;
 exports.toPath = toPath;
+const toPackageName = (t) => t;
+exports.toPackageName = toPackageName;

package/package.json

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