@nocobase/plugin-flow-engine 2.1.0-alpha.18 → 2.1.0-alpha.19

package/dist/server/flow-surfaces/approval/runtime-config.js

@@ -0,0 +1,299 @@
+/**
+ * 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 runtime_config_exports = {};
+__export(runtime_config_exports, {
+  APPROVAL_SINGLETON_ACTION_USES: () => APPROVAL_SINGLETON_ACTION_USES,
+  APPROVAL_SURFACE_ROOT_USES: () => APPROVAL_SURFACE_ROOT_USES,
+  FlowSurfaceApprovalRuntimeConfigService: () => FlowSurfaceApprovalRuntimeConfigService
+});
+module.exports = __toCommonJS(runtime_config_exports);
+var import_lodash = __toESM(require("lodash"));
+var import_service_utils = require("../service-utils");
+var import_errors = require("../errors");
+const APPROVAL_SURFACE_ROOT_USES = /* @__PURE__ */ new Set([
+  "TriggerChildPageModel",
+  "ApprovalChildPageModel",
+  "ApplyTaskCardDetailsModel",
+  "ApprovalTaskCardDetailsModel"
+]);
+const APPROVAL_SINGLETON_ACTION_USES = /* @__PURE__ */ new Set([
+  "ApplyFormSubmitModel",
+  "ApplyFormSaveDraftModel",
+  "ApplyFormWithdrawModel",
+  "ProcessFormApproveModel",
+  "ProcessFormRejectModel",
+  "ProcessFormReturnModel",
+  "ProcessFormDelegateModel",
+  "ProcessFormAddAssigneeModel"
+]);
+const APPROVAL_PROCESS_ACTION_STATUS_BY_USE = {
+  ProcessFormApproveModel: 2,
+  ProcessFormRejectModel: -1,
+  ProcessFormReturnModel: 1,
+  ProcessFormDelegateModel: 8,
+  ProcessFormAddAssigneeModel: 99
+};
+const APPROVAL_PROCESS_ACTION_STATUS_ORDER = [2, -1, 1, 8, 99];
+class FlowSurfaceApprovalRuntimeConfigService {
+  constructor(deps) {
+    this.deps = deps;
+  }
+  getRepositoryIfAvailable(resourceName) {
+    try {
+      return this.deps.db.getRepository(resourceName);
+    } catch {
+      return null;
+    }
+  }
+  readModelField(model, fieldName) {
+    var _a;
+    return ((_a = model == null ? void 0 : model.get) == null ? void 0 : _a.call(model, fieldName)) ?? (model == null ? void 0 : model[fieldName]);
+  }
+  readApprovalConfig(model) {
+    return import_lodash.default.cloneDeep(this.readModelField(model, "config") || {});
+  }
+  collectApprovalActionNodes(node, carry = []) {
+    if (!(node == null ? void 0 : node.uid)) {
+      return carry;
+    }
+    if (APPROVAL_SINGLETON_ACTION_USES.has(node.use || "")) {
+      carry.push(node);
+    }
+    Object.values(node.subModels || {}).forEach((subModel) => {
+      import_lodash.default.castArray(subModel).forEach((child) => this.collectApprovalActionNodes(child, carry));
+    });
+    return carry;
+  }
+  async findApprovalSurfaceRootForNode(uid, transaction) {
+    let cursor = String(uid || "").trim();
+    const visited = /* @__PURE__ */ new Set();
+    while (cursor && !visited.has(cursor)) {
+      visited.add(cursor);
+      const node = await this.deps.repository.findModelById(cursor, {
+        transaction,
+        includeAsyncNode: true
+      });
+      if (!(node == null ? void 0 : node.uid)) {
+        return null;
+      }
+      if (APPROVAL_SURFACE_ROOT_USES.has(node.use || "")) {
+        return node;
+      }
+      cursor = String(
+        node.parentId || await this.deps.locator.findParentUid(node.uid, transaction).catch(() => "") || ""
+      );
+    }
+    return null;
+  }
+  async findApprovalWorkflowBySurfaceRootUid(rootUid, transaction) {
+    const workflowsRepository = this.getRepositoryIfAvailable("workflows");
+    if (!workflowsRepository) {
+      return null;
+    }
+    const workflows = await workflowsRepository.find({
+      filter: {
+        type: "approval"
+      },
+      transaction
+    });
+    return workflows.find((workflow) => this.readApprovalConfig(workflow).approvalUid === rootUid) || null;
+  }
+  async findApprovalNodeBySurfaceRootUid(rootUid, transaction) {
+    const nodesRepository = this.getRepositoryIfAvailable("flow_nodes");
+    if (!nodesRepository) {
+      return null;
+    }
+    const nodes = await nodesRepository.find({
+      filter: {
+        type: "approval"
+      },
+      transaction
+    });
+    return nodes.find((node) => this.readApprovalConfig(node).approvalUid === rootUid) || null;
+  }
+  async patchApprovalRuntimeConfig(resourceName, model, nextConfig, transaction) {
+    const currentConfig = this.readApprovalConfig(model);
+    if (import_lodash.default.isEqual(currentConfig, nextConfig)) {
+      return;
+    }
+    await this.deps.db.getRepository(resourceName).update({
+      filterByTk: this.readModelField(model, "id"),
+      values: {
+        config: nextConfig
+      },
+      transaction
+    });
+  }
+  getApprovalActionStepValue(actionNode, fieldName) {
+    const clickSettings = import_lodash.default.get(actionNode, ["stepParams", "clickSettings"]);
+    return import_lodash.default.get(clickSettings, ["saveResource", fieldName]) ?? import_lodash.default.get(clickSettings, fieldName);
+  }
+  buildApprovalReturnRuntimeConfig(actionNode) {
+    const settings = this.getApprovalActionStepValue(actionNode, "approvalReturnNodeSettings") || {};
+    const type = String((settings == null ? void 0 : settings.type) || "start").trim();
+    if (type === "any") {
+      return {
+        returnTo: -1,
+        returnToNodeVariable: null
+      };
+    }
+    if (type === "count") {
+      const count = Number(settings == null ? void 0 : settings.count);
+      return {
+        returnTo: Number.isFinite(count) && count > 0 ? count : 1,
+        returnToNodeVariable: null
+      };
+    }
+    if (type === "specific") {
+      const target = String((settings == null ? void 0 : settings.target) || "").trim();
+      return {
+        returnTo: target || null,
+        returnToNodeVariable: target ? `{{$jobsMapByNodeKey.${target}}}` : null
+      };
+    }
+    return {
+      returnTo: null,
+      returnToNodeVariable: null
+    };
+  }
+  buildApprovalReassignRuntimeConfig(actionNode) {
+    const assigneesScope = this.getApprovalActionStepValue(actionNode, "assigneesScope") || {};
+    const assignees = import_lodash.default.castArray((assigneesScope == null ? void 0 : assigneesScope.assignees) || []).filter((item) => !import_lodash.default.isUndefined(item) && !import_lodash.default.isNull(item) && item !== "").map(
+      (item) => import_lodash.default.isPlainObject(item) && !Object.prototype.hasOwnProperty.call(item, "filter") ? { filter: item } : item
+    );
+    return {
+      assignees,
+      options: (0, import_service_utils.buildDefinedPayload)({
+        extraFieldKey: assigneesScope == null ? void 0 : assigneesScope.extraFieldKey
+      })
+    };
+  }
+  async syncApprovalWorkflowRuntimeConfig(root, transaction) {
+    const workflow = await this.findApprovalWorkflowBySurfaceRootUid(root.uid, transaction);
+    if (!workflow) {
+      return;
+    }
+    const currentConfig = this.readApprovalConfig(workflow);
+    const actions = this.collectApprovalActionNodes(root);
+    await this.patchApprovalRuntimeConfig(
+      "workflows",
+      workflow,
+      {
+        ...currentConfig,
+        withdrawable: actions.some((action) => action.use === "ApplyFormWithdrawModel")
+      },
+      transaction
+    );
+  }
+  async syncApprovalNodeRuntimeConfig(root, transaction) {
+    const node = await this.findApprovalNodeBySurfaceRootUid(root.uid, transaction);
+    if (!node) {
+      return;
+    }
+    const currentConfig = this.readApprovalConfig(node);
+    const actionNodes = this.collectApprovalActionNodes(root);
+    const statusSet = new Set(
+      actionNodes.map((action) => APPROVAL_PROCESS_ACTION_STATUS_BY_USE[action.use || ""]).filter((status) => !import_lodash.default.isUndefined(status))
+    );
+    const nextConfig = {
+      ...currentConfig,
+      actions: APPROVAL_PROCESS_ACTION_STATUS_ORDER.filter((status) => statusSet.has(status))
+    };
+    const returnAction = actionNodes.find((action) => action.use === "ProcessFormReturnModel");
+    Object.assign(
+      nextConfig,
+      returnAction ? this.buildApprovalReturnRuntimeConfig(returnAction) : {
+        returnTo: null,
+        returnToNodeVariable: null
+      }
+    );
+    const delegateAction = actionNodes.find((action) => action.use === "ProcessFormDelegateModel");
+    const delegateConfig = delegateAction ? this.buildApprovalReassignRuntimeConfig(delegateAction) : null;
+    nextConfig.toDelegateReassignees = (delegateConfig == null ? void 0 : delegateConfig.assignees) || [];
+    nextConfig.toDelegateReassigneesOptions = (delegateConfig == null ? void 0 : delegateConfig.options) || {};
+    const addAssigneeAction = actionNodes.find((action) => action.use === "ProcessFormAddAssigneeModel");
+    const addAssigneeConfig = addAssigneeAction ? this.buildApprovalReassignRuntimeConfig(addAssigneeAction) : null;
+    nextConfig.toAddReassignees = (addAssigneeConfig == null ? void 0 : addAssigneeConfig.assignees) || [];
+    nextConfig.toAddReassigneesOptions = (addAssigneeConfig == null ? void 0 : addAssigneeConfig.options) || {};
+    await this.patchApprovalRuntimeConfig("flow_nodes", node, nextConfig, transaction);
+  }
+  async syncApprovalRuntimeConfigForSurfaceRoot(root, transaction) {
+    if (!(root == null ? void 0 : root.uid)) {
+      return;
+    }
+    const currentRoot = await this.deps.repository.findModelById(root.uid, {
+      transaction,
+      includeAsyncNode: true
+    });
+    if (!(currentRoot == null ? void 0 : currentRoot.uid)) {
+      return;
+    }
+    if (currentRoot.use === "TriggerChildPageModel") {
+      await this.syncApprovalWorkflowRuntimeConfig(currentRoot, transaction);
+      return;
+    }
+    if (currentRoot.use === "ApprovalChildPageModel") {
+      await this.syncApprovalNodeRuntimeConfig(currentRoot, transaction);
+    }
+  }
+  async syncApprovalRuntimeConfigForNode(uid, transaction) {
+    const root = await this.findApprovalSurfaceRootForNode(uid, transaction);
+    if (root) {
+      await this.syncApprovalRuntimeConfigForSurfaceRoot(root, transaction);
+    }
+  }
+  async assertApprovalActionSingleton(parentUid, actionUse, transaction) {
+    var _a;
+    if (!APPROVAL_SINGLETON_ACTION_USES.has(actionUse)) {
+      return;
+    }
+    const parent = await this.deps.repository.findModelById(parentUid, {
+      transaction,
+      includeAsyncNode: true
+    });
+    const existing = import_lodash.default.castArray(((_a = parent == null ? void 0 : parent.subModels) == null ? void 0 : _a.actions) || []).find((action) => (action == null ? void 0 : action.use) === actionUse);
+    if (existing == null ? void 0 : existing.uid) {
+      (0, import_errors.throwBadRequest)(`flowSurfaces addAction approval action '${actionUse}' already exists in '${parent.use}'`);
+    }
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  APPROVAL_SINGLETON_ACTION_USES,
+  APPROVAL_SURFACE_ROOT_USES,
+  FlowSurfaceApprovalRuntimeConfigService
+});

