@transai/connector-runner-file 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-1133:** added file connector that uses the SDK ([#875](https://github.com/xip-online-applications/xod-core/pull/875))
+- **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
+
+- Copilot @Copilot
+- Rene Heijdens @H31nz3l
+- Youri Lefers @yourilefers

package/README.md

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

package/jest.config.ts

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

package/package.json

@@ -0,0 +1,16 @@
+{
+  "name": "@transai/connector-runner-file",
+  "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,33 @@
+{
+  "name": "connector-runner-file",
+  "$schema": "../../node_modules/nx/schemas/project-schema.json",
+  "sourceRoot": "libs/connector-runner-file/src",
+  "projectType": "library",
+  "tags": [
+    "connector:runner",
+    "connector:runner-sdk",
+    "connector:file",
+    "connector:source",
+    "connector:sink",
+    "provider:@transai"
+  ],
+  "targets": {
+    "build": {
+      "executor": "@transai/tools:connector",
+      "outputs": ["{options.outputPath}"],
+      "options": {
+        "external": ["cpu-features", "ssh2"]
+      }
+    },
+    "lint": {
+      "executor": "@nx/eslint:lint"
+    },
+    "test": {
+      "executor": "@nx/jest:jest",
+      "outputs": ["{workspaceRoot}/coverage/{projectRoot}"],
+      "options": {
+        "jestConfig": "libs/connector-runner-file/jest.config.ts"
+      }
+    }
+  }
+}

package/src/index.ts

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

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

@@ -0,0 +1,121 @@
+import {
+  ConnectorSDKInterface,
+  FilesSDKInterface,
+} from '@transai/connector-runtime-sdk';
+import { ActionInterface, XodJobType } from '@xip-online-data/types';
+
+import { ActionsHandler } from './actions-handler';
+import { FileConfig } from './types';
+
+describe('FileActionsHandler', () => {
+  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<FileConfig>;
+  let fileHandlerMock: FilesSDKInterface;
+
+  beforeEach(() => {
+    fileHandlerMock = {
+      write: jest.fn(),
+    } as unknown as FilesSDKInterface;
+
+    handler = new ActionsHandler(sdkMock, fileHandlerMock);
+  });
+
+  afterEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it('should be defined', () => {
+    expect(handler).toBeDefined();
+  });
+
+  describe('JOB actions', () => {
+    const action = {
+      identifier: 'action-1',
+      version: '2.0',
+      config: {
+        parsedTemplates: {
+          filename: jest.fn().mockReturnValue('test-file.txt'),
+          contents: jest.fn().mockReturnValue('file contents here'),
+        },
+      },
+    } as unknown as ActionInterface;
+
+    const jobMessage = {
+      type: 'JOB',
+      actionIdentifier: 'action-1',
+      actionVersion: 'latest',
+      payload: { some: 'data' },
+    } as unknown as XodJobType;
+
+    it('should write file on action', async () => {
+      const response = await handler.callbackFunctionChain(jobMessage, action);
+
+      expect(fileHandlerMock.write).toHaveBeenCalledWith(
+        'test-file.txt',
+        'file contents here',
+      );
+      expect(response.statusCode).toBe(201);
+    });
+
+    it('should handle errors during file write', async () => {
+      fileHandlerMock.write = jest
+        .fn()
+        .mockRejectedValue(new Error('Write error'));
+
+      const response = await handler.callbackFunctionChain(jobMessage, action);
+
+      expect(response.statusCode).toBe(500);
+      expect(
+        sdkMock.receiver.responses.internalServerError,
+      ).toHaveBeenCalledWith('Write error');
+    });
+
+    it('should handle test run without writing file', async () => {
+      const testRunMessage = {
+        ...jobMessage,
+        testRun: true,
+      } as XodJobType;
+
+      const response = await handler.callbackFunctionChain(
+        testRunMessage,
+        action,
+      );
+
+      expect(fileHandlerMock.write).not.toHaveBeenCalled();
+      expect(response.statusCode).toBe(201);
+    });
+  });
+});

package/src/lib/actions-handler.ts

@@ -0,0 +1,82 @@
+import {
+  CompileDelegate,
+  ConnectorSDKInterface,
+  FilesSDKInterface,
+} from '@transai/connector-runtime-sdk';
+import {
+  ActionInterface,
+  KafkaCallbackResponse,
+  XodJobType,
+} from '@xip-online-data/types';
+
+export class ActionsHandler {
+  readonly #connectorSDK: ConnectorSDKInterface;
+
+  readonly #fileHandler: FilesSDKInterface;
+
+  constructor(
+    connectorSDK: ConnectorSDKInterface,
+    fileHandler: FilesSDKInterface,
+  ) {
+    this.#connectorSDK = connectorSDK;
+    this.#fileHandler = fileHandler;
+  }
+
+  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> => {
+      this.#connectorSDK.logger.debug(
+        `Apply templates on payload: ${JSON.stringify(message.payload)}, action: ${JSON.stringify(action)}`,
+      );
+
+      const handleBars = action.config['parsedTemplates'] as {
+        filename: CompileDelegate;
+        contents: CompileDelegate;
+      };
+
+      try {
+        const parsedFilename = handleBars
+          .filename({
+            inputs: message.payload,
+          })
+          .trim();
+
+        const parsedContent = handleBars
+          .contents({
+            inputs: message.payload,
+          })
+          .trim();
+
+        if (message.testRun) {
+          this.#connectorSDK.logger.debug(
+            `Test run for ${message.eventId} with parsedContent ${parsedContent}, parsedFilename ${parsedFilename}`,
+          );
+          return callbackFunction(message);
+        }
+
+        await this.#fileHandler.write(parsedFilename, parsedContent);
+      } catch (error) {
+        return this.#connectorSDK.receiver.responses.internalServerError(
+          error instanceof Error ? error.message : 'Unknown error occurred',
+        )(message);
+      }
+
+      return callbackFunction(message);
+    };
+  }
+}

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

