@nocobase/plugin-flow-engine 2.1.0-beta.15 → 2.1.0-beta.17

package/dist/swagger/flow-surfaces.template-action-docs.d.ts

@@ -0,0 +1,62 @@
+/**
+ * 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 FlowSurfaceActionDocBuilder = (schemaName: string, example?: Record<string, any>, description?: string) => any;
+type FlowSurfaceActionResponsesBuilder = (schemaName: string, includeValidationError?: boolean) => any;
+type FlowSurfaceValuesCompatibilityNoteBuilder = (description: string) => string;
+export declare function createFlowSurfaceTemplateActionDocs(options: {
+    tag: string;
+    readAclNote: string;
+    requestBody: FlowSurfaceActionDocBuilder;
+    responses: FlowSurfaceActionResponsesBuilder;
+    valuesCompatibilityNote: FlowSurfaceValuesCompatibilityNoteBuilder;
+}): {
+    listTemplates: {
+        tags: string[];
+        summary: string;
+        description: string;
+        requestBody: any;
+        responses: any;
+    };
+    getTemplate: {
+        tags: string[];
+        summary: string;
+        description: string;
+        requestBody: any;
+        responses: any;
+    };
+    saveTemplate: {
+        tags: string[];
+        summary: string;
+        description: string;
+        requestBody: any;
+        responses: any;
+    };
+    updateTemplate: {
+        tags: string[];
+        summary: string;
+        description: string;
+        requestBody: any;
+        responses: any;
+    };
+    destroyTemplate: {
+        tags: string[];
+        summary: string;
+        description: string;
+        requestBody: any;
+        responses: any;
+    };
+    convertTemplateToCopy: {
+        tags: string[];
+        summary: string;
+        description: string;
+        requestBody: any;
+        responses: any;
+    };
+};
+export {};

package/dist/swagger/flow-surfaces.template-action-docs.js

@@ -0,0 +1,121 @@
+/**
+ * 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 flow_surfaces_template_action_docs_exports = {};
+__export(flow_surfaces_template_action_docs_exports, {
+  createFlowSurfaceTemplateActionDocs: () => createFlowSurfaceTemplateActionDocs
+});
+module.exports = __toCommonJS(flow_surfaces_template_action_docs_exports);
+function createFlowSurfaceTemplateActionDocs(options) {
+  const { tag, readAclNote, requestBody, responses, valuesCompatibilityNote } = options;
+  return {
+    listTemplates: {
+      tags: [tag],
+      summary: "Search saved flow surface templates for automation and CLI reuse",
+      description: valuesCompatibilityNote(
+        `Lists saved block / popup templates backed by FlowModel trees. Use \`search\` against \`name\` and required \`description\` to help humans and models choose the right template. ${readAclNote}`
+      ),
+      requestBody: requestBody("FlowSurfaceListTemplatesRequest", {
+        target: {
+          uid: "employee-table-block"
+        },
+        type: "popup",
+        actionType: "view",
+        actionScope: "record",
+        search: "employee popup",
+        page: 1,
+        pageSize: 20
+      }),
+      responses: responses("FlowSurfaceListTemplatesResult")
+    },
+    getTemplate: {
+      tags: [tag],
+      summary: "Read one saved flow surface template by uid",
+      description: valuesCompatibilityNote(`Reads one saved template and its usage count. ${readAclNote}`),
+      requestBody: requestBody("FlowSurfaceGetTemplateRequest", {
+        uid: "employee-form-template"
+      }),
+      responses: responses("FlowSurfaceTemplateRow")
+    },
+    saveTemplate: {
+      tags: [tag],
+      summary: "Save a block or popup source as a reusable template",
+      description: valuesCompatibilityNote(
+        'Saves the current source as a FlowModel-backed template. Only supported block sources plus supported popup action/field openers may be saved. `description` is required so API callers can search and choose templates accurately. `saveMode="duplicate"` only creates the template. `saveMode="convert"` additionally rewrites the current source into a template reference when the source kind supports it.'
+      ),
+      requestBody: requestBody("FlowSurfaceSaveTemplateRequest", {
+        target: {
+          uid: "employee-create-form"
+        },
+        name: "Employee create form",
+        description: "Reusable employee create form with common fields and popup behavior.",
+        saveMode: "duplicate"
+      }),
+      responses: responses("FlowSurfaceTemplateRow")
+    },
+    updateTemplate: {
+      tags: [tag],
+      summary: "Update template name and description",
+      description: valuesCompatibilityNote(
+        "Updates searchable template metadata only. Use this to refine template naming and required description without changing the stored FlowModel tree."
+      ),
+      requestBody: requestBody("FlowSurfaceUpdateTemplateRequest", {
+        uid: "employee-form-template",
+        name: "Employee create form",
+        description: "Reusable employee create form with validated field order."
+      }),
+      responses: responses("FlowSurfaceTemplateRow")
+    },
+    destroyTemplate: {
+      tags: [tag],
+      summary: "Delete an unused template and its stored target tree",
+      description: valuesCompatibilityNote(
+        "Deletes the template record and its stored FlowModel tree. The backend rejects deletion while `usageCount > 0` so callers do not break existing references accidentally."
+      ),
+      requestBody: requestBody("FlowSurfaceDestroyTemplateRequest", {
+        uid: "employee-form-template"
+      }),
+      responses: responses("FlowSurfaceDestroyTemplateResult")
+    },
+    convertTemplateToCopy: {
+      tags: [tag],
+      summary: "Convert a referenced block, fields template, or popup template to copy mode",
+      description: valuesCompatibilityNote(
+        "Converts the current template reference into a detached copy. Block and field references can only move from reference to copy. Popup template references can also be reconfigured separately through action/field openView updates, but this action gives an explicit detach path."
+      ),
+      requestBody: requestBody("FlowSurfaceConvertTemplateToCopyRequest", {
+        target: {
+          uid: "employee-form-block"
+        }
+      }),
+      responses: responses("FlowSurfaceConvertTemplateToCopyResult")
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createFlowSurfaceTemplateActionDocs
+});

package/dist/swagger/flow-surfaces.template-schemas.d.ts

@@ -0,0 +1,239 @@
+/**
+ * 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 FlowSurfaceSchemaRef = (name: string) => {
+    $ref: string;
+};
+export declare function createFlowSurfaceTemplateSchemas(options: {
+    ref: FlowSurfaceSchemaRef;
+    stringOrIntegerSchema: Record<string, any>;
+    actionTypeEnum: string[];
+}): {
+    FlowSurfaceTemplateRow: {
+        type: string;
+        required: string[];
+        properties: {
+            uid: {
+                type: string;
+            };
+            name: {
+                type: string;
+            };
+            description: {
+                type: string;
+            };
+            type: {
+                type: string;
+                enum: string[];
+            };
+            targetUid: {
+                type: string;
+            };
+            useModel: {
+                type: string;
+            };
+            dataSourceKey: {
+                type: string;
+            };
+            collectionName: {
+                type: string;
+            };
+            associationName: {
+                type: string;
+            };
+            filterByTk: Record<string, any>;
+            sourceId: Record<string, any>;
+            usageCount: {
+                type: string;
+            };
+            available: {
+                type: string;
+            };
+            disabledReason: {
+                type: string;
+            };
+        };
+        additionalProperties: boolean;
+    };
+    FlowSurfaceListTemplatesRequest: {
+        type: string;
+        properties: {
+            target: {
+                $ref: string;
+            };
+            type: {
+                type: string;
+                enum: string[];
+            };
+            usage: {
+                type: string;
+                enum: string[];
+            };
+            actionType: {
+                type: string;
+                enum: string[];
+            };
+            actionScope: {
+                type: string;
+                enum: string[];
+            };
+            search: {
+                type: string;
+            };
+            filter: {
+                type: string;
+                additionalProperties: boolean;
+            };
+            sort: {
+                oneOf: ({
+                    type: string;
+                    items?: undefined;
+                } | {
+                    type: string;
+                    items: {
+                        type: string;
+                    };
+                })[];
+            };
+            page: {
+                type: string;
+                minimum: number;
+            };
+            pageSize: {
+                type: string;
+                minimum: number;
+            };
+        };
+        additionalProperties: boolean;
+    };
+    FlowSurfaceListTemplatesResult: {
+        type: string;
+        required: string[];
+        properties: {
+            rows: {
+                type: string;
+                items: {
+                    $ref: string;
+                };
+            };
+            count: {
+                type: string;
+            };
+            page: {
+                type: string;
+            };
+            pageSize: {
+                type: string;
+            };
+            totalPage: {
+                type: string;
+            };
+        };
+        additionalProperties: boolean;
+    };
+    FlowSurfaceGetTemplateRequest: {
+        type: string;
+        required: string[];
+        properties: {
+            uid: {
+                type: string;
+            };
+        };
+        additionalProperties: boolean;
+    };
+    FlowSurfaceSaveTemplateRequest: {
+        type: string;
+        required: string[];
+        properties: {
+            target: {
+                $ref: string;
+            };
+            uid: {
+                type: string;
+            };
+            name: {
+                type: string;
+            };
+            description: {
+                type: string;
+            };
+            saveMode: {
+                type: string;
+                enum: string[];
+                default: string;
+            };
+        };
+        additionalProperties: boolean;
+    };
+    FlowSurfaceUpdateTemplateRequest: {
+        type: string;
+        required: string[];
+        properties: {
+            uid: {
+                type: string;
+            };
+            name: {
+                type: string;
+            };
+            description: {
+                type: string;
+            };
+        };
+        additionalProperties: boolean;
+    };
+    FlowSurfaceDestroyTemplateRequest: {
+        type: string;
+        required: string[];
+        properties: {
+            uid: {
+                type: string;
+            };
+        };
+        additionalProperties: boolean;
+    };
+    FlowSurfaceDestroyTemplateResult: {
+        type: string;
+        properties: {
+            uid: {
+                type: string;
+            };
+        };
+        additionalProperties: boolean;
+    };
+    FlowSurfaceConvertTemplateToCopyRequest: {
+        type: string;
+        required: string[];
+        properties: {
+            target: {
+                $ref: string;
+            };
+        };
+        additionalProperties: boolean;
+    };
+    FlowSurfaceConvertTemplateToCopyResult: {
+        type: string;
+        required: string[];
+        properties: {
+            uid: {
+                type: string;
+            };
+            type: {
+                type: string;
+                enum: string[];
+            };
+            gridUid: {
+                type: string;
+            };
+            popupUid: {
+                type: string;
+            };
+        };
+        additionalProperties: boolean;
+    };
+};
+export {};

package/dist/swagger/flow-surfaces.template-schemas.js

@@ -0,0 +1,255 @@
+/**
+ * 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 flow_surfaces_template_schemas_exports = {};
+__export(flow_surfaces_template_schemas_exports, {
+  createFlowSurfaceTemplateSchemas: () => createFlowSurfaceTemplateSchemas
+});
+module.exports = __toCommonJS(flow_surfaces_template_schemas_exports);
+function createFlowSurfaceTemplateSchemas(options) {
+  const { ref, stringOrIntegerSchema, actionTypeEnum } = options;
+  return {
+    FlowSurfaceTemplateRow: {
+      type: "object",
+      required: ["uid", "name", "description", "type", "targetUid"],
+      properties: {
+        uid: {
+          type: "string"
+        },
+        name: {
+          type: "string"
+        },
+        description: {
+          type: "string"
+        },
+        type: {
+          type: "string",
+          enum: ["block", "popup"]
+        },
+        targetUid: {
+          type: "string"
+        },
+        useModel: {
+          type: "string"
+        },
+        dataSourceKey: {
+          type: "string"
+        },
+        collectionName: {
+          type: "string"
+        },
+        associationName: {
+          type: "string"
+        },
+        filterByTk: stringOrIntegerSchema,
+        sourceId: stringOrIntegerSchema,
+        usageCount: {
+          type: "integer"
+        },
+        available: {
+          type: "boolean"
+        },
+        disabledReason: {
+          type: "string"
+        }
+      },
+      additionalProperties: false
+    },
+    FlowSurfaceListTemplatesRequest: {
+      type: "object",
+      properties: {
+        target: ref("FlowSurfaceWriteTarget"),
+        type: {
+          type: "string",
+          enum: ["block", "popup"]
+        },
+        usage: {
+          type: "string",
+          enum: ["block", "fields"]
+        },
+        actionType: {
+          type: "string",
+          enum: actionTypeEnum
+        },
+        actionScope: {
+          type: "string",
+          enum: ["block", "record"]
+        },
+        search: {
+          type: "string"
+        },
+        filter: {
+          type: "object",
+          additionalProperties: true
+        },
+        sort: {
+          oneOf: [
+            {
+              type: "string"
+            },
+            {
+              type: "array",
+              items: {
+                type: "string"
+              }
+            }
+          ]
+        },
+        page: {
+          type: "integer",
+          minimum: 1
+        },
+        pageSize: {
+          type: "integer",
+          minimum: 1
+        }
+      },
+      additionalProperties: false
+    },
+    FlowSurfaceListTemplatesResult: {
+      type: "object",
+      required: ["rows", "count", "page", "pageSize", "totalPage"],
+      properties: {
+        rows: {
+          type: "array",
+          items: ref("FlowSurfaceTemplateRow")
+        },
+        count: {
+          type: "integer"
+        },
+        page: {
+          type: "integer"
+        },
+        pageSize: {
+          type: "integer"
+        },
+        totalPage: {
+          type: "integer"
+        }
+      },
+      additionalProperties: false
+    },
+    FlowSurfaceGetTemplateRequest: {
+      type: "object",
+      required: ["uid"],
+      properties: {
+        uid: {
+          type: "string"
+        }
+      },
+      additionalProperties: false
+    },
+    FlowSurfaceSaveTemplateRequest: {
+      type: "object",
+      required: ["target", "name", "description"],
+      properties: {
+        target: ref("FlowSurfaceWriteTarget"),
+        uid: {
+          type: "string"
+        },
+        name: {
+          type: "string"
+        },
+        description: {
+          type: "string"
+        },
+        saveMode: {
+          type: "string",
+          enum: ["duplicate", "convert"],
+          default: "duplicate"
+        }
+      },
+      additionalProperties: false
+    },
+    FlowSurfaceUpdateTemplateRequest: {
+      type: "object",
+      required: ["uid", "name", "description"],
+      properties: {
+        uid: {
+          type: "string"
+        },
+        name: {
+          type: "string"
+        },
+        description: {
+          type: "string"
+        }
+      },
+      additionalProperties: false
+    },
+    FlowSurfaceDestroyTemplateRequest: {
+      type: "object",
+      required: ["uid"],
+      properties: {
+        uid: {
+          type: "string"
+        }
+      },
+      additionalProperties: false
+    },
+    FlowSurfaceDestroyTemplateResult: {
+      type: "object",
+      properties: {
+        uid: {
+          type: "string"
+        }
+      },
+      additionalProperties: false
+    },
+    FlowSurfaceConvertTemplateToCopyRequest: {
+      type: "object",
+      required: ["target"],
+      properties: {
+        target: ref("FlowSurfaceWriteTarget")
+      },
+      additionalProperties: false
+    },
+    FlowSurfaceConvertTemplateToCopyResult: {
+      type: "object",
+      required: ["uid", "type"],
+      properties: {
+        uid: {
+          type: "string"
+        },
+        type: {
+          type: "string",
+          enum: ["block", "fields", "popup"]
+        },
+        gridUid: {
+          type: "string"
+        },
+        popupUid: {
+          type: "string"
+        }
+      },
+      additionalProperties: false
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createFlowSurfaceTemplateSchemas
+});