@nocobase/flow-engine 2.0.0-alpha.2

package/src/resources/apiResource.ts

@@ -0,0 +1,148 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+
+import { APIClient } from '@nocobase/sdk';
+import { FlowContext } from '../flowContext';
+import { FlowResource, ResourceError } from './flowResource';
+
+export class APIResource<TData = any> extends FlowResource<TData> {
+  // 请求配置
+  protected request: any = {
+    // url: null as string | null,
+    headers: {} as Record<string, any>,
+
+    // 仅用于 Refresh
+    params: {} as Record<string, any>,
+    method: 'get' as string,
+    data: null as any,
+  };
+
+  protected api: APIClient;
+
+  constructor(context?: FlowContext) {
+    super(context);
+    if (context) {
+      this.api = context.api;
+    }
+  }
+
+  setAPIClient(api: APIClient) {
+    this.api = api;
+    return this;
+  }
+
+  getURL(): string {
+    return this.request.url;
+  }
+
+  setURL(value: string) {
+    this.request.url = value;
+    return this;
+  }
+
+  get loading() {
+    return this.getMeta('loading') || false;
+  }
+
+  set loading(value: boolean) {
+    this.setMeta({ loading: value });
+  }
+
+  clearRequestParameters() {
+    this.request.params = {};
+    return this;
+  }
+
+  setRequestParameters(params: Record<string, any>) {
+    this.request.params = { ...this.request.params, ...params };
+    return this;
+  }
+
+  setRequestMethod(method: string) {
+    this.request.method = method;
+    return this;
+  }
+
+  addRequestHeader(key: string, value: string) {
+    if (!this.request.headers) {
+      this.request.headers = {};
+    }
+    this.request.headers[key] = value;
+    return this;
+  }
+
+  removeRequestHeader(key: string) {
+    if (this.request.headers && key in this.request.headers) {
+      delete this.request.headers[key];
+    }
+    return this;
+  }
+
+  addRequestParameter(key: string, value: any) {
+    if (!this.request.params) {
+      this.request.params = {};
+    }
+    this.request.params[key] = value;
+    return this;
+  }
+
+  getRequestParameter(key: string) {
+    if (this.request.params && key in this.request.params) {
+      return this.request.params[key];
+    }
+    return null;
+  }
+
+  removeRequestParameter(key: string) {
+    if (this.request.params && key in this.request.params) {
+      delete this.request.params[key];
+    }
+    return this;
+  }
+
+  setRequestBody(data: any) {
+    this.request.data = data;
+    return this;
+  }
+
+  setRequestOptions(key: string, value: any) {
+    this.request[key] = value;
+    return this;
+  }
+
+  getRequestOptions() {
+    return this.request;
+  }
+
+  async refresh() {
+    if (!this.api) {
+      throw new Error('API client not set');
+    }
+    this.clearError();
+    try {
+      const { data } = await this.api.request({
+        url: this.getURL(),
+        ...this.getRefreshRequestOptions(),
+      });
+      this.setData(data);
+      this.emit('refresh');
+    } catch (err) {
+      const error = new ResourceError(err);
+      this.setError(error);
+      throw error;
+    }
+  }
+
+  protected getRefreshRequestOptions() {
+    const options = {
+      ...this.request,
+    };
+    return options;
+  }
+}

package/src/resources/baseRecordResource.ts

