@nocobase/plugin-flow-engine 2.1.0-alpha.40 → 2.1.0-alpha.46

package/dist/server/flow-surfaces/contract-guard.js

@@ -165,7 +165,7 @@ class FlowSurfaceContractGuard {
       if (typeof on === "string" && !allowedDirectEvents.has(eventName)) {
         (0, import_errors.throwBadRequest)(`flowSurfaces flow '${key}' event '${eventName}' is not allowed on '${node == null ? void 0 : node.use}'`);
       }
-      if (typeof on !== "string" && !allowedObjectEvents.has(eventName)) {
+      if (typeof on !== "string" && !allowedObjectEvents.has(eventName) && !allowedDirectEvents.has(eventName)) {
         (0, import_errors.throwBadRequest)(`flowSurfaces flow '${key}' event '${eventName}' is not allowed on '${node == null ? void 0 : node.use}'`);
       }
       const phase = onObj == null ? void 0 : onObj.phase;
@@ -349,33 +349,67 @@ function collectSchemaValueErrors(value, schema, path) {
 function normalizeDomainValue(value, contract, context) {
   const normalized = import_lodash.default.cloneDeep(value);
   Object.entries(contract.pathSchemas || {}).forEach(([path, schema]) => {
-    if (!import_lodash.default.has(normalized, path) || !isFilterGroupSchema(schema)) {
+    if (!import_lodash.default.has(normalized, path)) {
       return;
     }
-    import_lodash.default.set(normalized, path, normalizeFilterGroupValue(import_lodash.default.get(normalized, path), context, path));
+    if (isFilterGroupSchema(schema)) {
+      import_lodash.default.set(normalized, path, normalizeFilterGroupValue(import_lodash.default.get(normalized, path), context, path));
+    } else if (isLinkageRulesSchema(schema)) {
+      import_lodash.default.set(normalized, path, normalizeLinkageRulesValue(import_lodash.default.get(normalized, path), context, path));
+    }
   });
   return normalized;
 }
 function normalizeGroupValue(value, groupContract, context) {
   const normalized = import_lodash.default.cloneDeep(value);
   Object.entries(groupContract.pathSchemas || {}).forEach(([path, schema]) => {
-    if (!import_lodash.default.has(normalized, path) || !isFilterGroupSchema(schema)) {
+    if (!import_lodash.default.has(normalized, path)) {
       return;
     }
-    import_lodash.default.set(normalized, path, normalizeFilterGroupValue(import_lodash.default.get(normalized, path), context, path));
+    if (isFilterGroupSchema(schema)) {
+      import_lodash.default.set(normalized, path, normalizeFilterGroupValue(import_lodash.default.get(normalized, path), context, path));
+    } else if (isLinkageRulesSchema(schema)) {
+      import_lodash.default.set(normalized, path, normalizeLinkageRulesValue(import_lodash.default.get(normalized, path), context, path));
+    }
   });
   return normalized;
 }
 function isFilterGroupSchema(schema) {
   return (schema == null ? void 0 : schema["x-flowSurfaceFormat"]) === "filter-group";
 }
+function isLinkageRulesSchema(schema) {
+  return (schema == null ? void 0 : schema["x-flowSurfaceFormat"]) === "linkage-rules";
+}
 function normalizeFilterGroupValue(value, context, path) {
   const domainPath = context.groupKey ? `${context.domain}.${context.groupKey}.${path}` : `${context.domain}.${path}`;
   return (0, import_filter_group.normalizeFlowSurfaceFilterGroupValue)(
     value,
-    `flowSurfaces updateSettings domain '${domainPath}' on '${context.use}' expects FilterGroup like ${import_filter_group.FLOW_SURFACE_FILTER_GROUP_EXAMPLE}`
+    `flowSurfaces updateSettings domain '${domainPath}' on '${context.use}' expects FilterGroup like ${import_filter_group.FLOW_SURFACE_FILTER_GROUP_EXAMPLE}`,
+    { strictDateValues: true }
   );
 }
+function normalizeLinkageRulesValue(value, context, path) {
+  if (!Array.isArray(value)) {
+    return value;
+  }
+  return value.map((rule, index) => {
+    if (!import_lodash.default.isPlainObject(rule) || !import_lodash.default.has(rule, "condition")) {
+      return rule;
+    }
+    const normalizedRule = import_lodash.default.cloneDeep(rule);
+    const domainPath = context.groupKey ? `${context.domain}.${context.groupKey}.${path}[${index}].condition` : `${context.domain}.${path}[${index}].condition`;
+    import_lodash.default.set(
+      normalizedRule,
+      "condition",
+      (0, import_filter_group.normalizeFlowSurfaceCompatibleFilterGroupValue)(
+        import_lodash.default.get(normalizedRule, "condition"),
+        `flowSurfaces updateSettings domain '${domainPath}' on '${context.use}' expects FilterGroup or backend query filter like ${import_filter_group.FLOW_SURFACE_FILTER_GROUP_EXAMPLE}`,
+        { strictDateValues: true }
+      )
+    );
+    return normalizedRule;
+  });
+}
 function isContractDefinedFlowGroup(groupContract) {
   if (!groupContract) {
     return false;

package/dist/server/flow-surfaces/default-block-actions.js

@@ -104,6 +104,8 @@ const FLOW_SURFACE_DEFAULT_BLOCK_ACTIONS = {
   ],
   calendar: [
     { type: "filter", scope: "actions" },
+    { type: "turnPages", scope: "actions" },
+    { type: "selectView", scope: "actions" },
     { type: "refresh", scope: "actions" },
     {
       type: "addNew",

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

@@ -8,6 +8,7 @@
  */
 export type FlowSurfaceErrorType = 'bad_request' | 'forbidden' | 'conflict' | 'internal_error';
 export interface FlowSurfaceErrorItem {
+    index?: number;
     message: string;
     type: FlowSurfaceErrorType;
     code: string;
@@ -48,6 +49,20 @@ export declare class FlowSurfaceAggregateError extends FlowSurfaceError {
     readonly errors: FlowSurfaceErrorItem[];
     constructor(errors: FlowSurfaceErrorItemInput[], message?: string);
     toResponseBody(): {
+        message: string;
+        errorCount: number;
+        details: {
+            requiredBlockPolicy?: {
+                requiredBlockTypes: string[];
+                fixStrategy: string;
+                doNotReplaceOrDrop: boolean;
+            };
+            errorCount: number;
+            mustFixAllErrorsBeforeRetry: boolean;
+            retryPolicy: string;
+            sameWriteRetryRequired: boolean;
+            agentInstruction: string;
+        };
         errors: FlowSurfaceErrorItem[];
     };
 }

package/dist/server/flow-surfaces/errors.js

@@ -88,14 +88,27 @@ class FlowSurfaceInternalError extends FlowSurfaceError {
 }
 class FlowSurfaceAggregateError extends FlowSurfaceError {
   errors;
-  constructor(errors, message = "flowSurfaces authoring validation failed") {
-    const normalizedErrors = errors.map((error) => normalizeFlowSurfaceErrorItemInput(error));
-    super(message, 400, "bad_request", "FLOW_SURFACE_AUTHORING_VALIDATION_FAILED");
+  constructor(errors, message) {
+    const normalizedErrors = errors.map(
+      (error, index) => normalizeFlowSurfaceErrorItemInput({
+        ...error,
+        index: index + 1
+      })
+    );
+    super(
+      message || buildAggregateBadRequestMessage(normalizedErrors.length),
+      400,
+      "bad_request",
+      "FLOW_SURFACE_AUTHORING_VALIDATION_FAILED"
+    );
     this.name = "FlowSurfaceAggregateError";
     this.errors = normalizedErrors;
   }
   toResponseBody() {
     return {
+      message: this.message,
+      errorCount: this.errors.length,
+      details: buildAggregateBadRequestDetails(this.errors),
       errors: this.errors
     };
   }
@@ -162,6 +175,9 @@ function buildDefinedErrorItem(input) {
     code: input.code,
     status: input.status
   };
+  if (typeof input.index !== "undefined") {
+    output.index = input.index;
+  }
   if (typeof input.path !== "undefined") {
     output.path = input.path;
   }
@@ -176,6 +192,7 @@ function buildDefinedErrorItem(input) {
 function normalizeFlowSurfaceErrorItemInput(input) {
   return buildDefinedErrorItem({
     message: input.message,
+    index: input.index,
     type: input.type || "bad_request",
     code: input.code || "FLOW_SURFACE_AUTHORING_VALIDATION_ERROR",
     status: input.status || 400,
@@ -184,6 +201,35 @@ function normalizeFlowSurfaceErrorItemInput(input) {
     details: input.details
   });
 }
+function buildAggregateBadRequestMessage(errorCount) {
+  return `flowSurfaces authoring validation failed with ${errorCount} error(s); fix all errors before retrying the same write`;
+}
+function buildAggregateBadRequestDetails(errors) {
+  const requiredBlockTypes = Array.from(
+    new Set(
+      errors.map((error) => {
+        var _a;
+        return (_a = error.details) == null ? void 0 : _a.requiredBlockType;
+      }).filter(
+        (requiredBlockType) => typeof requiredBlockType === "string" && !!requiredBlockType
+      )
+    )
+  );
+  return {
+    errorCount: errors.length,
+    mustFixAllErrorsBeforeRetry: true,
+    retryPolicy: "fix_all_errors_before_retry_same_write",
+    sameWriteRetryRequired: true,
+    agentInstruction: "Read the complete errors[] array. Fix every listed error in one payload revision before retrying the same write. Do not fix only the first error and immediately retry. Do not drop, defer, or replace required chart, jsBlock, or JS/RunJS work to bypass validation.",
+    ...requiredBlockTypes.length ? {
+      requiredBlockPolicy: {
+        requiredBlockTypes,
+        fixStrategy: "repair_same_block_type",
+        doNotReplaceOrDrop: true
+      }
+    } : {}
+  };
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   FlowSurfaceAggregateError,

package/dist/server/flow-surfaces/event-flow-normalizer.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.
+ */
+export type FlowSurfaceEventFlowRecord = Record<string, unknown>;
+export type FlowSurfaceEventFlowRegistry = Record<string, FlowSurfaceEventFlowRecord>;
+export declare function buildFlowSurfaceEmptyEventCondition(): {
+    logic: string;
+    items: any[];
+};
+export declare function normalizeFlowSurfaceEventFlowOn(on: unknown): unknown;
+export declare function normalizeFlowSurfaceEventFlow(actionName: string, key: string, flowInput: unknown): FlowSurfaceEventFlowRecord;
+export declare function normalizeFlowSurfaceEventFlowRegistry(actionName: string, flowRegistry: Record<string, unknown>): FlowSurfaceEventFlowRegistry;
+export declare function normalizeFlowSurfaceEventFlowRegistry<T>(actionName: string, flowRegistry: T): T;
+export declare function isFlowSurfaceBeforeAllEventFlow(flow: unknown): boolean;

package/dist/server/flow-surfaces/event-flow-normalizer.js

@@ -0,0 +1,128 @@
+/**
+ * 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 event_flow_normalizer_exports = {};
+__export(event_flow_normalizer_exports, {
+  buildFlowSurfaceEmptyEventCondition: () => buildFlowSurfaceEmptyEventCondition,
+  isFlowSurfaceBeforeAllEventFlow: () => isFlowSurfaceBeforeAllEventFlow,
+  normalizeFlowSurfaceEventFlow: () => normalizeFlowSurfaceEventFlow,
+  normalizeFlowSurfaceEventFlowOn: () => normalizeFlowSurfaceEventFlowOn,
+  normalizeFlowSurfaceEventFlowRegistry: () => normalizeFlowSurfaceEventFlowRegistry
+});
+module.exports = __toCommonJS(event_flow_normalizer_exports);
+var import_lodash = __toESM(require("lodash"));
+var import_errors = require("./errors");
+function asPlainRecord(value) {
+  return import_lodash.default.isPlainObject(value) ? value : null;
+}
+function buildFlowSurfaceEmptyEventCondition() {
+  return { logic: "$and", items: [] };
+}
+function normalizeFlowSurfaceEventFlowOn(on) {
+  if (typeof on === "string") {
+    const eventName2 = on.trim();
+    if (!eventName2) {
+      return on;
+    }
+    return {
+      eventName: eventName2,
+      defaultParams: {
+        condition: buildFlowSurfaceEmptyEventCondition()
+      }
+    };
+  }
+  const onRecord = asPlainRecord(on);
+  if (!onRecord) {
+    return on;
+  }
+  const next = import_lodash.default.cloneDeep(onRecord);
+  const eventName = String(next.eventName || "").trim();
+  if (eventName) {
+    next.eventName = eventName;
+  }
+  const phase = String(next.phase || "").trim();
+  if (!phase || phase === "beforeAllFlows") {
+    delete next.phase;
+  } else {
+    next.phase = phase;
+  }
+  const defaultParams = asPlainRecord(next.defaultParams) || {};
+  if (!asPlainRecord(defaultParams.condition)) {
+    defaultParams.condition = buildFlowSurfaceEmptyEventCondition();
+  }
+  next.defaultParams = defaultParams;
+  return next;
+}
+function normalizeFlowSurfaceEventFlow(actionName, key, flowInput) {
+  const flowRecord = asPlainRecord(flowInput);
+  if (!flowRecord) {
+    (0, import_errors.throwBadRequest)(`flowSurfaces ${actionName} flow '${key}' must be an object`);
+  }
+  const flow = import_lodash.default.cloneDeep(flowRecord);
+  flow.key = key;
+  if (asPlainRecord(flow.on) || typeof flow.on === "string") {
+    flow.on = normalizeFlowSurfaceEventFlowOn(flow.on);
+  }
+  if (import_lodash.default.isUndefined(flow.steps)) {
+    flow.steps = {};
+  }
+  return flow;
+}
+function normalizeFlowSurfaceEventFlowRegistry(actionName, flowRegistry) {
+  const registryRecord = asPlainRecord(flowRegistry);
+  if (!registryRecord) {
+    return flowRegistry;
+  }
+  return Object.fromEntries(
+    Object.entries(registryRecord).map(([key, flow]) => [key, normalizeFlowSurfaceEventFlow(actionName, key, flow)])
+  );
+}
+function isFlowSurfaceBeforeAllEventFlow(flow) {
+  const flowRecord = asPlainRecord(flow);
+  if (!flowRecord) {
+    return false;
+  }
+  const onRecord = asPlainRecord(normalizeFlowSurfaceEventFlowOn(flowRecord.on));
+  return Boolean(onRecord) && typeof (onRecord == null ? void 0 : onRecord.eventName) === "string" && (typeof onRecord.phase === "undefined" || onRecord.phase === "beforeAllFlows");
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  buildFlowSurfaceEmptyEventCondition,
+  isFlowSurfaceBeforeAllEventFlow,
+  normalizeFlowSurfaceEventFlow,
+  normalizeFlowSurfaceEventFlowOn,
+  normalizeFlowSurfaceEventFlowRegistry
+});

package/dist/server/flow-surfaces/filter-group.d.ts

@@ -11,5 +11,13 @@ export declare const FLOW_SURFACE_EMPTY_FILTER_GROUP: {
     items: any[];
 };
 export declare const FLOW_SURFACE_FILTER_GROUP_EXAMPLE: string;
-export declare function normalizeFlowSurfaceFilterGroupValue(value: any, errorPrefix: string): any;
+export declare function assertFlowSurfaceFilterOperator(operator: unknown, path: string): void;
+export declare function normalizeFlowSurfaceFilterDateValue(operator: unknown, value: unknown, path: string): unknown;
+export declare function normalizeFlowSurfaceStrictFilterDateValue(operator: unknown, value: unknown, path: string): unknown;
+export declare function normalizeFlowSurfaceFilterGroupValue(value: any, errorPrefix: string, options?: {
+    strictDateValues?: boolean;
+}): any;
+export declare function normalizeFlowSurfaceCompatibleFilterGroupValue(value: unknown, errorPrefix: string, options?: {
+    strictDateValues?: boolean;
+}): any;
 export declare function assertFlowSurfaceFilterGroupShape(filter: any): void;