@nocobase/plugin-flow-engine 2.1.0-beta.14 → 2.1.0-beta.16

package/dist/server/flow-surfaces/reaction/types.js

@@ -0,0 +1,24 @@
+/**
+ * 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.
+ */
+
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var types_exports = {};
+module.exports = __toCommonJS(types_exports);

package/dist/server/flow-surfaces/reaction/utils.d.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.
+ */
+type RunJSValue = {
+    code: string;
+    version?: string;
+};
+export declare function extractPropertyPath(value: string): string[] | null;
+export declare function formatPathToVariable(path: string[]): string;
+export declare function isVariableExpression(value: unknown): boolean;
+export declare function normalizeRunJSValue(value: RunJSValue | null | undefined): Required<RunJSValue>;
+export {};

package/dist/server/flow-surfaces/reaction/utils.js

@@ -0,0 +1,67 @@
+/**
+ * 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.
+ */
+
+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))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var utils_exports = {};
+__export(utils_exports, {
+  extractPropertyPath: () => extractPropertyPath,
+  formatPathToVariable: () => formatPathToVariable,
+  isVariableExpression: () => isVariableExpression,
+  normalizeRunJSValue: () => normalizeRunJSValue
+});
+module.exports = __toCommonJS(utils_exports);
+function extractPropertyPath(value) {
+  if (typeof value !== "string") return null;
+  const trimmed = value.trim();
+  const variableRegex = /^\{\{\s*ctx(?:\.(.+?))?\s*\}\}$/;
+  const match = trimmed.match(variableRegex);
+  if (!match) return null;
+  const pathString = match[1];
+  if (!pathString) return [];
+  return pathString.split(".").map((part) => part.trim()).filter((part) => part.length > 0);
+}
+function formatPathToVariable(path) {
+  if (path.length === 0) return "{{ ctx }}";
+  return `{{ ctx.${path.join(".")} }}`;
+}
+function isVariableExpression(value) {
+  if (typeof value !== "string") return false;
+  const trimmed = value.trim();
+  const variableRegex = /^\{\{\s*ctx(?:\..+?)?\s*\}\}$/;
+  return variableRegex.test(trimmed);
+}
+function normalizeRunJSValue(value) {
+  return {
+    code: String((value == null ? void 0 : value.code) ?? ""),
+    version: String((value == null ? void 0 : value.version) ?? "v1")
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  extractPropertyPath,
+  formatPathToVariable,
+  isVariableExpression,
+  normalizeRunJSValue
+});

package/dist/server/flow-surfaces/reaction/value-expr.d.ts

