@transai/connector-runner-mkg 0.2.0 → 0.4.0

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

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

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

@@ -1,155 +0,0 @@
-/* eslint-disable camelcase,@typescript-eslint/naming-convention */
-import {
-  ConnectorRuntimeSDK,
-  ConnectorSDKInterface,
-  HttpClientSDKInterface,
-  HttpRequestOptions,
-} from '@transai/connector-runtime-sdk';
-import { ConnectorInterface } from '@xip-online-data/types';
-
-import { ActionsHandler } from './actions-handler';
-import { ExtractorService } from './extractor.service';
-import { MKG_TABLES } from './tables/_all';
-import {
-  ConnectorConfig,
-  SESSION_COOKIE_NAME,
-  SESSION_EXPIRATION_SECONDS,
-} from './types';
-
-export class ConnectorRunnerMkg extends ConnectorRuntimeSDK<ConnectorConfig> {
-  readonly #actionsHandler: ActionsHandler;
-
-  readonly #mkgHttpClient: HttpClientSDKInterface;
-
-  readonly #sessionTokenHttpClient: HttpClientSDKInterface;
-
-  #sessionToken?: {
-    token: string;
-    expiresAt: number;
-  };
-
-  constructor(
-    connector: ConnectorInterface,
-    connectorSDK: ConnectorSDKInterface,
-  ) {
-    super(connector, connectorSDK);
-
-    const { config } = this.connectorSDK;
-
-    this.#sessionTokenHttpClient = this.connectorSDK.httpClient({
-      baseUrl: `https://${config.server}:${config.port ?? 443}/${(config.path ?? '/mkg').replace(/^\/+/, '')}`,
-    });
-    this.#mkgHttpClient = this.connectorSDK
-      .httpClient({
-        baseUrl: `https://${config.server}:${config.port ?? 443}/${(config.path ?? '/mkg').replace(/^\/+/, '')}`,
-      })
-      .setRequestOptionsFormatter(this.#requestOptionsFormatter);
-
-    this.#actionsHandler = new ActionsHandler(
-      this.connectorSDK,
-      this.#mkgHttpClient,
-    );
-
-    this.callbackFunction = this.#actionsHandler.callbackFunctionChain;
-  }
-
-  override init = async (): Promise<void> => {
-    const { config } = this.connectorSDK;
-
-    Object.entries(config.tables ?? {}).forEach(
-      ([tableIdentifier, configOrTrue]) => {
-        // eslint-disable-next-line security/detect-object-injection
-        const table = MKG_TABLES[tableIdentifier];
-        if (!table) {
-          this.connectorSDK.logger.warn(
-            `[MKG] Unknown table identifier "${tableIdentifier}", skipping configuration.`,
-          );
-          return;
-        }
-
-        if (!table.interval || table.interval <= 0) {
-          this.connectorSDK.logger.verbose(
-            `[MKG] Table "${tableIdentifier}" does not have a valid interval configured, skipping registration.`,
-          );
-          return;
-        }
-
-        this.connectorSDK.processing.registerInterval(
-          table.interval,
-          new ExtractorService(
-            this.connectorSDK,
-            this.#mkgHttpClient,
-            tableIdentifier,
-            table.cloneFromTableConfig(configOrTrue),
-          ),
-          { immediate: table.immediate },
-        );
-      },
-    );
-  };
-
-  #requestOptionsFormatter = async <D = string | object>(
-    options: HttpRequestOptions<D>,
-  ): Promise<HttpRequestOptions<D>> => {
-    const { config } = this.connectorSDK;
-
-    return {
-      ...options,
-      headers: {
-        ...(options?.headers ?? {}),
-        Cookie: `${SESSION_COOKIE_NAME}=${await this.#getSessionCookie(config.username, config.password)}`,
-        'X-CustomerID': config.apiToken,
-      },
-    };
-  };
-
-  async #getSessionCookie(
-    j_username: string,
-    j_password: string,
-  ): Promise<string> {
-    const token = this.#sessionToken;
-    if (token && token.expiresAt > Date.now()) {
-      return token.token;
-    }
-
-    const response = await this.#sessionTokenHttpClient.post(
-      '/static/auth/j_spring_security_check',
-      {
-        j_username,
-        j_password,
-      },
-      {
-        headers: {
-          Accept: 'application/json',
-          'Content-Type': 'application/x-www-form-urlencoded',
-        },
-      },
-    );
-
-    if (!response) {
-      throw new Error('Failed to authenticate and retrieve session cookie');
-    }
-
-    const cookies = (response.headers?.['set-cookie'] ??
-      response.headers?.['Set-Cookie'] ??
-      []) as Array<string>;
-    const sessionCookie = cookies.find((cookie: string) =>
-      cookie.startsWith(`${SESSION_COOKIE_NAME}=`),
-    );
-
-    if (!sessionCookie) {
-      throw new Error('Session cookie not found in authentication response');
-    }
-
-    const sessionToken = sessionCookie
-      .split(';')[0]
-      ?.substring(`${SESSION_COOKIE_NAME}=`.length);
-
-    this.#sessionToken = {
-      token: sessionToken,
-      expiresAt: Date.now() + SESSION_EXPIRATION_SECONDS - 1000,
-    };
-
-    return sessionToken;
-  }
-}