@@ -0,0 +1,279 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+
+import { AxiosRequestConfig } from 'axios';
+import _ from 'lodash';
+import { APIResource } from './apiResource';
+import { FilterItem } from './filterItem';
+import { ResourceError } from './flowResource';
+
+export abstract class BaseRecordResource<TData = any> extends APIResource<TData> {
+  protected resourceName: string;
+  protected sourceId: string | number | null = null;
+
+  // 请求配置 - 与 APIClient 接口保持一致
+  protected request = {
+    // url: null as string | null,
+    method: 'get' as string,
+    params: {
+      // filter: {} as Record<string, any>,
+      // filterByTk: null as string | number | string[] | number[] | null,
+      // appends: null as string[] | null,
+      // fields: null as string[] | null,
+      // sort: null as string[] | null,
+      // except: null as string[] | null,
+      // whitelist: null as string[] | null,
+      // blacklist: null as string[] | null,
+    } as Record<string, any>,
+    headers: {} as Record<string, any>,
+  };
+
+  protected updateAssociationValues: string[] = [];
+  protected runActionOptions = {};
+
+  protected filterGroups = new Map<string, any>();
+
+  protected _refreshActionName = 'list';
+
+  get supportsFilter() {
+    return true;
+  }
+
+  setRefreshAction(refreshActionName: string) {
+    this._refreshActionName = refreshActionName;
+  }
+
+  mergeRequestConfig(...args: AxiosRequestConfig[]): AxiosRequestConfig {
+    const base = {} as AxiosRequestConfig;
+
+    // 限制到 2 层
+    const customizer = (objValue: any, srcValue: any, key: string, object: any, source: any, stack: any) => {
+      const depth = stack.size; // lodash 内部 stack 能告诉你当前深度
+      if (Array.isArray(srcValue)) {
+        // 数组覆盖
+        return srcValue;
+      }
+      if (depth > 1) {
+        // 超过 2 层就直接替换
+        return srcValue;
+      }
+    };
+
+    return args.reduce((acc, cur) => _.mergeWith(acc, cur, customizer), base);
+  }
+
+  setRunActionOptions(action: string, options: AxiosRequestConfig) {
+    this.runActionOptions[action] = options;
+    return this;
+  }
+
+  protected splitValue(value: string | string[]): string[] {
+    if (typeof value === 'string') {
+      return value.split(',').map((item) => item.trim());
+    }
+    return Array.isArray(value) ? value : [];
+  }
+
+  protected buildURL(action?: string): string {
+    let url = '';
+    if (this.resourceName) {
+      if (this.sourceId && this.resourceName.includes('.')) {
+        // 处理关联资源，如 users.tags 或 users.profile
+        const [parentResource, childResource] = this.resourceName.split('.');
+        url = `${parentResource}/${this.sourceId}/${childResource}:${action || 'get'}`;
+      } else {
+        url = `${this.resourceName}:${action || 'get'}`;
+      }
+    }
+    return url;
+  }
+
+  async runAction<TData = any, TMeta = any>(action: string, options: any) {
+    const config = this.mergeRequestConfig(
+      _.omit(this.request, ['params', 'data', 'method']),
+      {
+        method: 'post',
+        url: this.buildURL(action),
+      },
+      this.runActionOptions?.[action],
+      options,
+    );
+    if (['create', 'update', 'firstOrCreate', 'updateOrCreate'].includes(action)) {
+      config.params = config.params || {};
+      config.params.updateAssociationValues = this.getUpdateAssociationValues();
+    }
+    try {
+      const { data } = await this.api.request(config);
+      if (!data?.data) {
+        return data;
+      }
+      return { data: data.data, meta: data.meta } as {
+        data: TData;
+        meta?: TMeta;
+      };
+    } catch (err) {
+      throw new ResourceError(err);
+    }
+  }
+
+  setResourceName(resourceName: string) {
+    this.resourceName = resourceName;
+    return this;
+  }
+
+  getResourceName(): string {
+    return this.resourceName;
+  }
+
+  setSourceId(sourceId: string | number) {
+    this.sourceId = sourceId;
+    return this;
+  }
+
+  getSourceId(): string | number {
+    return this.sourceId;
+  }
+
+  setDataSourceKey(dataSourceKey: string) {
+    return this.addRequestHeader('X-Data-Source', dataSourceKey);
+  }
+
+  getDataSourceKey(): string {
+    return this.request.headers['X-Data-Source'];
+  }
+
+  setFilter(filter: Record<string, any>) {
+    return this.addRequestParameter('filter', JSON.stringify(filter));
+  }
+
+  getFilter(): Record<string, any> {
+    const value = [...this.filterGroups.values()].filter(Boolean);
+
+    if (value.length === 0) {
+      return;
+    }
+
+    return {
+      $and: value,
+    };
+  }
+
+  resetFilter() {
+    this.setFilter(this.getFilter());
+  }
+
+  addFilterGroup(key: string, filter: FilterItem | Record<string, any>) {
+    if (filter instanceof FilterItem) {
+      filter = filter.toJSON();
+    }
+    this.filterGroups.set(key, filter);
+    this.resetFilter();
+  }
+
+  removeFilterGroup(key: string) {
+    this.filterGroups.delete(key);
+    this.resetFilter();
+  }
+
+  setAppends(appends: string[]) {
+    return this.addRequestParameter('appends', appends);
+  }
+
+  getAppends(): string[] {
+    return this.request.params.appends || [];
+  }
+
+  addAppends(appends: string | string[]) {
+    const currentAppends = this.getAppends();
+    const newAppends = this.splitValue(appends);
+    newAppends.forEach((append) => {
+      if (!currentAppends.includes(append)) {
+        currentAppends.push(append);
+      }
+    });
+    this.request.params.appends = currentAppends;
+    return this;
+  }
+
+  removeAppends(appends: string | string[]) {
+    if (!this.request.params.appends) {
+      return this;
+    }
+    const currentAppends = this.getAppends();
+    const removeAppends = this.splitValue(appends);
+    this.request.params.appends = currentAppends.filter((append: string) => !removeAppends.includes(append));
+    return this;
+  }
+
+  getUpdateAssociationValues(): string[] {
+    return this.updateAssociationValues || [];
+  }
+
+  addUpdateAssociationValues(updateAssociationValues: string | string[]) {
+    const currentUpdateAssociationValues = this.getUpdateAssociationValues();
+    const newUpdateAssociationValues = this.splitValue(updateAssociationValues);
+    newUpdateAssociationValues.forEach((append) => {
+      if (!currentUpdateAssociationValues.includes(append)) {
+        currentUpdateAssociationValues.push(append);
+      }
+    });
+    this.updateAssociationValues = currentUpdateAssociationValues;
+    return this;
+  }
+
+  setFilterByTk(filterByTk: any) {
+    return this.addRequestParameter('filterByTk', filterByTk);
+  }
+
+  getFilterByTk(): any {
+    return this.request.params.filterByTk;
+  }
+
+  setFields(fields: string[] | string) {
+    return this.addRequestParameter('fields', this.splitValue(fields));
+  }
+
+  getFields(): string[] {
+    return this.request.params.fields || [];
+  }
+
+  setSort(sort: string | string[]) {
+    return this.addRequestParameter('sort', this.splitValue(sort));
+  }
+
+  getSort(): string[] {
+    return this.request.params.sort || [];
+  }
+
+  setExcept(except: string | string[]) {
+    return this.addRequestParameter('except', this.splitValue(except));
+  }
+
+  getExcept(): string[] {
+    return this.request.params.except || [];
+  }
+
+  setWhitelist(whitelist: string | string[]) {
+    return this.addRequestParameter('whitelist', this.splitValue(whitelist));
+  }
+
+  getWhitelist(): string[] {
+    return this.request.params.whitelist || [];
+  }
+
+  setBlacklist(blacklist: string | string[]) {
+    return this.addRequestParameter('blacklist', this.splitValue(blacklist));
+  }
+
+  getBlacklist(): string[] {
+    return this.request.params.blacklist || [];
+  }
+
+  abstract refresh(): Promise<void>;
+}