@@ -0,0 +1,15 @@
+/**
+ * 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 type { FlowSurfaceReactionFilter, FlowSurfaceValueExpr } from './types';
+export declare function barePathToVariableExpression(path: unknown, label?: string): string;
+export declare function normalizeReactionValueExpr(input: any): FlowSurfaceValueExpr;
+export declare function compileReactionValueExpr(input: FlowSurfaceValueExpr | any): any;
+export declare function normalizeReactionFilter(filter: FlowSurfaceReactionFilter | undefined): FlowSurfaceReactionFilter;
+export declare function compileReactionFilter(filter: FlowSurfaceReactionFilter | undefined): FlowSurfaceReactionFilter;
+export declare function normalizeReactionPath(path: unknown, label: string): string;

package/dist/server/flow-surfaces/reaction/value-expr.js

@@ -0,0 +1,209 @@
+/**
+ * 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.
+ */
+
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var value_expr_exports = {};
+__export(value_expr_exports, {
+  barePathToVariableExpression: () => barePathToVariableExpression,
+  compileReactionFilter: () => compileReactionFilter,
+  compileReactionValueExpr: () => compileReactionValueExpr,
+  normalizeReactionFilter: () => normalizeReactionFilter,
+  normalizeReactionPath: () => normalizeReactionPath,
+  normalizeReactionValueExpr: () => normalizeReactionValueExpr
+});
+module.exports = __toCommonJS(value_expr_exports);
+var import_lodash = __toESM(require("lodash"));
+var import_errors = require("../errors");
+var import_errors2 = require("./errors");
+var import_utils = require("./utils");
+const EMPTY_CONDITION = Object.freeze({ logic: "$and", items: [] });
+function normalizeBarePath(path, label) {
+  if (typeof path === "string" && (0, import_utils.isVariableExpression)(path)) {
+    const extracted = (0, import_utils.extractPropertyPath)(path);
+    if (Array.isArray(extracted)) {
+      return extracted.join(".");
+    }
+  }
+  const normalized = String(path ?? "").trim().split(".").map((segment) => segment.trim()).filter(Boolean).join(".");
+  if (!normalized) {
+    (0, import_errors.throwBadRequest)(`flowSurfaces reaction ${label} cannot be empty`, import_errors2.FLOW_SURFACE_REACTION_INVALID_CONDITION_PATH);
+  }
+  return normalized;
+}
+function barePathToVariableExpression(path, label = "path") {
+  const normalized = normalizeBarePath(path, label);
+  return (0, import_utils.formatPathToVariable)(
+    normalized.split(".").map((segment) => segment.trim()).filter(Boolean)
+  );
+}
+function normalizeReactionValueExpr(input) {
+  if (!import_lodash.default.isPlainObject(input) || !Object.prototype.hasOwnProperty.call(input, "source")) {
+    if (typeof input === "string" && (0, import_utils.isVariableExpression)(input)) {
+      return {
+        source: "path",
+        path: normalizeBarePath(input, "value.path")
+      };
+    }
+    if (import_lodash.default.isPlainObject(input) && Object.prototype.hasOwnProperty.call(input, "code")) {
+      const normalizedRunjs = (0, import_utils.normalizeRunJSValue)({
+        code: String(input.code ?? ""),
+        version: input.version == null ? void 0 : String(input.version)
+      });
+      return {
+        source: "runjs",
+        code: normalizedRunjs.code,
+        version: normalizedRunjs.version
+      };
+    }
+    return {
+      source: "literal",
+      value: import_lodash.default.cloneDeep(input)
+    };
+  }
+  const source = String(input.source || "").trim();
+  if (source === "literal") {
+    return {
+      source: "literal",
+      value: import_lodash.default.cloneDeep(input.value)
+    };
+  }
+  if (source === "path") {
+    return {
+      source: "path",
+      path: normalizeBarePath(input.path, "value.path")
+    };
+  }
+  if (source === "runjs") {
+    const normalizedRunjs = (0, import_utils.normalizeRunJSValue)({
+      code: String(input.code ?? ""),
+      version: input.version == null ? void 0 : String(input.version)
+    });
+    return {
+      source: "runjs",
+      code: normalizedRunjs.code,
+      version: normalizedRunjs.version
+    };
+  }
+  (0, import_errors.throwBadRequest)(`flowSurfaces reaction value.source '${source}' is unsupported`);
+}
+function compileReactionValueExpr(input) {
+  const normalized = normalizeReactionValueExpr(input);
+  if (normalized.source === "literal") {
+    return import_lodash.default.cloneDeep(normalized.value);
+  }
+  if (normalized.source === "path") {
+    return barePathToVariableExpression(normalized.path, "value.path");
+  }
+  const normalizedRunjs = (0, import_utils.normalizeRunJSValue)({
+    code: normalized.code,
+    version: normalized.version
+  });
+  return {
+    code: normalizedRunjs.code,
+    version: normalizedRunjs.version
+  };
+}
+function compileConditionNode(input) {
+  if (Array.isArray(input)) {
+    return input.map((item) => compileConditionNode(item));
+  }
+  if (import_lodash.default.isPlainObject(input)) {
+    if (Object.prototype.hasOwnProperty.call(input, "source")) {
+      return compileReactionValueExpr(input);
+    }
+    const output = {};
+    for (const [key, value] of Object.entries(input)) {
+      if (key === "path") {
+        output[key] = barePathToVariableExpression(value, "condition.path");
+        continue;
+      }
+      if (key === "value") {
+        output[key] = compileConditionNode(value);
+        continue;
+      }
+      output[key] = compileConditionNode(value);
+    }
+    return output;
+  }
+  return import_lodash.default.cloneDeep(input);
+}
+function normalizeReactionFilter(filter) {
+  if (import_lodash.default.isNil(filter)) {
+    return import_lodash.default.cloneDeep(EMPTY_CONDITION);
+  }
+  if (!import_lodash.default.isPlainObject(filter)) {
+    (0, import_errors.throwBadRequest)("flowSurfaces reaction when must be an object");
+  }
+  const visit = (input) => {
+    if (Array.isArray(input)) {
+      return input.map((item) => visit(item));
+    }
+    if (!import_lodash.default.isPlainObject(input)) {
+      return import_lodash.default.cloneDeep(input);
+    }
+    if (Object.prototype.hasOwnProperty.call(input, "source")) {
+      return normalizeReactionValueExpr(input);
+    }
+    const output = {};
+    for (const [key, value] of Object.entries(input)) {
+      if (key === "path") {
+        output[key] = normalizeBarePath(value, "condition.path");
+        continue;
+      }
+      if (key === "value") {
+        output[key] = visit(value);
+        continue;
+      }
+      output[key] = visit(value);
+    }
+    return output;
+  };
+  return visit(filter);
+}
+function compileReactionFilter(filter) {
+  return compileConditionNode(normalizeReactionFilter(filter));
+}
+function normalizeReactionPath(path, label) {
+  return normalizeBarePath(path, label);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  barePathToVariableExpression,
+  compileReactionFilter,
+  compileReactionValueExpr,
+  normalizeReactionFilter,
+  normalizeReactionPath,
+  normalizeReactionValueExpr
+});

