@hahnpro/flow-sdk 2025.2.0-beta.1 → 2025.2.0-beta.3

package/test/input-stream.decorator.spec.ts

@@ -1,379 +0,0 @@
-import { setTimeout } from 'timers/promises';
-
-import { jetstreamManager } from '@nats-io/jetstream';
-import { connect } from '@nats-io/transport-node';
-
-import { FlowApplication, FlowEvent, FlowFunction, FlowModule, FlowResource, FlowTask, InputStream } from '../src';
-import { loggerMock } from './mocks/logger.mock';
-import { NatsConnectionMock } from './mocks/nats-connection.mock';
-
-describe('InputStreamDecorator', () => {
-  let flowApp: FlowApplication;
-  let natsConnectionMock: NatsConnectionMock;
-
-  beforeEach(() => {
-    natsConnectionMock = new NatsConnectionMock();
-  });
-
-  afterEach(async () => {
-    if (flowApp) {
-      await flowApp.destroy(0);
-    }
-    await natsConnectionMock.close();
-    jest.resetAllMocks();
-    jest.clearAllMocks();
-  });
-
-  test('FLOW.ISD.1 should return input event data', async () => {
-    const testRes = new TestResource({ id: 'test' });
-    const result = await testRes.onDefaultRessource(new FlowEvent({ id: '1' }, { test1: 'data', test2: 'otherData' }));
-
-    const data = result.getData();
-    expect(data.test1).toBeDefined();
-    expect(data.test2).toBeDefined();
-    expect(data.hello).toBeDefined();
-  }, 60000);
-
-  test('FLOW.ISD.2 should not return input event data if stopPropagation is set', async () => {
-    const testRes = new TestResourceNoProp({ id: 'test' });
-    const result = await testRes.onDefaultNoProp(new FlowEvent({ id: '1' }, { test1: 'data' }));
-
-    const data = result.getData();
-    expect(data.test1).toBeUndefined();
-    expect(data.hello).toBeDefined();
-  }, 60000);
-
-  test('FLOW.ISD.3 should overwrite input event data', async () => {
-    const testRes = new TestResource({ id: 'test' });
-    const result = await testRes.onDefaultRessource(new FlowEvent({ id: '1' }, { test1: 'data', hello: 'otherData' }));
-
-    const data = result.getData();
-
-    expect(data.test1).toBeDefined();
-    expect(data.hello).toBeDefined();
-    expect(data.hello).toEqual('world');
-  }, 60000);
-
-  test('FLOW.ISD.4 should return input event data in a flow', (done) => {
-    const flow = {
-      elements: [
-        { id: 'testTrigger', module: 'test-module', functionFqn: 'test.resource.TestResource' },
-        { id: 'testResource', module: 'test-module', functionFqn: 'test.resource.TestResource' },
-      ],
-      connections: [{ id: 'testConnection1', source: 'testTrigger', target: 'testResource' }],
-    };
-    flowApp = new FlowApplication([TestModule], flow, { skipApi: true, logger: loggerMock });
-    flowApp.subscribe('testResource.default', {
-      next: (event: FlowEvent) => {
-        const data = event.getData();
-        expect(data.test1).toBeDefined();
-        expect(data.test2).toBeDefined();
-        expect(data.hello).toBeDefined();
-
-        done();
-      },
-    });
-    flowApp.emit(new FlowEvent({ id: 'testTrigger' }, { test1: 'data', test2: 'otherData' }));
-  }, 60000);
-
-  test('FLOW.ISD.5 should only log partial events', async () => {
-    const flow = {
-      context: {
-        deploymentId: 'test',
-      },
-      elements: [
-        { id: 'testTrigger', module: 'test-module', functionFqn: 'test.resource.TestResource' },
-        { id: 'testResource', module: 'test-module', functionFqn: 'test.resource.TestResource' },
-      ],
-      connections: [{ id: 'testConnection1', source: 'testTrigger', target: 'testResource' }],
-    };
-
-    const publish = jest.fn();
-    const amqpConnection: any = {
-      managedConnection: {
-        createChannel: () => ({
-          assertExchange: jest.fn(),
-          waitForConnect: jest.fn(),
-          consume: jest.fn(),
-          publish,
-        }),
-        close: async () => {},
-      },
-    };
-
-    flowApp = new FlowApplication([TestModule], flow, loggerMock, amqpConnection, natsConnectionMock as any, true, true);
-    const spy = jest.spyOn(flowApp, 'publishNatsEventFlowlogs');
-    await flowApp.init();
-    expect(flowApp.natsConnection).toBeDefined();
-
-    const done = new Promise<void>((resolve, reject) => {
-      flowApp.subscribe('testResource.default', {
-        next: async (event: FlowEvent) => {
-          try {
-            await setTimeout(1000);
-            expect(spy.mock.calls[0][0].getData()).toEqual({ test1: 'data' });
-            expect(spy.mock.calls[1][0].getData()).toEqual({ hello: 'world' });
-            resolve();
-          } catch (error) {
-            reject(error);
-          }
-        },
-      });
-    });
-    flowApp.emit(new FlowEvent({ id: 'testTrigger' }, { test1: 'data' }));
-    return done;
-  });
-
-  test('FLOW.ISD.6 stopPropagation should work in a mixed flow', (done) => {
-    const flow = {
-      elements: [
-        { id: 'testTrigger', module: 'test-module', functionFqn: 'test.resource.TestResource' },
-        { id: 'testTask1', module: 'test-module', functionFqn: 'test.task.task1' },
-        { id: 'testTask2', module: 'test-module', functionFqn: 'test.task.task2' },
-        { id: 'testRessource', module: 'test-module', functionFqn: 'test.resource.TestResource' },
-      ],
-      connections: [
-        { id: 'c1', source: 'testTrigger', target: 'testTask1' },
-        { id: 'c2', source: 'testTask1', target: 'testTask2' },
-        { id: 'c3', source: 'testTask2', target: 'testRessource' },
-      ],
-    };
-    flowApp = new FlowApplication([TestModule], flow, { skipApi: true, logger: loggerMock });
-    flowApp.subscribe('testTask1.default', {
-      next: (event: FlowEvent) => {
-        expect(event.getData()).toEqual({ input: 'data', task1: 'test' });
-      },
-    });
-    flowApp.subscribe('testTask2.default', {
-      next: (event: FlowEvent) => {
-        expect(event.getData()).toEqual({ task2: 'test' });
-      },
-    });
-    flowApp.subscribe('testRessource.default', {
-      next: (event: FlowEvent) => {
-        expect(event.getData()).toEqual({ task2: 'test', hello: 'world' });
-        done();
-      },
-    });
-    flowApp.emit(new FlowEvent({ id: 'testTrigger' }, { input: 'data' }));
-  }, 20000);
-
-  test('FLOW.ISD.7 stopPropagation should work in a mixed function', async () => {
-    const testRes = new TestResource({ id: 'test' });
-
-    let result = await testRes.onDefaultRessource(new FlowEvent({ id: '1' }, { baz: 42 }));
-    expect(result.getData()).toEqual({ baz: 42, hello: 'world' });
-
-    result = await testRes.onNotDefault(new FlowEvent({ id: '2' }, { baz: 42 }));
-    expect(result.getData()).toEqual({ foo: 'bar' });
-  });
-
-  test('FLOW.ISD.8 event propagation should work for parallel events', (done) => {
-    const task = new LongRunningTask({ id: 'test' });
-
-    task.onB(new FlowEvent({ id: '2' }, { input: 'b' })).then((r) => {
-      expect(r.getData()).toEqual({ input: 'b', output: 'b' });
-      done();
-    });
-
-    task.onA(new FlowEvent({ id: '1' }, { input: 'a' })).then((r) => {
-      expect(r.getData()).toEqual({ input: 'a', output: 'a' });
-    });
-  });
-
-  test('FLOW.ISD.9 arrow functions should work', async () => {
-    const task = new Arrow({ id: 'test' });
-    const result = await task.onDefault(new FlowEvent({ id: '2' }, { x: 23, y: 19 }));
-    expect(result.getData()).toEqual({ x: 23, y: 19, z: 42 });
-  });
-
-  test('FLOW.ISD.10 test single function with multiple streams with different configs', (done) => {
-    const flow = {
-      elements: [
-        { id: 'testTrigger', module: 'test-module', functionFqn: 'test.resource.TestResource' },
-        { id: 'testTask1', module: 'test-module', functionFqn: 'test.task.multi' },
-      ],
-      connections: [
-        { id: 'c1', source: 'testTrigger', target: 'testTask1', targetStream: 'default' },
-        { id: 'c2', source: 'testTrigger', target: 'testTask1', targetStream: 'other' },
-      ],
-    };
-    flowApp = new FlowApplication([TestModule], flow, { skipApi: true, logger: loggerMock });
-
-    let bothDone = false;
-    flowApp.subscribe('testTask1.default', {
-      next: (event: FlowEvent) => {
-        const data = event.getData();
-        expect(data.default).toEqual('test');
-        expect(data.input).toBeUndefined();
-        if (bothDone) {
-          done();
-        } else {
-          bothDone = true;
-        }
-      },
-    });
-    flowApp.subscribe('testTask1.other', {
-      next: (event: FlowEvent) => {
-        const data = event.getData();
-        expect(data.input).toEqual('data');
-        expect(data.other).toEqual('test');
-        if (bothDone) {
-          done();
-        } else {
-          bothDone = true;
-        }
-      },
-    });
-
-    flowApp.emit(new FlowEvent({ id: 'testTrigger' }, { input: 'data' }));
-  });
-
-  test('FLOW.ISD.11 stateful function should update state correctly', async () => {
-    const stateful = new Stateful({ id: 'stateful' });
-
-    expect(stateful.prop).toEqual(0);
-    await stateful.onDefault(new FlowEvent({ id: 'test1' }, {}));
-    expect(stateful.prop).toEqual(1);
-    await stateful.onDefault(new FlowEvent({ id: 'test2' }, {}));
-    expect(stateful.prop).toEqual(2);
-  });
-
-  test('FLOW.ISD.12 stateful function should work in flow', (done) => {
-    const flow = {
-      elements: [
-        { id: 'testTrigger', module: 'test-module', functionFqn: 'test.resource.TestResource' },
-        { id: 'stateful', module: 'test-module', functionFqn: 'test.task.stateful' },
-      ],
-      connections: [{ id: 'c1', source: 'testTrigger', target: 'stateful' }],
-    };
-    flowApp = new FlowApplication([TestModule], flow, { skipApi: true, logger: loggerMock });
-
-    let count = 0;
-    flowApp.subscribe('stateful.default', {
-      next: (event: FlowEvent) => {
-        const data = event.getData();
-        expect(data.prop).toEqual(count++);
-
-        if (count === 3) {
-          done();
-        }
-      },
-    });
-
-    flowApp.emit(new FlowEvent({ id: 'testTrigger' }, {}));
-
-    setTimeout(100).then(() => {
-      flowApp.emit(new FlowEvent({ id: 'testTrigger' }, {}));
-      // no waiting...
-      flowApp.emit(new FlowEvent({ id: 'testTrigger' }, {}));
-    });
-  });
-
-  test('FLOW.ISD.13 deprecated should still work as expected', () => {
-    const deprecated = new Deprecated({ id: 'dep' });
-    const event1 = deprecated.onDefault(new FlowEvent({ id: 'test' }, { test: 42 }));
-
-    expect(event1.getData()).toEqual({ hello: 'world' });
-  });
-});
-
-@FlowFunction('test.resource.TestResource')
-class TestResource extends FlowResource {
-  @InputStream('default')
-  public async onDefaultRessource(event: FlowEvent) {
-    return this.emitEvent({ hello: 'world' }, event);
-  }
-
-  @InputStream('notdefault', { stopPropagation: true })
-  public async onNotDefault(event: FlowEvent) {
-    return this.emitEvent({ foo: 'bar' }, event);
-  }
-}
-
-@FlowFunction('test.resource.LongRunningTask')
-class LongRunningTask extends FlowTask {
-  @InputStream('a')
-  public async onA(event: FlowEvent) {
-    return this.emitEvent({ output: 'a' }, event);
-  }
-
-  @InputStream('b')
-  public async onB(event: FlowEvent) {
-    await setTimeout(100);
-    return this.emitEvent({ output: 'b' }, event);
-  }
-}
-
-@FlowFunction('test.task.arrow')
-class Arrow extends FlowTask {
-  @InputStream()
-  public async onDefault(event: FlowEvent) {
-    const data = event.getData();
-    return this.calcSomething(data.x, data.y, event);
-  }
-
-  private calcSomething = (x = 0, y = 0, event) => this.emitEvent({ z: x + y }, event);
-}
-
-@FlowFunction('test.resource.TestResourceNoProp')
-class TestResourceNoProp extends FlowResource {
-  @InputStream('default', { stopPropagation: true })
-  public async onDefaultNoProp(event: FlowEvent) {
-    return this.emitEvent({ hello: 'world' }, event);
-  }
-}
-
-@FlowFunction('test.task.task1')
-class TestTask1 extends FlowTask {
-  @InputStream('default')
-  public async onDefaultTask1(event: FlowEvent) {
-    return this.emitEvent({ task1: 'test' }, event);
-  }
-}
-
-@FlowFunction('test.task.task2')
-class TestTask2 extends FlowTask {
-  @InputStream('default', { stopPropagation: true })
-  public async onDefaultTask2(event: FlowEvent) {
-    return this.emitEvent({ task2: 'test' }, event);
-  }
-}
-
-@FlowFunction('test.task.multi')
-class MultiStream extends FlowTask {
-  @InputStream('default', { stopPropagation: true })
-  public async onDefault(event: FlowEvent) {
-    return this.emitEvent({ default: 'test' }, event, 'default');
-  }
-
-  @InputStream('other')
-  public async onOther(event: FlowEvent) {
-    return this.emitEvent({ other: 'test' }, event, 'other');
-  }
-}
-
-@FlowFunction('test.task.stateful')
-class Stateful extends FlowTask {
-  public prop = 0;
-
-  @InputStream('default')
-  public async onDefault(event: FlowEvent) {
-    await setTimeout(200);
-    return this.emitEvent({ prop: this.prop++ }, event);
-  }
-}
-
-@FlowFunction('test.task.use-deprecated')
-class Deprecated extends FlowTask {
-  @InputStream()
-  public onDefault(event: FlowEvent) {
-    return this.emitOutput({ hello: 'world' });
-  }
-}
-
-@FlowModule({
-  name: 'test-module',
-  declarations: [TestResource, TestResourceNoProp, TestTask1, TestTask2, MultiStream, Stateful],
-})
-class TestModule {}

