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

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

@@ -0,0 +1,97 @@
+/**
+ * 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 executor_exports = {};
+__export(executor_exports, {
+  executeMutateOps: () => executeMutateOps
+});
+module.exports = __toCommonJS(executor_exports);
+var import_lodash = __toESM(require("lodash"));
+var import_errors = require("./errors");
+async function executeMutateOps(ops, ctx, dispatcher) {
+  const results = [];
+  for (const op of ops) {
+    const resolvedValues = resolveRefs(
+      import_lodash.default.cloneDeep({
+        ...op.target ? { target: op.target } : {},
+        ...op.values || {}
+      }),
+      ctx.refs
+    );
+    const result = await dispatcher(op, resolvedValues, ctx);
+    if (op.opId) {
+      ctx.refs.set(op.opId, result);
+    }
+    results.push({ opId: op.opId, result });
+  }
+  return results;
+}
+function resolveRefs(input, refs) {
+  if (Array.isArray(input)) {
+    return input.map((item) => resolveRefs(item, refs));
+  }
+  if (import_lodash.default.isPlainObject(input)) {
+    if (Object.prototype.hasOwnProperty.call(input, "$ref")) {
+      throw new import_errors.FlowSurfaceBadRequestError(
+        `flowSurfaces mutate refs must use { ref: "op.path" }; "$ref" is no longer supported`
+      );
+    }
+    if (Object.prototype.hasOwnProperty.call(input, "ref")) {
+      if (typeof input.ref !== "string") {
+        throw new import_errors.FlowSurfaceBadRequestError(`flowSurfaces mutate ref must be a string`);
+      }
+      return readRef(input.ref, refs);
+    }
+    return Object.fromEntries(Object.entries(input).map(([key, value]) => [key, resolveRefs(value, refs)]));
+  }
+  return input;
+}
+function readRef(path, refs) {
+  const trimmedPath = String(path || "").trim();
+  if (!trimmedPath) {
+    throw new import_errors.FlowSurfaceBadRequestError(`flowSurfaces mutate ref cannot be empty`);
+  }
+  const [opId, ...segments] = trimmedPath.split(".");
+  if (!refs.has(opId)) {
+    throw new import_errors.FlowSurfaceBadRequestError(`flowSurfaces mutate ref '${opId}' not found`);
+  }
+  const value = refs.get(opId);
+  return segments.length ? import_lodash.default.get(value, segments.join(".")) : value;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  executeMutateOps
+});

package/dist/server/flow-surfaces/field-semantics.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.
+ */
+export declare const MULTI_VALUE_ASSOCIATION_INTERFACES: Set<string>;
+export declare function normalizeFieldContainerKind(containerUse?: string): "form" | "details" | "filter-form" | "table";
+export declare function shouldUseAssociationTitleTextDisplay(input: {
+    containerUse?: string;
+    associationPathName?: string;
+    fieldInterface?: string | null;
+}): boolean;

package/dist/server/flow-surfaces/field-semantics.js