package/dist/server/flow-surfaces/reference-guards.d.ts

@@ -0,0 +1,19 @@
+/**
+ * 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 type { FlowSurfacePlanStepLink } from './types';
+export declare function isFlowSurfacePlanStepValue(input: any): input is FlowSurfacePlanStepLink;
+export declare function normalizeFlowSurfacePlanStepValue(actionName: string, input: any, fieldName: string): FlowSurfacePlanStepLink;
+export declare function throwUnsupportedFlowSurfaceDollarRef(actionName: string, path: string, allowed: string): never;
+export declare function throwUnsupportedFlowSurfaceRef(actionName: string, path: string, allowed: string): never;
+export declare function assertNoFlowSurfaceLegacyRef(input: any, options: {
+    actionName: string;
+    path: string;
+    dollarRefAllowed?: string;
+    refAllowed?: string;
+}): void;

package/dist/server/flow-surfaces/reference-guards.js

@@ -0,0 +1,103 @@
+/**
+ * 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.
+ */
+
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var reference_guards_exports = {};
+__export(reference_guards_exports, {
+  assertNoFlowSurfaceLegacyRef: () => assertNoFlowSurfaceLegacyRef,
+  isFlowSurfacePlanStepValue: () => isFlowSurfacePlanStepValue,
+  normalizeFlowSurfacePlanStepValue: () => normalizeFlowSurfacePlanStepValue,
+  throwUnsupportedFlowSurfaceDollarRef: () => throwUnsupportedFlowSurfaceDollarRef,
+  throwUnsupportedFlowSurfaceRef: () => throwUnsupportedFlowSurfaceRef
+});
+module.exports = __toCommonJS(reference_guards_exports);
+var import_lodash = __toESM(require("lodash"));
+var import_errors = require("./errors");
+function isFlowSurfacePlanStepValue(input) {
+  return import_lodash.default.isPlainObject(input) && Object.keys(input).every((key) => ["step", "path"].includes(key)) && typeof input.step === "string" && !!input.step.trim();
+}
+function normalizeFlowSurfacePlanStepValue(actionName, input, fieldName) {
+  if (!import_lodash.default.isPlainObject(input)) {
+    (0, import_errors.throwBadRequest)(`flowSurfaces ${actionName} ${fieldName} must be an object`);
+  }
+  if (Object.keys(input).some((key) => !["step", "path"].includes(key))) {
+    (0, import_errors.throwBadRequest)(`flowSurfaces ${actionName} ${fieldName} only supports step/path`);
+  }
+  const step = String(input.step || "").trim();
+  if (!step) {
+    (0, import_errors.throwBadRequest)(`flowSurfaces ${actionName} ${fieldName}.step cannot be empty`);
+  }
+  const path = import_lodash.default.isUndefined(input.path) ? void 0 : String(input.path || "").trim();
+  if (import_lodash.default.has(input, "path") && !path) {
+    (0, import_errors.throwBadRequest)(`flowSurfaces ${actionName} ${fieldName}.path cannot be empty`);
+  }
+  return {
+    step,
+    ...path ? { path } : {}
+  };
+}
+function throwUnsupportedFlowSurfaceDollarRef(actionName, path, allowed) {
+  (0, import_errors.throwBadRequest)(`flowSurfaces ${actionName} ${path} must use ${allowed}; "$ref" is not supported`);
+}
+function throwUnsupportedFlowSurfaceRef(actionName, path, allowed) {
+  (0, import_errors.throwBadRequest)(`flowSurfaces ${actionName} ${path} does not support { ref }; use ${allowed}`);
+}
+function assertNoFlowSurfaceLegacyRef(input, options) {
+  if (!import_lodash.default.isPlainObject(input)) {
+    return;
+  }
+  if (Object.prototype.hasOwnProperty.call(input, "$ref")) {
+    throwUnsupportedFlowSurfaceDollarRef(
+      options.actionName,
+      options.path,
+      options.dollarRefAllowed || options.refAllowed || "key"
+    );
+  }
+  if (Object.prototype.hasOwnProperty.call(input, "ref")) {
+    throwUnsupportedFlowSurfaceRef(
+      options.actionName,
+      options.path,
+      options.refAllowed || options.dollarRefAllowed || "key"
+    );
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  assertNoFlowSurfaceLegacyRef,
+  isFlowSurfacePlanStepValue,
+  normalizeFlowSurfacePlanStepValue,
+  throwUnsupportedFlowSurfaceDollarRef,
+  throwUnsupportedFlowSurfaceRef
+});