package/test/long-rpc.test.py

@@ -1,14 +0,0 @@
-import sys
-from time import sleep
-
-sys.path.append(sys.argv[1])
-from rpc_server import RemoteProcedure, start_consumer
-
-
-@RemoteProcedure
-def testA():
-    sleep(200)
-    return "test"
-
-
-start_consumer(sys.argv[2])

package/test/long-running-rpc.spec.ts

@@ -1,60 +0,0 @@
-import { join } from 'path';
-import { setTimeout } from 'timers/promises';
-
-import type { PythonShell } from 'python-shell';
-
-import { FlowApplication, FlowEvent, FlowFunction, FlowModule, FlowResource, InputStream } from '../src';
-
-describe('Flow RPC long running task', () => {
-  let flowApp: FlowApplication;
-
-  beforeAll(async () => {
-    const flow = {
-      elements: [{ id: 'testResource', module: 'test-module', functionFqn: 'test.resource.TestResource' }],
-      connections: [{ id: 'testConnection1', source: 'testTrigger', sourceStream: 'a', target: 'testResource', targetStream: 'a' }],
-      context: {
-        flowId: 'testFlow',
-        deploymentId: 'testDeployment',
-      },
-    };
-    flowApp = new FlowApplication([TestModule], flow, { amqpConfig: {}, skipApi: true });
-    await setTimeout(2000);
-  });
-
-  test('FLOW.LRPC.1 rpc long running task', (done) => {
-    flowApp.subscribe('testResource.a', {
-      next: async (event: FlowEvent) => {
-        expect(event.getData()).toBeDefined();
-        await flowApp.destroy();
-        done();
-      },
-    });
-
-    flowApp.emit(new FlowEvent({ id: 'testTrigger' }, {}, 'a'));
-  }, 250000);
-});
-
-@FlowFunction('test.resource.TestResource')
-class TestResource extends FlowResource {
-  private shell: PythonShell;
-
-  constructor(context) {
-    super(context);
-    this.shell = this.runPyRpcScript(join(__dirname, 'long-rpc.test.py'));
-  }
-
-  onDestroy = () => this.shell.kill();
-
-  @InputStream('a')
-  public async onA(event) {
-    this.callRpcFunction('testA')
-      .then((res: any) => this.emitEvent(res, event, 'a'))
-      .catch((err) => this.logger.error(err));
-  }
-}
-
-@FlowModule({
-  name: 'test-module',
-  declarations: [TestResource],
-})
-class TestModule {}

