@transai/connector-runner-api 0.1.0

package/.eslintrc.json

@@ -0,0 +1,18 @@
+{
+  "extends": ["../../.eslintrc.json"],
+  "ignorePatterns": ["!**/*"],
+  "overrides": [
+    {
+      "files": ["*.ts", "*.tsx", "*.js", "*.jsx"],
+      "rules": {}
+    },
+    {
+      "files": ["*.ts", "*.tsx"],
+      "rules": {}
+    },
+    {
+      "files": ["*.js", "*.jsx"],
+      "rules": {}
+    }
+  ]
+}

package/CHANGELOG.md

@@ -0,0 +1,19 @@
+## 0.1.0 (2025-11-19)
+
+### 🚀 Features
+
+- fix connector packages publish ([517d2fd2](https://github.com/xip-online-applications/xod-core/commit/517d2fd2))
+- **XODO-1134:** added generic API connector ([#883](https://github.com/xip-online-applications/xod-core/pull/883))
+- **XODO-1029 XODO-620:** added initial bystronic connector runner & opcua client ([#776](https://github.com/xip-online-applications/xod-core/pull/776))
+- **XODO-727:** connector orchestration config through API call ([#797](https://github.com/xip-online-applications/xod-core/pull/797))
+- **XODO-852:** made connectors publish to npm ([89cd40eb](https://github.com/xip-online-applications/xod-core/commit/89cd40eb))
+- **XODO-852:** made connectors buildable ([6ca5f111](https://github.com/xip-online-applications/xod-core/commit/6ca5f111))
+
+### 🧱 Updated Dependencies
+
+- Updated @transai/connector-runtime-sdk to 0.1.0
+
+### ❤️ Thank You
+
+- Rene Heijdens @H31nz3l
+- Youri Lefers @yourilefers

package/README.md

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

package/jest.config.ts

@@ -0,0 +1,10 @@
+export default {
+  displayName: 'connector-runner-api',
+  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-api',
+};

package/package.json

@@ -0,0 +1,16 @@
+{
+  "name": "@transai/connector-runner-api",
+  "version": "0.1.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-api",
+  "$schema": "../../node_modules/nx/schemas/project-schema.json",
+  "sourceRoot": "libs/connector-runner-api/src",
+  "projectType": "library",
+  "tags": [
+    "connector:runner",
+    "connector:runner-sdk",
+    "connector:api",
+    "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-api/jest.config.ts"
+      }
+    }
+  }
+}

package/src/index.ts

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

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

@@ -0,0 +1,53 @@
+import {
+  ConnectorRuntimeSDK,
+  ConnectorSDKInterface,
+  HttpClientSDKInterface,
+} from '@transai/connector-runtime-sdk';
+import { ConnectorInterface } from '@xip-online-data/types';
+
+import { ExtractorService } from './extractor.service';
+import { HttpClientAuthentication } from './http-client-authentication';
+import { ResultHandler } from './result.handler';
+import { ConnectorConfig } from './types';
+
+export class ConnectorRunnerApi extends ConnectorRuntimeSDK<ConnectorConfig> {
+  readonly #httpClient?: HttpClientSDKInterface = undefined;
+
+  constructor(
+    connector: ConnectorInterface,
+    connectorSDK: ConnectorSDKInterface,
+  ) {
+    super(connector, connectorSDK);
+
+    const { config } = this.connectorSDK;
+    if (config.url) {
+      this.#httpClient = this.connectorSDK
+        .httpClient({
+          baseUrl: config.url,
+        })
+        .setRequestOptionsFormatter(
+          HttpClientAuthentication.createForAuthConfig(
+            config,
+            this.connectorSDK.httpClient(),
+          ),
+        );
+    }
+  }
+
+  override init = async (): Promise<void> => {
+    const { config } = this.connectorSDK;
+    const resultHandler = new ResultHandler(this.connectorSDK);
+
+    (config.apiCalls ?? []).forEach((apiConfig) => {
+      this.connectorSDK.processing.registerInterval(
+        apiConfig.interval,
+        new ExtractorService(
+          this.connectorSDK,
+          apiConfig,
+          resultHandler,
+          this.#httpClient,
+        ),
+      );
+    });
+  };
+}

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

@@ -0,0 +1,90 @@
+import {
+  CompileDelegate,
+  ConnectorSDKInterface,
+  HttpClientSDKInterface,
+} from '@transai/connector-runtime-sdk';
+
+import { ExtractorService } from './extractor.service';
+import { ResultHandler } from './result.handler';
+import { ConnectorConfig } from './types';
+
+describe('ExtractorService', () => {
+  let service: ExtractorService;
+
+  const callConfig = {
+    name: 'TestCall',
+    interval: 60,
+    offsetFilePrefix: 'test_offset',
+    url: 'https://localhost:443',
+  };
+
+  const httpClientMock = {
+    request: jest.fn().mockResolvedValue({
+      status: 200,
+      data: 'some-result-data',
+    }),
+    setRequestOptionsFormatter: jest.fn().mockReturnThis(),
+  } as unknown as HttpClientSDKInterface;
+  let sdkMock: ConnectorSDKInterface<ConnectorConfig>;
+  let resultHandlerMock: ResultHandler;
+
+  beforeEach(() => {
+    sdkMock = {
+      logger: {
+        info: jest.fn(),
+        debug: jest.fn(),
+        error: jest.fn(),
+        verbose: jest.fn(),
+        warn: jest.fn(),
+      },
+      offsetStore: {
+        getOffset: jest.fn().mockResolvedValue({
+          id: 0,
+          timestamp: new Date().getTime(),
+          rawTimestamp: new Date().toISOString(),
+          isoDate: new Date().toISOString(),
+        }),
+      },
+      templating: {
+        compile: jest
+          .fn()
+          .mockImplementation(
+            (input) =>
+              jest.fn().mockReturnValue(`compiled-${input}`) as CompileDelegate,
+          ),
+      },
+      config: {},
+      httpClient: jest.fn().mockReturnValue(httpClientMock),
+    } as unknown as ConnectorSDKInterface<ConnectorConfig>;
+
+    resultHandlerMock = {
+      handleResult: jest.fn().mockResolvedValue(undefined),
+    } as unknown as ResultHandler;
+
+    service = new ExtractorService(sdkMock, callConfig, resultHandlerMock);
+  });
+
+  it('should initialize and register interval', () => {
+    expect(service).toBeDefined();
+  });
+
+  describe('extraction method', () => {
+    const runExtract = async (): Promise<void> => {
+      await expect(service.onRun()).resolves.not.toThrow();
+    };
+
+    it('should perform extraction without errors', async () => {
+      await runExtract();
+
+      expect(httpClientMock.request).toHaveBeenCalledWith(
+        'GET',
+        'compiled-https://localhost:443',
+        { data: undefined, headers: { 'Content-Type': 'text' } },
+      );
+      expect(resultHandlerMock.handleResult).toHaveBeenCalledWith(
+        'some-result-data',
+        callConfig,
+      );
+    });
+  });
+});

package/src/lib/extractor.service.ts

@@ -0,0 +1,97 @@
+import {
+  CompileDelegate,
+  ConnectorSDKInterface,
+  HttpClientSDKInterface,
+  HttpMethod,
+  IntervalHandler,
+} from '@transai/connector-runtime-sdk';
+
+import { HttpClientAuthentication } from './http-client-authentication';
+import { ResultHandler } from './result.handler';
+import { ApiConfig, ConnectorConfig } from './types';
+
+export class ExtractorService implements IntervalHandler {
+  readonly #sdk: ConnectorSDKInterface<ConnectorConfig>;
+
+  readonly #apiConfig: ApiConfig;
+
+  readonly #resultHandler: ResultHandler;
+
+  readonly #httpClient: HttpClientSDKInterface;
+
+  readonly #requestMethod: HttpMethod;
+
+  readonly #urlDelegate?: CompileDelegate;
+
+  readonly #bodyDelegate?: CompileDelegate;
+
+  constructor(
+    sdk: ConnectorSDKInterface<ConnectorConfig>,
+    apiConfig: ApiConfig,
+    resultHandler: ResultHandler,
+    httpClient?: HttpClientSDKInterface,
+  ) {
+    this.#sdk = sdk;
+    this.#apiConfig = apiConfig;
+    this.#resultHandler = resultHandler;
+
+    const { config } = this.#sdk;
+
+    this.#requestMethod = this.#apiConfig.method ?? config.method ?? 'GET';
+    this.#urlDelegate = this.#apiConfig.url
+      ? this.#sdk.templating.compile(this.#apiConfig.url)
+      : undefined;
+    this.#bodyDelegate = this.#apiConfig.body
+      ? this.#sdk.templating.compile(this.#apiConfig.body)
+      : undefined;
+
+    if (this.#apiConfig.url) {
+      this.#httpClient = this.#sdk
+        .httpClient()
+        .setRequestOptionsFormatter(
+          HttpClientAuthentication.createForAuthConfig(
+            this.#apiConfig,
+            this.#sdk.httpClient(),
+          ),
+        );
+    } else if (httpClient) {
+      this.#httpClient = httpClient;
+    } else {
+      throw new Error(
+        `No HTTP client or URL provided for API extractor: ${apiConfig.name}`,
+      );
+    }
+  }
+
+  get name(): string {
+    return `api-extractor-${this.#apiConfig.name}`;
+  }
+
+  async onRun(): Promise<void> {
+    const latestOffset = await this.#sdk.offsetStore.getOffset(
+      `${this.#apiConfig.offsetFilePrefix ?? 'offset'}_${this.#apiConfig.name}`,
+    );
+
+    this.#sdk.logger.verbose(`[API] [${this.#apiConfig.name}] Executing query`);
+
+    const compileOptions = {
+      ...latestOffset,
+      limit: this.#apiConfig.batchSize ?? 10,
+    };
+
+    const result = await this.#httpClient.request<string>(
+      this.#requestMethod,
+      this.#urlDelegate?.(compileOptions) ?? '',
+      {
+        data: this.#bodyDelegate?.(compileOptions),
+        headers: {
+          'Content-Type': this.#apiConfig.format ?? 'text',
+        },
+      },
+    );
+
+    await this.#resultHandler.handleResult(result.data, this.#apiConfig);
+
+    this.#sdk.logger.debug(`[API] [${this.#apiConfig.name}] Ran query`);
+  }
+}

package/src/lib/http-client-authentication.ts

@@ -0,0 +1,108 @@
+import {
+  HttpClientSDKInterface,
+  HttpRequestOptions,
+  HttpRequestOptionsFormatter,
+} from '@transai/connector-runtime-sdk';
+
+import { HttpClientAuthConfig } from './types';
+
+export class HttpClientAuthentication {
+  readonly #config: HttpClientAuthConfig;
+
+  readonly #tokenHttpClient: HttpClientSDKInterface;
+
+  #sessionToken?: {
+    token: string;
+    expiresAt: number;
+  };
+
+  private constructor(
+    config: HttpClientAuthConfig,
+    tokenHttpClient: HttpClientSDKInterface,
+  ) {
+    this.#config = config;
+    this.#tokenHttpClient = tokenHttpClient;
+  }
+
+  static createForAuthConfig(
+    config: HttpClientAuthConfig,
+    tokenHttpClient: HttpClientSDKInterface,
+  ): HttpRequestOptionsFormatter {
+    const instance = new HttpClientAuthentication(config, tokenHttpClient);
+
+    return instance.format.bind(instance);
+  }
+
+  async format<D = string | object>(
+    requestOptions: HttpRequestOptions<D>,
+  ): Promise<HttpRequestOptions<D>> {
+    if (this.#config.authorization) {
+      return {
+        ...requestOptions,
+        headers: {
+          ...requestOptions.headers,
+          // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+          Authorization: this.#config.authorization!,
+        },
+      };
+    }
+
+    if (
+      this.#config.tokenUrl &&
+      this.#config.clientId &&
+      this.#config.clientSecret
+    ) {
+      return {
+        ...requestOptions,
+        headers: {
+          ...requestOptions.headers,
+          // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+          Authorization: await this.#formatTokenAuth(),
+        },
+      };
+    }
+
+    return requestOptions;
+  }
+
+  async #formatTokenAuth(): Promise<string> {
+    const token = this.#sessionToken;
+    if (token && token.expiresAt > Date.now()) {
+      return token.token;
+    }
+
+    const response = await this.#tokenHttpClient.post<{
+      access_token: string;
+      expires_in: number;
+    }>(
+      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+      this.#config.tokenUrl!,
+      {
+        grant_type: 'client_credentials',
+        client_id: this.#config.clientId,
+        client_secret: this.#config.clientSecret,
+      },
+      {
+        headers: {
+          Accept: 'application/json',
+          'Content-Type': 'application/x-www-form-urlencoded',
+        },
+      },
+    );
+
+    if (!response) {
+      throw new Error(
+        'Failed to authenticate and retrieve authentication token',
+      );
+    }
+
+    const { access_token: accessToken, expires_in: expiresIn } = response.data;
+
+    this.#sessionToken = {
+      token: accessToken,
+      expiresAt: Date.now() + expiresIn * 1000 - 1000,
+    };
+
+    return accessToken;
+  }
+}

package/src/lib/result.handler.spec.ts

@@ -0,0 +1,135 @@
+import { ConnectorSDKInterface } from '@transai/connector-runtime-sdk';
+
+import { ResultHandler } from './result.handler';
+import { ApiConfig, ConnectorConfig } from './types';
+
+describe('ResultHandler', () => {
+  let resultHandler: ResultHandler;
+
+  let sdkMock: ConnectorSDKInterface<ConnectorConfig>;
+
+  beforeEach(() => {
+    sdkMock = {
+      logger: {
+        info: jest.fn(),
+        debug: jest.fn(),
+        error: jest.fn(),
+        verbose: jest.fn(),
+        warn: jest.fn(),
+      },
+      offsetStore: {
+        setOffset: jest.fn(),
+      },
+      config: {},
+      sender: {
+        documents: jest.fn().mockResolvedValue(true),
+        metricsLegacy: jest.fn().mockResolvedValue(true),
+      },
+    } as unknown as ConnectorSDKInterface<ConnectorConfig>;
+
+    resultHandler = new ResultHandler(sdkMock);
+  });
+
+  it('should be defined', () => {
+    expect(resultHandler).toBeDefined();
+  });
+
+  describe('handle batch data', () => {
+    const apiConfig = {
+      name: 'test-api',
+      listField: 'items',
+      incrementalField: 'updatedAt',
+      offsetFilePrefix: 'offset_test',
+      keyField: 'id',
+    } as ApiConfig;
+
+    const result = JSON.stringify({
+      items: [
+        { id: 1, updatedAt: '2024-01-01T00:00:00Z' },
+        { id: 2, updatedAt: '2024-01-02T00:00:00Z' },
+      ],
+    });
+
+    it('should send batch data and set offset', async () => {
+      await resultHandler.handleResult(result, apiConfig);
+
+      expect(sdkMock.sender.documents).toHaveBeenCalledWith(
+        [
+          { id: 1, updatedAt: '2024-01-01T00:00:00Z' },
+          { id: 2, updatedAt: '2024-01-02T00:00:00Z' },
+        ],
+        {
+          collection: 'api_test-api',
+          incrementalField: 'updatedAt',
+          keyField: 'id',
+        },
+      );
+
+      expect(sdkMock.offsetStore.setOffset).toHaveBeenCalledWith(
+        expect.objectContaining({
+          timestamp: new Date('2024-01-02T00:00:00Z').getTime(),
+        }),
+        'offset_test_test-api',
+      );
+    });
+
+    it('should send batch data as metrics', async () => {
+      await resultHandler.handleResult(result, {
+        ...apiConfig,
+        type: 'metric',
+      });
+
+      expect(sdkMock.sender.metricsLegacy).toHaveBeenCalledWith(
+        [
+          { id: 1, updatedAt: '2024-01-01T00:00:00Z' },
+          { id: 2, updatedAt: '2024-01-02T00:00:00Z' },
+        ],
+        {
+          collection: 'api_test-api',
+          incrementalField: 'updatedAt',
+          keyField: 'id',
+        },
+      );
+    });
+  });
+
+  describe('handle single record', () => {
+    const apiConfig = {
+      name: 'test-api',
+    } as ApiConfig;
+
+    const result = JSON.stringify({ id: 1, updatedAt: '2024-01-01T00:00:00Z' });
+
+    it('should send single record and set offset', async () => {
+      await resultHandler.handleResult(result, apiConfig);
+
+      expect(sdkMock.sender.documents).toHaveBeenCalledWith(
+        [{ id: 1, updatedAt: '2024-01-01T00:00:00Z' }],
+        {
+          collection: 'api_test-api',
+        },
+      );
+
+      expect(sdkMock.offsetStore.setOffset).toHaveBeenCalledWith(
+        expect.objectContaining({
+          timestamp: expect.any(Number),
+        }),
+        'offset_test-api',
+      );
+    });
+
+    it('should send single record as metric', async () => {
+      await resultHandler.handleResult(result, {
+        ...apiConfig,
+        type: 'metric',
+      });
+
+      expect(sdkMock.sender.metricsLegacy).toHaveBeenCalledWith(
+        [{ id: 1, updatedAt: '2024-01-01T00:00:00Z' }],
+        {
+          collection: 'api_test-api',
+        },
+      );
+    });
+  });
+});

package/src/lib/result.handler.ts

@@ -0,0 +1,100 @@
+import { ConnectorSDKInterface } from '@transai/connector-runtime-sdk';
+import { decode } from 'html-entities';
+
+import { ApiConfig, ConnectorConfig } from './types';
+
+export class ResultHandler {
+  readonly #sdk: ConnectorSDKInterface<ConnectorConfig>;
+
+  constructor(sdk: ConnectorSDKInterface<ConnectorConfig>) {
+    this.#sdk = sdk;
+  }
+
+  async handleResult(result: string, apiConfig: ApiConfig): Promise<void> {
+    const parsedContent = JSON.parse(decode(result));
+    const keys = Object.keys(parsedContent);
+    if (keys.length === 0) {
+      return;
+    }
+
+    if (apiConfig.listField) {
+      await this.#sendBatch(parsedContent, apiConfig);
+    } else {
+      await this.#sendSingleRecord(parsedContent, apiConfig);
+    }
+  }
+
+  async #sendBatch(
+    parsedContent: Record<string, Array<{ [key: string]: string }>>,
+    apiConfig: ApiConfig,
+  ): Promise<void> {
+    const list = parsedContent[apiConfig.listField ?? ''];
+    if (!(list && Array.isArray(list))) {
+      this.#sdk.logger.debug(
+        `[API] [${apiConfig.name}] No records found, skipping. ${JSON.stringify(list)}`,
+      );
+      return;
+    }
+
+    await this.#sendData(list, apiConfig);
+
+    const item = list[list.length - 1];
+    this.#sdk.offsetStore.setOffset(
+      {
+        timestamp: (apiConfig.incrementalField
+          ? new Date(item[apiConfig.incrementalField] as string)
+          : new Date()
+        ).getTime(),
+        id: 0,
+        rawTimestamp: 0,
+      },
+      `${apiConfig.offsetFilePrefix ?? 'offset'}_${apiConfig.name}`,
+    );
+  }
+
+  async #sendSingleRecord(
+    parsedContent: object,
+    apiConfig: ApiConfig,
+  ): Promise<void> {
+    const success = await this.#sendData([parsedContent], apiConfig);
+    if (!success) {
+      this.#sdk.logger.debug(
+        `[API] [${apiConfig.name}] Error while sending record to Kafka: `,
+        parsedContent,
+      );
+      return;
+    }
+
+    this.#sdk.offsetStore.setOffset(
+      {
+        timestamp: Date.now(),
+        id: 0,
+        rawTimestamp: 0,
+      },
+      `${apiConfig.offsetFilePrefix ?? 'offset'}_${apiConfig.name}`,
+    );
+  }
+
+  async #sendData(list: Array<object>, apiConfig: ApiConfig): Promise<boolean> {
+    const collection = `${this.#sdk.config.datasourceIdentifier ?? 'api'}_${apiConfig.name}`;
+    const metadata = {
+      ...(apiConfig.metadata ?? {}),
+      ...(apiConfig.incrementalField
+        ? { incrementalField: apiConfig.incrementalField }
+        : {}),
+      ...(apiConfig.keyField ? { keyField: apiConfig.keyField } : {}),
+      collection,
+    };
+
+    if (apiConfig.type === 'metric') {
+      return (
+        (await this.#sdk.sender.metricsLegacy(
+          list as Array<never>,
+          metadata,
+        )) === true
+      );
+    }
+
+    return (await this.#sdk.sender.documents(list, metadata)) === true;
+  }
+}

