@transai/connector-runner-mkg 0.2.0

package/.eslintrc.json

@@ -0,0 +1,30 @@
+{
+  "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/CHANGELOG.md

@@ -0,0 +1,24 @@
+## 0.2.0 (2025-11-19)
+
+### 🚀 Features
+
+- fix connector packages publish ([517d2fd2](https://github.com/xip-online-applications/xod-core/commit/517d2fd2))
+- **XODO-1108:** added actions for MKG tables ([#877](https://github.com/xip-online-applications/xod-core/pull/877))
+- add custom cron trigger functionality and related interfaces ([b859c50f](https://github.com/xip-online-applications/xod-core/commit/b859c50f))
+- **XODO-1125:** fixes ([b625be91](https://github.com/xip-online-applications/xod-core/commit/b625be91))
+- ability to send statistics to logs for now ([#863](https://github.com/xip-online-applications/xod-core/pull/863))
+- **XODO-1108:** added MKG ERP connector ([#840](https://github.com/xip-online-applications/xod-core/pull/840))
+
+### 🩹 Fixes
+
+- correct timestamp expectation in ExtractorService tests and add CustomCronTriggerRecord interface ([e3f53d35](https://github.com/xip-online-applications/xod-core/commit/e3f53d35))
+
+### 🧱 Updated Dependencies
+
+- Updated @transai/connector-runtime-sdk to 0.1.0
+
+### ❤️ Thank You
+
+- Copilot @Copilot
+- Rene Heijdens @H31nz3l
+- Youri Lefers @yourilefers

package/README.md

@@ -0,0 +1,11 @@
+# connector-runner-mkg
+
+This library was generated with [Nx](https://nx.dev).
+
+## Building
+
+Run `nx build connector-runner-mkg` to build the library.
+
+## Running unit tests
+
+Run `nx test connector-runner-mkg` to execute the unit tests via [Jest](https://jestjs.io).

package/jest.config.ts

@@ -0,0 +1,10 @@
+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/package.json

@@ -0,0 +1,16 @@
+{
+  "name": "@transai/connector-runner-mkg",
+  "version": "0.2.0",
+  "publishConfig": {
+    "access": "public"
+  },
+  "license": "LGPL-3.0-or-later",
+  "author": {
+    "name": "transAI",
+    "email": "samen@transai.com",
+    "url": "https://transai.com"
+  },
+  "type": "commonjs",
+  "main": "./index.js",
+  "typings": "./index.d.ts"
+}

package/project.json

@@ -0,0 +1,29 @@
+{
+  "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/index.ts

@@ -0,0 +1 @@
+export * from './lib/connector-runner-mkg';

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

@@ -0,0 +1,177 @@
+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

@@ -0,0 +1,143 @@
+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);
+      }
+    };
+  }
+}

package/src/lib/connector-runner-mkg.spec.ts

@@ -0,0 +1,219 @@
+import {
+  ConnectorSDKInterface,
+  HttpClientSDKInterface,
+  HttpRequestOptionsFormatter,
+} from '@transai/connector-runtime-sdk';
+import { ConnectorInterface } from '@xip-online-data/types';
+
+import { ActionsHandler } from './actions-handler';
+import { ConnectorRunnerMkg } from './connector-runner-mkg';
+import { ExtractorService } from './extractor.service';
+import { ConnectorConfig, SESSION_EXPIRATION_SECONDS } from './types';
+
+jest.mock('./actions-handler');
+jest.mock('./extractor.service');
+
+describe('ConnectorRunnerMkg', () => {
+  let runner: ConnectorRunnerMkg;
+
+  const testEndpoint = '/test-endpoint';
+  const sessionId = 'abcdef1234567890';
+
+  let requestFormatter: HttpRequestOptionsFormatter;
+
+  const httpClientMock = {
+    setRequestOptionsFormatter: jest.fn().mockImplementation((formatter) => {
+      requestFormatter = formatter;
+      return httpClientMock;
+    }),
+    post: jest.fn().mockImplementation(() => ({
+      status: 200,
+      headers: {
+        'set-cookie': [`JSESSIONID=${sessionId}; Path=/; HttpOnly`],
+      },
+    })),
+  } as unknown as HttpClientSDKInterface;
+  const connector = {} as ConnectorInterface;
+  const sdkMock = {
+    logger: {
+      warn: jest.fn(),
+      verbose: jest.fn(),
+      error: jest.fn(),
+    },
+    config: {
+      server: 'saas-test.mkg.eu',
+      username: 'some-username',
+      password: 'some-password',
+      apiToken: 'some-api-token',
+      tables: {
+        arti: true,
+        unknown_table: true,
+        clch: {
+          fields: [
+            'clch_volgnummer',
+            'clch_op_dek_uit',
+            'clch_vofr_oms_1',
+            'unknown',
+          ],
+        },
+      },
+    },
+    processing: {
+      registerInterval: jest.fn(),
+    },
+    receiver: {
+      emitEventType: jest.fn(),
+      responses: {
+        created: jest.fn(),
+      },
+      registerCallback: jest.fn(),
+    },
+    httpClient: jest.fn().mockReturnValue(httpClientMock),
+  } as unknown as ConnectorSDKInterface<ConnectorConfig>;
+  const actionsHandlerCallbackChain = jest.fn();
+
+  beforeEach(() => {
+    (ActionsHandler as jest.Mock).mockImplementation((sdk, httpClient) => {
+      expect(sdk).toBe(sdkMock);
+      expect(httpClient).toBe(httpClientMock);
+
+      return {
+        callbackFunctionChain: actionsHandlerCallbackChain,
+      } as unknown as ActionsHandler;
+    });
+
+    runner = new ConnectorRunnerMkg(connector, sdkMock);
+  });
+
+  afterEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it('should be defined', () => {
+    expect(runner).toBeDefined();
+  });
+
+  describe('initialization', () => {
+    beforeEach(() => {
+      (ExtractorService as jest.Mock).mockImplementation(
+        (sdk, httpClient, tableId, table) => {
+          expect(sdk).toBe(sdkMock);
+          expect(httpClient).toBe(httpClientMock);
+
+          switch (tableId) {
+            case 'arti':
+              expect(table).toEqual(
+                expect.objectContaining({
+                  identifier: 'arti',
+                }),
+              );
+              break;
+            case 'clch':
+              expect(table).toEqual(
+                expect.objectContaining({
+                  identifier: 'clch',
+                  fields: [
+                    'clch_volgnummer',
+                    'clch_op_dek_uit',
+                    'clch_vofr_oms_1',
+                  ],
+                }),
+              );
+              break;
+            default:
+              expect(false).toBe(true);
+              break;
+          }
+
+          return {} as ExtractorService;
+        },
+      );
+    });
+
+    it('should initialize without errors', async () => {
+      await expect(runner.init()).resolves.not.toThrow();
+
+      expect(sdkMock.httpClient).toHaveBeenCalledWith({
+        baseUrl: 'https://saas-test.mkg.eu:443/mkg',
+      });
+      expect(sdkMock.processing.registerInterval).toHaveBeenCalledTimes(2);
+      expect(sdkMock.processing.registerInterval).toHaveBeenNthCalledWith(
+        1,
+        300,
+        expect.any(Object),
+        { immediate: true },
+      );
+
+      expect(sdkMock.processing.registerInterval).toHaveBeenNthCalledWith(
+        2,
+        60,
+        expect.any(Object),
+        { immediate: true },
+      );
+    });
+  });
+
+  describe('token fetching', () => {
+    it('should have defined the formatter', () => {
+      expect(requestFormatter).toBeDefined();
+    });
+
+    it('should format requests with authentication', async () => {
+      const formattedOptions = await requestFormatter(
+        {
+          data: 'some-data',
+        },
+        'GET',
+        testEndpoint,
+      );
+
+      expect(formattedOptions).toEqual(
+        expect.objectContaining({
+          headers: expect.objectContaining({
+            Cookie: `JSESSIONID=${sessionId}`,
+            'X-CustomerID': 'some-api-token',
+          }),
+        }),
+      );
+    });
+
+    it('should format requests with custom header', async () => {
+      const formattedOptions = await requestFormatter(
+        {
+          headers: {
+            'Custom-Header': 'custom-value',
+          },
+        },
+        'GET',
+        testEndpoint,
+      );
+
+      expect(formattedOptions).toEqual(
+        expect.objectContaining({
+          headers: expect.objectContaining({
+            'Custom-Header': 'custom-value',
+            Cookie: `JSESSIONID=${sessionId}`,
+            'X-CustomerID': 'some-api-token',
+          }),
+        }),
+      );
+    });
+
+    it('should request token only once', async () => {
+      await requestFormatter({}, 'GET', testEndpoint);
+      await requestFormatter({}, 'GET', testEndpoint);
+
+      expect(httpClientMock.post).toHaveBeenCalledTimes(1);
+    });
+
+    it('should renew token after expiration', async () => {
+      jest.useFakeTimers();
+
+      await requestFormatter({}, 'GET', testEndpoint);
+      jest.setSystemTime(new Date().getTime() + SESSION_EXPIRATION_SECONDS);
+      await requestFormatter({}, 'GET', testEndpoint);
+
+      expect(httpClientMock.post).toHaveBeenCalledTimes(2);
+    });
+  });
+});