package/test/message.spec.ts

@@ -1,57 +0,0 @@
-import { CloudEvent } from 'cloudevents';
-
-import { delay, FlowApplication, FlowEvent, FlowFunction, FlowModule, FlowResource, InputStream } from '../src';
-import { natsFlowsPrefixFlowDeployment, publishNatsEvent } from '../src/lib/nats';
-import { loggerMock } from './mocks/logger.mock';
-import { natsPrepareForRealNats } from './mocks/nats-prepare.reals-nats';
-
-describe('Flow SDK', () => {
-  afterEach(() => {
-    jest.resetAllMocks();
-  });
-
-  test('FLOW.SDK.1 publish message', async () => {
-    const flow = {
-      elements: [
-        { id: 'testTrigger', module: 'test-module', functionFqn: 'test.resource.TestResource' },
-        { id: 'testResource', module: 'test-module', functionFqn: 'test.resource.TestResource' },
-      ],
-      connections: [{ id: 'testConnection1', source: 'testTrigger', target: 'testResource' }],
-      context: {
-        flowId: 'testFlow',
-        deploymentId: 'testDeployment',
-      },
-    };
-
-    const nc = await natsPrepareForRealNats(loggerMock);
-    const flowApp = new FlowApplication([TestModule], flow, { skipApi: true, logger: loggerMock, explicitInit: true, natsConnection: nc });
-    await flowApp.init();
-
-    const spy = jest.spyOn((flowApp as any)?.elements['testResource'], 'onMessage');
-    const event = new CloudEvent({
-      source: 'flowstudio/deployments',
-      type: natsFlowsPrefixFlowDeployment,
-      subject: 'testDeployment.message',
-      data: { elementId: 'testResource', test: 123 },
-    });
-    await publishNatsEvent(loggerMock, nc, event);
-    await delay(5);
-    expect(spy).toHaveBeenCalledTimes(1);
-    await flowApp.destroy();
-    await nc.close();
-  });
-});
-
-@FlowFunction('test.resource.TestResource')
-class TestResource extends FlowResource {
-  @InputStream()
-  public default(event: FlowEvent) {}
-
-  public onMessage = (msg) => {};
-}
-
-@FlowModule({
-  name: 'test-module',
-  declarations: [TestResource],
-})
-class TestModule {}

