@solidxai/core 0.1.13-beta.2 → 0.1.13-beta.21

package/src/services/view-metadata.service.ts

@@ -4,8 +4,6 @@ import { InjectEntityManager } from '@nestjs/typeorm';
 import { CRUDService } from 'src/services/crud.service';
 import { EntityManager } from 'typeorm';
 
-import { classify } from '../helpers/string.helper';
-import { Locale } from 'src/entities/locale.entity';
 import { ModelMetadataHelperService } from 'src/helpers/model-metadata-helper.service';
 import { SolidRegistry } from 'src/helpers/solid-registry';
 import { ModelMetadataRepository } from 'src/repository/model-metadata.repository';
@@ -197,64 +195,6 @@ export class ViewMetadataService extends CRUDService<ViewMetadata> {
     return this.getDefaultWorkflowFieldData(workflowField, workflowFieldName, fieldsMap);
   }
 
-  //for locales 
-  private async getEntityRecordsInAllLocales(
-    modelName: string,
-    id: string,
-    defaultEntityLocaleIdFromQuery?: string
-  ): Promise<{ records: any[], defaultEntityLocaleId: string | null }> {
-    const solidRegistry = await this.moduleRef.get(SolidRegistry, { strict: false });
-    // const currentEntityTarget = solidRegistry.getEntityTarget(this.entityManager, classify(modelName));
-    const currentEntityRepository = this.entityManager.getRepository(classify(modelName));
-
-    // Case 1: Creating a new record with no defaultEntityLocaleId to clone
-    if (id === 'new' && !defaultEntityLocaleIdFromQuery) {
-      this.logger.debug(`Creating new record without cloning from any defaultEntityLocaleId.`);
-      return { records: [], defaultEntityLocaleId: null };
-    }
-
-    // Case 2: Creating a new record and cloning from an existing defaultEntityLocaleId
-    if (id === 'new' && defaultEntityLocaleIdFromQuery) {
-      this.logger.debug(`Creating new record by cloning translations from defaultEntityLocaleId: ${defaultEntityLocaleIdFromQuery}`);
-
-      const records = await currentEntityRepository.find({
-        where: [
-          { defaultEntityLocaleId: defaultEntityLocaleIdFromQuery },
-          { id: defaultEntityLocaleIdFromQuery }
-        ]
-      });
-
-      this.logger.debug(`Found ${records.length} cloned records for new entity.`);
-      return { records, defaultEntityLocaleId: defaultEntityLocaleIdFromQuery };
-    }
-
-    // Case 3: Editing an existing entity
-    const entityRecord = await currentEntityRepository.findOne({ where: { id } });
-
-    if (!entityRecord) {
-      this.logger.warn(`No entity found for id ${id}`);
-      return { records: [], defaultEntityLocaleId: null };
-    }
-
-    const defaultEntityLocaleId = entityRecord.defaultEntityLocaleId || entityRecord.id;
-    if (entityRecord.defaultEntityLocaleId) {
-      this.logger.debug(`Editing translated locale record. Translation root id: ${defaultEntityLocaleId}`);
-    } else {
-      this.logger.debug(`Editing translation root record with id ${defaultEntityLocaleId}`);
-    }
-
-    const records = await currentEntityRepository.find({
-      where: [
-        { defaultEntityLocaleId: defaultEntityLocaleId },
-        { id: defaultEntityLocaleId }
-      ]
-    });
-
-    this.logger.debug(`Found ${records.length} records in all locales for existing entity.`);
-
-    return { records, defaultEntityLocaleId };
-  }
-
   // START: Custom Service Methods
   async getLayout(query, activeUser) {
     let { modelName, moduleName, viewType, id, populate, menuItemId, menuItemName, actionId, actionName } = query;
@@ -432,92 +372,12 @@ export class ViewMetadataService extends CRUDService<ViewMetadata> {
      * ]
      */
 
-    const applicableLocales: any = []
-    // if (entity.model.internationalisation) {
-    //   const allLocales = await this.entityManager.getRepository(Locale).find({});
-
-    //   if (id === 'new') {
-    //     allLocales.forEach(locale => {
-    //       applicableLocales.push({
-    //         locale: locale.locale,
-    //         displayName: locale.displayName,
-    //         isDefault: locale.isDefault ? 'yes' : 'no',
-    //         defaultEntityLocaleId: null,
-    //         entityId: null
-    //       });
-    //     });
-    //   }
-    //   else {
-    //     const defaultLocale = allLocales.find(locale => locale.isDefault);
-    //     this.logger.debug(`Default locale is: ${defaultLocale.locale}`);
-
-    //     // Get hold of the repository for the current model
-    //     const solidRegistry = await this.moduleRef.get(SolidRegistry, { strict: false });
-    //     const currentEntityTarget = solidRegistry.getEntityTarget(this.entityManager, classify(modelName));
-    //     const currentEntityRepository = this.entityManager.getRepository(currentEntityTarget);
-
-    //     // We are in edit mode, the id that is being edited could be a record tagged with the default locale or it could be tagged with a non-default locale.
-    //     const entityRecord = await currentEntityRepository.findOne({
-    //       where: {
-    //         id: id,
-    //       }
-    //     });
-    //     if(entityRecord){
-    //     //  Resolve the default entity locale id....
-    //       let defaultEntityLocaleId = null;
-    //       if (entityRecord.localeName === defaultLocale.locale) {
-    //         defaultEntityLocaleId = entityRecord.id;
-    //         this.logger.debug(`You are editing a record tagged with the default locale: ${entityRecord.localeName}.`);
-    //       }
-    //       else {
-    //         defaultEntityLocaleId = entityRecord.defaultEntityLocaleId;
-    //         this.logger.debug(`You are editing a record tagged with the non-default locale: ${entityRecord.localeName}. `);
-    //       }
-    //       this.logger.debug(`Identified default Entity Locale Id: ${defaultEntityLocaleId}`);
-
-    //       // Now we query for all records in the same model matching the defaultEntityLocaleId
-    //       // Get all records mathcing the defaultEntityLocaleId or where the id is same as the defaultEntityLocaleId
-    //       const entityRecordsInAllLocales = await currentEntityRepository.find({
-    //         where: [
-    //           { defaultEntityLocaleId: defaultEntityLocaleId },
-    //           { id: defaultEntityLocaleId }
-    //         ],
-    //       });
-    //       this.logger.debug(`Found ${entityRecordsInAllLocales.length} records in all locales for the defaultEntityLocaleId: ${defaultEntityLocaleId}`);
-
-    //       // Loop over all locales and populate the applicableLocales array
-    //       for (const locale of allLocales) {
-    //         // Find the record in the entityRecordsInAllLocales that matches the current locale
-    //         const matchingRecord = entityRecordsInAllLocales.find(record => record.localeName === locale.locale);
-
-    //         applicableLocales.push({
-    //           locale: locale.locale,
-    //           displayName: locale.displayName,
-    //           isDefault: locale.isDefault ? 'yes' : 'no',
-    //           defaultEntityLocaleId: defaultEntityLocaleId,
-    //           entityId: (matchingRecord ? matchingRecord.id : null)
-    //         });
-    //       }
-    //     }else{
-    //       this.logger.warn(`No record found for id: ${id} in model: ${modelName}. Cannot determine applicable locales.`);
-    //     }
-    //   }
-    // }
+    let applicableLocales: any[] = [];
     if (entity.model.internationalisation) {
-      const defaultEntityLocaleIdFromQuery = query?.defaultEntityLocaleId;
-      const { records: entityRecordsInAllLocales, defaultEntityLocaleId } =
-        await this.getEntityRecordsInAllLocales(modelName, id, defaultEntityLocaleIdFromQuery);
-      const allLocales = await this.entityManager.getRepository(Locale).find({});
-      for (const locale of allLocales) {
-        const matchingRecord = entityRecordsInAllLocales.find(record => record.localeName === locale.locale);
-        applicableLocales.push({
-          locale: locale.locale,
-          displayName: locale.displayName,
-          isDefault: locale.isDefault ? 'yes' : 'no',
-          defaultEntityLocaleId: defaultEntityLocaleId,
-          entityId: matchingRecord ? matchingRecord.id : null
-        });
-      }
+      const draftPublishEnabled = entity.model.draftPublishWorkflow === true;
+      applicableLocales = await this.internationalisationHelperService.buildApplicableLocales(
+        this.entityManager, modelName, id, query?.defaultEntityLocaleId, draftPublishEnabled,
+      );
     }
 
     const r = {

package/src/services/workflow/nodes/execution-fail.node.ts

@@ -0,0 +1,82 @@
+import { BadRequestException } from '@nestjs/common';
+import { WorkflowNodeProvider } from '../../../decorators/workflow-node-provider.decorator';
+import { WorkflowNodeHandler } from '../../../interfaces/workflow-node-handler.interface';
+import {
+  WorkflowNodeExecutionContext,
+  WorkflowNodeHandlerResult,
+} from '../../../types/workflow-dsl.types';
+
+@WorkflowNodeProvider({
+  type: 'execution.fail',
+  kind: 'task',
+  version: '1.0.0',
+  category: 'core',
+  subcategory: 'execution',
+  label: 'Fail Execution',
+  description: 'Fails intentionally with a configured message.',
+  tags: ['failure', 'error', 'testing'],
+  aliases: ['fail'],
+  configSchema: {
+    type: 'object',
+    properties: {
+      message: {
+        type: 'string',
+        default: 'Execution failed intentionally.',
+      },
+    },
+  },
+  authoring: {
+    defaultConfiguration: {
+      message: 'Execution failed intentionally.',
+    },
+    configurationFields: [
+      {
+        key: 'message',
+        label: 'Message',
+        description: 'Failure message. Expressions are allowed.',
+        valueType: 'string',
+        expressionAllowed: true,
+        group: 'General',
+      },
+    ],
+    supportsExpressions: true,
+    supportsDisableToggle: true,
+    supportsName: true,
+    supportsDescription: true,
+    searchableText: ['fail', 'failure', 'error', 'testing'],
+  },
+  runtime: {
+    emitsLogs: false,
+    emitsArtifacts: false,
+    deterministicOutputs: true,
+    executionMode: 'task',
+    successStatuses: [],
+  },
+  documentation: {
+    summary:
+      'Use this node in reference workflows and tests to intentionally exercise failure paths and error handlers.',
+  },
+  ui: {
+    icon: 'si-x-circle',
+    iconColor: '#dc2626',
+    iconBackgroundColor: '#fee2e2',
+    iconBorderColor: '#fecaca',
+    modalSize: 'lg',
+    layoutHints: {
+      groupOrder: ['General'],
+    },
+  },
+})
+export class ExecutionFailNode implements WorkflowNodeHandler {
+  async execute(
+    context: WorkflowNodeExecutionContext,
+  ): Promise<WorkflowNodeHandlerResult> {
+    const configuration = context.expression.interpolate(
+      context.node.configuration ?? {},
+      context,
+    );
+    throw new BadRequestException(
+      configuration.message ?? 'Execution failed intentionally.',
+    );
+  }
+}

package/src/services/workflow/nodes/for-each.node.ts

@@ -16,6 +16,8 @@ import {
   authoring: {
     defaultConfiguration: {
       items: '',
+      concurrencyLimit: 1,
+      aggregateOutputs: false,
     },
     configurationFields: [
       {
@@ -32,6 +34,35 @@ import {
           },
         },
       },
+      {
+        key: 'concurrencyLimit',
+        label: 'Concurrency Limit',
+        description:
+          'Maximum number of loop iterations to run at once. Use 1 for sequential execution and 0 for unlimited concurrency.',
+        valueType: 'number',
+        defaultValue: 1,
+        expressionAllowed: true,
+        group: 'General',
+      },
+      {
+        key: 'aggregateOutputs',
+        label: 'Aggregate Outputs',
+        description:
+          'Adds per-iteration child outputs to this forEach node output for downstream expressions.',
+        valueType: 'boolean',
+        defaultValue: false,
+        expressionAllowed: true,
+        group: 'General',
+      },
+      {
+        key: 'outputKey',
+        label: 'Output Key',
+        description:
+          'Optional expression used as the per-iteration key when aggregate outputs is enabled.',
+        valueType: 'string',
+        expressionAllowed: true,
+        group: 'General',
+      },
     ],
     childSlots: [
       {
@@ -42,6 +73,13 @@ import {
         layout: 'sequential',
         required: true,
       },
+      {
+        key: 'errors',
+        label: 'Errors',
+        description: 'Nodes that run sequentially if this loop fails.',
+        kind: 'sequence',
+        layout: 'sequential',
+      },
     ],
     supportsDescription: true,
     supportsName: true,
@@ -66,32 +104,128 @@ export class ForEachNode implements WorkflowNodeHandler {
   ): Promise<WorkflowNodeHandlerResult> {
     const configuration = context.node.configuration ?? {};
     const items = context.expression.interpolate(configuration.items ?? [], context);
+    const concurrencyLimit = this.resolveConcurrencyLimit(
+      context.expression.interpolate(configuration.concurrencyLimit ?? 1, context),
+    );
+    const aggregateOutputs = Boolean(
+      context.expression.interpolate(configuration.aggregateOutputs ?? false, context),
+    );
 
     if (!Array.isArray(items)) {
       throw new BadRequestException('forEach requires configuration.items array.');
     }
 
     const childNodes = context.node.tasks ?? [];
+    const iterationsByIndex: Record<number, any> = {};
+    const iterationsByKey: Record<string, any> = {};
+    const shouldAggregateByKey =
+      aggregateOutputs && configuration.outputKey !== undefined && configuration.outputKey !== null;
 
-    for (let index = 0; index < items.length; index++) {
+    await this.runIterations(items, concurrencyLimit, async (item, index) => {
       const inheritedOutputs = context.outputs ?? {};
       const iterationOutputs = { ...inheritedOutputs };
-
-      await context.runNodes(childNodes, {
-        item: items[index],
+      const parentLoops = context.loops ?? [];
+      const currentLoop = {
+        item,
+        index,
+        nodeId: context.node.id,
+        stepExecutionKey: context.stepExecution.stepExecutionKey,
+      };
+      const loopContext = {
+        item,
         index,
+        parent: parentLoops[parentLoops.length - 1],
+        parents: [...parentLoops].reverse(),
+        loops: [...parentLoops, currentLoop],
+      };
+      const outputKey = shouldAggregateByKey
+        ? String(context.expression.interpolate(configuration.outputKey, {
+            ...context,
+            ...loopContext,
+            outputs: iterationOutputs,
+          }))
+        : undefined;
+
+      const childOutputs = await context.runNodes(childNodes, {
+        ...loopContext,
         outputs: iterationOutputs,
       });
-    }
+
+      if (aggregateOutputs) {
+        const iterationResult = {
+          item,
+          index,
+          outputs: childOutputs,
+        };
+
+        iterationsByIndex[index] = iterationResult;
+        if (outputKey !== undefined) {
+          iterationsByKey[outputKey] = iterationResult;
+        }
+      }
+    });
 
     return {
       output: {
         count: items.length,
         childNodeIds: childNodes.map((childNode) => childNode.id),
+        concurrencyLimit,
         // Keep the control-node output intentionally small. Per-iteration
         // outputs are already stored on the child workflowStepExecution rows.
-        iterationOutputsStoredOnSteps: true,
+        iterationOutputsStoredOnSteps: !aggregateOutputs,
+        ...(aggregateOutputs
+          ? {
+              iterations: {
+                byIndex: iterationsByIndex,
+                ...(shouldAggregateByKey
+                  ? {
+                      byKey: iterationsByKey,
+                    }
+                  : {}),
+              },
+            }
+          : {}),
       },
     };
   }
+
+  private resolveConcurrencyLimit(value: any): number {
+    const parsed = Number(value === '' || value === null || value === undefined ? 1 : value);
+    if (!Number.isFinite(parsed) || parsed < 0) {
+      throw new BadRequestException(
+        'forEach configuration.concurrencyLimit must be 0 or a positive number.',
+      );
+    }
+
+    return Math.floor(parsed);
+  }
+
+  private async runIterations<T>(
+    items: T[],
+    concurrencyLimit: number,
+    handler: (item: T, index: number) => Promise<void>,
+  ): Promise<void> {
+    if (concurrencyLimit === 1 || items.length <= 1) {
+      for (let index = 0; index < items.length; index++) {
+        await handler(items[index], index);
+      }
+      return;
+    }
+
+    const limit = concurrencyLimit === 0 ? items.length : concurrencyLimit;
+    let nextIndex = 0;
+
+    const workers = Array.from(
+      { length: Math.min(limit, items.length) },
+      async () => {
+        while (nextIndex < items.length) {
+          const index = nextIndex;
+          nextIndex += 1;
+          await handler(items[index], index);
+        }
+      },
+    );
+
+    await Promise.all(workers);
+  }
 }

package/src/services/workflow/nodes/if.node.ts

@@ -42,6 +42,13 @@ import {
         description: 'Nodes that run when the condition evaluates to false.',
         kind: 'sequence',
       },
+      {
+        key: 'errors',
+        label: 'Errors',
+        description: 'Nodes that run sequentially if the selected branch fails.',
+        kind: 'sequence',
+        layout: 'sequential',
+      },
     ],
     supportsDescription: true,
     supportsName: true,

package/src/services/workflow/nodes/log-write.node.ts

@@ -162,6 +162,7 @@ import {
         description: 'The resolved log level.',
         valueType: 'string',
         path: 'level',
+        includeInRuntimeContext: false,
       },
       {
         key: 'message',
@@ -169,6 +170,7 @@ import {
         description: 'The rendered log message.',
         valueType: 'string',
         path: 'message',
+        includeInRuntimeContext: false,
       },
     ],
     supportsExpressions: true,