@@ -0,0 +1,80 @@
+/**
+ * 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 field_semantics_exports = {};
+__export(field_semantics_exports, {
+  MULTI_VALUE_ASSOCIATION_INTERFACES: () => MULTI_VALUE_ASSOCIATION_INTERFACES,
+  normalizeFieldContainerKind: () => normalizeFieldContainerKind,
+  shouldUseAssociationTitleTextDisplay: () => shouldUseAssociationTitleTextDisplay
+});
+module.exports = __toCommonJS(field_semantics_exports);
+const FORM_FIELD_CONTAINER_USES = /* @__PURE__ */ new Set([
+  "FormBlockModel",
+  "CreateFormModel",
+  "EditFormModel",
+  "FormGridModel",
+  "FormItemModel",
+  "AssignFormModel",
+  "AssignFormGridModel"
+]);
+const DETAILS_FIELD_CONTAINER_USES = /* @__PURE__ */ new Set([
+  "DetailsBlockModel",
+  "DetailsGridModel",
+  "DetailsItemModel",
+  "ListBlockModel",
+  "GridCardBlockModel",
+  "ListItemModel",
+  "GridCardItemModel"
+]);
+const FILTER_FIELD_CONTAINER_USES = /* @__PURE__ */ new Set(["FilterFormBlockModel", "FilterFormGridModel", "FilterFormItemModel"]);
+const TABLE_FIELD_CONTAINER_USES = /* @__PURE__ */ new Set(["TableBlockModel", "TableColumnModel"]);
+const MULTI_VALUE_ASSOCIATION_INTERFACES = /* @__PURE__ */ new Set(["m2m", "o2m", "mbm"]);
+function normalizeFieldContainerKind(containerUse) {
+  const normalized = String(containerUse || "").trim();
+  if (FORM_FIELD_CONTAINER_USES.has(normalized)) {
+    return "form";
+  }
+  if (DETAILS_FIELD_CONTAINER_USES.has(normalized)) {
+    return "details";
+  }
+  if (FILTER_FIELD_CONTAINER_USES.has(normalized)) {
+    return "filter-form";
+  }
+  if (TABLE_FIELD_CONTAINER_USES.has(normalized)) {
+    return "table";
+  }
+  return null;
+}
+function shouldUseAssociationTitleTextDisplay(input) {
+  const containerKind = normalizeFieldContainerKind(input.containerUse);
+  return (containerKind === "table" || containerKind === "details") && !String(input.associationPathName || "").trim() && MULTI_VALUE_ASSOCIATION_INTERFACES.has(String(input.fieldInterface || "").trim());
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  MULTI_VALUE_ASSOCIATION_INTERFACES,
+  normalizeFieldContainerKind,
+  shouldUseAssociationTitleTextDisplay
+});

package/dist/server/{flow-schema-registry → flow-surfaces}/index.d.ts

@@ -6,5 +6,6 @@
  * 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 * from './types';
-export * from './FlowSchemaRegistry';
+import type { Plugin } from '@nocobase/server';
+import { FlowSurfacesService } from './service';
+export declare function registerFlowSurfacesResource(plugin: Plugin): FlowSurfacesService;

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