@@ -0,0 +1,73 @@
+import {
+  ConnectorSDKInterface,
+  FilesSDKInterface,
+} from '@transai/connector-runtime-sdk';
+import { ConnectorInterface } from '@xip-online-data/types';
+
+import { ConnectorRunnerFile } from './connector-runner-file';
+import { Processor } from './processor';
+import { FileConfig } from './types';
+
+jest.mock('./processor');
+
+describe('ConnectorRunnerFile', () => {
+  let runner: ConnectorRunnerFile;
+
+  let sdkMock: ConnectorSDKInterface<FileConfig>;
+  const processorMock = {} as unknown as Processor;
+
+  beforeEach(() => {
+    (Processor as unknown as jest.Mock).mockImplementation(() => processorMock);
+
+    sdkMock = {
+      logger: {
+        warn: jest.fn(),
+        info: jest.fn(),
+        debug: jest.fn(),
+        error: jest.fn(),
+      },
+      config: {
+        dsn: 'dummy://path/to/files',
+        fileSelectors: [{ selector: 'some-file-.+' }],
+      },
+      receiver: {
+        emitEventType: jest.fn(),
+        responses: {
+          created: jest.fn(),
+        },
+        registerCallback: jest.fn(),
+      },
+      processing: {
+        registerInterval: jest.fn(),
+      },
+      files: jest.fn().mockReturnValue({
+        pathAsDsn: (path: string) => `dummy:${path}`,
+      }),
+    } as unknown as ConnectorSDKInterface<FileConfig>;
+
+    runner = new ConnectorRunnerFile({} as ConnectorInterface, sdkMock);
+  });
+
+  it('should be defined', () => {
+    expect(runner).toBeDefined();
+  });
+
+  it('should initialize file selector processes', async () => {
+    (Processor as unknown as jest.Mock).mockImplementation(
+      (sdk, fileSelector, fileHandler: FilesSDKInterface) => {
+        expect(sdk).toBe(sdkMock);
+        expect(fileSelector).toEqual({ selector: 'some-file-.+' });
+        expect(fileHandler.pathAsDsn('/')).toEqual('dummy:/');
+
+        return processorMock;
+      },
+    );
+
+    await runner.init();
+
+    expect(sdkMock.processing.registerInterval).toHaveBeenCalledWith(
+      60,
+      processorMock,
+    );
+  });
+});

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

