@nocobase/plugin-flow-engine 2.1.0-alpha.12 → 2.1.0-alpha.14

package/dist/server/flow-surfaces/types.d.ts

@@ -0,0 +1,192 @@
+/**
+ * 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 { FLOW_SURFACE_MUTATE_OP_TYPES } from './constants';
+export type FlowSurfaceNodeDomain = 'props' | 'decoratorProps' | 'stepParams' | 'flowRegistry';
+export type FlowSurfaceMergeStrategy = 'deep' | 'replace';
+export type FlowSurfaceActionScope = 'block' | 'record' | 'form' | 'filterForm' | 'actionPanel';
+export type FlowSurfaceReadLocator = {
+    uid?: string;
+    pageSchemaUid?: string;
+    tabSchemaUid?: string;
+    routeId?: string;
+};
+export type FlowSurfaceWriteTarget = {
+    uid: string;
+};
+export type FlowSurfaceResolveTarget = FlowSurfaceReadLocator | FlowSurfaceWriteTarget;
+export type FlowSurfaceConfigureOptionValueType = 'string' | 'number' | 'boolean' | 'object' | 'array';
+export type FlowSurfaceConfigureOption = {
+    type: FlowSurfaceConfigureOptionValueType;
+    description?: string;
+    enum?: Array<string | number | boolean>;
+    example?: any;
+    supportsFlowContext?: boolean;
+};
+export type FlowSurfaceConfigureOptions = Record<string, FlowSurfaceConfigureOption>;
+export type FlowSurfaceResourceBindingKey = 'currentCollection' | 'currentRecord' | 'associatedRecords' | 'otherRecords';
+export type FlowSurfaceResourceBindingAssociationField = {
+    key: string;
+    label: string;
+    collectionName: string;
+    associationName?: string;
+};
+export type FlowSurfaceResourceBindingOption = {
+    key: FlowSurfaceResourceBindingKey;
+    label: string;
+    description?: string;
+    requires?: string[];
+    dataSourceKey?: string;
+    collectionName?: string;
+    associationFields?: FlowSurfaceResourceBindingAssociationField[];
+};
+export type FlowSurfaceSemanticResourceInput = {
+    binding: FlowSurfaceResourceBindingKey;
+    dataSourceKey?: string;
+    collectionName?: string;
+    associationField?: string;
+};
+export type FlowSurfaceReadTarget = {
+    locator: FlowSurfaceReadLocator;
+    uid: string;
+    kind: FlowSurfaceContainerKind;
+};
+export type FlowSurfaceContainerKind = 'page' | 'tab' | 'grid' | 'block' | 'node';
+export type FlowSurfaceDomainContract = {
+    allowedKeys: string[];
+    wildcard?: boolean;
+    mergeStrategy: FlowSurfaceMergeStrategy;
+    schema: Record<string, any>;
+    groups?: Record<string, FlowSurfaceDomainGroupContract>;
+};
+export type FlowSurfaceEventCapabilities = {
+    direct?: string[];
+    object?: string[];
+};
+export type FlowSurfaceDomainGroupContract = {
+    allowedPaths: string[];
+    clearable?: boolean;
+    mergeStrategy: FlowSurfaceMergeStrategy;
+    schema: Record<string, any>;
+    eventBindingSteps?: string[] | '*';
+    pathSchemas?: Record<string, Record<string, any>>;
+};
+export type FlowSurfaceEventBindingContract = {
+    stepKeys?: string[] | '*';
+};
+export type FlowSurfaceLayoutCapabilities = {
+    supported: boolean;
+};
+export type FlowSurfaceNodeContract = {
+    editableDomains: FlowSurfaceNodeDomain[];
+    domains: Partial<Record<FlowSurfaceNodeDomain, FlowSurfaceDomainContract>>;
+    eventCapabilities?: FlowSurfaceEventCapabilities;
+    layoutCapabilities?: FlowSurfaceLayoutCapabilities;
+    eventBindings?: Record<string, FlowSurfaceEventBindingContract>;
+};
+export type FlowSurfaceCatalogItem = {
+    key: string;
+    label: string;
+    use: string;
+    kind: 'page' | 'tab' | 'block' | 'field' | 'action';
+    scope?: FlowSurfaceActionScope;
+    scene?: string;
+    requiredInitParams?: string[];
+    allowedContainerUses?: string[];
+    editableDomains: FlowSurfaceNodeDomain[];
+    settingsSchema: Record<string, any>;
+    settingsContract?: Partial<Record<FlowSurfaceNodeDomain, FlowSurfaceDomainContract>>;
+    configureOptions?: FlowSurfaceConfigureOptions;
+    resourceBindings?: FlowSurfaceResourceBindingOption[];
+    eventCapabilities?: FlowSurfaceEventCapabilities;
+    layoutCapabilities?: FlowSurfaceLayoutCapabilities;
+    createSupported?: boolean;
+};
+export type FlowSurfaceNodeSpec = {
+    uid?: string;
+    clientKey?: string;
+    use: string;
+    props?: Record<string, any>;
+    decoratorProps?: Record<string, any>;
+    stepParams?: Record<string, any>;
+    flowRegistry?: Record<string, any>;
+    subModels?: Record<string, FlowSurfaceNodeSpec | FlowSurfaceNodeSpec[]>;
+};
+export type FlowSurfaceNodeSubModel = FlowSurfaceNodeSpec | FlowSurfaceNodeSpec[];
+export type FlowSurfaceNodeDefaults = Partial<Pick<FlowSurfaceNodeSpec, 'props' | 'decoratorProps' | 'stepParams' | 'flowRegistry' | 'subModels'>>;
+export type FlowSurfaceApplyMode = 'replace';
+export type FlowSurfaceComposeMode = 'append' | 'replace';
+export type FlowSurfaceApplySpec = {
+    props?: Record<string, any>;
+    decoratorProps?: Record<string, any>;
+    stepParams?: Record<string, any>;
+    flowRegistry?: Record<string, any>;
+    subModels?: Record<string, FlowSurfaceNodeSpec | FlowSurfaceNodeSpec[]>;
+};
+export type FlowSurfaceAtomicFlag = true;
+export type FlowSurfaceMutateValues = {
+    ops?: FlowSurfaceMutateOp[];
+    atomic?: true;
+};
+export type FlowSurfaceApplyValues = {
+    target: FlowSurfaceWriteTarget;
+    spec: FlowSurfaceApplySpec;
+    mode?: 'replace';
+};
+export type FlowSurfaceComposeValues = {
+    target: FlowSurfaceWriteTarget;
+    mode?: FlowSurfaceComposeMode;
+    blocks?: Array<Record<string, any>>;
+    layout?: Record<string, any>;
+};
+export type FlowSurfaceConfigureValues = {
+    target: FlowSurfaceWriteTarget;
+    changes: Record<string, any>;
+};
+export type FlowSurfaceContextVarInfo = {
+    title?: string;
+    type?: string;
+    interface?: string;
+    description?: string;
+    enumValues?: string[];
+    min?: number;
+    max?: number;
+    disabled?: boolean;
+    disabledReason?: string;
+    properties?: Record<string, FlowSurfaceContextVarInfo>;
+};
+export type FlowSurfaceContextValues = {
+    target: FlowSurfaceWriteTarget;
+    path?: string;
+    maxDepth?: number;
+};
+export type FlowSurfaceContextResponse = {
+    vars: Record<string, FlowSurfaceContextVarInfo>;
+};
+export type FlowSurfaceMutateOpType = (typeof FLOW_SURFACE_MUTATE_OP_TYPES)[number];
+export type FlowSurfaceMutateOp = {
+    opId?: string;
+    type: FlowSurfaceMutateOpType;
+    target?: FlowSurfaceWriteTarget;
+    values?: Record<string, any>;
+};
+export type FlowSurfaceResolvedTarget = {
+    target: FlowSurfaceResolveTarget;
+    uid: string;
+    kind: FlowSurfaceContainerKind;
+    node?: any;
+    route?: any;
+    pageRoute?: any;
+    tabRoute?: any;
+    pageModel?: any;
+};
+export type FlowSurfaceExecutorContext = {
+    transaction?: any;
+    refs: Map<string, any>;
+    clientKeyToUid: Record<string, string>;
+};

package/dist/server/{flow-schema-contributions/actions/aclCheck.js → flow-surfaces/types.js}

@@ -11,10 +11,6 @@ var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
 var __copyProps = (to, from, except, desc) => {
   if (from && typeof from === "object" || typeof from === "function") {
     for (let key of __getOwnPropNames(from))
@@ -24,23 +20,5 @@ var __copyProps = (to, from, except, desc) => {
   return to;
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var aclCheck_exports = {};
-__export(aclCheck_exports, {
-  aclCheckSchemaContribution: () => aclCheckSchemaContribution
-});
-module.exports = __toCommonJS(aclCheck_exports);
-var import_shared = require("../shared");
-const aclCheckSchemaContribution = {
-  name: "aclCheck",
-  title: "ACL check",
-  source: "official",
-  strict: false,
-  paramsSchema: import_shared.emptyObjectSchema,
-  docs: {
-    minimalExample: {}
-  }
-};
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  aclCheckSchemaContribution
-});
+var types_exports = {};
+module.exports = __toCommonJS(types_exports);

package/dist/server/index.d.ts

@@ -8,4 +8,4 @@
  */
 export { default } from './plugin';
 export { FlowModelRepository } from './repository';