package/src/resources/filterItem.ts

@@ -0,0 +1,74 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+
+type FilterOptions = {
+  path: string;
+  value: any;
+  operator?: string;
+};
+export class FilterItem {
+  constructor(protected options: FilterOptions) {
+    if (options instanceof FilterItem) {
+      return options;
+    }
+    this.options = options;
+  }
+  toJSON() {
+    if (this.options.operator) {
+      return {
+        [this.options.path]: {
+          [this.options.operator]: this.options.value,
+        },
+      };
+    }
+    return {
+      [this.options.path]: this.options.value,
+    };
+  }
+}
+
+export type FilterGroupOptions = {
+  logic: '$and' | '$or';
+  items: Array<FilterItem | FilterOptions | FilterGroup | FilterGroupOptions>;
+};
+
+export class FilterGroup {
+  protected options: {
+    logic: '$and' | '$or';
+    items: Array<FilterItem | FilterGroup>;
+  };
+  constructor(options: FilterGroupOptions) {
+    if (options instanceof FilterGroup) {
+      return options;
+    }
+    if (options.logic !== '$and' && options.logic !== '$or') {
+      throw new Error('Logic must be either $and or $or');
+    }
+    if (!Array.isArray(options.items)) {
+      throw new Error('Items must be an array');
+    }
+    this.options = {
+      logic: options.logic,
+      items: options.items.map((item: any) => {
+        if (item.logic) {
+          return new FilterGroup(item);
+        }
+        return new FilterItem(item);
+      }),
+    };
+  }
+
+  toJSON() {
+    return {
+      [this.options.logic]: this.options.items.map((item) => {
+        return item.toJSON();
+      }),
+    };
+  }
+}