package/dist/server/flow-surfaces/approval/semantic-use.d.ts

@@ -0,0 +1,23 @@
+/**
+ * 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 declare const APPROVAL_PAGE_MODEL_USES: readonly ["TriggerChildPageModel", "ApprovalChildPageModel"];
+export declare const APPROVAL_TAB_MODEL_USES: readonly ["TriggerChildPageTabModel", "ApprovalChildPageTabModel"];
+export declare const APPROVAL_BLOCK_GRID_USES: readonly ["TriggerBlockGridModel", "ApprovalBlockGridModel"];
+export declare const APPROVAL_FORM_GRID_USES: readonly ["PatternFormGridModel"];
+export declare const APPROVAL_TASK_CARD_GRID_USES: readonly ["ApplyTaskCardGridModel", "ApprovalTaskCardGridModel"];
+export declare const APPROVAL_DETAILS_GRID_USES: readonly ["ApprovalDetailsGridModel", "ApplyTaskCardGridModel", "ApprovalTaskCardGridModel"];
+export declare const APPROVAL_FORM_BLOCK_USES: readonly ["ApplyFormModel", "ProcessFormModel"];
+export declare const APPROVAL_DETAILS_BLOCK_USES: readonly ["ApprovalDetailsModel", "ApplyTaskCardDetailsModel", "ApprovalTaskCardDetailsModel"];
+export declare const APPROVAL_FIELD_WRAPPER_USES: readonly ["PatternFormItemModel", "ApprovalDetailsItemModel", "ApplyTaskCardDetailsItemModel", "ApprovalTaskCardDetailsItemModel"];
+export declare const APPROVAL_ACTION_CONTAINER_USES: readonly ["ApplyFormModel", "ProcessFormModel"];
+export declare function normalizeApprovalSemanticUse(use?: string): string;
+export declare function getApprovalDefaultGridUse(use?: string): string;
+export declare function getApprovalFieldWrapperUse(containerUse?: string): string;
+export declare function isApprovalFormContainerUse(use?: string): boolean;
+export declare function isApprovalTaskCardGridUse(use?: string): boolean;

package/dist/server/flow-surfaces/approval/semantic-use.js

@@ -0,0 +1,155 @@
+/**
+ * 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 semantic_use_exports = {};
+__export(semantic_use_exports, {
+  APPROVAL_ACTION_CONTAINER_USES: () => APPROVAL_ACTION_CONTAINER_USES,
+  APPROVAL_BLOCK_GRID_USES: () => APPROVAL_BLOCK_GRID_USES,
+  APPROVAL_DETAILS_BLOCK_USES: () => APPROVAL_DETAILS_BLOCK_USES,
+  APPROVAL_DETAILS_GRID_USES: () => APPROVAL_DETAILS_GRID_USES,
+  APPROVAL_FIELD_WRAPPER_USES: () => APPROVAL_FIELD_WRAPPER_USES,
+  APPROVAL_FORM_BLOCK_USES: () => APPROVAL_FORM_BLOCK_USES,
+  APPROVAL_FORM_GRID_USES: () => APPROVAL_FORM_GRID_USES,
+  APPROVAL_PAGE_MODEL_USES: () => APPROVAL_PAGE_MODEL_USES,
+  APPROVAL_TAB_MODEL_USES: () => APPROVAL_TAB_MODEL_USES,
+  APPROVAL_TASK_CARD_GRID_USES: () => APPROVAL_TASK_CARD_GRID_USES,
+  getApprovalDefaultGridUse: () => getApprovalDefaultGridUse,
+  getApprovalFieldWrapperUse: () => getApprovalFieldWrapperUse,
+  isApprovalFormContainerUse: () => isApprovalFormContainerUse,
+  isApprovalTaskCardGridUse: () => isApprovalTaskCardGridUse,
+  normalizeApprovalSemanticUse: () => normalizeApprovalSemanticUse
+});
+module.exports = __toCommonJS(semantic_use_exports);
+const APPROVAL_PAGE_MODEL_USES = ["TriggerChildPageModel", "ApprovalChildPageModel"];
+const APPROVAL_TAB_MODEL_USES = ["TriggerChildPageTabModel", "ApprovalChildPageTabModel"];
+const APPROVAL_BLOCK_GRID_USES = ["TriggerBlockGridModel", "ApprovalBlockGridModel"];
+const APPROVAL_FORM_GRID_USES = ["PatternFormGridModel"];
+const APPROVAL_TASK_CARD_GRID_USES = ["ApplyTaskCardGridModel", "ApprovalTaskCardGridModel"];
+const APPROVAL_DETAILS_GRID_USES = ["ApprovalDetailsGridModel", ...APPROVAL_TASK_CARD_GRID_USES];
+const APPROVAL_FORM_BLOCK_USES = ["ApplyFormModel", "ProcessFormModel"];
+const APPROVAL_DETAILS_BLOCK_USES = [
+  "ApprovalDetailsModel",
+  "ApplyTaskCardDetailsModel",
+  "ApprovalTaskCardDetailsModel"
+];
+const APPROVAL_FIELD_WRAPPER_USES = [
+  "PatternFormItemModel",
+  "ApprovalDetailsItemModel",
+  "ApplyTaskCardDetailsItemModel",
+  "ApprovalTaskCardDetailsItemModel"
+];
+const APPROVAL_ACTION_CONTAINER_USES = ["ApplyFormModel", "ProcessFormModel"];
+const APPROVAL_FORM_CONTAINER_USE_SET = /* @__PURE__ */ new Set([
+  ...APPROVAL_FORM_BLOCK_USES,
+  ...APPROVAL_FORM_GRID_USES,
+  "PatternFormItemModel"
+]);
+const APPROVAL_SEMANTIC_USE_ALIASES = {
+  TriggerChildPageModel: "ChildPageModel",
+  ApprovalChildPageModel: "ChildPageModel",
+  TriggerChildPageTabModel: "ChildPageTabModel",
+  ApprovalChildPageTabModel: "ChildPageTabModel",
+  TriggerBlockGridModel: "BlockGridModel",
+  ApprovalBlockGridModel: "BlockGridModel",
+  PatternFormGridModel: "FormGridModel",
+  ApprovalDetailsGridModel: "DetailsGridModel",
+  ApplyTaskCardGridModel: "DetailsGridModel",
+  ApprovalTaskCardGridModel: "DetailsGridModel",
+  ApplyFormModel: "FormBlockModel",
+  ProcessFormModel: "FormBlockModel",
+  ApprovalDetailsModel: "DetailsBlockModel",
+  ApplyTaskCardDetailsModel: "DetailsBlockModel",
+  ApprovalTaskCardDetailsModel: "DetailsBlockModel",
+  PatternFormItemModel: "FormItemModel",
+  ApprovalDetailsItemModel: "DetailsItemModel",
+  ApplyTaskCardDetailsItemModel: "DetailsItemModel",
+  ApprovalTaskCardDetailsItemModel: "DetailsItemModel",
+  PatternFormAssociationFieldGroupModel: "FormAssociationFieldGroupModel",
+  ApprovalDetailsAssociationFieldGroupModel: "DetailsAssociationFieldGroupModel",
+  ApplyTaskCardDetailsAssociationFieldGroupModel: "DetailsAssociationFieldGroupModel",
+  ApprovalTaskCardDetailsAssociationFieldGroupModel: "DetailsAssociationFieldGroupModel"
+};
+const APPROVAL_DEFAULT_GRID_USE_BY_OWNER_USE = {
+  TriggerChildPageTabModel: "TriggerBlockGridModel",
+  ApprovalChildPageTabModel: "ApprovalBlockGridModel",
+  ApplyFormModel: "PatternFormGridModel",
+  ProcessFormModel: "PatternFormGridModel",
+  ApprovalDetailsModel: "ApprovalDetailsGridModel",
+  ApplyTaskCardDetailsModel: "ApplyTaskCardGridModel",
+  ApprovalTaskCardDetailsModel: "ApprovalTaskCardGridModel"
+};
+const APPROVAL_FIELD_WRAPPER_USE_BY_CONTAINER_USE = {
+  ApplyFormModel: "PatternFormItemModel",
+  ProcessFormModel: "PatternFormItemModel",
+  PatternFormGridModel: "PatternFormItemModel",
+  ApprovalDetailsModel: "ApprovalDetailsItemModel",
+  ApprovalDetailsGridModel: "ApprovalDetailsItemModel",
+  ApplyTaskCardDetailsModel: "ApplyTaskCardDetailsItemModel",
+  ApplyTaskCardGridModel: "ApplyTaskCardDetailsItemModel",
+  ApprovalTaskCardDetailsModel: "ApprovalTaskCardDetailsItemModel",
+  ApprovalTaskCardGridModel: "ApprovalTaskCardDetailsItemModel"
+};
+function normalizeApprovalSemanticUse(use) {
+  const normalized = String(use || "").trim();
+  if (!normalized) {
+    return normalized;
+  }
+  return APPROVAL_SEMANTIC_USE_ALIASES[normalized] || normalized;
+}
+function getApprovalDefaultGridUse(use) {
+  const normalized = String(use || "").trim();
+  return normalized ? APPROVAL_DEFAULT_GRID_USE_BY_OWNER_USE[normalized] : void 0;
+}
+function getApprovalFieldWrapperUse(containerUse) {
+  const normalized = String(containerUse || "").trim();
+  return normalized ? APPROVAL_FIELD_WRAPPER_USE_BY_CONTAINER_USE[normalized] : void 0;
+}
+function isApprovalFormContainerUse(use) {
+  return APPROVAL_FORM_CONTAINER_USE_SET.has(String(use || "").trim());
+}
+function isApprovalTaskCardGridUse(use) {
+  return APPROVAL_TASK_CARD_GRID_USES.includes(
+    String(use || "").trim()
+  );
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  APPROVAL_ACTION_CONTAINER_USES,
+  APPROVAL_BLOCK_GRID_USES,
+  APPROVAL_DETAILS_BLOCK_USES,
+  APPROVAL_DETAILS_GRID_USES,
+  APPROVAL_FIELD_WRAPPER_USES,
+  APPROVAL_FORM_BLOCK_USES,
+  APPROVAL_FORM_GRID_USES,
+  APPROVAL_PAGE_MODEL_USES,
+  APPROVAL_TAB_MODEL_USES,
+  APPROVAL_TASK_CARD_GRID_USES,
+  getApprovalDefaultGridUse,
+  getApprovalFieldWrapperUse,
+  isApprovalFormContainerUse,
+  isApprovalTaskCardGridUse,
+  normalizeApprovalSemanticUse
+});

