@transai/connector-runner-mkg 0.2.0

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

@@ -0,0 +1,155 @@
+/* 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

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

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

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

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

package/src/lib/tables/arti.ts

@@ -0,0 +1,99 @@
+import { MkgTable } from './base/table';
+
+export const MKG_TABLE_ARTI = new MkgTable({
+  identifier: 'arti',
+  interval: 300,
+  fields: [
+    'arti_parameter_2',
+    'arti_prijs_vast_man',
+    'arti_seriegrootte',
+    'arti_vrij_memo_1',
+    'arti_bestellen',
+    'arti_btw_aanpasbaar',
+    'arti_vrij_datum_1',
+    'arti_eenh_uitgifte',
+    'arti_eenh_prijs_inkoop',
+    'arti_partij_per_1',
+    'arti_partij',
+    'arti_voorraad_waarde_mach',
+    'arti_parameter_4',
+    'arti_eenh_ontvangst',
+    'arti_prijs_vast_mat',
+    'arti_verh_tijd_aantal_grp',
+    'arti_voorraad_aantal',
+    'arti_bestel_freq_eenh',
+    'arti_vrij_datum_4',
+    'arti_eenh_vrk',
+    'arti_trans_eenh',
+    'arti_kosten_artikel',
+    'arti_verh_tijd_aantal_vrd',
+    'arti_verh_volume_aantal_grp',
+    'arti_memo_verkoop_intern',
+    'arti_verh_volume_aantal_vrd',
+    'arti_vrij_memo_2',
+    'arti_zoeknaam',
+    'arti_blok_verkoop',
+    'arti_verh_aantal_aantal_vrd',
+    'arti_actief',
+    'arti_bestelcode',
+    'arti_locatie',
+    'arti_prijs_netto_mat',
+    'arti_prijs_vast',
+    'arti_vrij_veld_1',
+    'arti_parameter_1',
+    'arti_vrij_datum_2',
+    'arti_gewicht_per_m',
+    'arti_memo_inkoop_extern',
+    'arti_inkoopofferte',
+    'arti_prijs_gemiddeld_mat',
+    'arti_dienst_verkoop',
+    'arti_oms_2',
+    'arti_levertijd_inkoop',
+    'arti_verh_tijd_eenh_grp',
+    'arti_prijs_netto_uitb',
+    'arti_oppervlakte',
+    'arti_voorraadsysteem',
+    'arti_kostprijssysteem',
+    'arti_niet_autores',
+    'arti_wvp_obv_gvp',
+    'arti_vrij_memo_5',
+    'arti_prijs_inkoop',
+    'arti_levertijd_productie',
+    'arti_verh_gewicht_aantal_grp',
+    'arti_verh_gewicht_eenh_grp',
+    'arti_vrij_veld_2',
+    'arti_prijs_gemiddeld_mach',
+    'arti_lijst_3',
+    'arti_verh_gewicht_aantal_vrd',
+    'arti_parameter_3',
+    'arti_lijst_1',
+    'arti_prijs_vast_mach',
+    'arti_vrij_veld_5',
+    'arti_ict_fact_verkoop',
+    'arti_verh_lengte_aantal_vrd',
+    'arti_backflush',
+    'arti_vrij_datum_3',
+    'arti_vrd_aanvullen_tot',
+    'arti_inkoop_artikel',
+    'arti_verh_rest_aantal_grp',
+    'arti_eenh_vrd',
+    'arti_prijs_vast_uitb',
+    'arti_trans_gewicht',
+    'arti_memo_inkoop_intern',
+    'arti_vrij_memo_3',
+    'arti_prijs_netto',
+    'arti_mat_lengte',
+    'arti_bestelhoeveelheid',
+    'arti_eenh_bestelling',
+    'arti_verh_oppv_eenh_grp',
+    'arti_voorraad_artikel',
+    'arti_backflush_uitval',
+    'arti_lijst_9',
+    'arti_vrij_datum_5',
+    'arti_verh_oppv_aantal_grp',
+    'arti_prijs_gemiddeld_uitb',
+    'arti_prijs_verkoop_eenm',
+    'arti_oms_3',
+    'arti_oms_1',
+  ],
+});

package/src/lib/tables/base/action.ts

@@ -0,0 +1,70 @@
+import { MkgTableInterface } from '../../types';
+
+type MkgActionMethod = 'GET' | 'POST' | 'PUT' | 'DELETE';
+
+export interface MkgActionInterface {
+  identifier: string;
+
+  method: MkgActionMethod;
+
+  fields: Array<string>;
+
+  optionalFields?: Array<string>;
+
+  path?: (inputData: Record<string, unknown>) => string;
+}
+
+export class MkgAction implements MkgActionInterface {
+  readonly identifier: string;
+
+  readonly method: MkgActionMethod;
+
+  readonly fields: Array<string>;
+
+  readonly optionalFields: Array<string>;
+
+  readonly path: (inputData: Record<string, unknown>) => string;
+
+  #table!: MkgTableInterface;
+
+  constructor(params: MkgActionInterface) {
+    this.identifier = params.identifier;
+    this.method = params.method;
+    this.fields = params.fields;
+    this.optionalFields = params.optionalFields ?? [];
+    this.path = params.path ?? ((): string => this.#table.identifier);
+  }
+
+  withParentTable(table: MkgTableInterface): MkgAction {
+    const action = new MkgAction(this);
+    action.#table = table;
+
+    return action;
+  }
+
+  fieldSet(inputData: Record<string, unknown>): Record<string, unknown> {
+    const fieldData = new Map<string, unknown>();
+
+    this.fields.forEach((field) => {
+      // eslint-disable-next-line security/detect-object-injection
+      const inputDataValue = inputData[field];
+      if (!inputDataValue) {
+        throw new Error(
+          `Missing required field '${field}' for action '${this.identifier}'`,
+        );
+      }
+
+      fieldData.set(field, inputDataValue);
+    });
+
+    this.optionalFields.forEach((field) => {
+      // eslint-disable-next-line security/detect-object-injection
+      const inputDataValue = inputData[field];
+      if (inputDataValue) {
+        fieldData.set(field, inputDataValue);
+      }
+    });
+
+    return Object.fromEntries(fieldData.entries());
+  }
+}

package/src/lib/tables/base/table.ts

@@ -0,0 +1,57 @@
+import {
+  DEFAULT_DATE_FIELD,
+  DEFAULT_INTERVAL,
+  DEFAULT_NUM_ROWS,
+  DEFAULT_ROW_KEY_FIELD,
+  MkgTableInterface,
+  TableConfig,
+} from '../../types';
+
+import { MkgAction } from './action';
+
+export class MkgTable implements MkgTableInterface {
+  readonly identifier: string;
+
+  readonly fields: Array<string>;
+
+  readonly immediate: boolean;
+
+  readonly interval: number;
+
+  readonly identifierField: string;
+
+  readonly dateField: string;
+
+  readonly rows: number;
+
+  readonly actions: Array<MkgAction>;
+
+  constructor(params: MkgTableInterface, actions: Array<MkgAction> = []) {
+    this.identifier = params.identifier;
+    this.fields = params.fields;
+    this.immediate = params.immediate !== false;
+    this.interval =
+      params.interval ?? (this.fields.length > 0 ? DEFAULT_INTERVAL : 0);
+    this.identifierField = params.identifierField ?? DEFAULT_ROW_KEY_FIELD;
+    this.dateField = params.dateField ?? DEFAULT_DATE_FIELD;
+    this.rows = params.rows ?? DEFAULT_NUM_ROWS;
+    this.actions = actions.map((action) => action.withParentTable(this));
+  }
+
+  cloneFromTableConfig(tableConfig: TableConfig | true): MkgTable {
+    if (tableConfig === true || tableConfig.fields === undefined) {
+      return this;
+    }
+
+    return new MkgTable({
+      ...this,
+      fields: this.fields.filter((field) =>
+        tableConfig.fields?.includes(field),
+      ),
+    });
+  }
+
+  action(identifier: string): MkgAction | undefined {
+    return this.actions.find((a) => a.identifier === identifier);
+  }
+}