package/src/lib/types.ts

@@ -0,0 +1,38 @@
+import { HttpMethod } from '@transai/connector-runtime-sdk';
+import { BaseConnectorConfig } from '@xip-online-data/types';
+
+export interface HttpClientConfig {
+  method?: HttpMethod;
+  url?: string;
+}
+
+export interface HttpClientAuthConfig {
+  tokenUrl?: string;
+  clientId?: string;
+  clientSecret?: string;
+  authorization?: string;
+}
+
+export interface ApiConfig extends HttpClientConfig, HttpClientAuthConfig {
+  name: string;
+  interval: number;
+
+  body?: string;
+  batchSize?: number;
+  offsetFilePrefix?: string;
+  format?: string;
+  listField?: string;
+  keyField?: string;
+  incrementalField?: string;
+  type?: 'metric' | 'document';
+  metadata?: {
+    [key: string]: string;
+  };
+}
+
+export interface ConnectorConfig
+  extends BaseConnectorConfig,
+    HttpClientConfig,
+    HttpClientAuthConfig {
+  apiCalls?: Array<ApiConfig>;
+}

package/tsconfig.json

@@ -0,0 +1,22 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": {
+    "module": "commonjs",
+    "forceConsistentCasingInFileNames": true,
+    "strict": true,
+    "noImplicitOverride": true,
+    "noImplicitReturns": true,
+    "noFallthroughCasesInSwitch": true,
+    "noPropertyAccessFromIndexSignature": true
+  },
+  "files": [],
+  "include": [],
+  "references": [
+    {
+      "path": "./tsconfig.lib.json"
+    },
+    {
+      "path": "./tsconfig.spec.json"
+    }
+  ]
+}

package/tsconfig.lib.json

@@ -0,0 +1,10 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "outDir": "../../dist/out-tsc",
+    "declaration": true,
+    "types": ["node"]
+  },
+  "include": ["src/**/*.ts"],
+  "exclude": ["jest.config.ts", "src/**/*.spec.ts", "src/**/*.test.ts"]
+}

package/tsconfig.spec.json

@@ -0,0 +1,14 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "outDir": "../../dist/out-tsc",
+    "module": "commonjs",
+    "types": ["jest", "node"]
+  },
+  "include": [
+    "jest.config.ts",
+    "src/**/*.test.ts",
+    "src/**/*.spec.ts",
+    "src/**/*.d.ts"
+  ]
+}