@postxl/generator 0.56.8 → 0.57.1

package/dist/generator.js

@@ -42,6 +42,7 @@ const lock_1 = require("@postxl/lock");
 const react_generator_1 = require("./generators/enums/react.generator");
 const types_generator_1 = require("./generators/enums/types.generator");
 const businesslogic_actiontypes_generator_1 = require("./generators/indices/businesslogic-actiontypes.generator");
+const businesslogic_update_clonecontext_generator_1 = require("./generators/indices/businesslogic-update-clonecontext.generator");
 const businesslogic_update_index_generator_1 = require("./generators/indices/businesslogic-update-index.generator");
 const businesslogic_update_module_generator_1 = require("./generators/indices/businesslogic-update-module.generator");
 const businesslogic_update_service_generator_1 = require("./generators/indices/businesslogic-update-service.generator");
@@ -67,6 +68,7 @@ const selectors_generator_1 = require("./generators/indices/selectors.generator"
 const stubs_generator_1 = require("./generators/indices/stubs.generator");
 const testdata_service_generator_1 = require("./generators/indices/testdata-service.generator");
 const types_generator_2 = require("./generators/indices/types.generator");
+const admin_page_generator_1 = require("./generators/models/admin.page.generator");
 const businesslogic_update_generator_1 = require("./generators/models/businesslogic-update.generator");
 const businesslogic_view_generator_1 = require("./generators/models/businesslogic-view.generator");
 const importexport_decoder_generator_1 = require("./generators/models/importexport-decoder.generator");
@@ -98,6 +100,7 @@ const CONFIG_SCHEMA = zod_1.z
     trpcRoutesFolder: zod_1.z.string().optional(),
     reactFolderOutput: zod_1.z.string().optional(),
     prismaMigrationsFolder: zod_1.z.string().optional(),
+    pathToAdminPages: zod_1.z.string().optional(),
     randomSeed: zod_1.z
         .string()
         .optional()
@@ -123,6 +126,7 @@ const CONFIG_SCHEMA = zod_1.z
             seedDataPath: (0, types_1.toPath)(s.pathToSeedData || './backend/seed-data/src/'),
             seedLibPath: (0, types_1.toPath)(s.pathToSeedLib || './backend/libs/seed/src/'),
             trpcRoutesFolderPath: (0, types_1.toPath)(s.trpcRoutesFolder || './backend/libs/trpc/src/routes/'),
+            adminPagesFolderPath: (0, types_1.toPath)(s.pathToAdminPages || './web/src/pages/admin/'),
         },
         randomSeed: s.randomSeed,
         force: s.force,
@@ -191,6 +195,8 @@ function generate({ models, enums, config, prismaClientPath, logger, }) {
             generated.write(`/${meta.trpc.routerFilePath}.ts`, (0, route_generator_1.generateRoute)({ model, meta }));
             // React
             yield generated.copy((0, react_generator_2.generateReactComponentsForModel)({ model, meta }), meta.react.folderPath);
+            // Admin
+            generated.write(`/${meta.admin.filePath}.tsx`, (0, admin_page_generator_1.generateAdminPage)({ meta }));
             logger.log(`- ${model.name} processed`);
         }
         // Generate Enums
