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

package/src/services/workflow/workflow-runtime.service.ts

@@ -161,7 +161,11 @@ export class WorkflowRuntimeService {
     const execution = existingExecution
       ? await this.writer.startExecution(existingExecution, effectiveRequest)
       : await this.writer.createExecution(definition, effectiveRequest);
-    const nodeCount = this.countNodes(definitionDsl.nodes);
+    const nodeCount = this.countNodes([
+      ...(definitionDsl.nodes ?? []),
+      ...(definitionDsl.errors ?? []),
+      ...(definitionDsl.finally ?? []),
+    ]);
     const outputs: Record<string, any> = {};
     const runtimeContext: WorkflowRuntimeContext = {
       execution,
@@ -175,26 +179,52 @@ export class WorkflowRuntimeService {
       },
     };
 
+    this.logger.log(
+      `Starting workflow execution ${execution.executionIdentifier} for ${definition.key} with ${nodeCount} node(s).`,
+    );
+    await this.writer.writeLog(execution, undefined, {
+      level: 'info',
+      eventType: 'execution.started',
+      message: `Workflow execution started for ${definition.key}.`,
+      metadata: {
+        executionIdentifier: execution.executionIdentifier,
+        workflowKey: definition.key,
+        triggerType: execution.triggerType,
+        nodeCount,
+        inputKeys: Object.keys(runtimeContext.input ?? {}),
+        variableKeys: Object.keys(runtimeContext.variables ?? {}),
+      },
+    }, this.nextLogSequence(runtimeContext));
+
+    let executionError: unknown;
+
     try {
-      this.logger.log(
-        `Starting workflow execution ${execution.executionIdentifier} for ${definition.key} with ${nodeCount} node(s).`,
-      );
+      await this.runNodes(definitionDsl.nodes, runtimeContext);
+    } catch (error) {
+      executionError = error;
+      await this.runGlobalErrorHandlers(definitionDsl, runtimeContext, error);
+    }
+
+    try {
+      await this.runFinallyHandlers(definitionDsl, runtimeContext);
+    } catch (finallyError) {
       await this.writer.writeLog(execution, undefined, {
-        level: 'info',
-        eventType: 'execution.started',
-        message: `Workflow execution started for ${definition.key}.`,
+        level: 'error',
+        eventType: 'finally.failed',
+        message: `Finally handler failed: ${this.errorMessage(finallyError)}.`,
+        context: this.summarizeError(finallyError),
         metadata: {
-          executionIdentifier: execution.executionIdentifier,
-          workflowKey: definition.key,
-          triggerType: execution.triggerType,
-          nodeCount,
-          inputKeys: Object.keys(runtimeContext.input ?? {}),
-          variableKeys: Object.keys(runtimeContext.variables ?? {}),
+          originalError: executionError
+            ? this.summarizeError(executionError)
+            : undefined,
         },
       }, this.nextLogSequence(runtimeContext));
+      if (!executionError) {
+        executionError = finallyError;
+      }
+    }
 
-      await this.runNodes(definitionDsl.nodes, runtimeContext);
-
+    if (!executionError) {
       const completed = await this.writer.completeExecution(execution, outputs);
 
       this.logger.log(
@@ -212,26 +242,26 @@ export class WorkflowRuntimeService {
       }, this.nextLogSequence(runtimeContext));
 
       return this.toResponse(completed);
-    } catch (error) {
-      const failed = await this.writer.failExecution(execution, error);
+    }
 
-      this.logger.error(
-        `Failed workflow execution ${failed.executionIdentifier} for ${definition.key}: ${failed.errorSummary}`,
-        error instanceof Error ? error.stack : undefined,
-      );
-      await this.writer.writeLog(failed, undefined, {
-        level: 'error',
-        eventType: 'execution.failed',
-        message: failed.errorSummary,
-        context: this.summarizeError(error),
-        metadata: {
-          executionIdentifier: failed.executionIdentifier,
-          durationMs: failed.durationMs,
-        },
-      }, this.nextLogSequence(runtimeContext));
+    const failed = await this.writer.failExecution(execution, executionError);
 
-      return this.toResponse(failed);
-    }
+    this.logger.error(
+      `Failed workflow execution ${failed.executionIdentifier} for ${definition.key}: ${failed.errorSummary}`,
+      executionError instanceof Error ? executionError.stack : undefined,
+    );
+    await this.writer.writeLog(failed, undefined, {
+      level: 'error',
+      eventType: 'execution.failed',
+      message: failed.errorSummary,
+      context: this.summarizeError(executionError),
+      metadata: {
+        executionIdentifier: failed.executionIdentifier,
+        durationMs: failed.durationMs,
+      },
+    }, this.nextLogSequence(runtimeContext));
+
+    return this.toResponse(failed);
   }
 
   async getExecutionStatus(executionId: number): Promise<WorkflowExecutionResponse> {
@@ -363,17 +393,19 @@ export class WorkflowRuntimeService {
     nodes: WorkflowNodeDefinition[],
     context: WorkflowRuntimeContext,
   ): Promise<Record<string, any>> {
+    const nodeOutputs: Record<string, any> = {};
+
     for (const node of nodes ?? []) {
-      await this.runNode(node, context);
+      nodeOutputs[node.id] = await this.runNode(node, context);
     }
 
-    return context.outputs;
+    return nodeOutputs;
   }
 
   private async runNode(
     node: WorkflowNodeDefinition,
     context: WorkflowRuntimeContext,
-  ): Promise<void> {
+  ): Promise<Record<string, any>> {
     const inputPayload = {
       configuration: node.configuration,
       input: context.input,
@@ -400,7 +432,7 @@ export class WorkflowRuntimeService {
         message: `Skipped disabled node ${node.id}.`,
         metadata: this.nodeLogMetadata(node, context, step),
       }, this.nextLogSequence(context));
-      return;
+      return context.outputs[node.id];
     }
 
     try {
@@ -444,7 +476,7 @@ export class WorkflowRuntimeService {
       });
 
       const output = result.output ?? {};
-      context.outputs[node.id] = output;
+      context.outputs[node.id] = this.getRuntimeContextOutput(node, output);
 
       for (const artifact of result.artifacts ?? []) {
         await this.writer.writeArtifact(context.execution, step, artifact);
@@ -472,6 +504,8 @@ export class WorkflowRuntimeService {
           artifactCount: result.artifacts?.length ?? 0,
         },
       }, this.nextLogSequence(context));