-export { FlowSchemaService } from './flow-schema-service';
+export { resolveVariablesBatch, resolveVariablesTemplate } from './variables/resolve';

package/dist/server/index.js

@@ -37,15 +37,17 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var server_exports = {};
 __export(server_exports, {
   FlowModelRepository: () => import_repository.FlowModelRepository,
-  FlowSchemaService: () => import_flow_schema_service.FlowSchemaService,
-  default: () => import_plugin.default
+  default: () => import_plugin.default,
+  resolveVariablesBatch: () => import_resolve.resolveVariablesBatch,
+  resolveVariablesTemplate: () => import_resolve.resolveVariablesTemplate
 });
 module.exports = __toCommonJS(server_exports);
 var import_plugin = __toESM(require("./plugin"));
 var import_repository = require("./repository");
-var import_flow_schema_service = require("./flow-schema-service");
+var import_resolve = require("./variables/resolve");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   FlowModelRepository,
-  FlowSchemaService
+  resolveVariablesBatch,
+  resolveVariablesTemplate
 });

package/dist/server/plugin.d.ts

@@ -6,12 +6,9 @@
  * 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 type { FlowSchemaContribution } from '@nocobase/flow-engine';
 import PluginUISchemaStorageServer from './server';
 export declare class PluginFlowEngineServer extends PluginUISchemaStorageServer {
-    private globalContext;
     afterAdd(): Promise<void>;
-    getFlowSchemaContributions(): FlowSchemaContribution;
     beforeLoad(): Promise<void>;
     getDatabaseByDataSourceKey(dataSourceKey?: string): import("@nocobase/database").default;
     load(): Promise<void>;

package/dist/server/plugin.js

@@ -41,19 +41,12 @@ __export(plugin_exports, {
 });
 module.exports = __toCommonJS(plugin_exports);
 var import_utils = require("@nocobase/utils");
-var import_flow_schema_contributions = require("./flow-schema-contributions");
+var import_flow_surfaces = require("./flow-surfaces");
 var import_server = __toESM(require("./server"));
-var import_contexts = require("./template/contexts");
-var import_resolver = require("./template/resolver");
-var import_registry = require("./variables/registry");
-var import_utils2 = require("./variables/utils");
+var import_resolve = require("./variables/resolve");
 class PluginFlowEngineServer extends import_server.default {
-  globalContext;
   async afterAdd() {
   }
-  getFlowSchemaContributions() {
-    return import_flow_schema_contributions.flowSchemaContribution;
-  }
   async beforeLoad() {
     await super.beforeLoad();
   }
@@ -66,12 +59,11 @@ class PluginFlowEngineServer extends import_server.default {
     return cm.db;
   }
   async load() {
-    var _a, _b;
     await super.load();
+    (0, import_flow_surfaces.registerFlowSurfacesResource)(this);
     this.app.auditManager.registerAction("flowSql:save");
     this.app.auditManager.registerAction("flowModels:save");
     this.app.auditManager.registerAction("flowModels:duplicate");
-    this.globalContext = new import_contexts.GlobalContext((_b = (_a = this.app.environment) == null ? void 0 : _a.getVariables) == null ? void 0 : _b.call(_a));
     this.app.acl.allow("flowSql", "runById", "loggedIn");
     this.app.acl.allow("flowSql", "getBind", "loggedIn");
     this.app.acl.allow("variables", "resolve", "loggedIn");
@@ -81,28 +73,12 @@ class PluginFlowEngineServer extends import_server.default {
       actions: {
         // 解析 JSON 模板中的 ctx 变量
         resolve: async (ctx, next) => {
-          var _a2, _b2;
-          const raw = ((_b2 = (_a2 = ctx.action) == null ? void 0 : _a2.params) == null ? void 0 : _b2.values) ?? {};
+          var _a, _b;
+          const raw = ((_b = (_a = ctx.action) == null ? void 0 : _a.params) == null ? void 0 : _b.values) ?? {};
           const values = typeof (raw == null ? void 0 : raw.values) !== "undefined" ? raw.values : raw;
           if (Array.isArray(values == null ? void 0 : values.batch)) {
             const batchItems = values.batch;
-            await (0, import_utils2.prefetchRecordsForResolve)(
-              ctx,
-              batchItems.map((it) => ({
-                template: it.template,
-                contextParams: it.contextParams || {}
-              }))
-            );
-            const results = [];
-            for (const item of batchItems) {
-              const template2 = (item == null ? void 0 : item.template) ?? {};
-              const contextParams2 = (item == null ? void 0 : item.contextParams) || {};
-              const requestCtx2 = new import_contexts.HttpRequestContext(ctx);
-              requestCtx2.delegate(this.globalContext);
-              await import_registry.variables.attachUsedVariables(requestCtx2, ctx, template2, contextParams2);
-              const resolved2 = await (0, import_resolver.resolveJsonTemplate)(template2, requestCtx2);
-              results.push({ id: item == null ? void 0 : item.id, data: resolved2 });
-            }
+            const results = await (0, import_resolve.resolveVariablesBatch)(ctx, batchItems);
             ctx.body = { results };
             await next();
             return;
@@ -115,12 +91,7 @@ class PluginFlowEngineServer extends import_server.default {
           }
           const template = values.template;
           const contextParams = (values == null ? void 0 : values.contextParams) || {};
-          await (0, import_utils2.prefetchRecordsForResolve)(ctx, [{ template, contextParams }]);
-          const requestCtx = new import_contexts.HttpRequestContext(ctx);
-          requestCtx.delegate(this.globalContext);
-          await import_registry.variables.attachUsedVariables(requestCtx, ctx, template, contextParams);
-          const resolved = await (0, import_resolver.resolveJsonTemplate)(template, requestCtx);
-          ctx.body = resolved;
+          ctx.body = await (0, import_resolve.resolveVariablesTemplate)(ctx, template, contextParams);
           await next();
         }
       }

package/dist/server/repository.d.ts

@@ -18,16 +18,6 @@ export interface GetPropertiesOptions {
     readFromCache?: boolean;
     transaction?: Transaction;
 }
-export interface FlowModelNodeRecord {
-    uid: string;
-    name?: string | null;
-    options?: unknown;
-    depth?: number | null;
-    type?: string | null;
-    async?: boolean | null;
-    parent?: string | null;
-    sort?: number | null;
-}
 export type FlowModelAttachPosition = 'first' | 'last' | TargetPosition;
 export interface FlowModelAttachOptions {
     parentId: string;
@@ -88,16 +78,9 @@ export declare class FlowModelRepository extends Repository {
     }): Promise<void>;
     remove(uid: string, options?: Transactionable & removeParentOptions): Promise<void>;
     insertAdjacent(position: 'beforeBegin' | 'afterBegin' | 'beforeEnd' | 'afterEnd', target: string, schema: any, options?: InsertAdjacentOptions): Promise<any>;
-    duplicate(modelUid: string, options?: Transactionable): Promise<{
-        subModels?: Record<string, any>;
-        async: boolean;
-        uid: any;
-    }>;
+    duplicate(modelUid: string, options?: Transactionable): Promise<any>;
     private dedupeNodesForDuplicate;
     private replaceStepParamsModelUids;
-    private sortNodesForDuplicate;
-    private prepareNodesForDuplicate;
-    private cloneNodesWithUidMap;
     insert(schema: any, options?: Transactionable): Promise<any>;
     insertNewSchema(schema: any, options?: Transactionable & {
         returnNode?: boolean;
@@ -120,7 +103,7 @@ export declare class FlowModelRepository extends Repository {
     protected insertAfterEnd(targetUid: string, schema: any, options?: InsertAdjacentOptions): Promise<any>;
     protected insertNodes(nodes: SchemaNode[], options?: Transactionable): Promise<any[]>;
     private doGetProperties;
-    findNodesById(uid: string, options?: GetJsonSchemaOptions): Promise<FlowModelNodeRecord[]>;
+    findNodesById(uid: string, options?: GetJsonSchemaOptions): Promise<unknown[]>;
     private doGetJsonSchema;
     private ignoreSchemaProperties;
     private breakOnMatched;
@@ -129,57 +112,16 @@ export declare class FlowModelRepository extends Repository {
     private insertSchemaRecord;
     private prepareSingleNodeForInsert;
     static modelToSingleNodes(model: any, parentChildOptions?: any): SchemaNode[];
-    static nodeToModel(node: any): {
-        async: boolean;
-        uid: any;
-    };
-    static nodesToModel(nodes: any[], rootUid: string): {
-        subModels?: Record<string, any>;
-        async: boolean;
-        uid: any;
-    };
-    insertModel(model: any, options?: Transactionable): Promise<{
-        subModels?: Record<string, any>;
-        async: boolean;
-        uid: any;
-    }>;
+    static nodeToModel(node: any): any;
+    static nodesToModel(nodes: any[], rootUid: string): any;
+    insertModel(model: any, options?: Transactionable): Promise<any>;
     updateSingleNode(node: SchemaNode, options?: Transactionable): Promise<boolean>;
     upsertModel(model: any, options?: Transactionable): Promise<string>;
-    findModelById(uid: string, options?: GetJsonSchemaOptions): Promise<{
-        subModels?: Record<string, any>;
-        async: boolean;
-        uid: any;
-    }>;
+    findModelById(uid: string, options?: GetJsonSchemaOptions): Promise<any>;
     findModelByParentId(parentUid: string, options?: GetJsonSchemaOptions & {
         subKey?: string;
-    }): Promise<{
-        subModels?: Record<string, any>;
-        async: boolean;
-        uid: any;
-    }>;
-    ensureModel(values: any, options?: Transactionable & {
-        includeAsyncNode?: boolean;
-    }): Promise<{
-        subModels?: Record<string, any>;
-        async: boolean;
-        uid: any;
-    }>;
-    attach(uid: string, attachOptions: FlowModelAttachOptions, options?: Transactionable): Promise<{
-        subModels?: Record<string, any>;
-        async: boolean;
-        uid: any;
-    }>;
-    duplicateWithTargetUid(modelUid: string, targetUid: string, options?: Transactionable & {
-        includeAsyncNode?: boolean;
-    }): Promise<{
-        subModels?: Record<string, any>;
-        async: boolean;
-        uid: any;
-    }>;
-    move(moveOptions: {
-        sourceId: string;
-        targetId: string;
-        position: 'before' | 'after';
-    }, options?: Transactionable): Promise<any>;
+    }): Promise<any>;
+    attach(uid: string, attachOptions: FlowModelAttachOptions, options?: Transactionable): Promise<any>;
+    move(options: any): Promise<any>;
 }
 export default FlowModelRepository;