@transai/connector-runner-microsoft-office365-email 0.1.0 → 0.2.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

@@ -1,8 +1,31 @@
+## 0.2.0 (2025-11-19)
+
+### 🚀 Features
+
+- **XODO-1133:** added file connector that uses the SDK ([#875](https://github.com/xip-online-applications/xod-core/pull/875))
+- **XODO-1125:** use delta link in Office365 connector ([#865](https://github.com/xip-online-applications/xod-core/pull/865))
+- ability to send statistics to logs for now ([#863](https://github.com/xip-online-applications/xod-core/pull/863))
+- let mail processor save attachments ([#836](https://github.com/xip-online-applications/xod-core/pull/836))
+- add method to fetch email attachments ([#833](https://github.com/xip-online-applications/xod-core/pull/833))
+
+### 🩹 Fixes
+
+- remove mailbox from collection ([64d58424](https://github.com/xip-online-applications/xod-core/commit/64d58424))
+- mail processor not sending correct format ([ecb008f7](https://github.com/xip-online-applications/xod-core/commit/ecb008f7))
+- interval starting ([f8e2ee14](https://github.com/xip-online-applications/xod-core/commit/f8e2ee14))
+
+### ❤️ Thank You
+
+- Copilot @Copilot
+- frankdikker
+- Rene Heijdens @H31nz3l
+- Youri Lefers @yourilefers
+
 # Changelog
 
 This file was generated using [@jscutlery/semver](https://github.com/jscutlery/semver).
 
-# 0.1.0 (2025-10-23)
+# 0.1.0 (2025-10-24)
 
 
 ### Features

package/jest.config.ts

@@ -0,0 +1,11 @@
+export default {
+  displayName: 'connector-runner-microsoft-office365-email',
+  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-microsoft-office365-email',
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@transai/connector-runner-microsoft-office365-email",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "type": "commonjs",
   "main": "./index.js",
   "typings": "./index.d.ts"

package/project.json

@@ -0,0 +1,45 @@
+{
+  "name": "connector-runner-microsoft-office365-email",
+  "$schema": "../../node_modules/nx/schemas/project-schema.json",
+  "sourceRoot": "libs/connector-runner-microsoft-office365-email/src",
+  "projectType": "library",
+  "tags": [
+    "connector:runner",
+    "connector:runner-sdk",
+    "connector:email",
+    "connector:source",
+    "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-microsoft-office365-email/jest.config.ts"
+      }
+    },
+    "version": {
+      "executor": "@jscutlery/semver:version",
+      "options": {
+        "postTargets": ["build", "deploy"]
+      }
+    },
+    "deploy": {
+      "executor": "ngx-deploy-npm:deploy",
+      "dependsOn": ["build"],
+      "options": {
+        "distFolderPath": "dist/connectors/connector-runner-microsoft-office365-email"
+      }
+    }
+  }
+}

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

@@ -0,0 +1,171 @@
+import { ConnectorSDKInterface } from '@transai/connector-runtime-sdk';
+import { MailClientInterface } from '@xip-online-data/microsoft-office365-mail-client';
+import { ActionInterface, XodBaseMessageType } from '@xip-online-data/types';
+
+import { ActionsHandler } from './actions-handler';
+
+describe('ActionsHandler', () => {
+  let handler: ActionsHandler;
+
+  let sdkMock: ConnectorSDKInterface;
+  let mailClientMock: MailClientInterface;
+
+  beforeEach(() => {
+    sdkMock = {
+      logger: {
+        info: jest.fn(),
+        debug: jest.fn(),
+        error: jest.fn(),
+      },
+      receiver: {
+        emitEventType: jest.fn().mockReturnValue(
+          jest.fn().mockReturnValue({
+            statusCode: 201,
+          }),
+        ),
+        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,
+            }),
+          ),
+        },
+        getActionConfig: jest.fn(),
+      },
+    } as unknown as ConnectorSDKInterface;
+
+    mailClientMock = {
+      reply: jest.fn(),
+      addCategory: jest.fn(),
+      removeCategory: jest.fn(),
+    } as unknown as MailClientInterface;
+
+    handler = new ActionsHandler(sdkMock, mailClientMock);
+  });
+
+  it('should be defined', () => {
+    expect(handler).toBeDefined();
+  });
+
+  describe('JOB actions', () => {
+    it('should handle JOB message without action config', async () => {
+      const jobMessage = {
+        type: 'JOB',
+        payload: {},
+      } as XodBaseMessageType;
+
+      (sdkMock.receiver.getActionConfig as jest.Mock).mockReturnValueOnce(
+        undefined,
+      );
+      const response = await handler.callbackFunctionChain(jobMessage);
+
+      expect(sdkMock.receiver.getActionConfig).toHaveBeenCalledWith(jobMessage);
+      expect(response.statusCode).toBe(400);
+    });
+
+    it('should handle JOB message that sends a reply', async () => {
+      const jobMessage = {
+        type: 'JOB',
+        payload: {},
+      } as XodBaseMessageType;
+      const action = {
+        identifier: 'action-1',
+        config: {
+          parsedTemplates: {
+            action: jest.fn().mockReturnValue('REPLY'),
+            params: jest
+              .fn()
+              .mockReturnValue(
+                '{ "messageId": "123", "from": "foo@example.com", "mailBody": "Test reply" }',
+              ),
+          },
+        },
+      } as unknown as ActionInterface;
+
+      (sdkMock.receiver.getActionConfig as jest.Mock).mockReturnValueOnce(
+        action,
+      );
+      const response = await handler.callbackFunctionChain(jobMessage);
+
+      expect(mailClientMock.reply).toHaveBeenCalledWith(
+        '123',
+        'foo@example.com',
+        'Test reply',
+        true,
+      );
+      expect(response.statusCode).toBe(201);
+    });
+
+    it('should handle JOB message that add a category', async () => {
+      const jobMessage = {
+        type: 'JOB',
+        payload: {},
+      } as XodBaseMessageType;
+      const action = {
+        identifier: 'action-1',
+        config: {
+          parsedTemplates: {
+            action: jest.fn().mockReturnValue('CATEGORY_ADD'),
+            params: jest
+              .fn()
+              .mockReturnValue(
+                '{ "messageId": "123", "category": "some-category" }',
+              ),
+          },
+        },
+      } as unknown as ActionInterface;
+
+      (sdkMock.receiver.getActionConfig as jest.Mock).mockReturnValueOnce(
+        action,
+      );
+      const response = await handler.callbackFunctionChain(jobMessage);
+
+      expect(mailClientMock.addCategory).toHaveBeenCalledWith(
+        '123',
+        'some-category',
+      );
+      expect(response.statusCode).toBe(201);
+    });
+
+    it('should handle JOB message that removes a category', async () => {
+      const jobMessage = {
+        type: 'JOB',
+        payload: {},
+      } as XodBaseMessageType;
+      const action = {
+        identifier: 'action-1',
+        config: {
+          parsedTemplates: {
+            action: jest.fn().mockReturnValue('CATEGORY_REMOVE'),
+            params: jest
+              .fn()
+              .mockReturnValue(
+                '{ "messageId": "123", "category": "some-category" }',
+              ),
+          },
+        },
+      } as unknown as ActionInterface;
+
+      (sdkMock.receiver.getActionConfig as jest.Mock).mockReturnValueOnce(
+        action,
+      );
+      const response = await handler.callbackFunctionChain(jobMessage);
+
+      expect(mailClientMock.removeCategory).toHaveBeenCalledWith(
+        '123',
+        'some-category',
+      );
+      expect(response.statusCode).toBe(201);
+    });
+  });
+});

package/src/lib/actions-handler.ts

@@ -0,0 +1,171 @@
+import {
+  CompileDelegate,
+  ConnectorSDKInterface,
+} from '@transai/connector-runtime-sdk';
+import { MailClientInterface } from '@xip-online-data/microsoft-office365-mail-client';
+import {
+  KafkaCallbackResponse,
+  XodActionType,
+  XodBaseMessageType,
+  XodJobType,
+} from '@xip-online-data/types';
+
+export class ActionsHandler {
+  readonly #connectorSDK: ConnectorSDKInterface;
+
+  readonly #mailClient: MailClientInterface;
+
+  constructor(
+    connectorSDK: ConnectorSDKInterface,
+    mailClient: MailClientInterface,
+  ) {
+    this.#connectorSDK = connectorSDK;
+    this.#mailClient = mailClient;
+  }
+
+  get callbackFunctionChain(): (
+    m: XodBaseMessageType,
+  ) => Promise<KafkaCallbackResponse> {
+    return this.#jobCallbackFunction(
+      this.#actionCallbackFunction(
+        this.#connectorSDK.receiver.emitEventType(
+          this.#connectorSDK.receiver.responses.created(),
+        ),
+      ),
+    );
+  }
+
+  #jobCallbackFunction(
+    callbackFunction: (
+      message: XodBaseMessageType,
+    ) => Promise<KafkaCallbackResponse>,
+  ) {
+    return async (m: XodBaseMessageType): Promise<KafkaCallbackResponse> => {
+      if (m.type !== 'JOB') {
+        return callbackFunction(m);
+      }
+
+      const message = m as XodJobType;
+      const action = this.#connectorSDK.receiver.getActionConfig(message);
+      if (!action) {
+        return this.#connectorSDK.receiver.responses.badRequest(
+          'Action configuration not found',
+        )(message);
+      }
+
+      try {
+        this.#connectorSDK.logger.debug(
+          `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();
+
+        if (message.testRun) {
+          this.#connectorSDK.logger.info(
+            `Test run for ${message.eventId} with payload ${parsedParams} to action ${parsedAction}`,
+          );
+          return callbackFunction(message);
+        }
+
+        this.#connectorSDK.logger.debug(
+          `Parsed action: ${parsedAction}, parameters: ${parsedParams}`,
+        );
+
+        const parsedParamsJson = JSON.parse(parsedParams);
+        this.#connectorSDK.logger.debug(
+          `Parsed params json: ${JSON.stringify(parsedParamsJson)}`,
+        );
+
+        switch (parsedAction) {
+          case 'REPLY':
+            await this.#mailClient.reply(
+              parsedParamsJson.messageId,
+              parsedParamsJson.from,
+              parsedParamsJson.mailBody,
+              true,
+            );
+            break;
+          case 'FORWARD':
+            // this.#mailClient.forward(parsedParams);
+            break;
+          case 'SEND':
+            // this.#mailClient.send(parsedParams);
+            break;
+          case 'CATEGORY_ADD':
+            await this.#mailClient.addCategory(
+              parsedParamsJson.messageId,
+              parsedParamsJson.category,
+            );
+            break;
+          case 'CATEGORY_REMOVE':
+            await this.#mailClient.removeCategory(
+              parsedParamsJson.messageId,
+              parsedParamsJson.category,
+            );
+            break;
+          default:
+            this.#connectorSDK.logger.error(
+              `Unknown action type: ${parsedAction} in message ${message.eventId}`,
+            );
+        }
+
+        return callbackFunction(message);
+      } catch (error: unknown) {
+        return this.#connectorSDK.receiver.responses.internalServerError(
+          error instanceof Error ? error.message : 'Unknown error occurred',
+        )(message);
+      }
+    };
+  }
+
+  #actionCallbackFunction(
+    callbackFunction: (
+      message: XodBaseMessageType,
+    ) => Promise<KafkaCallbackResponse>,
+  ) {
+    return async (m: XodBaseMessageType): Promise<KafkaCallbackResponse> => {
+      if (m.type !== 'ACTION') {
+        return callbackFunction(m);
+      }
+
+      const message = m as XodActionType;
+      try {
+        if (!message.payload.destination || !message.payload.content) {
+          return this.#connectorSDK.receiver.responses.badRequest(
+            'Destination or content not found',
+          )(message);
+        }
+
+        // her comes the action handling logic
+        const result = { success: true, data: 'Not implemented yet' };
+
+        if (result.success) {
+          return callbackFunction(message);
+        }
+
+        return this.#connectorSDK.receiver.responses.internalServerError(
+          result.data,
+        )(message);
+      } catch (error) {
+        return this.#connectorSDK.receiver.responses.internalServerError(
+          error instanceof Error ? error.message : 'Unknown error occurred',
+        )(message);
+      }
+    };
+  }
+}

package/src/lib/connector-runner-microsoft-office365-email.spec.ts

@@ -0,0 +1,82 @@
+import { ConnectorSDKInterface } from '@transai/connector-runtime-sdk';
+import { ConnectorInterface } from '@xip-online-data/types';
+
+import { ConnectorRunnerMicrosoftOffice365Email } from './connector-runner-microsoft-office365-email';
+import { MailProcessor } from './mail-processor';
+import { ConnectorConfig } from './types';
+
+describe('ConnectorRunnerMicrosoftOffice365Email', () => {
+  let connector: ConnectorRunnerMicrosoftOffice365Email;
+
+  let sdkMock: ConnectorSDKInterface;
+
+  beforeEach(() => {
+    sdkMock = {
+      logger: {
+        warn: jest.fn(),
+        info: jest.fn(),
+        debug: jest.fn(),
+        error: jest.fn(),
+      },
+      config: {
+        mailConfig: {
+          username: 'some-tenant',
+          tenantId: 'some-id',
+          clientId: 'some-client-id',
+          clientSecret: 'some-client-secret',
+        },
+        mailboxes: [
+          {
+            mailboxIdentifier: 'inbox-1',
+            mailbox: 'mailbox',
+          },
+        ],
+      } as ConnectorConfig,
+      receiver: {
+        emitEventType: jest.fn(),
+        responses: {
+          created: jest.fn(),
+        },
+        registerCallback: jest.fn(),
+      },
+      processing: {
+        registerInterval: jest.fn(),
+      },
+    } as unknown as ConnectorSDKInterface<ConnectorConfig>;
+
+    connector = new ConnectorRunnerMicrosoftOffice365Email(
+      {} as ConnectorInterface,
+      sdkMock,
+    );
+  });
+
+  it('should be defined', () => {
+    expect(connector).toBeDefined();
+  });
+
+  describe('start', () => {
+    it('should start the connector', async () => {
+      await expect(connector.start()).resolves.toBeUndefined();
+    });
+
+    it('should register interval for each mailbox', async () => {
+      await connector.init();
+
+      expect(sdkMock.processing.registerInterval).toHaveBeenCalledWith(
+        expect.any(Number),
+        expect.any(Object),
+        { immediate: true },
+      );
+    });
+
+    it('should build correct mail processor', async () => {
+      sdkMock.processing.registerInterval = jest
+        .fn()
+        .mockImplementation((interval, processor) => {
+          expect(processor).toBeInstanceOf(MailProcessor);
+        });
+
+      await connector.start();
+    });
+  });
+});

package/src/lib/connector-runner-microsoft-office365-email.ts

@@ -0,0 +1,53 @@
+import {
+  ConnectorRuntimeSDK,
+  ConnectorSDKInterface,
+} from '@transai/connector-runtime-sdk';
+import { MailClient } from '@xip-online-data/microsoft-office365-mail-client';
+import { ConnectorInterface } from '@xip-online-data/types';
+
+import { ActionsHandler } from './actions-handler';
+import { MailProcessor } from './mail-processor';
+import { ConnectorConfig } from './types';
+
+export class ConnectorRunnerMicrosoftOffice365Email extends ConnectorRuntimeSDK<ConnectorConfig> {
+  readonly #mailClient: MailClient;
+
+  readonly #actionsHandler: ActionsHandler;
+
+  constructor(
+    connector: ConnectorInterface,
+    connectorSDK: ConnectorSDKInterface,
+  ) {
+    super(connector, connectorSDK);
+
+    const { config } = this.connectorSDK;
+    this.#mailClient = new MailClient(config.mailConfig);
+
+    this.#actionsHandler = new ActionsHandler(
+      this.connectorSDK,
+      this.#mailClient,
+    );
+
+    this.callbackFunction = this.#actionsHandler.callbackFunctionChain;
+  }
+
+  override init = async (): Promise<void> => {
+    const { config } = this.connectorSDK;
+
+    await Promise.all(
+      config.mailboxes.map(async (mailSourceConfig) => {
+        const mailProcessor = new MailProcessor(
+          this.connectorSDK,
+          mailSourceConfig,
+          this.#mailClient,
+        );
+
+        await this.connectorSDK.processing.registerInterval(
+          mailSourceConfig.interval ?? mailProcessor.DEFAULT_INTERVAL_SECONDS,
+          mailProcessor,
+          { immediate: true },
+        );
+      }),
+    );
+  };
+}