@@ -0,0 +1,50 @@
+import {
+  ConnectorRuntimeSDK,
+  ConnectorSDKInterface,
+  FilesSDKInterface,
+} from '@transai/connector-runtime-sdk';
+import { ConnectorInterface } from '@xip-online-data/types';
+
+import { ActionsHandler } from './actions-handler';
+import { Processor } from './processor';
+import { FileConfig } from './types';
+
+export class ConnectorRunnerFile extends ConnectorRuntimeSDK<FileConfig> {
+  readonly #fileHandler: FilesSDKInterface;
+
+  constructor(
+    connector: ConnectorInterface,
+    connectorSDK: ConnectorSDKInterface,
+  ) {
+    super(connector, connectorSDK);
+
+    const { config } = this.connectorSDK;
+    this.#fileHandler = this.connectorSDK.files(config.dsn);
+
+    const actionsHandler = new ActionsHandler(
+      this.connectorSDK,
+      this.#fileHandler,
+    );
+
+    this.callbackFunction = actionsHandler.callbackFunctionChain;
+  }
+
+  override init = async (): Promise<void> => {
+    const { config } = this.connectorSDK;
+
+    await Promise.all(
+      (config.fileSelectors ?? []).map(async (fileSelector) => {
+        const processor = new Processor(
+          this.connectorSDK,
+          fileSelector,
+          this.#fileHandler,
+        );
+
+        await this.connectorSDK.processing.registerInterval(
+          fileSelector.intervalSeconds ?? Processor.DEFAULT_INTERVAL_SECONDS,
+          processor,
+        );
+      }),
+    );
+  };
+}

package/src/lib/processor.spec.ts

@@ -0,0 +1,119 @@
+import {
+  ConnectorSDKInterface,
+  FilesSDKInterface,
+} from '@transai/connector-runtime-sdk';
+// eslint-disable-next-line @nx/enforce-module-boundaries
+import { FileHandler } from '@xip-online-data/file-handler';
+
+import { Processor } from './processor';
+import { FileConfig } from './types';
+
+jest.mock('@xip-online-data/file-handler');
+
+describe('FileProcessor', () => {
+  let processor: Processor;
+
+  const sourceDsn = 'dummy://source/path';
+  const destinationDsn = 'dummy://destination/path';
+
+  const readFile = {
+    get: jest.fn().mockReturnValue(Buffer.from('some-string')),
+    close: jest.fn().mockReturnValue(true),
+  };
+  const parsedFile = { foo: 'bar' };
+
+  const fileHandlerMock = {
+    list: jest.fn().mockResolvedValue([
+      { type: 'FILE', name: 'test-file-001.csv' },
+      { type: 'FILE', name: 'other-file.txt' },
+      { type: 'DIRECTORY', name: 'some-dir' },
+    ]),
+    read: jest.fn().mockResolvedValue(readFile),
+    delete: jest.fn(),
+  } as unknown as FilesSDKInterface;
+  const destinationFileHandlerMock = {
+    write: jest.fn(),
+    pathAsDsn: jest.fn(),
+  } as unknown as FilesSDKInterface;
+  const fileReaderMock = {
+    handleBuffer: jest.fn().mockResolvedValue(parsedFile),
+  } as unknown as FileHandler;
+
+  const sdkMock = {
+    logger: {
+      warn: jest.fn(),
+      info: jest.fn(),
+      debug: jest.fn(),
+      error: jest.fn(),
+      verbose: jest.fn(),
+    },
+    config: {
+      dsn: sourceDsn,
+    },
+    telemetry: {
+      increment: jest.fn(),
+    },
+    sender: {
+      documents: jest.fn(),
+    },
+    files: jest.fn().mockImplementation(() => destinationFileHandlerMock),
+  } as unknown as ConnectorSDKInterface<FileConfig>;
+
+  beforeEach(() => {
+    (FileHandler as unknown as jest.Mock).mockImplementation(
+      () => fileReaderMock,
+    );
+
+    processor = new Processor(
+      sdkMock,
+      {
+        selector: 'test-file-.+\\.csv',
+        delimiter: ',',
+        action: 'move',
+        destinationDsn,
+      },
+      fileHandlerMock,
+    );
+  });
+
+  it('should be defined', () => {
+    expect(processor).toBeDefined();
+  });
+
+  it('should give the correct name', () => {
+    expect(processor.name).toBe('file-processor-test-file-.+\\.csv');
+  });
+
+  it('should process files correctly', async () => {
+    await processor.onRun();
+
+    expect(fileHandlerMock.read).toHaveBeenCalledWith('/test-file-001.csv');
+    expect(fileReaderMock.handleBuffer).toHaveBeenCalledWith(
+      '/test-file-001.csv',
+      readFile.get(),
+      [],
+      undefined,
+    );
+    expect(sdkMock.sender.documents).toHaveBeenCalledWith(
+      [
+        {
+          foo: 'bar',
+          _filename: 'test-file-001.csv',
+        },
+      ],
+      {
+        keyField: '_filename',
+        collection: 'file_test-file-.+\\.csv',
+      },
+    );
+    expect(destinationFileHandlerMock.write).toHaveBeenCalledWith(
+      'test-file-001.csv',
+      readFile,
+    );
+    expect(fileHandlerMock.delete).toHaveBeenCalledWith('/test-file-001.csv');
+    expect(sdkMock.telemetry.increment).toHaveBeenCalledWith(
+      'files.processed.count',
+      1,
+    );
+  });
+});

