@flusys/nestjs-entity-builder 9.1.0-rc.1 → 9.1.0

package/fesm/719.js

@@ -153,7 +153,7 @@ __webpack_require__.d(__webpack_exports__, {
 
 
 
-const SLUG_SUFFIX = {
+/** The path of each endpoint's Request step: `api-flows/<entity>/<path>`. */ const ENTITY_FLOW_PATHS = {
     insert: 'insert',
     insertMany: 'insert-many',
     getById: 'get-by-id',
@@ -165,7 +165,7 @@ const SLUG_SUFFIX = {
     bulkUpsert: 'bulk-upsert',
     delete: 'delete'
 };
-const DEFAULT_FLOW_NAME = {
+const DEFAULT_ENDPOINT_NAME = {
     insert: 'Insert',
     insertMany: 'Insert many',
     getById: 'Get by id',
@@ -183,7 +183,7 @@ const DEFAULT_INPUT_LABEL = {
     search: 'Search'
 };
 const DEFAULT_NO_MATCH_MESSAGE = 'No record matches the filter.';
-const MAX_FLOW_NAME_LENGTH = 255;
+const MAX_NAME_LENGTH = 255;
 /** A supplied text when it has content, the English default otherwise. */ const textOr = (value, fallback)=>value?.trim() || fallback;
 const INPUT_TYPE = {
     [_enums_field_type_enum_js__rspack_import_1/* .FieldType.TEXT */.P.TEXT]: 'string',
@@ -200,8 +200,13 @@ const INPUT_TYPE = {
     [_enums_field_type_enum_js__rspack_import_1/* .FieldType.JSON */.P.JSON]: 'object',
     [_enums_field_type_enum_js__rspack_import_1/* .FieldType.FILE */.P.FILE]: 'string'
 };
-const MAX_SLUG_LENGTH = 63;
 const LIST_LIMIT = 50;
+const READ_ENDPOINTS = new Set([
+    'getById',
+    'getByIds',
+    'getAll',
+    'getByFilter'
+]);
 /** A bulk flow runs up to three steps per item (bulkUpsert: check, write, keep), well inside FLOW_LIMITS.MAX_STEPS_PER_RUN. */ const BULK_MAX_ITEMS = 200;
 const COLUMN = {
     x: 40,
@@ -219,11 +224,7 @@ const lit = (value)=>({
         type: 'literal',
         value
     });
-/** `customer_ticket` + getAll -> `customer-ticket-get-all`, shortened so it always fits the slug length. */ function entityFlowSlug(entityCode, endpoint) {
-    const suffix = SLUG_SUFFIX[endpoint];
-    const base = entityCode.replace(/_/g, '-').slice(0, MAX_SLUG_LENGTH - suffix.length - 1).replace(/-+$/, '');
-    return `${base}-${suffix}`;
-}
+/** `customer_ticket` -> `customer-ticket`: an entity code always fits a flow URL name. */ const entityFlowSlug = (entityCode)=>entityCode.replace(/_/g, '-');
 function optionValues(options) {
     return (options ?? []).map((o)=>o && typeof o === 'object' && 'value' in o ? String(o.value) : String(o));
 }
@@ -275,56 +276,59 @@ const respond = (id, column, statusCode, body, row)=>({
             body
         }
     });
-/** The body is the list itself (`itemSchema` checks each item): foreach `input` -> `body` (per item) ... done -> respond with the collected results. */ function bulkGraph(itemSchema, body, bodyEdges, collect, statusCode) {
-    return {
-        bodyType: 'list',
-        inputSchema: itemSchema,
-        steps: [
-            {
-                id: 'each',
-                type: 'foreach',
-                column: 1,
-                config: {
-                    items: ref('input'),
-                    maxItems: BULK_MAX_ITEMS,
-                    collect
-                }
-            },
-            ...body,
-            respond('respond', 2, statusCode, ref('context.each.results'))
-        ],
-        edges: [
-            [
-                'each',
-                'each',
-                body[0].id
-            ],
-            ...bodyEdges,
-            [
-                'each',
-                'done',
-                'respond'
-            ]
-        ],
-        isTransactional: true
-    };
-}
-function endpointGraph(entity, endpoint, texts) {
+/**
+ * The steps of one endpoint. Its step ids are `<endpoint>_<step>` (`id()`), so the endpoints of one
+ * flow never share a step. A bulk body is the list itself (`itemSchema` checks each item):
+ * foreach `input` -> `body` (per item) ... done -> respond with the collected results.
+ */ function endpointGraph(entity, endpoint, texts) {
+    const id = (step)=>`${endpoint}_${step}`;
     const entityCode = entity.code;
     const single = (inputSchema, step, statusCode = 200)=>({
             inputSchema,
             steps: [
                 {
                     ...step,
+                    id: id('record'),
                     column: 1
                 },
-                respond('respond', 2, statusCode, ref(`context.${step.id}`))
+                respond(id('respond'), 2, statusCode, ref(`context.${id('record')}`))
             ],
             edges: [
                 [
-                    step.id,
+                    id('record'),
                     'out',
-                    'respond'
+                    id('respond')
+                ]
+            ]
+        });
+    const bulk = (itemSchema, body, bodyEdges, collect, statusCode)=>({
+            bodyType: 'list',
+            inputSchema: itemSchema,
+            steps: [
+                {
+                    id: id('each'),
+                    type: 'foreach',
+                    column: 1,
+                    config: {
+                        items: ref('input'),
+                        maxItems: BULK_MAX_ITEMS,
+                        collect
+                    }
+                },
+                ...body,
+                respond(id('respond'), 2, statusCode, ref(`context.${id('each')}.results`))
+            ],
+            edges: [
+                [
+                    id('each'),
+                    'each',
+                    body[0].id
+                ],
+                ...bodyEdges,
+                [
+                    id('each'),
+                    'done',
+                    id('respond')
                 ]
             ]
         });
@@ -333,7 +337,6 @@ function endpointGraph(entity, endpoint, texts) {
     switch(endpoint){
         case 'insert':
             return single(insertInputs, {
-                id: 'record',
                 type: 'entity_insert',
                 config: {
                     entityCode,
@@ -341,9 +344,9 @@ function endpointGraph(entity, endpoint, texts) {
                 }
             }, 201);
         case 'insertMany':
-            return bulkGraph(insertInputs, [
+            return bulk(insertInputs, [
                 {
-                    id: 'record',
+                    id: id('record'),
                     type: 'entity_insert',
                     column: 1,
                     row: 1,
@@ -352,12 +355,11 @@ function endpointGraph(entity, endpoint, texts) {
                         fields: fieldMap(entity.fields, 'loop.item')
                     }
                 }
-            ], [], ref('context.record'), 201);
+            ], [], ref(`context.${id('record')}`), 201);
         case 'getById':
             return single([
                 idInput(texts)
             ], {
-                id: 'record',
                 type: 'entity_get',
                 config: {
                     entityCode,
@@ -368,7 +370,6 @@ function endpointGraph(entity, endpoint, texts) {
             return single([
                 idsInput(texts)
             ], {
-                id: 'records',
                 type: 'entity_query',
                 config: {
                     entityCode,
@@ -390,7 +391,6 @@ function endpointGraph(entity, endpoint, texts) {
                 },
                 ...optionalFieldInputs(filterFields)
             ], {
-                id: 'records',
                 type: 'entity_query',
                 config: {
                     entityCode,
@@ -410,7 +410,7 @@ function endpointGraph(entity, endpoint, texts) {
                 ],
                 steps: [
                     {
-                        id: 'records',
+                        id: id('records'),
                         type: 'entity_query',
                         column: 1,
                         config: {
@@ -423,7 +423,7 @@ function endpointGraph(entity, endpoint, texts) {
                         }
                     },
                     {
-                        id: 'found',
+                        id: id('found'),
                         type: 'condition',
                         column: 2,
                         config: {
@@ -431,15 +431,15 @@ function endpointGraph(entity, endpoint, texts) {
                                 operator: 'AND',
                                 conditions: [
                                     {
-                                        field: 'context.records.items',
+                                        field: `context.${id('records')}.items`,
                                         comparison: 'is_not_empty'
                                     }
                                 ]
                             }
                         }
                     },
-                    respond('respond', 3, 200, ref('context.records.items.0')),
-                    respond('not_found', 3, 404, {
+                    respond(id('respond'), 3, 200, ref(`context.${id('records')}.items.0`)),
+                    respond(id('not_found'), 3, 404, {
                         success: lit(false),
                         message: lit(texts.noMatchMessage),
                         messageKey: lit(_config_message_keys_js__rspack_import_2/* .GENERIC_RECORD_MESSAGES.NO_MATCH */.j4.NO_MATCH)
@@ -447,19 +447,19 @@ function endpointGraph(entity, endpoint, texts) {
                 ],
                 edges: [
                     [
-                        'records',
+                        id('records'),
                         'out',
-                        'found'
+                        id('found')
                     ],
                     [
-                        'found',
+                        id('found'),
                         'true',
-                        'respond'
+                        id('respond')
                     ],
                     [
-                        'found',
+                        id('found'),
                         'false',
-                        'not_found'
+                        id('not_found')
                     ]
                 ]
             };
@@ -468,7 +468,6 @@ function endpointGraph(entity, endpoint, texts) {
                 idInput(texts),
                 ...optionalFieldInputs(entity.fields)
             ], {
-                id: 'record',
                 type: 'entity_update',
                 config: {
                     entityCode,
@@ -477,12 +476,12 @@ function endpointGraph(entity, endpoint, texts) {
                 }
             });
         case 'updateMany':
-            return bulkGraph([
+            return bulk([
                 idInput(texts),
                 ...optionalFieldInputs(entity.fields)
             ], [
                 {
-                    id: 'record',
+                    id: id('record'),
                     type: 'entity_update',
                     column: 1,
                     row: 1,
@@ -492,9 +491,9 @@ function endpointGraph(entity, endpoint, texts) {
                         fields: fieldMap(entity.fields, 'loop.item')
                     }
                 }
-            ], [], ref('context.record'), 200);
+            ], [], ref(`context.${id('record')}`), 200);
         case 'bulkUpsert':
-            return bulkGraph([
+            return bulk([
                 {
                     ...idInput(texts),
                     required: false
@@ -502,7 +501,7 @@ function endpointGraph(entity, endpoint, texts) {
                 ...optionalFieldInputs(entity.fields)
             ], [
                 {
-                    id: 'has_id',
+                    id: id('has_id'),
                     type: 'condition',
                     column: 1,
                     row: 1,
@@ -519,7 +518,7 @@ function endpointGraph(entity, endpoint, texts) {
                     }
                 },
                 {
-                    id: 'updated',
+                    id: id('updated'),
                     type: 'entity_update',
                     column: 2,
                     row: 1,
@@ -530,7 +529,7 @@ function endpointGraph(entity, endpoint, texts) {
                     }
                 },
                 {
-                    id: 'inserted',
+                    id: id('inserted'),
                     type: 'entity_insert',
                     column: 2,
                     row: 2,
@@ -540,54 +539,53 @@ function endpointGraph(entity, endpoint, texts) {
                     }
                 },
                 {
-                    id: 'keep_updated',
+                    id: id('keep_updated'),
                     type: 'set',
                     column: 3,
                     row: 1,
                     config: {
                         values: {
-                            saved: ref('context.updated')
+                            saved: ref(`context.${id('updated')}`)
                         }
                     }
                 },
                 {
-                    id: 'keep_inserted',
+                    id: id('keep_inserted'),
                     type: 'set',
                     column: 3,
                     row: 2,
                     config: {
                         values: {
-                            saved: ref('context.inserted')
+                            saved: ref(`context.${id('inserted')}`)
                         }
                     }
                 }
             ], [
                 [
-                    'has_id',
+                    id('has_id'),
                     'true',
-                    'updated'
+                    id('updated')
                 ],
                 [
-                    'has_id',
+                    id('has_id'),
                     'false',
-                    'inserted'
+                    id('inserted')
                 ],
                 [
-                    'updated',
+                    id('updated'),
                     'out',
-                    'keep_updated'
+                    id('keep_updated')
                 ],
                 [
-                    'inserted',
+                    id('inserted'),
                     'out',
-                    'keep_inserted'
+                    id('keep_inserted')
                 ]
             ], ref('vars.saved'), 200);
         case 'delete':
             return single([
                 idInput(texts)
             ], {
-                id: 'record',
                 type: 'entity_delete',
                 config: {
                     entityCode,
@@ -597,11 +595,13 @@ function endpointGraph(entity, endpoint, texts) {
     }
 }
 /**
- * A ready-made flow for one record endpoint of the generic API controller. It runs as the
- * caller, so the entity permissions still decide who may use it, and it is an ordinary flow
- * afterwards - the user can change or delete it like any other. The bulk endpoints take the list
- * of records as the body and loop over it in one transaction, so a failing item rolls back the whole request.
- */ function buildEntityFlow(entity, endpoint, texts = {}) {
+ * The ready-made flow of an entity: `api-flows/<entity>` with one Request step per endpoint of the
+ * generic API controller, each on its own path (`ENTITY_FLOW_PATHS`) with its own body, laid out
+ * one below the other. It runs as the caller, so the entity permissions still decide who may use
+ * it, and it is an ordinary flow afterwards - the user can change or delete it like any other. A
+ * flow with a write endpoint is transactional: a bulk endpoint loops over its list in one
+ * transaction, so a failing item rolls back the whole request.
+ */ function buildEntityFlow(entity, endpoints, texts = {}) {
     const resolved = {
         inputLabels: {
             id: textOr(texts.inputLabels?.id, DEFAULT_INPUT_LABEL.id),
@@ -610,57 +610,65 @@ function endpointGraph(entity, endpoint, texts) {
         },
         noMatchMessage: textOr(texts.noMatchMessage, DEFAULT_NO_MATCH_MESSAGE)
     };
-    const graph = endpointGraph(entity, endpoint, resolved);
-    const nodes = [
-        {
-            id: 'trigger',
+    const nodes = [];
+    const edges = [];
+    let band = 0;
+    for (const endpoint of endpoints){
+        const graph = endpointGraph(entity, endpoint, resolved);
+        const at = (column, row = 0)=>({
+                x: COLUMN.x + column * COLUMN.gap,
+                y: ROW.y + (band + row) * ROW.gap
+            });
+        const config = {
+            path: ENTITY_FLOW_PATHS[endpoint],
+            bodyType: graph.bodyType ?? 'object',
+            inputSchema: graph.inputSchema
+        };
+        nodes.push({
+            id: endpoint,
             type: 'trigger',
-            name: '',
-            position: {
-                x: COLUMN.x,
-                y: ROW.y
-            },
-            config: {}
-        },
-        ...graph.steps.map(({ column, row, ...step })=>({
+            name: textOr(texts.names?.[endpoint], DEFAULT_ENDPOINT_NAME[endpoint]).slice(0, MAX_NAME_LENGTH),
+            position: at(0),
+            config
+        }, ...graph.steps.map(({ column, row, ...step })=>({
                 ...step,
                 name: '',
-                position: {
-                    x: COLUMN.x + column * COLUMN.gap,
-                    y: ROW.y + (row ?? 0) * ROW.gap
-                }
-            }))
-    ];
-    const edges = [
-        [
-            'trigger',
-            'out',
-            graph.steps[0].id
-        ],
-        ...graph.edges
-    ].map(([from, port, to])=>({
-            id: `e_${from}_${port}_${to}`,
-            from,
-            port,
-            to
-        }));
+                position: at(column, row)
+            })));
+        edges.push(...[
+            [
+                endpoint,
+                'out',
+                graph.steps[0].id
+            ],
+            ...graph.edges
+        ].map(([from, port, to])=>({
+                id: `e_${from}_${port}_${to}`,
+                from,
+                port,
+                to
+            })));
+        band += 1 + Math.max(0, ...graph.steps.map((step)=>step.row ?? 0));
+    }
     return {
-        name: `${entity.label} - ${textOr(texts.names?.[endpoint], DEFAULT_FLOW_NAME[endpoint])}`.slice(0, MAX_FLOW_NAME_LENGTH),
-        slug: entityFlowSlug(entity.code, endpoint),
+        name: entity.label.slice(0, MAX_NAME_LENGTH),
+        slug: entityFlowSlug(entity.code),
         isActive: true,
         authMode: 'jwt',
         runAs: 'caller',
-        isTransactional: graph.isTransactional ?? false,
-        bodyType: graph.bodyType ?? 'object',
-        inputSchema: graph.inputSchema,
+        isTransactional: endpoints.some((endpoint)=>!READ_ENDPOINTS.has(endpoint)),
+        bodyType: 'object',
+        inputSchema: [],
         nodes,
         edges
     };
 }
 
 __webpack_require__.d(__webpack_exports__, {
-  C: () => (buildEntityFlow),
-  x: () => (entityFlowSlug)
+  CO: () => (buildEntityFlow)
+}, {
+  IP: ENTITY_FLOW_PATHS,
+  x2: entityFlowSlug
 });
 
 
@@ -3417,18 +3425,18 @@ class SchemaSyncService {
                 }
             }
             if (flowEndpoints.length) {
-                const slugs = flowEndpoints.map((endpoint)=>(0,_entity_flow_scaffold_js__rspack_import_9/* .entityFlowSlug */.x)(dto.code, endpoint));
-                const clashes = await ctx.qr.manager.getRepository(_entities_flow_definition_entity_js__rspack_import_6/* .FlowDefinition */.G).find({
+                const slug = (0,_entity_flow_scaffold_js__rspack_import_9/* .entityFlowSlug */.x2)(dto.code);
+                const clash = await ctx.qr.manager.getRepository(_entities_flow_definition_entity_js__rspack_import_6/* .FlowDefinition */.G).findOne({
                     select: {
                         slug: true
                     },
                     where: {
-                        slug: (0,typeorm__rspack_import_3.In)(slugs)
+                        slug
                     },
                     withDeleted: true
                 });
-                for (const clash of clashes)ctx.block((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_16/* .SCHEMA_BLOCKER_MESSAGES.FLOW_SLUG_TAKEN */.M3.FLOW_SLUG_TAKEN, {
-                    slug: clash.slug
+                if (clash) ctx.block((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_16/* .SCHEMA_BLOCKER_MESSAGES.FLOW_SLUG_TAKEN */.M3.FLOW_SLUG_TAKEN, {
+                    slug
                 }));
             }
             if (ctx.blocked) return {
@@ -3519,36 +3527,34 @@ class SchemaSyncService {
                     try {
                         await this.entityPermissionService.provisionForEntity(created.definition);
                     } finally{
-                        created.warnings.push(...await this.createEndpointFlows(dto, flowEndpoints, user));
+                        if (flowEndpoints.length) created.warnings.push(...await this.createEndpointFlow(dto, flowEndpoints, user));
                     }
                 }
             };
         };
     }
     /**
-   * One ready-made flow per requested endpoint, saved through FlowDefinitionService so it is
-   * validated like any other flow. Each is saved on its own: one that fails does not stop the
-   * rest, and is reported as a warning since the entity is already committed.
-   */ async createEndpointFlows(dto, endpoints, user) {
-        const entity = {
+   * The entity's ready-made flow, one Request step per requested endpoint, saved through
+   * FlowDefinitionService so it is validated like any other flow. The entity is already committed,
+   * so a flow that cannot be saved is reported as a warning.
+   */ async createEndpointFlow(dto, endpoints, user) {
+        const flow = (0,_entity_flow_scaffold_js__rspack_import_9/* .buildEntityFlow */.CO)({
             code: dto.code,
             label: dto.label,
             fields: dto.fields ?? []
-        };
-        const warnings = [];
-        for (const endpoint of endpoints){
-            const flow = (0,_entity_flow_scaffold_js__rspack_import_9/* .buildEntityFlow */.C)(entity, endpoint, dto.flowTexts);
-            try {
-                await this.flowDefinitionService.insert(flow, user);
-            } catch (error) {
-                this.logger.error(`Endpoint flow '${flow.slug}' of entity '${dto.code}' could not be created: ${error.message}`);
-                warnings.push((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_16/* .SCHEMA_WARNING_MESSAGES.ENDPOINT_FLOW_FAILED */.Uu.ENDPOINT_FLOW_FAILED, {
+        }, endpoints, dto.flowTexts);
+        try {
+            await this.flowDefinitionService.insert(flow, user);
+            return [];
+        } catch (error) {
+            this.logger.error(`The flow '${flow.slug}' of entity '${dto.code}' could not be created: ${error.message}`);
+            return [
+                (0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_16/* .SCHEMA_WARNING_MESSAGES.ENDPOINT_FLOW_FAILED */.Uu.ENDPOINT_FLOW_FAILED, {
                     slug: flow.slug,
                     detail: (0,_flow_engine_flow_errors_js__rspack_import_7/* .errorRef */.O$)(error)
-                }));
-            }
+                })
+            ];
         }
-        return warnings;
     }
     /** Preview of `createEntity`: the CREATE TABLE / CREATE INDEX statements, nothing is created. */ async planCreateEntity(dto, user) {
         this.validateCreateRequest(dto);