package/dist/server/flow-surfaces/blueprint/compile-blocks.js

@@ -90,7 +90,17 @@ const APPLY_BLUEPRINT_FIELD_ALLOWED_KEYS = [
   "chart"
 ];
 const APPLY_BLUEPRINT_ACTION_ALLOWED_KEYS = ["key", "type", "title", "settings", "popup", "script", "chart"];
-const APPLY_BLUEPRINT_POPUP_ALLOWED_KEYS = ["title", "mode", "template", "blocks", "layout"];
+const APPLY_BLUEPRINT_POPUP_ALLOWED_KEYS = [
+  "title",
+  "mode",
+  "template",
+  "tryTemplate",
+  "defaultType",
+  "saveAsTemplate",
+  "blocks",
+  "layout"
+];
+const APPLY_BLUEPRINT_POPUP_SAVE_AS_TEMPLATE_ALLOWED_KEYS = ["name", "description", "local"];
 const APPLY_BLUEPRINT_LAYOUT_ALLOWED_KEYS = ["rows"];
 const APPLY_BLUEPRINT_LAYOUT_CELL_ALLOWED_KEYS = ["key", "span"];
 const APPLY_BLUEPRINT_BLOCK_RESOURCE_ALLOWED_KEYS = [
@@ -489,6 +499,23 @@ function compilePopup(popup, scopePrefix, assets, context, options = {}) {
   (0, import_private_utils.assertOnlyAllowedKeys)(popup, context, APPLY_BLUEPRINT_POPUP_ALLOWED_KEYS);
   const popupTitle = (0, import_private_utils.readOptionalString)(popup.title);
   const template = ensureOptionalTemplate(popup.template, `${context}.template`);
+  const tryTemplate = import_lodash.default.isUndefined(popup.tryTemplate) ? void 0 : import_lodash.default.isBoolean(popup.tryTemplate) ? popup.tryTemplate : (0, import_errors.throwBadRequest)(`${context}.tryTemplate must be a boolean`);
+  const defaultType = import_lodash.default.isUndefined(popup.defaultType) ? void 0 : popup.defaultType === "view" || popup.defaultType === "edit" ? popup.defaultType : (0, import_errors.throwBadRequest)(`${context}.defaultType must be 'view' or 'edit'`);
+  const saveAsTemplate = import_lodash.default.isUndefined(popup.saveAsTemplate) ? void 0 : import_lodash.default.isPlainObject(popup.saveAsTemplate) ? ((0, import_private_utils.assertOnlyAllowedKeys)(
+    popup.saveAsTemplate,
+    `${context}.saveAsTemplate`,
+    APPLY_BLUEPRINT_POPUP_SAVE_AS_TEMPLATE_ALLOWED_KEYS
+  ), {
+    name: (0, import_private_utils.assertNonEmptyString)(popup.saveAsTemplate.name, `${context}.saveAsTemplate.name`),
+    description: (0, import_private_utils.assertNonEmptyString)(popup.saveAsTemplate.description, `${context}.saveAsTemplate.description`),
+    local: (0, import_private_utils.readOptionalString)(popup.saveAsTemplate.local)
+  }) : (0, import_errors.throwBadRequest)(`${context}.saveAsTemplate must be an object`);
+  if (saveAsTemplate && template) {
+    (0, import_errors.throwBadRequest)(`${context}.saveAsTemplate cannot be combined with ${context}.template`);
+  }
+  if (saveAsTemplate && !import_lodash.default.isUndefined(tryTemplate)) {
+    (0, import_errors.throwBadRequest)(`${context}.saveAsTemplate cannot be combined with ${context}.tryTemplate`);
+  }
   if (template) {
     return {
       popup: {
@@ -499,6 +526,9 @@ function compilePopup(popup, scopePrefix, assets, context, options = {}) {
   }
   const rawPopupBlocks = readOptionalItems(popup.blocks, `${context}.blocks`);
   const popupBlocks = options.ownerActionType === "edit" && rawPopupBlocks.length ? normalizeEditPopupBlocks(rawPopupBlocks, context) : rawPopupBlocks;
+  if (saveAsTemplate && !popupBlocks.length) {
+    (0, import_errors.throwBadRequest)(`${context}.saveAsTemplate requires explicit popup.blocks`);
+  }
   const compiledBlocks = popupBlocks.length ? compileBlocks(
     popupBlocks,
     scopePrefix,
@@ -518,6 +548,9 @@ function compilePopup(popup, scopePrefix, assets, context, options = {}) {
   const compiledPopup = (0, import_service_utils.buildDefinedPayload)({
     mode: popupMode || (popupBlocks.length || template || layout ? "replace" : void 0),
     template,
+    ...tryTemplate ? { tryTemplate: true } : {},
+    ...defaultType ? { defaultType } : {},
+    ...saveAsTemplate ? { saveAsTemplate } : {},
     blocks: compiledBlocks.blocks.length ? compiledBlocks.blocks : void 0,
     layout
   });
@@ -541,7 +574,8 @@ function compileField(input, index, scopePrefix, assets, localBlockKeys, context
     const fieldPath2 = (0, import_private_utils.assertNonEmptyString)(input, `${context}[${index}]`);
     return {
       key: (0, import_service_utils.normalizeFlowSurfaceComposeKey)((0, import_private_utils.buildScopedKey)(scopePrefix, fieldPath2), `${context}[${index}]`),
-      fieldPath: fieldPath2
+      fieldPath: fieldPath2,
+      __autoPopupForRelationField: true
     };
   }
   if (!import_lodash.default.isPlainObject(input)) {

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

@@ -69,6 +69,13 @@ export type FlowSurfaceApplyBlueprintPopup = {
     title?: string;
     mode?: 'replace' | 'append';
     template?: Record<string, any>;
+    tryTemplate?: boolean;
+    defaultType?: 'view' | 'edit';
+    saveAsTemplate?: {
+        name: string;
+        description: string;
+        local?: string;
+    };
     blocks?: FlowSurfaceApplyBlueprintBlockSpec[];
     layout?: FlowSurfaceApplyBlueprintLayout;
 };

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

@@ -80,10 +80,12 @@ export declare function buildSyntheticRootPageTabModel(options: {
 export declare function buildBlockTree(options: {
     type?: string;
     use?: string;
+    containerUse?: string;
     resourceInit?: Record<string, any>;
     props?: Record<string, any>;
     decoratorProps?: Record<string, any>;
     stepParams?: Record<string, any>;
+    flowRegistry?: Record<string, any>;
 }): FlowSurfaceNodeSpec;
 export declare function buildPopupPageTree(options: {
     pageUid?: string;