package/src/lib/processor.ts

@@ -0,0 +1,186 @@
+import path from 'path';
+
+import {
+  ConnectorSDKInterface,
+  FileHandleInterface,
+  FileInfo,
+  FilesSDKInterface,
+  IntervalHandler,
+} from '@transai/connector-runtime-sdk';
+// eslint-disable-next-line @nx/enforce-module-boundaries
+import { FileHandler, ParsedFile } from '@xip-online-data/file-handler';
+
+import { FileConfig, FileSelectorConfig } from './types';
+
+export class Processor implements IntervalHandler {
+  static readonly DEFAULT_INTERVAL_SECONDS = 60;
+
+  readonly #connectorSDK: ConnectorSDKInterface<FileConfig>;
+
+  readonly #fileSelector: FileSelectorConfig;
+
+  readonly #fileHandler: FilesSDKInterface;
+
+  readonly #destinationFileHandler?: FilesSDKInterface;
+
+  readonly #fileReader: FileHandler;
+
+  readonly #fileSelectionRegex: RegExp;
+
+  constructor(
+    connectorSDK: ConnectorSDKInterface<FileConfig>,
+    fileSelector: FileSelectorConfig,
+    fileHandler: FilesSDKInterface,
+  ) {
+    this.#connectorSDK = connectorSDK;
+    this.#fileSelector = fileSelector;
+    this.#fileHandler = fileHandler;
+    this.#fileReader = new FileHandler(fileSelector.delimiter);
+
+    const { selector } = this.#fileSelector;
+    // eslint-disable-next-line security/detect-non-literal-regexp
+    this.#fileSelectionRegex = new RegExp(
+      typeof selector !== 'string' ? selector.pattern : selector,
+      typeof selector !== 'string' && selector.flags ? selector.flags : 'i',
+    );
+
+    if (this.#fileSelector.destinationDsn) {
+      this.#destinationFileHandler = this.#connectorSDK.files(
+        this.#fileSelector.destinationDsn,
+      );
+    } else if (this.#fileSelector.action === 'move') {
+      throw new Error(
+        `Destination DSN must be provided for 'move' action in file selector: ${this.name}`,
+      );
+    }
+  }
+
+  get name(): string {
+    const { selector } = this.#fileSelector;
+    return `file-processor-${typeof selector === 'string' ? selector : selector.pattern}`;
+  }
+
+  async onRun(): Promise<void> {
+    const processedFiles = await this.#listDirectory();
+    this.#connectorSDK.telemetry.increment(
+      'files.processed.count',
+      processedFiles,
+    );
+  }
+
+  async #listDirectory(dirPath = '/'): Promise<number> {
+    const contents = await this.#fileHandler.list(dirPath);
+    const numberOfProcessedFilesList = await Promise.all(
+      contents.map(async (fileInfo): Promise<number> => {
+        if (fileInfo.type === 'FILE') {
+          const processed = await this.#processFile(fileInfo, dirPath);
+          return processed ? 1 : 0;
+        }
+
+        if (this.#fileSelector.recursive === true) {
+          return this.#listDirectory(path.join(dirPath, fileInfo.name));
+        }
+
+        return Promise.resolve(0);
+      }),
+    );
+
+    return numberOfProcessedFilesList.reduce((acc, curr) => acc + curr, 0);
+  }
+
+  async #processFile(fileInfo: FileInfo, dirPath: string): Promise<boolean> {
+    const filePath = path.join(dirPath, fileInfo.name);
+    if (!this.#fileSelectionRegex.test(fileInfo.name)) {
+      this.#connectorSDK.logger.verbose(
+        `Skipping file at path: ${filePath} as it does not match selector regex`,
+      );
+      return false;
+    }
+
+    this.#connectorSDK.logger.debug(`Processing file at path: ${filePath}`);
+    let fileContent: FileHandleInterface | undefined;
+    let parsedContent: ParsedFile | undefined;
+
+    try {
+      fileContent = await this.#fileHandler.read(filePath);
+
+      // Parse file to JSON using FileHandler based on file type
+      parsedContent = await this.#fileReader.handleBuffer(
+        filePath,
+        fileContent.get(),
+        this.#fileSelector.optionalHeaders ?? [],
+        this.#fileSelector.optionalSettings,
+      );
+
+      if (!parsedContent) {
+        this.#connectorSDK.logger.info(
+          `Failed to parse file at path: ${filePath}`,
+        );
+        fileContent.close();
+        return false;
+      }
+
+      this.#connectorSDK.logger.debug(
+        `Parsed file successfully at path: ${filePath}`,
+      );
+    } catch (error) {
+      this.#connectorSDK.logger.error(
+        `Error parsing file at path: ${filePath}, error: ${error}`,
+      );
+      fileContent?.close();
+      return false;
+    }
+
+    try {
+      const data = [
+        {
+          ...parsedContent,
+          _filename: FileHandler.getFileName(filePath) ?? fileInfo.name,
+        } as object,
+      ];
+      const metadata = {
+        keyField: '_filename',
+        collection: `${this.#connectorSDK.config.datasourceIdentifier ?? 'file'}_${this.#fileSelector.identifier ?? this.#fileSelectionRegex.source}`,
+      };
+
+      if (this.#fileSelector.type === 'metric') {
+        await this.#connectorSDK.sender.metricsLegacy(
+          data as Array<never>,
+          metadata,
+        );
+      } else {
+        await this.#connectorSDK.sender.documents(data, metadata);
+      }
+    } catch (error) {
+      this.#connectorSDK.logger.error(
+        `Error sending parsed file from path: ${filePath}, error: ${error}`,
+      );
+      fileContent?.close();
+      return false;
+    }
+
+    try {
+      // eslint-disable-next-line default-case
+      switch (this.#fileSelector.action) {
+        case 'move':
+          await this.#destinationFileHandler?.write(fileInfo.name, fileContent);
+          await this.#fileHandler.delete(filePath);
+          this.#connectorSDK.logger.debug(
+            `"Moved" file at path: ${filePath} to ${this.#destinationFileHandler?.pathAsDsn(fileInfo.name)} after processing`,
+          );
+          break;
+
+        case 'delete':
+          await this.#fileHandler.delete(filePath);
+          this.#connectorSDK.logger.debug(
+            `Deleted file at path: ${filePath} after processing`,
+          );
+          break;
+      }
+    } finally {
+      fileContent?.close();
+    }
+
+    return true;
+  }
+}

