@flowgram.ai/test-run-plugin 0.1.0-alpha.20

package/src/services/pipeline/pipeline.ts

@@ -0,0 +1,143 @@
+/**
+ * Copyright (c) 2025 Bytedance Ltd. and/or its affiliates
+ * SPDX-License-Identifier: MIT
+ */
+
+import type { StoreApi } from 'zustand';
+import { nanoid } from 'nanoid';
+import { injectable, interfaces } from 'inversify';
+import { Emitter } from '@flowgram.ai/utils';
+
+import { Tap } from './tap';
+import type { TestRunPipelinePlugin } from './plugin';
+import { StoreService } from '../store';
+export interface TestRunPipelineEntityOptions {
+  plugins: (new () => TestRunPipelinePlugin)[];
+}
+
+interface TestRunPipelineEntityState<T = any> {
+  status: 'idle' | 'preparing' | 'executing' | 'canceled' | 'finished';
+  data?: T;
+  result?: any;
+  getData: () => T;
+  setData: (next: any) => void;
+}
+
+export interface TestRunPipelineEntityCtx<T = any> {
+  id: string;
+  store: StoreApi<TestRunPipelineEntityState<T>>;
+  operate: {
+    update: (data: any) => void;
+    cancel: () => void;
+  };
+}
+
+const initialState: Omit<TestRunPipelineEntityState, 'getData' | 'setData'> = {
+  status: 'idle',
+  data: {},
+};
+
+@injectable()
+export class TestRunPipelineEntity extends StoreService<TestRunPipelineEntityState> {
+  container: interfaces.Container | undefined;
+
+  id = nanoid();
+
+  prepare = new Tap<TestRunPipelineEntityCtx>();
+
+  private execute?: (ctx: TestRunPipelineEntityCtx) => Promise<void> | void;
+
+  private progress?: (ctx: TestRunPipelineEntityCtx) => Promise<void> | void;
+
+  get status() {
+    return this.getState().status;
+  }
+
+  set status(next: TestRunPipelineEntityState['status']) {
+    this.setState({ status: next });
+  }
+
+  onProgressEmitter = new Emitter<any>();
+
+  onProgress = this.onProgressEmitter.event;
+
+  onFinishedEmitter = new Emitter();
+
+  onFinished = this.onFinishedEmitter.event;
+
+  constructor() {
+    super((set, get) => ({
+      ...initialState,
+      getData: () => get().data || {},
+      setData: (next: any) => set((state) => ({ ...state, data: { ...state.data, ...next } })),
+    }));
+  }
+
+  public init(options: TestRunPipelineEntityOptions) {
+    if (!this.container) {
+      return;
+    }
+    const { plugins } = options;
+    for (const PluginClass of plugins) {
+      const plugin = this.container.resolve<TestRunPipelinePlugin>(PluginClass);
+      plugin.apply(this);
+    }
+  }
+
+  public registerExecute(fn: (ctx: TestRunPipelineEntityCtx) => Promise<void> | void) {
+    this.execute = fn;
+  }
+
+  public registerProgress(fn: (ctx: TestRunPipelineEntityCtx) => Promise<void> | void) {
+    this.progress = fn;
+  }
+
+  async start<T>(options?: { data: T }) {
+    const { data } = options || {};
+    if (this.status !== 'idle') {
+      return;
+    }
+    /** initialization data */
+    this.setState({ data });
+    const ctx: TestRunPipelineEntityCtx = {
+      id: this.id,
+      store: this.store,
+      operate: {
+        update: this.update.bind(this),
+        cancel: this.cancel.bind(this),
+      },
+    };
+
+    this.status = 'preparing';
+    await this.prepare.call(ctx);
+    if (this.status !== 'preparing') {
+      return;
+    }
+
+    this.status = 'executing';
+    if (this.execute) {
+      await this.execute(ctx);
+    }
+    if (this.progress) {
+      await this.progress(ctx);
+    }
+    if (this.status === 'executing') {
+      this.status = 'finished';
+      this.onFinishedEmitter.fire(this.getState().result);
+    }
+  }
+
+  update(result: any) {
+    this.setState({ result });
+    this.onProgressEmitter.fire(result);
+  }
+
+  cancel() {
+    if ((this.status = 'preparing')) {
+      this.prepare.freeze();
+    }
+    this.status = 'canceled';
+  }
+
+  dispose() {}
+}

package/src/services/pipeline/plugin.ts

@@ -0,0 +1,11 @@
+/**
+ * Copyright (c) 2025 Bytedance Ltd. and/or its affiliates
+ * SPDX-License-Identifier: MIT
+ */
+
+import type { TestRunPipelineEntity } from './pipeline';
+
+export interface TestRunPipelinePlugin {
+  name: string;
+  apply(pipeline: TestRunPipelineEntity): void;
+}

package/src/services/pipeline/tap.ts

@@ -0,0 +1,34 @@
+/**
+ * Copyright (c) 2025 Bytedance Ltd. and/or its affiliates
+ * SPDX-License-Identifier: MIT
+ */
+
+import { MaybePromise } from '../../types';
+
+interface TapValue<T> {
+  name: string;
+  fn: (arg: T) => MaybePromise<void>;
+}
+
+export class Tap<T> {
+  private taps: TapValue<T>[] = [];
+
+  private frozen = false;
+
+  tap(name: string, fn: TapValue<T>['fn']) {
+    this.taps.push({ name, fn });
+  }
+
+  async call(ctx: T) {
+    for (const tap of this.taps) {
+      if (this.frozen) {
+        return;
+      }
+      await tap.fn(ctx);
+    }
+  }
+
+  freeze() {
+    this.frozen = true;
+  }
+}

package/src/services/store.ts