package/src/resources/flowResource.ts

@@ -0,0 +1,143 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+
+import { observable } from '@formily/reactive';
+import { FlowContext, FlowEngineContext } from '../flowContext';
+
+interface TDataItem {
+  id: string | number;
+  [key: string]: any;
+}
+type TDataItemWithKey = TDataItem & { _rowKey: string };
+
+function toErrMessages(error) {
+  if (typeof error?.response?.data === 'string') {
+    const tempElement = document.createElement('div');
+    tempElement.innerHTML = error?.response?.data;
+    let message = tempElement.textContent || tempElement.innerText;
+    if (message.includes('Error occurred while trying')) {
+      message = 'The application may be starting up. Please try again later.';
+      return [{ code: 'APP_WARNING', message }];
+    }
+    if (message.includes('502 Bad Gateway')) {
+      message = 'The application may be starting up. Please try again later.';
+      return [{ code: 'APP_WARNING', message }];
+    }
+    return [{ message }];
+  }
+  if (error?.response?.data?.error) {
+    return [error?.response?.data?.error];
+  }
+  return (
+    error?.response?.data?.errors ||
+    error?.response?.data?.messages ||
+    error?.response?.error || [{ message: error.message || 'Server error' }]
+  );
+}
+
+export class ResourceError extends Error {
+  data: { message: string; code?: string };
+
+  constructor(error) {
+    const data = toErrMessages(error).shift();
+    super(data.message);
+    this.name = 'ResponseError';
+  }
+
+  get code() {
+    return this.data?.code || 'UNKNOWN_ERROR';
+  }
+
+  get message() {
+    return this.data?.message || 'An unknown error occurred';
+  }
+}
+
+export class FlowResource<TData = any> {
+  protected _data = observable.ref<TData>(null);
+  protected _meta = observable.ref<Record<string, any>>({});
+  protected _error = observable.ref<ResourceError>(null);
+  protected context: FlowContext;
+
+  constructor(context: FlowContext) {
+    this.context = new FlowContext();
+    this.context.addDelegate(context);
+  }
+
+  getData(): TData {
+    return this._data.value;
+  }
+
+  hasData(): boolean {
+    const data = this.getData();
+    if (Array.isArray(data)) {
+      return data.length > 0;
+    } else if (data && typeof data === 'object') {
+      return Object.keys(data).length > 0;
+    }
+    return false;
+  }
+
+  setData(value: TData) {
+    this._data.value = value;
+    return this;
+  }
+
+  getMeta(metaKey?: string) {
+    return metaKey ? this._meta.value[metaKey] : this._meta.value;
+  }
+
+  setMeta(meta: Record<string, any>) {
+    this._meta.value = { ...this._meta.value, ...meta };
+    return this;
+  }
+
+  get error(): ResourceError | null {
+    return this._error.value;
+  }
+
+  getError(): ResourceError | null {
+    return this._error.value;
+  }
+
+  setError(error: ResourceError | null): this {
+    this._error.value = error;
+    return this;
+  }
+
+  clearError(): this {
+    this._error.value = null;
+    return this;
+  }
+
+  private events: Record<string, Array<(...args: any[]) => void>> = {};
+
+  on(event: string, callback: (...args: any[]) => void) {
+    (this.events[event] ||= []).push(callback);
+  }
+
+  once(event: string, callback: (...args: any[]) => void) {
+    const wrapper = (...args: any[]) => {
+      // 触发回调
+      callback(...args);
+      // 自动移除监听器
+      this.off(event, wrapper);
+    };
+    // 注册包装后的回调
+    this.on(event, wrapper);
+  }
+
+  off(event: string, callback: (...args: any[]) => void) {
+    this.events[event] = (this.events[event] || []).filter((fn) => fn !== callback);
+  }
+
+  emit(event: string, ...args: any[]) {
+    (this.events[event] || []).forEach((fn) => fn(...args));
+  }
+}

package/src/resources/index.ts

@@ -0,0 +1,17 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+
+export * from './apiResource';
+export * from './baseRecordResource';
+export * from './filterItem';
+export * from './flowResource';
+export * from './multiRecordResource';
+export * from './singleRecordResource';
+export * from './sqlResource';
+//