package/src/lib/extractor.service.spec.ts

@@ -1,123 +0,0 @@
-import {
-  ConnectorSDKInterface,
-  HttpClientSDKInterface,
-} from '@transai/connector-runtime-sdk';
-
-import { ExtractorService } from './extractor.service';
-import { MkgTable } from './tables/base/table';
-import { ConnectorConfig } from './types';
-
-describe('ExtractorService', () => {
-  let service: ExtractorService;
-
-  const sdkMock = {
-    logger: {
-      info: jest.fn(),
-      debug: jest.fn(),
-      error: jest.fn(),
-      verbose: jest.fn(),
-    },
-    offsetStore: {
-      getOffset: jest.fn().mockResolvedValue({
-        id: 0,
-        timestamp: new Date().getTime(),
-        rawTimestamp: new Date().toISOString(),
-        isoDate: new Date().toISOString(),
-      }),
-      setOffset: jest.fn().mockResolvedValue(undefined),
-    },
-    sender: {
-      documents: jest.fn().mockResolvedValue(undefined),
-    },
-    config: {},
-  } as unknown as ConnectorSDKInterface<ConnectorConfig>;
-
-  const httpClientMock = {} as HttpClientSDKInterface;
-
-  beforeEach(() => {
-    service = new ExtractorService(
-      sdkMock,
-      httpClientMock,
-      'test-table',
-      new MkgTable({
-        identifier: 'test-table',
-        fields: ['field1', 'field2'],
-      }).cloneFromTableConfig({
-        fields: ['field1', 'field11', 'field2'],
-      }),
-    );
-  });
-
-  afterEach(() => {
-    jest.clearAllMocks();
-  });
-
-  it('should initialize and register interval', () => {
-    expect(service).toBeDefined();
-  });
-
-  describe('onRun', () => {
-    it('should run without errors', async () => {
-      const data = [
-        {
-          sys_dat_wijzig: '2025-11-02',
-          RowKey: '1',
-          field1: 'value1',
-          field2: 'value2',
-        },
-        {
-          sys_dat_wijzig: '2025-11-03',
-          RowKey: '2',
-          field1: 'value3',
-          field2: 'value4',
-        },
-      ];
-      httpClientMock.get = jest.fn().mockResolvedValue({
-        success: true,
-        data: {
-          response: {
-            ResultData: [
-              {
-                'test-table': data,
-              },
-            ],
-          },
-        },
-      });
-
-      await expect(service.onRun()).resolves.toBeUndefined();
-
-      expect(sdkMock.sender.documents).toHaveBeenCalledWith(data, {
-        keyField: 'RowKey',
-        collection: 'mkg_test-table',
-      });
-      expect(sdkMock.offsetStore.setOffset).toHaveBeenCalledWith(
-        {
-          id: '2',
-          timestamp: expect.any(Number),
-          rawTimestamp: expect.any(String),
-        },
-        'offset_test-table',
-      );
-    });
-
-    it('should now send documents on error response', async () => {
-      httpClientMock.get = jest.fn().mockResolvedValue({
-        success: false,
-        error: 'some-error',
-      });
-
-      await expect(service.onRun()).resolves.toBeUndefined();
-
-      expect(sdkMock.sender.documents).not.toHaveBeenCalled();
-      expect(sdkMock.offsetStore.setOffset).toHaveBeenCalledWith(
-        {
-          id: '0',
-          timestamp: expect.any(Number),
-          rawTimestamp: expect.any(String),
-        },
-        'offset_test-table',
-      );
-    });
-  });
-});