@@ -0,0 +1,27 @@
+/**
+ * Copyright (c) 2025 Bytedance Ltd. and/or its affiliates
+ * SPDX-License-Identifier: MIT
+ */
+
+import { createStore } from 'zustand/vanilla';
+import type { StoreApi, StateCreator } from 'zustand';
+import { injectable, unmanaged } from 'inversify';
+/**
+ * 包含 Store 的 Service
+ */
+@injectable()
+export class StoreService<State> {
+  store: StoreApi<State>;
+
+  get getState() {
+    return this.store.getState.bind(this.store);
+  }
+
+  get setState() {
+    return this.store.setState.bind(this.store);
+  }
+
+  constructor(@unmanaged() stateCreator: StateCreator<State>) {
+    this.store = createStore(stateCreator);
+  }
+}

package/src/services/test-run.ts

@@ -0,0 +1,100 @@
+/**
+ * Copyright (c) 2025 Bytedance Ltd. and/or its affiliates
+ * SPDX-License-Identifier: MIT
+ */
+
+import { inject, injectable } from 'inversify';
+import { Disposable, DisposableCollection, Emitter } from '@flowgram.ai/utils';
+import type { FlowNodeEntity, FlowNodeType } from '@flowgram.ai/document';
+
+import { TestRunPipelineFactory } from './pipeline/factory';
+import { TestRunFormManager } from './form';
+import { FormSchema } from '../form-engine';
+import { TestRunPipelineEntity, type TestRunPipelineEntityOptions } from './pipeline';
+import { TestRunConfig } from './config';
+
+@injectable()
+export class TestRunService {
+  @inject(TestRunConfig) private readonly config: TestRunConfig;
+
+  @inject(TestRunPipelineFactory) private readonly pipelineFactory: TestRunPipelineFactory;
+
+  @inject(TestRunFormManager) readonly formManager: TestRunFormManager;
+
+  pipelineEntities = new Map<string, TestRunPipelineEntity>();
+
+  pipelineBindings = new Map<string, Disposable>();
+
+  onPipelineProgressEmitter = new Emitter();
+
+  onPipelineProgress = this.onPipelineProgressEmitter.event;
+
+  onPipelineFinishedEmitter = new Emitter();
+
+  onPipelineFinished = this.onPipelineFinishedEmitter.event;
+
+  public isEnabled(nodeType: FlowNodeType) {
+    const config = this.config.nodes[nodeType];
+    return config && config?.enabled !== false;
+  }
+
+  async toSchema(node: FlowNodeEntity) {
+    const nodeType = node.flowNodeType;
+    const config = this.config.nodes[nodeType];
+    if (!this.isEnabled(nodeType)) {
+      return {};
+    }
+    const properties =
+      typeof config.properties === 'function'
+        ? await config.properties({ node })
+        : config.properties;
+
+    return {
+      type: 'object',
+      properties,
+    };
+  }
+
+  createFormWithSchema(schema: FormSchema) {
+    const form = this.formManager.createForm();
+    form.init({ schema });
+    return form;
+  }
+
+  async createForm(node: FlowNodeEntity) {
+    const schema = await this.toSchema(node);
+    return this.createFormWithSchema(schema);
+  }
+
+  createPipeline(options: TestRunPipelineEntityOptions) {
+    const pipeline = this.pipelineFactory();
+    this.pipelineEntities.set(pipeline.id, pipeline);
+    pipeline.init(options);
+    return pipeline;
+  }
+
+  connectPipeline(pipeline: TestRunPipelineEntity) {
+    if (this.pipelineBindings.get(pipeline.id)) {
+      return;
+    }
+    const disposable = new DisposableCollection(
+      pipeline.onProgress(this.onPipelineProgressEmitter.fire.bind(this.onPipelineProgressEmitter)),
+      pipeline.onFinished(this.onPipelineFinishedEmitter.fire.bind(this.onPipelineFinishedEmitter))
+    );
+    this.pipelineBindings.set(pipeline.id, disposable);
+  }
+
+  disconnectPipeline(id: string) {
+    if (this.pipelineBindings.has(id)) {
+      const disposable = this.pipelineBindings.get(id);
+      disposable?.dispose();
+      this.pipelineBindings.delete(id);
+    }
+  }
+
+  disconnectAllPipeline() {
+    for (const id of this.pipelineBindings.keys()) {
+      this.disconnectPipeline(id);
+    }
+  }
+}

package/src/types.ts

@@ -0,0 +1,29 @@
+/**
+ * Copyright (c) 2025 Bytedance Ltd. and/or its affiliates
+ * SPDX-License-Identifier: MIT
+ */
+
+import type { FlowNodeType, FlowNodeEntity } from '@flowgram.ai/document';
+
+import type { FormSchema, FormComponents } from './form-engine';
+
+export type MaybePromise<T> = T | Promise<T>;
+
+type PropertiesFunctionParams = {
+  node: FlowNodeEntity;
+};
+
+export interface NodeTestConfig {
+  /** Enable node TestRun */
+  enabled?: boolean;
+  /** Input schema properties */
+  properties?:
+    | Record<string, FormSchema>
+    | ((params: PropertiesFunctionParams) => MaybePromise<Record<string, FormSchema>>);
+}
+export type NodeMap = Record<FlowNodeType, NodeTestConfig>;
+
+export interface TestRunPluginConfig {
+  components?: FormComponents;
+  nodes?: NodeMap;
+}

package/tsconfig.json

@@ -0,0 +1,12 @@
+{
+  "extends": "@flowgram.ai/ts-config/tsconfig.flow.base.json",
+  "compilerOptions": {
+    "jsx": "react-jsx"
+  },
+  "include": [
+    "./src"
+  ],
+  "exclude": [
+    "node_modules"
+  ]
+}