+
+      return output;
     } catch (error) {
       await this.writer.failStep(step, error);
 
@@ -486,7 +520,7 @@ export class WorkflowRuntimeService {
           context: this.summarizeError(error),
           metadata: this.nodeLogMetadata(node, context, step),
         }, this.nextLogSequence(context));
-        return;
+        return context.outputs[node.id];
       }
 
       await this.writer.writeLog(context.execution, step, {
@@ -496,10 +530,158 @@ export class WorkflowRuntimeService {
         context: this.summarizeError(error),
         metadata: this.nodeLogMetadata(node, context, step),
       }, this.nextLogSequence(context));
+      await this.runLocalErrorHandlers(node, context, error);
       throw error;
     }
   }
 
+  private async runGlobalErrorHandlers(
+    definitionDsl: WorkflowDefinitionDsl,
+    context: WorkflowRuntimeContext,
+    error: unknown,
+  ): Promise<void> {
+    const errorNodes = definitionDsl.errors ?? [];
+    if (!errorNodes.length) {
+      return;
+    }
+
+    await this.runErrorHandlers(
+      errorNodes,
+      context,
+      error,
+      'global',
+      undefined,
+      undefined,
+    );
+  }
+
+  private async runFinallyHandlers(
+    definitionDsl: WorkflowDefinitionDsl,
+    context: WorkflowRuntimeContext,
+  ): Promise<void> {
+    const finallyNodes = definitionDsl.finally ?? [];
+    if (!finallyNodes.length) {
+      return;
+    }
+
+    await this.writer.writeLog(context.execution, undefined, {
+      level: 'info',
+      eventType: 'finally.started',
+      message: 'Running workflow finally handlers.',
+      metadata: {
+        handlerNodeCount: finallyNodes.length,
+      },
+    }, this.nextLogSequence(context));
+
+    await this.runNodes(finallyNodes, context);
+
+    await this.writer.writeLog(context.execution, undefined, {
+      level: 'info',
+      eventType: 'finally.completed',
+      message: 'Workflow finally handlers completed.',
+      metadata: {
+        handlerNodeCount: finallyNodes.length,
+      },
+    }, this.nextLogSequence(context));
+  }
+
+  private async runLocalErrorHandlers(
+    node: WorkflowNodeDefinition,
+    context: WorkflowRuntimeContext,
+    error: unknown,
+  ): Promise<void> {
+    const errorNodes = node.errors ?? [];
+    if (!errorNodes.length) {
+      return;
+    }
+
+    await this.runErrorHandlers(
+      errorNodes,
+      context,
+      error,
+      'local',
+      node.id,
+      context.stepExecution?.stepExecutionKey,
+    );
+  }
+
+  private async runErrorHandlers(
+    errorNodes: WorkflowNodeDefinition[],
+    context: WorkflowRuntimeContext,
+    error: unknown,
+    scope: 'global' | 'local',
+    sourceNodeId?: string,
+    sourceStepExecutionKey?: string,
+  ): Promise<void> {
+    const errorContext = this.buildErrorContext(error, sourceNodeId, sourceStepExecutionKey);
+
+    await this.writer.writeLog(context.execution, undefined, {
+      level: 'warn',
+      eventType: `error-handler.${scope}.started`,
+      message:
+        scope === 'global'
+          ? 'Running workflow-level error handlers.'
+          : `Running local error handlers for node ${sourceNodeId}.`,
+      context: errorContext,
+      metadata: {
+        sourceNodeId,
+        sourceStepExecutionKey,
+        handlerNodeCount: errorNodes.length,
+      },
+    }, this.nextLogSequence(context));
+
+    try {
+      await this.runNodes(errorNodes, {
+        ...context,
+        error: errorContext,
+        parentNodeId: sourceNodeId ?? context.parentNodeId,
+        parentStepExecutionKey:
+          sourceStepExecutionKey ?? context.parentStepExecutionKey,
+      });
+    } catch (handlerError) {
+      await this.writer.writeLog(context.execution, undefined, {
+        level: 'error',
+        eventType: `error-handler.${scope}.failed`,
+        message: `Error handler failed: ${this.errorMessage(handlerError)}.`,
+        context: this.summarizeError(handlerError),
+        metadata: {
+          originalError: errorContext,
+          sourceNodeId,
+          sourceStepExecutionKey,
+        },
+      }, this.nextLogSequence(context));
+      return;
+    }
+
+    await this.writer.writeLog(context.execution, undefined, {
+      level: 'info',
+      eventType: `error-handler.${scope}.completed`,
+      message:
+        scope === 'global'
+          ? 'Workflow-level error handlers completed.'
+          : `Local error handlers completed for node ${sourceNodeId}.`,
+      context: errorContext,
+      metadata: {
+        sourceNodeId,
+        sourceStepExecutionKey,
+      },
+    }, this.nextLogSequence(context));
+  }
+
+  private buildErrorContext(
+    error: unknown,
+    nodeId?: string,
+    stepExecutionKey?: string,
+  ): Record<string, any> {
+    const summary = this.summarizeError(error);
+    return {
+      ...summary,
+      message: this.errorMessage(error),
+      nodeId,
+      stepExecutionKey,
+    };
+  }
+
   private assertDefinitionYaml(value: any): WorkflowDefinitionDsl {
     if (!value || typeof value !== 'string') {
       throw new BadRequestException(
@@ -627,6 +809,7 @@ export class WorkflowRuntimeService {
         ...(node.then ?? []),
         ...(node.else ?? []),
         ...(node.defaults ?? []),
+        ...(node.errors ?? []),
         ...Object.values(node.cases ?? {}).flat(),
       ];
 
@@ -660,6 +843,58 @@ export class WorkflowRuntimeService {
     };
   }
 
+  private getRuntimeContextOutput(
+    node: WorkflowNodeDefinition,
+    output: Record<string, any>,
+  ): Record<string, any> {
+    const hiddenOutputPaths =
+      this.registry
+        .getMetadata(node.type)
+        .authoring?.outputs?.filter(
+          (definition) => definition.includeInRuntimeContext === false,
+        )
+        .map((definition) => definition.path ?? definition.key)
+        .filter(Boolean) ?? [];
+
+    if (!hiddenOutputPaths.length || !output || typeof output !== 'object') {
+      return output;
+    }
+
+    const runtimeOutput = this.cloneOutput(output);
+    hiddenOutputPaths.forEach((path) => {
+      this.deletePath(runtimeOutput, path);
+    });
+
+    return runtimeOutput;
+  }
+
+  private cloneOutput(output: Record<string, any>): Record<string, any> {
+    if (typeof structuredClone === 'function') {
+      return structuredClone(output);
+    }
+
+    return JSON.parse(JSON.stringify(output));
+  }
+
+  private deletePath(target: Record<string, any>, path: string) {
+    const parts = path.split('.').filter(Boolean);
+    if (!parts.length) {
+      return;
+    }
+
+    let cursor: any = target;
+    for (let index = 0; index < parts.length - 1; index += 1) {
+      cursor = cursor?.[parts[index]];
+      if (!cursor || typeof cursor !== 'object') {
+        return;
+      }
+    }
+
+    if (cursor && typeof cursor === 'object') {
+      delete cursor[parts[parts.length - 1]];
+    }
+  }
+
   private summarizeValue(value: any): any {
     if (Array.isArray(value)) {
       return {

package/src/solid-core.module.ts

@@ -1,6 +1,5 @@
 import "multer";
-import { Global, MiddlewareConsumer, Module, NestModule } from "@nestjs/common";
-import * as express from "express";
+import { Global, Module } from "@nestjs/common";
 import { ConfigModule, ConfigService } from "@nestjs/config";
 import {
   APP_FILTER,
@@ -38,6 +37,8 @@ import { MqDashboardQueueNameVariableOptionsProvider } from "./services/selectio
 import { PseudoForeignKeySelectionProvider } from "./services/selection-providers/pseudo-foreign-key-selection-provider.service";
 import { ModuleMetadataSeederService } from "./seeders/module-metadata-seeder.service";
 import { ModuleTestDataService } from "./seeders/module-test-data.service";
+import { DraftPublishHelperService } from "./services/draft-publish-helper.service";
+import { InternationalisationHelperService } from "./services/internationalisation-helper.service";
 import { CrudHelperService } from "./services/crud-helper.service";
 import { DatasourceManagementService } from "./services/datasource-management.service";
 import { DatasourceIntrospectionService } from "./services/datasource-introspection.service";
@@ -56,10 +57,10 @@ import { ModulePackageService } from "./services/module-package.service";
 import { SolidIntrospectService } from "./services/solid-introspect.service";
 // import { ListOfComputedFieldProvider } from './providers/list-of-computed-field-provider.service';
 import { ServeStaticModule } from "@nestjs/serve-static";
-import { extname, join } from "path";
+import { basename, join } from "path";
 import { RefreshModelCommand } from "./commands/refresh-model.command";
 import { MediaController } from "./controllers/media.controller";
-import { INLINE_SAFE_EXTENSIONS } from "./constants/media-file-types";
+import { getLowercaseFileExtension, INLINE_SAFE_EXTENSIONS } from "./constants/media-file-types";
 
 import { RefreshModuleCommand } from "./commands/refresh-module.command";
 import { ModelMetadataSubscriber } from "./subscribers/model-metadata.subscriber";
@@ -96,6 +97,7 @@ import { GoogleAuthenticationController } from "./controllers/google-authenticat
 import { MenuItemMetadataController } from "./controllers/menu-item-metadata.controller";
 import { MqMessageQueueController } from "./controllers/mq-message-queue.controller";
 import { MqMessageController } from "./controllers/mq-message.controller";
+import { MpinAuthenticationController } from "./controllers/mpin-authentication.controller";
 import { OTPAuthenticationController } from "./controllers/otp-authentication.controller";
 import { ServiceController } from "./controllers/service.controller";
 import { SmsTemplateController } from "./controllers/sms-template.controller";
@@ -165,8 +167,10 @@ import { TwilioSmsQueueSubscriberRedis } from "./jobs/redis/twilio-sms-subscribe
 import { UserRegistrationListener } from "./listeners/user-registration.listener";
 import { GoogleOauthStrategy } from "./passport-strategies/google-oauth.strategy";
 import { ApiKeyService } from "./services/api-key.service";
+import { MpinService } from "./services/mpin.service";
 import { ActiveSessionStorageService } from "./services/active-session-storage.service";
 import { AuthenticationService } from "./services/authentication.service";
+import { MetadataValidationService } from "./services/metadata-validation.service";
 import { BcryptService } from "./services/bcrypt.service";
 import { UuidExternalIdEntityComputedFieldProvider } from "./services/computed-fields/entity/uuid-externalid-entity-computed-field-provider.service";
 import { UuidExternalIdComputedFieldProvider } from "./services/computed-fields/uuid-external-id-computed-field-provider.service";
@@ -244,6 +248,7 @@ import { Setting } from './entities/setting.entity';
 import { UserActivityHistory } from './entities/user-activity-history.entity';
 import { UserViewMetadata } from './entities/user-view-metadata.entity';
 import { UserApiKey } from './entities/user-api-key.entity';
+import { UserDeviceCredential } from './entities/user-device-credential.entity';
 import { User } from './entities/user.entity';
 import { HttpExceptionFilter } from './filters/http-exception.filter';
 import { ModelMetadataHelperService } from './helpers/model-metadata-helper.service';
@@ -316,6 +321,7 @@ import { SmsTemplateRepository } from './repository/sms-template.repository';
 import { UserActivityHistoryRepository } from './repository/user-activity-history.repository';
 import { UserViewMetadataRepository } from './repository/user-view-metadata.repository';
 import { UserApiKeyRepository } from './repository/user-api-key.repository';
+import { UserDeviceCredentialRepository } from './repository/user-device-credential.repository';
 import { UserRepository } from './repository/user.repository';
 import { ViewMetadataRepository } from './repository/view-metadata.repository';
 import { PermissionMetadataSeederService } from './seeders/permission-metadata-seeder.service';
@@ -441,10 +447,12 @@ import { WorkflowInvocationService } from './services/workflow/workflow-invocati
 import { WorkflowNodeRegistryService } from './services/workflow/workflow-node-registry.service';
 import { WorkflowRuntimeService } from './services/workflow/workflow-runtime.service';
 import { WorkflowScheduledTriggerJobService } from './services/workflow/workflow-scheduled-trigger.job';
+import { ExecutionFailNode } from './services/workflow/nodes/execution-fail.node';
 import { ForEachNode } from './services/workflow/nodes/for-each.node';
 import { HttpRequestNode } from './services/workflow/nodes/http-request.node';
 import { IfNode } from './services/workflow/nodes/if.node';
 import { LogWriteNode } from './services/workflow/nodes/log-write.node';
+import { LoopUntilNode } from './services/workflow/nodes/loop-until.node';
 import { ParallelNode } from './services/workflow/nodes/parallel.node';
 import { RuntimePythonNode } from './services/workflow/nodes/runtime-python.node';
 import { SequentialNode } from './services/workflow/nodes/sequential.node';
@@ -496,6 +504,7 @@ import { SwitchNode } from './services/workflow/nodes/switch.node';
       SmsTemplate,
       User,
       UserApiKey,
+      UserDeviceCredential,
       UserActivityHistory,
       UserViewMetadata,
       ViewMetadata,
@@ -533,7 +542,11 @@ import { SwitchNode } from './services/workflow/nodes/switch.node';
           // else (including svg, html, and any other uploaded file) is forced to download
           // rather than be displayed/executed by the browser, regardless of what mimetype or
           // extension it was uploaded with.
-          if (!INLINE_SAFE_EXTENSIONS.has(extname(path).toLowerCase().replace(/^\./, ''))) {
+          // basename first: getLowercaseFileExtension takes a file name, not a path, so a
+          // directory containing a dot must not be mistaken for the extension. An
+          // extensionless file yields undefined, which is not inline-safe - so it correctly
+          // falls through to the forced-download branch.
+          if (!INLINE_SAFE_EXTENSIONS.has(getLowercaseFileExtension(basename(path)) ?? '')) {
             res.setHeader("Content-Type", "application/octet-stream");
             res.setHeader("Content-Disposition", "attachment");
           }
@@ -544,6 +557,19 @@ import { SwitchNode } from './services/workflow/nodes/switch.node';
       imports: [ConfigModule],
       useFactory: async (configService: ConfigService) => ({
         dest: process.env.AB_MEDIA_UPLOAD_DIR ?? "media-uploads",
+        // A global floor under whatever per-field mediaMaxSizeKb restrictions apply, not a
+        // replacement for them - some upload paths (e.g. chatter attachments) had no size cap
+        // enforced anywhere before this. Must stay >= the largest legitimate per-field limit
+        // already configured (chatter's messageAttachments is 102400 KB / 100MB), since Multer
+        // enforces this before any of our own field-level checks ever run. Mirrored (read-only,
+        // for visibility only - see comment there for why) as the "maxMediaFileSizeMb" setting
+        // in default-settings-provider.service.ts; keep both parsing expressions in sync.
+        limits: {
+          fileSize: (() => {
+            const parsedMb = Number(process.env.AB_MEDIA_MAX_FILE_SIZE_MB);
+            return (Number.isFinite(parsedMb) && parsedMb > 0 ? parsedMb : 100) * 1024 * 1024;
+          })(),
+        },
       }),
       inject: [ConfigService],
     }),
@@ -587,6 +613,7 @@ import { SwitchNode } from './services/workflow/nodes/switch.node';
     GupshupWebhookController,
     MetaCloudWhatsappWebhookController,
     OTPAuthenticationController,
+    MpinAuthenticationController,
     PermissionMetadataController,
     RoleMetadataController,
     SavedFiltersController,
@@ -642,6 +669,7 @@ import { SwitchNode } from './services/workflow/nodes/switch.node';
     ModuleMetadataExplorerService,
     ModuleMetadataHelperService,
     ModulePackageService,
+    MetadataValidationService,
     ModelMetadataService,
     ModelMetadataHelperService,
     FieldMetadataService,
@@ -654,6 +682,8 @@ import { SwitchNode } from './services/workflow/nodes/switch.node';
     InfoService,
     SolidIntrospectService,
     DiscoveryService,
+    DraftPublishHelperService,
+    InternationalisationHelperService,
     CrudHelperService,
     CRUDService,
     Reflector,
@@ -749,6 +779,7 @@ import { SwitchNode } from './services/workflow/nodes/switch.node';
     ApiKeyGuard,
     MediaSignedUrlGuard,
     ApiKeyService,
+    MpinService,
     ActiveSessionStorageService,
     AuthenticationService,
     GoogleAuthenticationController,
@@ -818,6 +849,7 @@ import { SwitchNode } from './services/workflow/nodes/switch.node';
     PermissionMetadataSeederService,
     UserService,
     UserApiKeyRepository,
+    UserDeviceCredentialRepository,
     UserRepository,
     SettingService,
     ConcatComputedFieldProvider,
@@ -947,10 +979,12 @@ import { SwitchNode } from './services/workflow/nodes/switch.node';
     WorkflowDefinitionValidatorService,
     WorkflowNodeRegistryService,
     WorkflowScheduledTriggerJobService,
+    ExecutionFailNode,
     LogWriteNode,
     HttpRequestNode,
     IfNode,
     ForEachNode,
+    LoopUntilNode,
     ParallelNode,
     RuntimePythonNode,
     SequentialNode,
@@ -972,6 +1006,8 @@ import { SwitchNode } from './services/workflow/nodes/switch.node';
     ChatterMessageRepository,
     ChatterMessageService,
     ConfigModule,
+    DraftPublishHelperService,
+    InternationalisationHelperService,
     CrudHelperService,
     CRUDService,
     CsvService,
@@ -994,6 +1030,7 @@ import { SwitchNode } from './services/workflow/nodes/switch.node';
     SmsFactory,
     MediaService,
     MediaStorageProviderMetadataService,
+    MetadataValidationService,
     ModelMetadataHelperService,
     ModelMetadataService,
     ModuleMetadataService,
@@ -1033,13 +1070,7 @@ import { SwitchNode } from './services/workflow/nodes/switch.node';
     WorkflowExpressionService,
   ],
 })
-export class SolidCoreModule implements NestModule {
-  configure(consumer: MiddlewareConsumer) {
-    consumer
-      .apply(
-        express.json({ limit: "10mb" }),
-        express.urlencoded({ limit: "10mb", extended: true }),
-      )
-      .forRoutes("*");
-  }
-}
+// Body-size limits live in bootstrapSolidApp (see SolidBootstrapOptions.bodyLimit).
+// They cannot be applied here: module middleware is registered in registerRouter(),
+// which runs after Nest's own parser middleware, so anything set here never takes effect.
+export class SolidCoreModule {}