@@ -228,6 +234,7 @@ function generate({ models, enums, config, prismaClientPath, logger, }) {
         generated.write(`/${meta.businessLogic.view.moduleFilePath}.ts`, (0, businesslogic_view_module_generator_1.generateBusinessLogicViewModule)({ models, meta }));
         generated.write(`/${meta.businessLogic.view.serviceFilePath}.ts`, (0, businesslogic_view_service_generator_1.generateBusinessLogicViewService)({ models, meta }));
         generated.write(`/${meta.businessLogic.update.indexFilePath}.ts`, (0, businesslogic_update_index_generator_1.generateBusinessLogicUpdateIndex)({ models, meta }));
+        generated.write(`/${meta.businessLogic.update.cloneContextFilePath}.ts`, (0, businesslogic_update_clonecontext_generator_1.generateBusinessLogicCloneContext)({ models, meta }));
         generated.write(`/${meta.businessLogic.update.moduleFilePath}.ts`, (0, businesslogic_update_module_generator_1.generateBusinessLogicUpdateModule)({ models, meta }));
         generated.write(`/${meta.businessLogic.update.serviceFilePath}.ts`, (0, businesslogic_update_service_generator_1.generateBusinessLogicUpdateService)({ models, meta }));
         generated.write(`/${meta.businessLogic.update.actionTypesFilePath}.ts`, (0, businesslogic_actiontypes_generator_1.generateBusinessLogicActionTypes)({ models, meta }));

package/dist/generators/indices/businesslogic-update-clonecontext.generator.d.ts

@@ -0,0 +1,9 @@
+import { SchemaMetaData } from '../../lib/meta';
+import { Model } from '../../lib/schema/schema';
+/**
+ * Generates the clone context for the business logic update service.
+ */
+export declare function generateBusinessLogicCloneContext({ models, meta: schemaMeta, }: {
+    models: Model[];
+    meta: SchemaMetaData;
+}): string;

package/dist/generators/indices/businesslogic-update-clonecontext.generator.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateBusinessLogicCloneContext = void 0;
+const imports_1 = require("../../lib/imports");
+const meta_1 = require("../../lib/meta");
+/**
+ * Generates the clone context for the business logic update service.
+ */
+function generateBusinessLogicCloneContext({ models, meta: schemaMeta, }) {
+    const imports = imports_1.ImportsGenerator.from(schemaMeta.businessLogic.update.cloneContextFilePath);
+    const typeDefinitions = [];
+    const mapAssignments = [];
+    for (const model of models) {
+        const modelMeta = (0, meta_1.getModelMetadata)({ model });
+        imports.addImports({
+            [schemaMeta.types.importPath]: [modelMeta.types.brandedIdType, modelMeta.types.typeName],
+        });
+        typeDefinitions.push(`${modelMeta.businessLogic.update.cloneContextMap}: Map<${modelMeta.types.brandedIdType}, ${modelMeta.types.typeName}>`);
+        mapAssignments.push(`${modelMeta.businessLogic.update.cloneContextMap}: new Map()`);
+    }
+    return /* ts */ `
+${imports.generate()}
+
+/**
+ * The context that is passed in a clone action.
+ *
+ * This context is used to track which items have already been cloned and link them to the cloned item.
+ */
+export type CloneContext = {
+  ${typeDefinitions.join('\n')}
+}
+
+export function createCloneContext(): CloneContext {
+  return {
+    ${mapAssignments.join(',\n')}
+  }
+}`;
+}
+exports.generateBusinessLogicCloneContext = generateBusinessLogicCloneContext;

package/dist/generators/indices/businesslogic-update-index.generator.js

@@ -15,6 +15,7 @@ function generateBusinessLogicUpdateIndex({ models, meta }) {
         const meta = (0, meta_1.getModelMetadata)({ model });
         exports.exportSelectionFromPath(meta.businessLogic.update.serviceFilePath, [
             meta.businessLogic.update.serviceClassName,
+            meta.businessLogic.update.decoders.name,
         ]);
     }
     return exports.generate();

package/dist/generators/models/admin.page.generator.d.ts

@@ -0,0 +1,7 @@
+import { ModelMetaData } from '../../lib/meta';
+/**
+ * returns an admin page for a given model.
+ */
+export declare function generateAdminPage({ meta }: {
+    meta: ModelMetaData;
+}): string;

package/dist/generators/models/admin.page.generator.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateAdminPage = void 0;
+const imports_1 = require("../../lib/imports");
+/**
+ * returns an admin page for a given model.
+ */
+function generateAdminPage({ meta }) {
+    const { react } = meta;
+    const imports = imports_1.ImportsGenerator.from(meta.admin.filePath).addImport({
+        items: [react.components.libraryComponentName, react.components.modals.createComponentName],
+        from: meta.react.importPath,
+    });
+    return `
+import styled from 'styled-components'
+
+import { ActionWrapper, ActionsBarWrapper, Search, Spacer } from '@components/atoms/ActionsBar'
+import { Button } from '@components/atoms/Button'
+import { Headline } from '@components/atoms/Headline'
+
+${imports.generate()}
+
+import { Content, Layout } from '@components/shared/Layout'
+import { t } from '@i18n/translation'
+import { useState } from 'react'
+
+export default function Admin${meta.internalSingularNameCapitalized}Page() {
+  const [query, setQuery] = useState('')
+  const [isCreateModalOpen, setIsCreateModalOpen] = useState(false)
+
+  return (
+    <Layout>
+        <Header>
+          <Headline label="${meta.userFriendlyName}" />
+          <ActionsBarWrapper>
+            <Search
+              key="Search"
+              placeholder="Search ${meta.userFriendlyNamePlural}"
+              icon="magnifying-glass"
+              value={query}
+              onChange={(e) => setQuery(e.target.value)}
+            />
+
+            <Spacer key="Spacer" />
+
+            <ActionWrapper key="GlobalFilter">
+              <Button label={t['Create']} icon="plus" fill="fill" __cypress_selector__="indexPage-buttons-create" onClick={() => setIsCreateModalOpen(true)}/>
+            </ActionWrapper>
+          </ActionsBarWrapper>
+        </Header>
+
+        <Content>
+            <${meta.react.components.libraryComponentName} />
+        </Content>
+
+        <${meta.react.components.modals.createComponentName} 
+            show={isCreateModalOpen} 
+            onHide={() => setIsCreateModalOpen(false)} 
+        />
+      </Layout>
+    )
+}
+
+const Header = styled.header\`
+  display: flex;
+  flex-direction: column;
+  align-items: stretch;
+
+  gap: var(--headline-spacing);
+\`
+`;
+}
+exports.generateAdminPage = generateAdminPage;

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

@@ -41,10 +41,18 @@ function generateModelBusinessLogicUpdate({ model, meta }) {
         iExecution: schemaMeta.actions.execution.interface,
         typeName: meta.types.typeName,
         brandedId: model.brandedIdType,
-        createType: `Create${meta.internalSingularNameCapitalized}`,
-        updateType: `Update${meta.internalSingularNameCapitalized}`,
-        upsertType: `Upsert${meta.internalSingularNameCapitalized}`,
-        cloneType: `Clone${meta.internalSingularNameCapitalized}`,
+        decoders: {
+            name: meta.businessLogic.update.decoders.name,
+            createType: `Create${meta.internalSingularNameCapitalized}`,
+            updateType: `Update${meta.internalSingularNameCapitalized}`,
+            upsertType: `Upsert${meta.internalSingularNameCapitalized}`,
+            cloneType: `Clone${meta.internalSingularNameCapitalized}`,
+        },
+        cloneContext: {
+            type: schemaMeta.businessLogic.update.cloneContextType,
+            createMethod: schemaMeta.businessLogic.update.cloneContextCreateMethod,
+            map: meta.businessLogic.update.cloneContextMap,
+        },
     };
     const imports = imports_1.ImportsGenerator.from(meta.businessLogic.update.serviceFilePath);
     imports.addImports({
@@ -58,6 +66,10 @@ function generateModelBusinessLogicUpdate({ model, meta }) {
         [meta.businessLogic.view.serviceFilePath]: [meta.businessLogic.view.serviceClassName],
         [schemaMeta.actions.importPath]: [schemaMeta.actions.execution.interface, schemaMeta.actions.dispatcher.definition],
         [schemaMeta.businessLogic.update.serviceFilePath]: schemaMeta.businessLogic.update.serviceClassName,
+        [schemaMeta.businessLogic.update.cloneContextFilePath]: [
+            schemaMeta.businessLogic.update.cloneContextType,
+            schemaMeta.businessLogic.update.cloneContextCreateMethod,
+        ],
         [schemaMeta.businessLogic.view.serviceFilePath]: schemaMeta.businessLogic.view.serviceClassName,
     });
     for (const relation of (0, fields_1.getRelationFields)(model)) {
@@ -85,7 +97,7 @@ function generateModelBusinessLogicUpdate({ model, meta }) {
         `@Inject(forwardRef(() => ${schemaMeta.businessLogic.update.serviceClassName})) private readonly updateService: ${schemaMeta.businessLogic.update.serviceClassName}`,
         `@Inject(forwardRef(() => ${schemaMeta.businessLogic.view.serviceClassName})) private readonly viewService: ${schemaMeta.businessLogic.view.serviceClassName}`,
     ];
-    const { zodCreateObject, zodUpdateObject, zodUpsertObject, zodCloneObject } = meta.businessLogic.update;
+    const decoders = meta.businessLogic.update.decoders;
     const { view, update } = meta.businessLogic;
     /* prettier-ignore */
     return /* ts */ `
@@ -99,37 +111,37 @@ function generateModelBusinessLogicUpdate({ model, meta }) {
     export type Actions = {
       ${(0, jsdoc_1.toJsDocComment)([`Creates a new ${meta.userFriendlyName} and returns it.`])}
       create: {
-        payload: ${m.createType}
+        payload: ${m.decoders.createType}
         result: ${m.typeName}
       }
 
       ${(0, jsdoc_1.toJsDocComment)([`Creates multiple new ${meta.userFriendlyNamePlural} and returns them.`])}
       createMany: {
-        payload: ${m.createType}[]
+        payload: ${m.decoders.createType}[]
         result: ${m.typeName}[]
       }
 
       ${(0, jsdoc_1.toJsDocComment)([`Updates a ${meta.userFriendlyName} and returns it.`])}
       update: {
-        payload: ${m.updateType}
+        payload: ${m.decoders.updateType}
         result: ${m.typeName}
       }
 
       ${(0, jsdoc_1.toJsDocComment)([`Updates multiple ${meta.userFriendlyNamePlural} and returns them.`])}
       updateMany: {
-        payload: ${m.updateType}[]
+        payload: ${m.decoders.updateType}[]
         result: ${m.typeName}[]
       }
 
       ${(0, jsdoc_1.toJsDocComment)([`Creates or updates a ${meta.userFriendlyName} and returns it.`])}
       upsert: {
-        payload: ${m.upsertType}
+        payload: ${m.decoders.upsertType}
         result: ${m.typeName}
       }
 
       ${(0, jsdoc_1.toJsDocComment)([`Creates or updates multiple ${meta.userFriendlyNamePlural} and returns them.`])}
       upsertMany: {
-        payload: ${m.upsertType}[]
+        payload: ${m.decoders.upsertType}[]
         result: ${m.typeName}[]
       }
       
@@ -147,7 +159,7 @@ function generateModelBusinessLogicUpdate({ model, meta }) {
 
       ${(0, jsdoc_1.toJsDocComment)([`Clones a ${meta.userFriendlyName} and returns the clone.`])}
       clone: {
-        payload: ${m.cloneType}
+        payload: ${m.decoders.cloneType}
         result: ${m.typeName}
       }
     }
@@ -155,46 +167,53 @@ function generateModelBusinessLogicUpdate({ model, meta }) {
     /**
      * Zod decoder for validating the create input of a ${meta.userFriendlyName}.
      */
-    export const ${zodCreateObject} = z.object({
+    export const ${decoders.create} = z.object({
       ${model.fields
         .filter((f) => !f.attributes.isReadonly)
         .map((f) => `${f.name}: z.${(0, zod_1.getZodDecoderDefinition)({ field: f })}`)
         .join(',')}
     })
 
-    type ${m.createType} = z.infer<typeof ${zodCreateObject}>
+    type ${m.decoders.createType} = z.infer<typeof ${decoders.create}>
 
     /**
      * Zod decoder for validating the update input of a ${meta.userFriendlyName} .
      */
-    export const ${zodUpdateObject} = z.object({
+    export const ${decoders.update} = 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.updateType} = z.infer<typeof ${zodUpdateObject}>
+    type ${m.decoders.updateType} = z.infer<typeof ${decoders.update}>
 
     /**
      * Zod decoder for validating the upsert input of a ${meta.userFriendlyName} .
      */
-    export const ${zodUpsertObject} = z.union([${zodUpdateObject}, ${zodCreateObject}])
+    export const ${decoders.upsert} = z.union([${decoders.update}, ${decoders.create}])
     
-    type ${m.upsertType} = z.infer<typeof ${zodUpsertObject}>
+    type ${m.decoders.upsertType} = z.infer<typeof ${decoders.upsert}>
 
     /**
      * Zod decoder for validating the clone input of a ${meta.userFriendlyName} .
      */
-    export const ${zodCloneObject} = z.object({
+    export const ${decoders.clone} = 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.cloneType} = z.infer<typeof ${zodCloneObject}>
+    type ${m.decoders.cloneType} = z.infer<typeof ${decoders.clone}>
 
+    export const ${decoders.name} = {
+      create: ${decoders.create},
+      update: ${decoders.update},
+      upsert: ${decoders.upsert},
+      clone: ${decoders.clone},
+    }
+    
     export type ${update.serviceInterfaceName} = ${schemaMeta.actions.dispatcher.definition}<Actions>
 
     @Injectable()
@@ -210,32 +229,32 @@ function generateModelBusinessLogicUpdate({ model, meta }) {
       }
 
       ${(0, jsdoc_1.toJsDocComment)([`Creates a new ${meta.userFriendlyName} and returns it.`])}
-      public async create({ data, execution }: { data: ${m.createType}; execution: ${m.iExecution} }): Promise<${m.typeName}> {
+      public async create({ data, execution }: { data: ${m.decoders.createType}; execution: ${m.iExecution} }): Promise<${m.typeName}> {
         return this.data.create({ item: data, execution })
       }
 
       ${(0, jsdoc_1.toJsDocComment)([`Creates multiple new ${meta.userFriendlyNamePlural} and returns them.`])}
-      public async createMany({ data, execution }: { data: ${m.createType}[]; execution: ${m.iExecution} }): Promise<${m.typeName}[]> {
+      public async createMany({ data, execution }: { data: ${m.decoders.createType}[]; execution: ${m.iExecution} }): Promise<${m.typeName}[]> {
         return this.data.createMany({ items: data, execution })
       }
 
       ${(0, jsdoc_1.toJsDocComment)([`Updates a ${meta.userFriendlyName} and returns it.`])}
-      public async update({ data, execution }: { data: ${m.updateType}; execution: ${m.iExecution} }): Promise<${m.typeName}> {
+      public async update({ data, execution }: { data: ${m.decoders.updateType}; execution: ${m.iExecution} }): Promise<${m.typeName}> {
         return this.data.update({ item: data, execution })
       }
 
       ${(0, jsdoc_1.toJsDocComment)([`Updates multiple ${meta.userFriendlyNamePlural} and returns them.`])}
-      public async updateMany({ data, execution }: { data: ${m.updateType}[]; execution: ${m.iExecution} }): Promise<${m.typeName}[]> {
+      public async updateMany({ data, execution }: { data: ${m.decoders.updateType}[]; execution: ${m.iExecution} }): Promise<${m.typeName}[]> {
         return this.data.updateMany({ items: data, execution })
       }
 
       ${(0, jsdoc_1.toJsDocComment)([`Creates or updates a ${meta.userFriendlyName} and returns it.`])}
-      public async upsert({ data, execution }: { data: ${m.upsertType}; execution: ${m.iExecution} }): Promise<${m.typeName}> {
+      public async upsert({ data, execution }: { data: ${m.decoders.upsertType}; execution: ${m.iExecution} }): Promise<${m.typeName}> {
         return this.data.upsert({ item: data, execution })
       }
 
       ${(0, jsdoc_1.toJsDocComment)([`Creates or updates multiple ${meta.userFriendlyNamePlural} and returns them.`])}
-      public async upsertMany({ data, execution }: { data: ${m.upsertType}[]; execution: ${m.iExecution} }): Promise<${m.typeName}[]> {
+      public async upsertMany({ data, execution }: { data: ${m.decoders.upsertType}[]; execution: ${m.iExecution} }): Promise<${m.typeName}[]> {
         return this.data.upsertMany({ items: data, execution })
       }
 
@@ -330,6 +349,10 @@ function generateCloneMethod({ model, meta, m }) {
     const backReferenceCloning = [];
     const backReferenceNames = [];
     for (const { referencingField, referencingModel } of model.references) {
+        // We only clone back references that are marked as cloneWithParent.
+        if (!referencingField.attributes.cloneWithParent) {
+            continue;
+        }
         const refModelMeta = (0, meta_1.getModelMetadata)({ model: referencingModel });
         const refFieldMeta = (0, meta_1.getFieldMetadata)({ field: referencingField });
         backReferenceNames.push(`${refModelMeta.userFriendlyNamePlural}.${referencingField.name}`);
@@ -337,15 +360,22 @@ function generateCloneMethod({ model, meta, m }) {
         backReferenceCloning.push(`
       // ${referencingModel.name}.${referencingField.name}
       for (const childId of await this.viewService.${view.serviceVariableName}.data.${refFieldMeta.getByForeignKeyIdsMethodFnName}(id)) {
-        await this.updateService.${update.serviceVariableName}.clone({ data: { id: childId, ${referencingField.name}: clone.id }, execution })
+        await this.updateService.${update.serviceVariableName}.clone({ data: { id: childId, ${referencingField.name}: clone.id }, execution, context })
       }
     `);
     }
     return `
   ${(0, jsdoc_1.toJsDocComment)([`Creates a new ${meta.userFriendlyName} deep clone and returns it.`])}
   public async clone(
-    { data: { id, ...data }, execution }: { data: ${m.cloneType}; execution: ${m.iExecution} }
+    { data: { id, ...data }, execution, context = ${m.cloneContext.createMethod}() }: 
+    { data: ${m.decoders.cloneType}; execution: ${m.iExecution}; context?: ${m.cloneContext.type} }
   ): Promise<${m.typeName}> {
+    const alreadyCloned = context.${m.cloneContext.map}.get(id)
+    if (alreadyCloned) {
+      // We already cloned this item before, so we return the cloned item.
+      return alreadyCloned
+    }
+    
     const source = await this.view.get(id)
     if (!source) {
       throw new Error(\`${meta.userFriendlyName} with id \${id} not found\`)
@@ -353,6 +383,8 @@ function generateCloneMethod({ model, meta, m }) {
 
     const clone = await this.data.create({ item: { ...omitId(source), ...data }, execution })
 
+    context.${m.cloneContext.map}.set(id, clone)
+
     ${backReferenceCloning.join('\n')}
 
     return clone

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

@@ -12,14 +12,14 @@ function generateRoute({ model, meta }) {
     const defaultValueMethod = `
     getDefault: procedure.query(({ ctx }) => ctx.view.${meta.data.dataServiceName}.${dataRepositoryVariableName}.defaultValue),
   `;
-    const { zodCreateObject, zodUpdateObject, zodUpsertObject, zodCloneObject } = meta.businessLogic.update;
+    const decoders = meta.businessLogic.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.businessLogic.update.serviceFilePath]: [zodCreateObject, zodUpdateObject, zodUpsertObject, zodCloneObject],
+        [meta.businessLogic.update.importPath]: [decoders.name],
     });
     return /* ts */ `
 import { z } from 'zod'
@@ -61,27 +61,27 @@ export const ${meta.trpc.routerName} = router({
     }),
 
     create: procedure
-      .input(${zodCreateObject})
+      .input(${decoders.name}.create)
       .mutation(({ input, ctx }) => ctx.dispatch({scope: "${scopeName}", type: "create", payload: input})),
     
     createMany: procedure
-      .input(z.array(${zodCreateObject}))
+      .input(z.array(${decoders.name}.create))
       .mutation(({ input, ctx }) => ctx.dispatch({scope: "${scopeName}", type: "createMany", payload: input})),
 
     update: procedure
-      .input(${zodUpdateObject})
+      .input(${decoders.name}.update)
       .mutation(({ input, ctx }) => ctx.dispatch({scope: "${scopeName}", type: "update", payload: input})),
 
     updateMany: procedure
-      .input(z.array(${zodUpdateObject}))
+      .input(z.array(${decoders.name}.update))
       .mutation(({ input, ctx }) => ctx.dispatch({scope: "${scopeName}", type: "updateMany", payload: input})),
 
     upsert: procedure
-      .input(${zodUpsertObject})
+      .input(${decoders.name}.upsert)
       .mutation(({ input, ctx }) => ctx.dispatch({scope: "${scopeName}", type: "upsert", payload: input})),
 
     upsertMany: procedure
-      .input(z.array(${zodUpsertObject}))
+      .input(z.array(${decoders.name}.upsert))
       .mutation(({ input, ctx }) => ctx.dispatch({scope: "${scopeName}", type: "upsertMany", payload: input})),
 
     delete: procedure
@@ -93,7 +93,7 @@ export const ${meta.trpc.routerName} = router({
       .mutation(({ input, ctx }) => ctx.dispatch({scope: "${scopeName}", type: "deleteMany", payload: input})),
 
     clone: procedure
-      .input(${zodCloneObject})
+      .input(${decoders.name}.clone)
       .mutation(({ input, ctx }) => ctx.dispatch({scope: "${scopeName}", type: "clone", payload: input})),
 })
 `;

package/dist/lib/attributes.d.ts

@@ -90,6 +90,11 @@ export type FieldAttributes = {
      * The field that should be used as the default label for the model.
      */
     isLabel?: boolean;
+    /**
+     * Schema tag: `@@CloneWithParent()`
+     * If set, the all models that reference the parent that was cloned should also be cloned.
+     */
+    cloneWithParent?: boolean;
 };
 export type EnumAttributes = {
     /**

package/dist/lib/meta.d.ts

@@ -568,6 +568,18 @@ export type SchemaMetaData = {
              * Path to the file containing the overall action types
              */
             actionTypesFilePath: Types.FilePath;
+            /**
+             * Path to the file containing the clone context
+             */
+            cloneContextFilePath: Types.FilePath;
+            /**
+             * The name of the clone context type
+             */
+            cloneContextType: Types.TypeName;
+            /**
+             * The name of the function that creates a clone context
+             */
+            cloneContextCreateMethod: Types.FunctionName;
         };
     };
     seedData: {
@@ -788,11 +800,11 @@ export type ModelMetaData = {
              */
             className: Types.ClassName;
             /**
-             * The name of the function that decodes a source (database) object to a fully typed object, e.g. `toAggregation`.
+             * The name of the function that decodes a source (database) object to a fully typed object (e.g. `toAggregation`.)
              */
             decoderFnName: Types.FunctionName;
             /**
-             * The name of the method that should be used to get objects from the database, e.g. `aggregations`.
+             * The name of the method that should be used to get objects from the database (e.g. `aggregations`.)
              */
             getMethodFnName: Types.FunctionName;
         };
@@ -834,7 +846,7 @@ export type ModelMetaData = {
          */
         exportDataTypeName: Types.TypeName;
         /**
-         * Name of the function that adds an instance of this model to the exporter, e.g. `addAggregation`.
+         * Name of the function that adds an instance of this model to the exporter (e.g. `addAggregation`.)
          */
         exportAddFunctionName: Types.FunctionName;
         /**
@@ -858,23 +870,23 @@ export type ModelMetaData = {
              */
             filePath: Types.FilePath;
             /**
-             * Name of the type that represents the model in Excel import/export, e.g. `Aggregation_EncodedExcelData`.
+             * Name of the type that represents the model in Excel import/export (e.g. `Aggregation_EncodedExcelData`.)
              */
             encodedExcelType: Types.TypeName;
             /**
-             * Name of the decoder function that represents the Excel table import type, e.g. `aggregationExcelTableDecoder`.
+             * Name of the decoder function that represents the Excel table import type (e.g. `aggregationExcelTableDecoder`.)
              */
             tableDecoder: Types.FunctionName;
             /**
-             * Name of the function that converts a model item to the Excel format, e.g. `encodeAggregation`.
+             * Name of the function that converts a model item to the Excel format (e.g. `encodeAggregation`.)
              */
             itemEncoderFunctionName: Types.FunctionName;
             /**
-             * Name of the function that converts an array of model items to the Excel format, e.g. `encodeAggregations`.
+             * Name of the function that converts an array of model items to the Excel format (e.g. `encodeAggregations`.)
              */
             arrayEncoderFunctionName: Types.FunctionName;
             /**
-             * Name of the array in the decoded data containing all entities of this model, e.g. `aggregations`.
+             * Name of the array in the decoded data containing all entities of this model (e.g. `aggregations`.)
              */
             decodedModelArrayName: Types.VariableName;
         };
@@ -897,6 +909,10 @@ export type ModelMetaData = {
          * The definitions for the view service of a model
          */
         view: {
+            /**
+             * Path that may be used to import the types of this model.
+             */
+            importPath: Types.BackendModulePath;
             /**
              * The name by which the model's view class is exposed in the viewService/context. (e.g. aggregations)
              */
@@ -918,6 +934,10 @@ export type ModelMetaData = {
          * The definitions for the update service of a model
          */
         update: {
+            /**
+             * Path that may be used to import the types of this model.
+             */
+            importPath: Types.BackendModulePath;
             /**
              * The name by which the model's update class is exposed in the updateService/context. (e.g. AggregationUpdateService)
              */
@@ -942,22 +962,32 @@ 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 clones an object (e.g. `aggregationCloneDecoder`.)
+                 */
+                clone: Types.FunctionName;
+            };
             /**
-             * The name of the function that decodes a Create object to a fully typed object, e.g. `aggregationCreateDecoder`.
-             */
-            zodCreateObject: Types.FunctionName;
-            /**
-             * The name of the function that decodes an Update object to a fully typed object, e.g. `aggregationUpdateDecoder`.
-             */
-            zodUpdateObject: Types.FunctionName;
-            /**
-             * The name of the function that decodes an Upsert object to a fully typed object, e.g. `aggregationUpsertDecoder`.
-             */
-            zodUpsertObject: Types.FunctionName;
-            /**
-             * The name of the function that clones an object, e.g. `aggregationCloneDecoder`.
+             * The name of the map variable in the clone context that holds the cloned items of this model (e.g. `aggregation`)
              */
-            zodCloneObject: Types.FunctionName;
+            cloneContextMap: Types.VariableName;
         };
         /**
          * Name by which the business logic service exposes the data service.
@@ -993,6 +1023,10 @@ export type ModelMetaData = {
          * The path to the folder that contains React components for this model.
          */
         folderPath: Types.FilePath;
+        /**
+         * Globally accessible import path for the model's React components.
+         */
+        importPath: Types.FilePath;
         context: {
             /**
              * Name of the function that should be used as React hook (e.g. `useAggregationContext`).
@@ -1087,6 +1121,15 @@ export type ModelMetaData = {
             reactQueryMethod: Types.FunctionName;
         };
     };
+    /**
+     * Properties provided by the `admin.page` generators.
+     */
+    admin: {
+        /**
+         * The absolute file path of the admin page for this model.
+         */
+        filePath: Types.FilePath;
+    };
     /**
      * Properties provided by the `types` generators.
      */
@@ -1100,7 +1143,7 @@ export type ModelMetaData = {
          */
         importPath: Types.BackendModulePath;
         /**
-         * The name of the type that represents a branded ID, e.g. `AggregationId`.
+         * The name of the type that represents a branded ID (e.g. `AggregationId`.)
          */
         brandedIdType: Types.TypeName;
         /**
@@ -1110,11 +1153,11 @@ export type ModelMetaData = {
         toBrandedIdTypeFnName: Types.FunctionName;
         zodDecoderFnNames: {
             /**
-             * The name of the function that decodes a scalar value to a branded ID type, e.g. `aggregationIdDecoder`.
+             * The name of the function that decodes a scalar value to a branded ID type (e.g. `aggregationIdDecoder`.)
              */
             id: Types.FunctionName;
             /**
-             * The name of the function that decodes a source (database) object to a fully typed object, e.g. `aggregationDatabaseDecoder`.
+             * The name of the function that decodes a source (database) object to a fully typed object (e.g. `aggregationDatabaseDecoder`.)
              */
             fromDatabase: Types.FunctionName;
         };
@@ -1123,15 +1166,15 @@ export type ModelMetaData = {
          */
         dto: {
             /**
-             * The name of the type that represents a DTO for creating a new object, e.g. `AggregationCreateDTO`.
+             * The name of the type that represents a DTO for creating a new object (e.g. `AggregationCreateDTO`.)
              */
             create: Types.TypeName;
             /**
-             * The name of the type that represents a DTO for updating an existing object, e.g. `AggregationUpdateDTO`.
+             * The name of the type that represents a DTO for updating an existing object (e.g. `AggregationUpdateDTO`.)
              */
             update: Types.TypeName;
             /**
-             * The name of the type that represents a DTO for upserting an existing object, e.g. `AggregationUpsertDTO`.
+             * The name of the type that represents a DTO for upserting an existing object (e.g. `AggregationUpsertDTO`.)
              */
             upsert: Types.TypeName;
         };
@@ -1140,17 +1183,17 @@ export type ModelMetaData = {
          */
         typeDefFileName: Types.FileName;
         /**
-         * The name of the type that represents a fully typed, flat object, e.g. `Aggregation`.
+         * The name of the type that represents a fully typed, flat object (e.g. `Aggregation`.)
          * This type only refers to related types by their branded ID.
          */
         typeName: Types.TypeName;
         /**
-         * The name of the type that represents a fully typed object, e.g. `AggregationFull`.
+         * The name of the type that represents a fully typed object (e.g. `AggregationFull`.)
          * This type refers to relations by linking to the (flat) types.
          */
         linkedTypeName: Types.TypeName;
         /**
-         * The name of the type that represents a source (i.e. database) object, e.g. `Aggregation`.
+         * The name of the type that represents a source (i.e. database) object (e.g. `Aggregation`.)
          */
         sourceType: Types.TypeName;
     };
@@ -1167,15 +1210,15 @@ export type FieldMetaData = {
      */
     tsFieldName: Types.VariableName;
     /**
-     * The name of the method that should be used to get all child objects for a given item, e.g. `getItemsForAggregation`.
+     * The name of the method that should be used to get all child objects for a given item (e.g. `getItemsForAggregation`.)
      */
     getByForeignKeyMethodFnName: Types.FunctionName;
     /**
-     * The name of the method that should be used to get all child Ids for a given item, e.g. `getIdsForAggregation`.
+     * The name of the method that should be used to get all child Ids for a given item (e.g. `getIdsForAggregation`.)
      */
     getByForeignKeyIdsMethodFnName: Types.FunctionName;
     /**
-     * The name of the column in the seed Excel table, e.g. `Aggregation`.
+     * The name of the column in the seed Excel table (e.g. `Aggregation`.)
      */
     excelColumnName: string;
 };
@@ -1216,7 +1259,7 @@ export type EnumMetaData = {
          */
         membersMap: Types.VariableName;
         /**
-         * Relative path to the file that contains the enum's types, e.g. `./aggregation.type`.
+         * Relative path to the file that contains the enum's types (e.g. `./aggregation.type`.)
          */
         filePath: Types.FilePath;
         /**

package/dist/lib/meta.js

@@ -119,6 +119,9 @@ function getSchemaMetadata({ config }) {
                 serviceClassName: Types.toClassName(`UpdateService`),
                 serviceFilePath: Types.toPath(`${config.paths.businessLogicPath}update/update.service`),
                 actionTypesFilePath: Types.toPath(`${config.paths.businessLogicPath}update/actions`),
+                cloneContextFilePath: Types.toPath(`${config.paths.businessLogicPath}update/clone.context`),
+                cloneContextType: Types.toTypeName(`CloneContext`),
+                cloneContextCreateMethod: Types.toFunctionName(`createCloneContext`),
             },
         },
         data: {
@@ -331,22 +334,28 @@ function getModelMetadata({ model }) {
             scopeName: Types.toVariableName(`${camelCase}`),
             importPath: Types.toBackendModulePath(`@backend/business-logic`),
             view: {
+                importPath: Types.toBackendModulePath(`@backend/business-logic/view`),
                 serviceClassName: Types.toClassName(`${PascalCase}ViewService`),
                 serviceVariableName: Types.toVariableName(`${uncapitalizedPlural}`),
                 serviceFileName: Types.toFileName(`${camelCase}.view.service`),
                 serviceFilePath: Types.toPath(`${config.paths.businessLogicPath}view/${camelCase}.view.service`),
             },
             update: {
+                importPath: Types.toBackendModulePath(`@backend/business-logic/update`),
                 serviceClassName: Types.toClassName(`${PascalCase}UpdateService`),
                 serviceInterfaceName: Types.toTypeName(`I${PascalCase}UpdateService`),
                 serviceVariableName: Types.toVariableName(`${uncapitalizedPlural}`),
                 serviceFileName: Types.toFileName(`${camelCase}.update.service`),
                 serviceFilePath: Types.toPath(`${config.paths.businessLogicPath}update/${camelCase}.update.service`),
                 actionModelDiscriminantName: Types.toVariableName(`${camelCase}`),
-                zodCreateObject: Types.toFunctionName(`${camelCase}CreateDecoder`),
-                zodUpdateObject: Types.toFunctionName(`${camelCase}UpdateDecoder`),
-                zodUpsertObject: Types.toFunctionName(`${camelCase}UpsertDecoder`),
-                zodCloneObject: Types.toFunctionName(`${camelCase}CloneDecoder`),
+                decoders: {
+                    name: Types.toVariableName(`${camelCase}Decoders`),
+                    create: Types.toFunctionName(`${camelCase}CreateDecoder`),
+                    update: Types.toFunctionName(`${camelCase}UpdateDecoder`),
+                    upsert: Types.toFunctionName(`${camelCase}UpsertDecoder`),
+                    clone: Types.toFunctionName(`${camelCase}CloneDecoder`),
+                },
+                cloneContextMap: Types.toVariableName(`${camelCase}`),
             },
             dataRepositoryVariableName: Types.toVariableName(`data`),
         },
@@ -358,6 +367,7 @@ function getModelMetadata({ model }) {
         react: {
             folderName: Types.toFolderName(`${PascalCase}`),
             folderPath: Types.toPath(`${config.paths.reactFolderPath}models/${PascalCase}/`),
+            importPath: Types.toPath(`@components/models/${PascalCase}`),
             context: {
                 hookFnName: Types.toFunctionName(`use${PascalCase}Context`),
                 instanceGetterHookFnName: Types.toFunctionName(`use${PascalCase}`),
@@ -402,6 +412,9 @@ function getModelMetadata({ model }) {
                 reactQueryMethod: Types.toFunctionName(`${uncapitalizedPlural}.delete`),
             },
         },
+        admin: {
+            filePath: Types.toPath(`${config.paths.adminPagesFolderPath}/${uncapitalized}`),
+        },
         types: {
             importPath: Types.toBackendModulePath(`@backend/types`),
             filePath: Types.toPath(`${config.paths.modelTypeDefinitionsPath}${camelCase}.type`),

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

@@ -87,6 +87,10 @@ export type SchemaConfig = {
          * Path to the directory containing trpc routes.
          */
         trpcRoutesFolderPath: Types.FilePath;
+        /**
+         * Path to the directory containing admin pages.
+         */
+        adminPagesFolderPath: Types.FilePath;
     };
     /**
      * Whether the generator should overwrite existing files.

package/dist/prisma/attributes.js

@@ -144,9 +144,10 @@ function getFieldAttributes(field) {
             .or(zod_1.default.string().transform((s) => parseInt(s, 10)))
             .optional(),
         readonly: blankStringBooleanDecoder,
+        cloneWithParent: blankStringBooleanDecoder,
     })
         .transform((obj) => {
-        var _a;
+        var _a, _b;
         if (isPrismaIgnored && !obj.ignore) {
             throw new Error(`Field ${field.name} is ignored by Prisma, but is missing the "ignore" PostXL attribute!`);
         }
@@ -160,6 +161,7 @@ function getFieldAttributes(field) {
             isReadonly: obj.readonly || field.isGenerated || field.isUpdatedAt || field.name === 'createdAt' || field.isId,
             isUpdatedAt: (_a = field.isUpdatedAt) !== null && _a !== void 0 ? _a : false,
             isCreatedAt: field.name === 'createdAt',
+            cloneWithParent: (_b = obj.cloneWithParent) !== null && _b !== void 0 ? _b : false,
         };
     });
     const result = decoder.safeParse(attributes);

package/package.json

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