package/test/mocks/logger.mock.ts

@@ -1,7 +0,0 @@
-export const loggerMock = {
-  debug: jest.fn(),
-  error: jest.fn(),
-  log: jest.fn(),
-  verbose: jest.fn(),
-  warn: jest.fn(),
-};

package/test/mocks/nats-connection.mock.ts

@@ -1,135 +0,0 @@
-/**
- * Mock implementation of a NATS connection for testing purposes.
- *
- * @details
- * - only mocks the publish and subscribe methods.
- *    - supports basic subject matching
- *    - supports wildcard subscriptions with > are supported (e.g., 'foo.>')
- *    - single wildcard subscriptions with * are not supported (e.g., 'foo.*')
- */
-export class NatsConnectionMock {
-  private stopAllSubscriptions = false;
-
-  /**
-   * Sends a request to a subject and waits for a response.
-   * Returns a response based on messages available in the queues.
-   *
-   * @param subject - The subject to send the request to.
-   * @param payload - The request payload (optional).
-   * @param options - Request options (optional).
-   * @returns A promise that resolves to a mock message response or rejects if no message is available.
-   */
-  public async request(subject: string, payload?: any, options?: any): Promise<any> {
-    if (subject.startsWith('$JS.API.')) {
-      return Promise.resolve({
-        data: new TextEncoder().encode('{}'),
-        json: () => JSON.parse('{}'),
-      });
-    }
-    await new Promise((resolve) => setTimeout(resolve, 10));
-    const message = this.getMessageFromQueue(subject);
-    if (message) {
-      return Promise.resolve({
-        data: message,
-        subject: subject,
-        reply: undefined,
-        headers: undefined,
-        json: () => JSON.parse(message),
-      });
-    } else {
-      return Promise.reject(new Error(`No message available for subject: ${subject}`));
-    }
-  }
-
-  /**
-   * Stores message queues for each subject.
-   * @private
-   */
-  private queues: { [subject: string]: any[] } = {};
-
-  /**
-   * Publishes a message to a specific subject.
-   * If the subject does not exist, it initializes a new queue for it.
-   *
-   * @param subject - The subject to publish the message to.
-   * @param payload - The message payload to publish (optional).
-   */
-  public publish(subject: string, payload?: any) {
-    if (!this.queues[subject]) {
-      this.queues[subject] = [];
-    }
-    this.queues[subject].push(JSON.stringify(payload));
-  }
-
-  /**
-   * Closes the connection
-   */
-  public async close(): Promise<void> {
-    this.stopAllSubscriptions = true;
-    await new Promise((resolve) => setTimeout(resolve, 50));
-  }
-
-  public async drain(): Promise<void> {
-    await this.close();
-  }
-
-  /**
-   * Checks if the connection is closed.
-   * @returns `false` as the mock connection is always open.
-   */
-  public isClosed() {
-    return this.stopAllSubscriptions;
-  }
-
-  private getMessageFromQueue(subject: string, queues = this.queues) {
-    if (!queues[subject]) {
-      queues[subject] = [];
-    }
-    if (subject.endsWith('.>')) {
-      for (const key in queues) {
-        if (key.startsWith(subject.slice(0, -1)) && queues[key].length > 0) {
-          return queues[key].shift();
-        }
-      }
-    } else if (queues[subject].length > 0) {
-      return queues[subject].shift();
-    }
-    return undefined;
-  }
-
-  /**
-   * Subscribes to a specific subject and returns an async iterator for messages.
-   * Supports wildcard subjects ending with `.>` to subscribe to multiple subjects.
-   *
-   * @param subject - The subject to subscribe to.
-   * @param queues - The message queues to use (default is the internal queues).
-   * @param getter
-   * @param stopAllSubscriptions
-   * @returns An object containing the `unsubscribe` method and an async iterator for messages.
-   */
-  public subscribe(
-    subject: string,
-    queues = this.queues,
-    getter = this.getMessageFromQueue,
-    stopAllSubscriptions = this.stopAllSubscriptions,
-  ) {
-    let activeSub = true;
-    return {
-      unsubscribe: () => {
-        activeSub = false;
-      },
-      async *[Symbol.asyncIterator]() {
-        while (activeSub && !stopAllSubscriptions) {
-          const nextMsg = getter(subject, queues);
-          if (nextMsg) {
-            yield {
-              json: () => JSON.parse(nextMsg),
-            };
-          }
-          await new Promise((resolve) => setTimeout(resolve, 10));
-        }
-        return;
-      },
-    };
-  }
-}

package/test/mocks/nats-prepare.reals-nats.ts

@@ -1,15 +0,0 @@
-import { jetstreamManager } from '@nats-io/jetstream';
-import { NatsConnection } from '@nats-io/nats-core';
-import { connect } from '@nats-io/transport-node';
-
-import { Logger } from '../../src';
-
-export async function natsPrepareForRealNats(logger: Logger): Promise<NatsConnection> {
-  const natsConnection = await connect();
-  const jsm = await jetstreamManager(natsConnection);
-  const flowStream = await jsm.streams.info('flows').catch((err: any) => logger.error(err));
-  if (!flowStream) {
-    await jsm.streams.add({ name: 'flows', subjects: ['fs.>'] }).catch((err: any) => logger.error(err));
-  }
-  return natsConnection;
-}