@transai/connector-runner-mkg 0.2.0 → 0.4.0

package/libs/types/src/lib/types.d.ts

@@ -0,0 +1,116 @@
+export interface MessageMonitorConfig {
+    type: 'in-memory' | 'redis' | 'disabled';
+}
+export declare enum ConfiguredConnectorTypes {
+    API = "api",
+    API_SINK = "api-sink",
+    API_SOURCE = "api-source",
+    DUMMY_NODE = "dummy-node",
+    FILE_COPY = "file-copy",
+    FILE = "file",
+    FILE_SINK = "file-sink",
+    FILE_SOURCE = "file-source",
+    SAMBA_SINK = "samba-sink",
+    SAMBA_SOURCE = "samba-source",
+    SQL_SINK = "sql-sink",
+    SQL_SOURCE = "sql-source",
+    MQTT = "mqtt",
+    CUBE_QUERY_RUNNER = "cube-query-runner",
+    FACTORY_NEBULA_SOURCE = "factory-nebula-source",
+    BYSTRONIC = "bystronic",
+    IMAP_SOURCE = "imap-source",
+    IMAP_SINK = "imap-sink",
+    OPCUA_SOURCE = "opcua-source",
+    OPCUA_SINK = "opcua-sink",
+    AI_AGENT = "ai-agent",
+    MICROSOFT_OFFICE365_EMAIL = "microsoft-office365-email",
+    MKG = "mkg"
+}
+export interface ConnectorConfig {
+    type: ConfiguredConnectorTypes;
+    identifier: string;
+}
+export interface RedisMessageMonitorConfig extends MessageMonitorConfig {
+    type: 'redis';
+    url: string;
+    ttl?: number;
+}
+export interface InMemoryMessageMonitorConfig extends MessageMonitorConfig {
+    type: 'in-memory';
+    messagesToKeep: number;
+}
+export interface DisabledMessageMonitorConfig extends MessageMonitorConfig {
+    type: 'disabled';
+}
+export interface TopicRegex {
+    pattern: string;
+    flags: string;
+}
+export interface FileRegex {
+    pattern: string;
+    flags: string;
+}
+export declare function isTopicRegex(obj: TopicRegex | string): obj is TopicRegex;
+export interface CubeConfigHeaders {
+    Authorization: string;
+}
+export interface CubeConfig {
+    auth0_client_secret?: string;
+    auth0_client_id?: string;
+    auth0_audience?: string;
+    auth0_token_url?: string;
+    authorization?: string;
+    apiUrl: string;
+    headers?: CubeConfigHeaders;
+    redis_url?: string;
+}
+export declare function isCubeConfigType(obj: CubeConfig): obj is CubeConfig;
+export interface AwsKafkaSaslConfig {
+    region?: string;
+    accessKeyId?: string;
+    secretAccessKey?: string;
+    mechanism: 'aws';
+}
+export declare function isAwsKafkaSalsConfig(obj: AwsKafkaSaslConfig): obj is AwsKafkaSaslConfig;
+export interface DatabaseConfig {
+    uri: string;
+    ssl?: boolean;
+    tenantPassword?: string;
+}
+export interface ActionConfig {
+    timeSensitive: boolean;
+}
+export interface KafkaBrokerConfig {
+    groupId: string;
+    clientId: string;
+    brokers: Array<string>;
+    consumerTopics?: Array<string | TopicRegex>;
+    sasl?: AwsKafkaSaslConfig;
+    intervalCheckForNewTopics?: number;
+    disableLogs?: boolean;
+    autoCommitThreshold?: number;
+    autoCommitInterval?: number;
+    partitionsConsumedConcurrently?: number;
+    messageMonitor?: RedisMessageMonitorConfig | InMemoryMessageMonitorConfig | DisabledMessageMonitorConfig;
+    useConfluentLibrary?: boolean;
+    newConsumerProtocol?: boolean;
+}
+export declare function isKafkaBrokerConfigType(obj: KafkaBrokerConfig): obj is KafkaBrokerConfig;
+export declare function isActionConfigType(obj: any): obj is ActionConfig;
+export declare function isDatabaseConfigType(obj: DatabaseConfig): obj is DatabaseConfig;
+export interface BaseConnectorConfig {
+    processIdentifier: string;
+    tenantIdentifier: string;
+    datasourceIdentifier: string;
+    kafka: KafkaBrokerConfig;
+    action?: ActionConfig;
+}
+export declare function isBaseConnectorConfigType(obj: BaseConnectorConfig): obj is BaseConnectorConfig;
+export interface AiAgentConfig {
+    openai: {
+        apiKey: string;
+        model: 'gpt-3.5-turbo' | 'gpt-4' | 'gpt-4-turbo' | 'gpt-4o' | 'gpt-4o-mini' | 'o1-preview' | 'o1-mini';
+        temperature?: number;
+        timeout?: number;
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@transai/connector-runner-mkg",
-  "version": "0.2.0",
+  "version": "0.4.0",
   "publishConfig": {
     "access": "public"
   },

package/.eslintrc.json

@@ -1,30 +0,0 @@
-{
-  "extends": ["../../.eslintrc.json"],
-  "ignorePatterns": ["!**/*"],
-  "overrides": [
-    {
-      "files": ["*.ts", "*.tsx", "*.js", "*.jsx"],
-      "rules": {}
-    },
-    {
-      "files": ["*.ts", "*.tsx"],
-      "rules": {}
-    },
-    {
-      "files": ["*.js", "*.jsx"],
-      "rules": {}
-    },
-    {
-      "files": ["*.json"],
-      "parser": "jsonc-eslint-parser",
-      "rules": {
-        "@nx/dependency-checks": [
-          "error",
-          {
-            "ignoredFiles": ["{projectRoot}/eslint.config.{js,cjs,mjs}"]
-          }
-        ]
-      }
-    }
-  ]
-}

package/jest.config.ts

@@ -1,10 +0,0 @@
-export default {
-  displayName: 'connector-runner-mkg',
-  preset: '../../jest.preset.js',
-  testEnvironment: 'node',
-  transform: {
-    '^.+\\.[tj]s$': ['ts-jest', { tsconfig: '<rootDir>/tsconfig.spec.json' }],
-  },
-  moduleFileExtensions: ['ts', 'js', 'html'],
-  coverageDirectory: '../../coverage/libs/connector-runner-mkg',
-};

package/project.json

@@ -1,29 +0,0 @@
-{
-  "name": "connector-runner-mkg",
-  "$schema": "../../node_modules/nx/schemas/project-schema.json",
-  "sourceRoot": "libs/connector-runner-mkg/src",
-  "projectType": "library",
-  "tags": [
-    "connector:runner",
-    "connector:runner-sdk",
-    "connector:mkg",
-    "connector:source",
-    "provider:@transai"
-  ],
-  "targets": {
-    "build": {
-      "executor": "@transai/tools:connector",
-      "outputs": ["{options.outputPath}"]
-    },
-    "lint": {
-      "executor": "@nx/eslint:lint"
-    },
-    "test": {
-      "executor": "@nx/jest:jest",
-      "outputs": ["{workspaceRoot}/coverage/{projectRoot}"],
-      "options": {
-        "jestConfig": "libs/connector-runner-mkg/jest.config.ts"
-      }
-    }
-  }
-}

package/src/lib/actions-handler.spec.ts

@@ -1,177 +0,0 @@
-import {
-  ConnectorSDKInterface,
-  HttpClientSDKInterface,
-} from '@transai/connector-runtime-sdk';
-import { ActionInterface, XodJobType } from '@xip-online-data/types';
-
-import { ActionsHandler } from './actions-handler';
-
-describe('ActionsHandler', () => {
-  let handler: ActionsHandler;
-
-  const sdkMock = {
-    logger: {
-      warn: jest.fn(),
-      info: jest.fn(),
-      debug: jest.fn(),
-      error: jest.fn(),
-      verbose: jest.fn(),
-    },
-    receiver: {
-      responses: {
-        created: jest.fn().mockReturnValue(
-          jest.fn().mockReturnValue({
-            statusCode: 201,
-          }),
-        ),
-        badRequest: jest.fn().mockReturnValue(
-          jest.fn().mockReturnValue({
-            statusCode: 400,
-          }),
-        ),
-        internalServerError: jest.fn().mockReturnValue(
-          jest.fn().mockReturnValue({
-            statusCode: 500,
-          }),
-        ),
-      },
-      emitEventType: jest.fn().mockReturnValue(
-        jest.fn().mockReturnValue({
-          statusCode: 201,
-        }),
-      ),
-    },
-  } as unknown as ConnectorSDKInterface;
-  let httpClientMock: HttpClientSDKInterface;
-
-  beforeEach(() => {
-    httpClientMock = {
-      request: jest.fn().mockResolvedValue({
-        success: true,
-        statusCode: 201,
-      }),
-    } as unknown as HttpClientSDKInterface;
-
-    handler = new ActionsHandler(sdkMock, httpClientMock);
-  });
-
-  afterEach(() => {
-    jest.clearAllMocks();
-  });
-
-  it('should be defined', () => {
-    expect(handler).toBeDefined();
-  });
-
-  describe('JOB actions', () => {
-    const action = {
-      config: {
-        parsedTemplates: {
-          action: jest.fn().mockReturnValue('prmv.create.prdh_prdr'),
-          params: jest.fn().mockReturnValue(
-            JSON.stringify({
-              prmv_oms_1: 'API materiaal test',
-              cred_num: 'some-cred_num',
-              prdh_num: '56',
-              prdr_num: '78',
-            }),
-          ),
-        },
-      },
-    } as unknown as ActionInterface;
-
-    const jobMessage = {
-      type: 'JOB',
-      actionIdentifier: 'action-1',
-      actionVersion: 'latest',
-      payload: { some: 'data' },
-    } as unknown as XodJobType;
-
-    it('should execute request on action', async () => {
-      const response = await handler.callbackFunctionChain(jobMessage, action);
-
-      expect(response.statusCode).toBe(201);
-      expect(httpClientMock.request).toHaveBeenCalledWith(
-        'POST',
-        '/web/v3/MKG/Documents/prdr/1+56+78/prdr_prmv',
-        {
-          data: {
-            request: {
-              InputData: {
-                prmv: [
-                  {
-                    prmv_oms_1: 'API materiaal test',
-                    cred_num: 'some-cred_num',
-                  },
-                ],
-              },
-            },
-          },
-        },
-      );
-    });
-
-    it('should handle test run without firing request', async () => {
-      const testRunMessage = {
-        ...jobMessage,
-        testRun: true,
-      } as XodJobType;
-
-      const response = await handler.callbackFunctionChain(
-        testRunMessage,
-        action,
-      );
-
-      expect(response.statusCode).toBe(201);
-      expect(httpClientMock.request).not.toHaveBeenCalled();
-    });
-
-    it('should reject on unknown action', async () => {
-      const action = {
-        config: {
-          parsedTemplates: {
-            action: jest.fn().mockReturnValue('prmv.blaat'),
-            params: jest.fn().mockReturnValue(JSON.stringify({})),
-          },
-        },
-      } as unknown as ActionInterface;
-
-      const response = await handler.callbackFunctionChain(jobMessage, action);
-
-      expect(response.statusCode).toBe(400);
-      expect(httpClientMock.request).not.toHaveBeenCalled();
-    });
-
-    it('should reject on unknown table', async () => {
-      const action = {
-        config: {
-          parsedTemplates: {
-            action: jest.fn().mockReturnValue('blaat.blaat'),
-            params: jest.fn().mockReturnValue(JSON.stringify({})),
-          },
-        },
-      } as unknown as ActionInterface;
-
-      const response = await handler.callbackFunctionChain(jobMessage, action);
-
-      expect(response.statusCode).toBe(400);
-      expect(httpClientMock.request).not.toHaveBeenCalled();
-    });
-
-    it('should not fail on unsupported action format', async () => {
-      const action = {
-        config: {
-          parsedTemplates: {
-            action: jest.fn().mockReturnValue('blaat'),
-            params: jest.fn().mockReturnValue(JSON.stringify({})),
-          },
-        },
-      } as unknown as ActionInterface;
-
-      const response = await handler.callbackFunctionChain(jobMessage, action);
-
-      expect(response.statusCode).toBe(400);
-      expect(httpClientMock.request).not.toHaveBeenCalled();
-    });
-  });
-});

package/src/lib/actions-handler.ts

@@ -1,143 +0,0 @@
-import {
-  CompileDelegate,
-  ConnectorSDKInterface,
-  HttpClientSDKInterface,
-  HttpError,
-} from '@transai/connector-runtime-sdk';
-import {
-  ActionInterface,
-  KafkaCallbackResponse,
-  XodJobType,
-} from '@xip-online-data/types';
-
-import { MKG_TABLES } from './tables/_all';
-
-export class ActionsHandler {
-  readonly #connectorSDK: ConnectorSDKInterface;
-
-  readonly #httpClient: HttpClientSDKInterface;
-
-  constructor(
-    connectorSDK: ConnectorSDKInterface,
-    httpClient: HttpClientSDKInterface,
-  ) {
-    this.#connectorSDK = connectorSDK;
-    this.#httpClient = httpClient;
-  }
-
-  get callbackFunctionChain(): (
-    message: XodJobType,
-    action: ActionInterface,
-  ) => Promise<KafkaCallbackResponse> {
-    return this.#jobCallbackFunction(
-      this.#connectorSDK.receiver.emitEventType(
-        this.#connectorSDK.receiver.responses.created(),
-      ),
-    );
-  }
-
-  #jobCallbackFunction(
-    callbackFunction: (message: XodJobType) => Promise<KafkaCallbackResponse>,
-  ) {
-    return async (
-      message: XodJobType,
-      action: ActionInterface,
-    ): Promise<KafkaCallbackResponse> => {
-      try {
-        this.#connectorSDK.logger.debug(
-          `[MKG] Apply templates on payload: ${JSON.stringify(message.payload)}, action: ${JSON.stringify(action)}`,
-        );
-
-        const handleBars = action.config['parsedTemplates'] as {
-          action: CompileDelegate;
-          params: CompileDelegate;
-        };
-
-        const parsedAction = handleBars
-          .action({
-            inputs: message.payload,
-          })
-          .trim();
-
-        const parsedParams = handleBars
-          .params({
-            inputs: message.payload,
-          })
-          .trim();
-
-        const parsedParamsJson = JSON.parse(parsedParams);
-        this.#connectorSDK.logger.debug(
-          `[MKG] Parsed action: ${parsedAction}, params json: ${JSON.stringify(parsedParamsJson)}`,
-        );
-
-        const [tableIdentifier, ...rest] = parsedAction.split('.');
-        const actionIdentifier = rest.join('.');
-        // eslint-disable-next-line security/detect-object-injection
-        const mkgTable = MKG_TABLES[tableIdentifier];
-        if (!mkgTable) {
-          this.#connectorSDK.logger.warn(
-            `[MKG] Unknown table identifier "${tableIdentifier}" in message ${message.eventId}`,
-          );
-          return this.#connectorSDK.receiver.responses.badRequest(
-            `[MKG] Unknown table identifier "${tableIdentifier}"`,
-          )(message);
-        }
-
-        const mkgAction = mkgTable.action(actionIdentifier);
-        if (!mkgAction) {
-          const logMessage = `[MKG] Unknown action identifier "${actionIdentifier}" within table "${tableIdentifier}" in message ${message.eventId}`;
-          this.#connectorSDK.logger.warn(logMessage);
-          return this.#connectorSDK.receiver.responses.badRequest(logMessage)(
-            message,
-          );
-        }
-
-        if (message.testRun) {
-          this.#connectorSDK.logger.info(
-            `[MKG] Test run for ${message.eventId} with payload ${parsedParams} to action ${parsedAction}`,
-          );
-          return callbackFunction(message);
-        }
-
-        try {
-          const response = await this.#httpClient.request(
-            mkgAction.method,
-            `/web/v3/MKG/Documents/${mkgAction.path(parsedParamsJson)}`,
-            {
-              ...(['POST', 'PUT'].includes(mkgAction.method)
-                ? {
-                    data: {
-                      request: {
-                        InputData: {
-                          [tableIdentifier]: [
-                            mkgAction.fieldSet(parsedParamsJson),
-                          ],
-                        },
-                      },
-                    },
-                  }
-                : {}),
-            },
-          );
-
-          this.#connectorSDK.logger.debug(
-            `[MKG] Got action "${actionIdentifier}" of table "${tableIdentifier}" response from MKG: ${JSON.stringify(response)}`,
-          );
-        } catch (error: HttpError | unknown) {
-          const logMessage = `[MKG] Failed to perform action "${actionIdentifier}" of table "${tableIdentifier}": (${(error as HttpError)?.status}) ${(error as HttpError)?.error ?? (error as Error)?.message}`;
-          this.#connectorSDK.logger.error(logMessage);
-
-          return this.#connectorSDK.receiver.responses.unprocessableEntity(
-            logMessage,
-          )(message);
-        }
-
-        return callbackFunction(message);
-      } catch (error: unknown) {
-        return this.#connectorSDK.receiver.responses.internalServerError(
-          error instanceof Error ? error.message : 'Unknown error occurred',
-        )(message);
-      }
-    };
-  }
-}