package/dist/server/flow-surfaces/route-sync.d.ts

@@ -0,0 +1,47 @@
+/**
+ * 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 FlowModelRepository from '../repository';
+export declare class FlowSurfaceRouteSync {
+    private readonly db;
+    private readonly repository;
+    constructor(db: any, repository: FlowModelRepository);
+    buildPageTree(pageRouteLike: any, transaction?: any): Promise<any>;
+    buildTabAnchor(tabRouteLike: any, transaction?: any): Promise<{
+        subModels?: {
+            grid: Record<string, any>;
+        };
+        uid: string;
+        use: string;
+        props: {
+            route: Record<string, any>;
+            title: string;
+            icon: string;
+        };
+        decoratorProps: Record<string, any>;
+        flowRegistry: Record<string, any>;
+        stepParams: {
+            pageTabSettings: any;
+        };
+    }>;
+    removeRouteAnchorChildren(schemaUid: string, transaction?: any): Promise<void>;
+    removeTabAnchorTree(schemaUid: string, transaction?: any): Promise<void>;
+    persistPageSettings(target: any, current: any, nextPayload: Record<string, any>, transaction?: any): Promise<void>;
+    persistTabSettings(target: any, current: any, nextPayload: Record<string, any>, transaction?: any): Promise<void>;
+    findPersistedTabAnchor(schemaUid: string, transaction?: any): Promise<any>;
+    hydrateRoute(routeLike: any, transaction?: any): Promise<any>;
+    private readPageRouteBackedState;
+    private buildPageRoutePatch;
+    private normalizePagePayload;
+    private buildTabRoutePatch;
+    normalizeTabPayload(current: any, nextPayload: Record<string, any>, routePatch: Record<string, any>): {
+        props: any;
+        stepParams: any;
+        flowRegistry: any;
+    };
+}