package/src/lib/types.ts

@@ -0,0 +1,51 @@
+import { BaseConnectorConfig } from '@xip-online-data/types';
+
+export interface FileSelectorConfig {
+  /**
+   * A regex pattern or string to select matching files. If the identifier is not
+   * provided, the selector string itself will be used as the identifier.
+   */
+  selector:
+    | {
+        pattern: string;
+        flags?: string;
+      }
+    | string;
+
+  /**
+   * The action to take on the file after processing. 'move' to move the file to
+   * a different DSN (requires destinationDsn), 'delete' to delete the file, or
+   * 'nothing' to leave the file as is (default).
+   */
+  action?: 'move' | 'delete' | 'nothing';
+
+  /**
+   * If the action is 'move', the destination DSN where the file should be moved.
+   */
+  destinationDsn?: string;
+
+  /**
+   * An optional identifier for the file selector, used for the collection.
+   */
+  identifier?: string;
+
+  intervalSeconds?: number;
+
+  /**
+   * Look for files recursively in subdirectories.
+   */
+  recursive?: boolean;
+
+  delimiter?: string;
+  optionalHeaders?: Array<string>;
+  optionalSettings?: {
+    [key: string]: unknown;
+  };
+
+  type?: 'metric' | 'document';
+}
+
+export interface FileConfig extends BaseConnectorConfig {
+  dsn: string;
+  fileSelectors?: Array<FileSelectorConfig>;
+}

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"
+  ]
+}