@@ -0,0 +1,352 @@
+/**
+ * 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_exports = {};
+__export(flow_surfaces_exports, {
+  registerFlowSurfacesResource: () => registerFlowSurfacesResource
+});
+module.exports = __toCommonJS(flow_surfaces_exports);
+var import_resourcer = require("@nocobase/resourcer");
+var import_constants = require("./constants");
+var import_errors = require("./errors");
+var import_service = require("./service");
+function getValues(ctx) {
+  var _a, _b, _c;
+  return ((_b = (_a = ctx.action) == null ? void 0 : _a.params) == null ? void 0 : _b.values) ?? ((_c = ctx.action) == null ? void 0 : _c.params) ?? {};
+}
+function isImplicitEmptyValuesBag(value) {
+  return !!value && typeof value === "object" && !Array.isArray(value) && Object.getPrototypeOf(value) === Object.prototype && Object.keys(value).length === 0;
+}
+function getRawReadQuery(ctx) {
+  var _a;
+  const querystring = String(((_a = ctx.request) == null ? void 0 : _a.querystring) ?? "");
+  if (!querystring) {
+    return {};
+  }
+  try {
+    return (0, import_resourcer.parseQuery)(querystring) || {};
+  } catch {
+    return {};
+  }
+}
+function hasExplicitQueryWrapper(ctx, key) {
+  const query = getRawReadQuery(ctx);
+  return Object.prototype.hasOwnProperty.call(query, key);
+}
+function hasExplicitRequestBody(ctx) {
+  var _a;
+  const headers = ((_a = ctx.request) == null ? void 0 : _a.headers) ?? {};
+  const contentLength = headers["content-length"];
+  if (Array.isArray(contentLength)) {
+    return contentLength.some((value) => value !== "0");
+  }
+  if (typeof contentLength === "string") {
+    return contentLength !== "0";
+  }
+  return Boolean(headers["transfer-encoding"]);
+}
+function getReadValues(ctx) {
+  var _a, _b, _c;
+  if (((_b = (_a = ctx.request) == null ? void 0 : _a.method) == null ? void 0 : _b.toUpperCase()) !== "GET") {
+    (0, import_errors.throwBadRequest)(
+      `flowSurfaces:get only supports GET with root query locator fields like /api/flowSurfaces:get?uid=...`
+    );
+  }
+  if (hasExplicitQueryWrapper(ctx, "target")) {
+    (0, import_errors.throwBadRequest)(`flowSurfaces:get only accepts root locator fields; do not wrap them in 'target'`);
+  }
+  if (hasExplicitQueryWrapper(ctx, "values")) {
+    (0, import_errors.throwBadRequest)(`flowSurfaces:get only accepts root locator fields; do not wrap them in 'values'`);
+  }
+  const params = ((_c = ctx.action) == null ? void 0 : _c.params) ?? {};
+  if (!Object.prototype.hasOwnProperty.call(params, "values")) {
+    return params;
+  }
+  const values = params.values;
+  if (typeof values !== "undefined" && !isImplicitEmptyValuesBag(values)) {
+    return params;
+  }
+  if (hasExplicitRequestBody(ctx)) {
+    return params;
+  }
+  const { values: _values, ...rest } = params;
+  return rest;
+}
+function writeFlowSurfaceErrorResponse(ctx, error) {
+  const normalized = (0, import_errors.normalizeFlowSurfaceError)(error);
+  ctx.withoutDataWrapping = true;
+  ctx.type = "application/json";
+  ctx.status = normalized.status;
+  ctx.body = normalized.toResponseBody();
+}
+function isAclPermissionDeniedForFlowSurfaces(ctx, error) {
+  var _a, _b;
+  const resourceName = ((_a = ctx.action) == null ? void 0 : _a.resourceName) ?? ((_b = ctx.permission) == null ? void 0 : _b.resourceName);
+  return resourceName === "flowSurfaces" && (error == null ? void 0 : error.status) === 403 && (error == null ? void 0 : error.message) === "No permissions";
+}
+function toFlowSurfaceForbiddenError(error) {
+  const message = error instanceof Error ? error.message : String(error);
+  return new import_errors.FlowSurfaceForbiddenError(message);
+}
+async function runFlowSurfaceAclErrorWrapper(ctx, next) {
+  try {
+    await next();
+  } catch (error) {
+    if (!isAclPermissionDeniedForFlowSurfaces(ctx, error)) {
+      throw error;
+    }
+    writeFlowSurfaceErrorResponse(ctx, toFlowSurfaceForbiddenError(error));
+  }
+}
+async function runFlowSurfaceAction(ctx, next, handler) {
+  try {
+    ctx.body = await handler();
+    await next();
+  } catch (error) {
+    writeFlowSurfaceErrorResponse(ctx, error);
+    await next();
+  }
+}
+function registerFlowSurfacesResource(plugin) {
+  const service = new import_service.FlowSurfacesService(plugin);
+  const actions = {
+    catalog: async (ctx, next) => {
+      await runFlowSurfaceAction(ctx, next, () => service.catalog(getValues(ctx)));
+    },
+    context: async (ctx, next) => {
+      await runFlowSurfaceAction(ctx, next, () => service.context(getValues(ctx)));
+    },
+    get: async (ctx, next) => {
+      await runFlowSurfaceAction(ctx, next, () => service.get(getReadValues(ctx)));
+    },
+    compose: async (ctx, next) => {
+      await runFlowSurfaceAction(
+        ctx,
+        next,
+        () => service.transaction((transaction) => service.compose(getValues(ctx), { transaction }))
+      );
+    },
+    configure: async (ctx, next) => {
+      await runFlowSurfaceAction(
+        ctx,
+        next,
+        () => service.transaction((transaction) => service.configure(getValues(ctx), { transaction }))
+      );
+    },
+    createMenu: async (ctx, next) => {
+      await runFlowSurfaceAction(
+        ctx,
+        next,
+        () => service.transaction((transaction) => service.createMenu(getValues(ctx), { transaction }))
+      );
+    },
+    updateMenu: async (ctx, next) => {
+      await runFlowSurfaceAction(
+        ctx,
+        next,
+        () => service.transaction((transaction) => service.updateMenu(getValues(ctx), { transaction }))
+      );
+    },
+    createPage: async (ctx, next) => {
+      await runFlowSurfaceAction(
+        ctx,
+        next,
+        () => service.transaction((transaction) => service.createPage(getValues(ctx), { transaction }))
+      );
+    },
+    destroyPage: async (ctx, next) => {
+      await runFlowSurfaceAction(
+        ctx,
+        next,
+        () => service.transaction((transaction) => service.destroyPage(getValues(ctx), { transaction }))
+      );
+    },
+    addTab: async (ctx, next) => {
+      await runFlowSurfaceAction(
+        ctx,
+        next,
+        () => service.transaction((transaction) => service.addTab(getValues(ctx), { transaction }))
+      );
+    },
+    updateTab: async (ctx, next) => {
+      await runFlowSurfaceAction(
+        ctx,
+        next,
+        () => service.transaction((transaction) => service.updateTab(getValues(ctx), { transaction }))
+      );
+    },
+    moveTab: async (ctx, next) => {
+      await runFlowSurfaceAction(
+        ctx,
+        next,
+        () => service.transaction((transaction) => service.moveTab(getValues(ctx), { transaction }))
+      );
+    },
+    removeTab: async (ctx, next) => {
+      await runFlowSurfaceAction(
+        ctx,
+        next,
+        () => service.transaction((transaction) => service.removeTab(getValues(ctx), { transaction }))
+      );
+    },
+    addPopupTab: async (ctx, next) => {
+      await runFlowSurfaceAction(
+        ctx,
+        next,
+        () => service.transaction((transaction) => service.addPopupTab(getValues(ctx), { transaction }))
+      );
+    },
+    updatePopupTab: async (ctx, next) => {
+      await runFlowSurfaceAction(
+        ctx,
+        next,
+        () => service.transaction((transaction) => service.updatePopupTab(getValues(ctx), { transaction }))
+      );
+    },
+    movePopupTab: async (ctx, next) => {
+      await runFlowSurfaceAction(
+        ctx,
+        next,
+        () => service.transaction((transaction) => service.movePopupTab(getValues(ctx), { transaction }))
+      );
+    },
+    removePopupTab: async (ctx, next) => {
+      await runFlowSurfaceAction(
+        ctx,
+        next,
+        () => service.transaction((transaction) => service.removePopupTab(getValues(ctx), { transaction }))
+      );
+    },
+    addBlock: async (ctx, next) => {
+      await runFlowSurfaceAction(
+        ctx,
+        next,
+        () => service.transaction((transaction) => service.addBlock(getValues(ctx), { transaction }))
+      );
+    },
+    addBlocks: async (ctx, next) => {
+      await runFlowSurfaceAction(ctx, next, () => service.addBlocks(getValues(ctx)));
+    },
+    addField: async (ctx, next) => {
+      await runFlowSurfaceAction(
+        ctx,
+        next,
+        () => service.transaction((transaction) => service.addField(getValues(ctx), { transaction }))
+      );
+    },
+    addFields: async (ctx, next) => {
+      await runFlowSurfaceAction(ctx, next, () => service.addFields(getValues(ctx)));
+    },
+    addAction: async (ctx, next) => {
+      await runFlowSurfaceAction(
+        ctx,
+        next,
+        () => service.transaction((transaction) => service.addAction(getValues(ctx), { transaction }))
+      );
+    },
+    addActions: async (ctx, next) => {
+      await runFlowSurfaceAction(ctx, next, () => service.addActions(getValues(ctx)));
+    },
+    addRecordAction: async (ctx, next) => {
+      await runFlowSurfaceAction(
+        ctx,
+        next,
+        () => service.transaction((transaction) => service.addRecordAction(getValues(ctx), { transaction }))
+      );
+    },
+    addRecordActions: async (ctx, next) => {
+      await runFlowSurfaceAction(ctx, next, () => service.addRecordActions(getValues(ctx)));
+    },
+    updateSettings: async (ctx, next) => {
+      await runFlowSurfaceAction(
+        ctx,
+        next,
+        () => service.transaction((transaction) => service.updateSettings(getValues(ctx), { transaction }))
+      );
+    },
+    setEventFlows: async (ctx, next) => {
+      await runFlowSurfaceAction(
+        ctx,
+        next,
+        () => service.transaction((transaction) => service.setEventFlows(getValues(ctx), { transaction }))
+      );
+    },
+    setLayout: async (ctx, next) => {
+      await runFlowSurfaceAction(
+        ctx,
+        next,
+        () => service.transaction((transaction) => service.setLayout(getValues(ctx), { transaction }))
+      );
+    },
+    moveNode: async (ctx, next) => {
+      await runFlowSurfaceAction(
+        ctx,
+        next,
+        () => service.transaction((transaction) => service.moveNode(getValues(ctx), { transaction }))
+      );
+    },
+    removeNode: async (ctx, next) => {
+      await runFlowSurfaceAction(
+        ctx,
+        next,
+        () => service.transaction((transaction) => service.removeNode(getValues(ctx), { transaction }))
+      );
+    },
+    mutate: async (ctx, next) => {
+      await runFlowSurfaceAction(
+        ctx,
+        next,
+        () => service.transaction((transaction) => service.mutate(getValues(ctx), { transaction }))
+      );
+    },
+    apply: async (ctx, next) => {
+      await runFlowSurfaceAction(
+        ctx,
+        next,
+        () => service.transaction((transaction) => service.apply(getValues(ctx), { transaction }))
+      );
+    }
+  };
+  plugin.app.acl.registerSnippet({
+    name: "ui.flowSurfaces",
+    actions: ["flowSurfaces:*"]
+  });
+  plugin.app.acl.allow("flowSurfaces", [...import_constants.FLOW_SURFACES_READ_ACTION_NAMES], "loggedIn");
+  plugin.app.acl.use(runFlowSurfaceAclErrorWrapper, {
+    tag: "flow-surfaces-acl-errors",
+    after: "allow-manager",
+    before: "core"
+  });
+  plugin.app.resourceManager.define({
+    name: "flowSurfaces",
+    actions
+  });
+  return service;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  registerFlowSurfacesResource
+});

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

@@ -0,0 +1,28 @@
+/**
+ * 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 FlowModelRepository from '../repository';
+import type { FlowSurfaceResolveTarget, FlowSurfaceResolvedTarget } from './types';
+export declare class SurfaceLocator {
+    private readonly db;
+    private readonly repository;
+    constructor(db: any, repository: FlowModelRepository);
+    resolve(target: FlowSurfaceResolveTarget, options?: {
+        transaction?: any;
+    }): Promise<FlowSurfaceResolvedTarget>;
+    findParentUid(uid: string, transaction?: any): Promise<any>;
+    findRouteBySchemaUid(schemaUid: string, transaction?: any): Promise<any>;
+    resolveCollectionContext(uid: string, transaction?: any): Promise<{
+        ownerUid: string;
+        model: any;
+        resourceInit: any;
+    }>;
+    private resolveByUid;
+    private resolvePageSchemaUid;
+    private findPageRouteFromModel;
+}