package/src/lib/extractor.service.ts

@@ -1,125 +0,0 @@
-import {
-  ConnectorSDKInterface,
-  HttpClientSDKInterface,
-  HttpError,
-  IntervalHandler,
-  StoredOffset,
-} from '@transai/connector-runtime-sdk';
-
-import {
-  ConnectorConfig,
-  DEFAULT_DATASOURCE,
-  MkgTableInterface,
-} from './types';
-
-type FetchDataResponse<D> = {
-  response: {
-    ResultData: [
-      {
-        [key: string]: Array<D>;
-      },
-    ];
-  };
-};
-
-export class ExtractorService implements IntervalHandler {
-  readonly #sdk: ConnectorSDKInterface<ConnectorConfig>;
-
-  readonly #httpClient: HttpClientSDKInterface;
-
-  readonly #tableIdentifier: string;
-
-  readonly #table: Required<MkgTableInterface>;
-
-  readonly #fieldsList: string;
-
-  constructor(
-    sdk: ConnectorSDKInterface<ConnectorConfig>,
-    httpClient: HttpClientSDKInterface,
-    tableIdentifier: string,
-    table: Required<MkgTableInterface>,
-  ) {
-    this.#sdk = sdk;
-    this.#httpClient = httpClient;
-    this.#tableIdentifier = tableIdentifier;
-    this.#table = table;
-    this.#fieldsList = table.fields.join(',');
-  }
-
-  get name(): string {
-    return `mkg-extractor-${this.#tableIdentifier}`;
-  }
-
-  async onRun(): Promise<void> {
-    try {
-      const now = new Date();
-      const latestOffset = await this.#sdk.offsetStore.getOffset(
-        `offset_${this.#tableIdentifier}`,
-      );
-
-      const data = await this.#fetchData(latestOffset);
-      if (data.length > 0) {
-        await this.#sdk.sender.documents(data, {
-          keyField: this.#table.identifierField,
-          collection: `${this.#sdk.config.datasourceIdentifier ?? DEFAULT_DATASOURCE}_${this.#tableIdentifier}`,
-        });
-      }
-
-      this.#sdk.logger.debug(
-        `[MKG] Processed ${data.length} records from ${this.#tableIdentifier}`,
-      );
-
-      this.#sdk.offsetStore.setOffset(
-        {
-          id: String(
-            data[data.length - 1]?.[this.#table.identifierField] ??
-              latestOffset.id,
-          ),
-          timestamp: now.getTime(),
-          rawTimestamp: now.toISOString(),
-        },
-        `offset_${this.#tableIdentifier}`,
-      );
-    } catch (error) {
-      this.#sdk.logger.error(
-        `[MKG] Failed to retrieve and process data from OPC UA source service`,
-        { error },
-      );
-    }
-  }
-
-  #fetchData = async (
-    latestOffset: StoredOffset,
-  ): Promise<
-    Array<{
-      [key: string]: string | number | boolean;
-    }>
-  > => {
-    const parameters = new URLSearchParams();
-    parameters.set('NumRows', String(this.#table.rows));
-    parameters.set(
-      'Filter',
-      `${this.#table.dateField}>=${latestOffset.rawTimestamp}`,
-    );
-    parameters.set('FieldList', `${this.#table.dateField},${this.#fieldsList}`);
-
-    try {
-      const response = await this.#httpClient.get<
-        FetchDataResponse<{
-          [key: string]: string | number | boolean;
-        }>
-      >(
-        `/web/v3/MKG/Documents/${this.#tableIdentifier}?${parameters.toString()}`,
-      );
-
-      return (
-        response.data?.response?.ResultData?.[0]?.[this.#tableIdentifier] ?? []
-      );
-    } catch (error: HttpError | unknown) {
-      const logMessage = `[MKG] Failed to fetch data from table "${this.#tableIdentifier}": (${(error as HttpError)?.status}) ${(error as HttpError)?.error ?? (error as Error)?.message}`;
-      this.#sdk.logger.error(logMessage);
-    }
-
-    return [];
-  };
-}

package/src/lib/tables/_all.ts

@@ -1,60 +0,0 @@
-import { MKG_TABLE_ARTG } from './artg';
-import { MKG_TABLE_ARTI } from './arti';
-import { MkgTable } from './base/table';
-import { MKG_TABLE_BWRG } from './bwrg';
-import { MKG_TABLE_BWRK } from './bwrk';
-import { MKG_TABLE_CLCH } from './clch';
-import { MKG_TABLE_DEBI } from './debi';
-import { MKG_TABLE_MAGL } from './magl';
-import { MKG_TABLE_MAGZ } from './magz';
-import { MKG_TABLE_MEDW } from './medw';
-import { MKG_TABLE_PARL } from './parl';
-import { MKG_TABLE_PLNB } from './plnb';
-import { MKG_TABLE_PRBV } from './prbv';
-import { MKG_TABLE_PRDH } from './prdh';
-import { MKG_TABLE_PRDR } from './prdr';
-import { MKG_TABLE_PRMV } from './prmv';
-import { MKG_TABLE_RELA } from './rela';
-import { MKG_TABLE_RGRS } from './rgrs';
-import { MKG_TABLE_RSRC } from './rsrc';
-import { MKG_TABLE_RSRD } from './rsrd';
-import { MKG_TABLE_RSRG } from './rsrg';
-import { MKG_TABLE_STLH } from './stlh';
-import { MKG_TABLE_STLM } from './stlm';
-import { MKG_TABLE_STLR } from './stlr';
-import { MKG_TABLE_VRDG } from './vrdg';
-
-const tables = [
-  MKG_TABLE_RELA,
-  MKG_TABLE_DEBI,
-  MKG_TABLE_MEDW,
-  MKG_TABLE_ARTI,
-  MKG_TABLE_RSRC,
-  MKG_TABLE_RSRD,
-  MKG_TABLE_RSRG,
-  MKG_TABLE_MAGZ,
-  MKG_TABLE_MAGL,
-  MKG_TABLE_STLH,
-  MKG_TABLE_STLR,
-  MKG_TABLE_STLM,
-  MKG_TABLE_PRDH,
-  MKG_TABLE_BWRK,
-  MKG_TABLE_BWRG,
-  MKG_TABLE_CLCH,
-  MKG_TABLE_VRDG,
-  MKG_TABLE_RGRS,
-  MKG_TABLE_PLNB,
-  MKG_TABLE_ARTG,
-  MKG_TABLE_PRDR,
-  MKG_TABLE_PRMV,
-  MKG_TABLE_PRBV,
-  MKG_TABLE_PARL,
-];
-
-export const MKG_TABLES: { [identifier: string]: MkgTable } = tables.reduce(
-  (acc, table) => {
-    acc[table.identifier] = table;
-    return acc;
-  },
-  {} as { [identifier: string]: MkgTable },
-);

package/src/lib/tables/artg.ts

@@ -1,12 +0,0 @@
-import { MkgTable } from './base/table';
-
-export const MKG_TABLE_ARTG = new MkgTable({
-  identifier: 'artg',
-  fields: [
-    'artg_num',
-    'artg_rela',
-    'artg_cred',
-    'artg_oms',
-    'artg_inkoopofferte',
-  ],
-});