@nocobase/plugin-flow-engine 2.1.0-beta.2 → 2.1.0-beta.20

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

@@ -0,0 +1,145 @@
+/**
+ * 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 errors_exports = {};
+__export(errors_exports, {
+  FlowSurfaceBadRequestError: () => FlowSurfaceBadRequestError,
+  FlowSurfaceConflictError: () => FlowSurfaceConflictError,
+  FlowSurfaceError: () => FlowSurfaceError,
+  FlowSurfaceForbiddenError: () => FlowSurfaceForbiddenError,
+  FlowSurfaceInternalError: () => FlowSurfaceInternalError,
+  isFlowSurfaceBadRequestError: () => isFlowSurfaceBadRequestError,
+  isFlowSurfaceConflictError: () => isFlowSurfaceConflictError,
+  isFlowSurfaceError: () => isFlowSurfaceError,
+  isFlowSurfaceForbiddenError: () => isFlowSurfaceForbiddenError,
+  isFlowSurfaceInternalError: () => isFlowSurfaceInternalError,
+  normalizeFlowSurfaceError: () => normalizeFlowSurfaceError,
+  throwBadRequest: () => throwBadRequest,
+  throwConflict: () => throwConflict,
+  throwForbidden: () => throwForbidden,
+  throwInternalError: () => throwInternalError,
+  toFlowSurfaceErrorItem: () => toFlowSurfaceErrorItem
+});
+module.exports = __toCommonJS(errors_exports);
+class FlowSurfaceError extends Error {
+  constructor(message, status, type, code) {
+    super(message);
+    this.status = status;
+    this.type = type;
+    this.code = code;
+    this.name = "FlowSurfaceError";
+  }
+  toResponseBody() {
+    return {
+      errors: [toFlowSurfaceErrorItem(this)]
+    };
+  }
+}
+class FlowSurfaceBadRequestError extends FlowSurfaceError {
+  constructor(message, code = "FLOW_SURFACE_BAD_REQUEST") {
+    super(message, 400, "bad_request", code);
+    this.name = "FlowSurfaceBadRequestError";
+  }
+}
+class FlowSurfaceForbiddenError extends FlowSurfaceError {
+  constructor(message, code = "FLOW_SURFACE_FORBIDDEN") {
+    super(message, 403, "forbidden", code);
+    this.name = "FlowSurfaceForbiddenError";
+  }
+}
+class FlowSurfaceConflictError extends FlowSurfaceError {
+  constructor(message, code = "FLOW_SURFACE_CONFLICT") {
+    super(message, 409, "conflict", code);
+    this.name = "FlowSurfaceConflictError";
+  }
+}
+class FlowSurfaceInternalError extends FlowSurfaceError {
+  constructor(message, code = "FLOW_SURFACE_INTERNAL_ERROR") {
+    super(message, 500, "internal_error", code);
+    this.name = "FlowSurfaceInternalError";
+  }
+}
+function isFlowSurfaceError(error) {
+  return error instanceof FlowSurfaceError;
+}
+function isFlowSurfaceBadRequestError(error) {
+  return error instanceof FlowSurfaceBadRequestError;
+}
+function isFlowSurfaceForbiddenError(error) {
+  return error instanceof FlowSurfaceForbiddenError;
+}
+function isFlowSurfaceConflictError(error) {
+  return error instanceof FlowSurfaceConflictError;
+}
+function isFlowSurfaceInternalError(error) {
+  return error instanceof FlowSurfaceInternalError;
+}
+function toFlowSurfaceErrorItem(error) {
+  return {
+    message: error.message,
+    type: error.type,
+    code: error.code,
+    status: error.status
+  };
+}
+function normalizeFlowSurfaceError(error) {
+  if (error instanceof FlowSurfaceError) {
+    return error;
+  }
+  const message = error instanceof Error ? error.message : String(error);
+  return new FlowSurfaceInternalError(message);
+}
+function throwBadRequest(message, code) {
+  throw new FlowSurfaceBadRequestError(message, code);
+}
+function throwForbidden(message, code) {
+  throw new FlowSurfaceForbiddenError(message, code);
+}
+function throwConflict(message, code) {
+  throw new FlowSurfaceConflictError(message, code);
+}
+function throwInternalError(message, code) {
+  throw new FlowSurfaceInternalError(message, code);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  FlowSurfaceBadRequestError,
+  FlowSurfaceConflictError,
+  FlowSurfaceError,
+  FlowSurfaceForbiddenError,
+  FlowSurfaceInternalError,
+  isFlowSurfaceBadRequestError,
+  isFlowSurfaceConflictError,
+  isFlowSurfaceError,
+  isFlowSurfaceForbiddenError,
+  isFlowSurfaceInternalError,
+  normalizeFlowSurfaceError,
+  throwBadRequest,
+  throwConflict,
+  throwForbidden,
+  throwInternalError,
+  toFlowSurfaceErrorItem
+});

package/dist/server/flow-surfaces/executor.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.
+ */
+import type { FlowSurfaceExecutorContext, FlowSurfaceMutateOp } from './types';
+export declare function executeMutateOps(ops: FlowSurfaceMutateOp[], ctx: FlowSurfaceExecutorContext, dispatcher: (op: FlowSurfaceMutateOp, values: Record<string, any>, ctx: FlowSurfaceExecutorContext) => Promise<any>): Promise<{
+    opId?: string;
+    result: any;
+}[]>;
+export declare function resolveFlowSurfaceValueKeys(input: any, keys: Map<string, any>): any;
+export declare function inspectFlowSurfaceValueKey(path: string, keys: Map<string, any>): {
+    found: true;
+    value: any;
+    missingHead?: undefined;
+} | {
+    found: false;
+    missingHead: string;
+    value?: undefined;
+};

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

@@ -0,0 +1,132 @@
+/**
+ * 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,
+  inspectFlowSurfaceValueKey: () => inspectFlowSurfaceValueKey,
+  resolveFlowSurfaceValueKeys: () => resolveFlowSurfaceValueKeys
+});
+module.exports = __toCommonJS(executor_exports);
+var import_lodash = __toESM(require("lodash"));
+var import_errors = require("./errors");
+var import_reference_guards = require("./reference-guards");
+var import_created_keys = require("./planning/created-keys");
+async function executeMutateOps(ops, ctx, dispatcher) {
+  const results = [];
+  for (const op of ops) {
+    const resolvedValues = resolveFlowSurfaceValueKeys(
+      import_lodash.default.cloneDeep({
+        ...op.target ? { target: op.target } : {},
+        ...op.values || {}
+      }),
+      ctx.keys
+    );
+    const result = await dispatcher(op, resolvedValues, ctx);
+    if (op.opId) {
+      ctx.keys.set(op.opId, result);
+    }
+    results.push({ opId: op.opId, result });
+  }
+  return results;
+}
+function resolveFlowSurfaceValueKeys(input, keys) {
+  if (Array.isArray(input)) {
+    return input.map((item) => resolveFlowSurfaceValueKeys(item, keys));
+  }
+  if (import_lodash.default.isPlainObject(input)) {
+    (0, import_reference_guards.assertNoFlowSurfaceLegacyRef)(input, {
+      actionName: "mutate",
+      path: "values",
+      dollarRefAllowed: "{ key } or { step, path }",
+      refAllowed: "{ key } or { step, path }"
+    });
+    if ((0, import_reference_guards.isFlowSurfacePlanStepValue)(input)) {
+      return readStepResult(input, keys);
+    }
+    if ((0, import_created_keys.isFlowSurfacePureKeyObject)(input)) {
+      return readKey(input.key, keys);
+    }
+    return Object.fromEntries(
+      Object.entries(input).map(([key, value]) => [key, resolveFlowSurfaceValueKeys(value, keys)])
+    );
+  }
+  return input;
+}
+function inspectFlowSurfaceValueKey(path, keys) {
+  const trimmedPath = String(path || "").trim();
+  if (!trimmedPath) {
+    throw new import_errors.FlowSurfaceBadRequestError(`flowSurfaces mutate key cannot be empty`);
+  }
+  if (keys.has(trimmedPath)) {
+    return {
+      found: true,
+      value: keys.get(trimmedPath)
+    };
+  }
+  return {
+    found: false,
+    missingHead: trimmedPath
+  };
+}
+function readKey(path, keys) {
+  const resolved = inspectFlowSurfaceValueKey(path, keys);
+  if (!resolved.found) {
+    throw new import_errors.FlowSurfaceBadRequestError(`flowSurfaces mutate key '${resolved.missingHead}' not found`);
+  }
+  return resolved.value;
+}
+function readStepResult(input, keys) {
+  const step = String(input.step || "").trim();
+  if (!step) {
+    throw new import_errors.FlowSurfaceBadRequestError(`flowSurfaces mutate step cannot be empty`);
+  }
+  if (!keys.has(step)) {
+    throw new import_errors.FlowSurfaceBadRequestError(`flowSurfaces mutate step '${step}' not found`);
+  }
+  const value = keys.get(step);
+  const path = import_lodash.default.isUndefined(input.path) ? void 0 : String(input.path || "").trim();
+  if (import_lodash.default.has(input, "path") && !path) {
+    throw new import_errors.FlowSurfaceBadRequestError(`flowSurfaces mutate path cannot be empty`);
+  }
+  return path ? import_lodash.default.get(value, path) : value;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  executeMutateOps,
+  inspectFlowSurfaceValueKey,
+  resolveFlowSurfaceValueKeys
+});

package/dist/server/flow-surfaces/field-binding-registry.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 type FlowSurfaceFieldBindingScope = 'display' | 'editable' | 'filter';
+export type FlowSurfaceFieldBindingResolution = {
+    modelClassName: string;
+    ownerPlugin?: string;
+    isDefault: boolean;
+};
+export declare function getRegisteredFieldUses(scope?: FlowSurfaceFieldBindingScope, enabledPackages?: ReadonlySet<string>): ReadonlySet<string>;
+export declare function resolveRegisteredFieldBinding(input: {
+    containerUse?: string;
+    field: any;
+    dataSourceKey?: string;
+    enabledPackages?: ReadonlySet<string>;
+    getCollection?: (dataSourceKey: string, collectionName: string) => any;
+    useStrictOnly?: boolean;
+}): FlowSurfaceFieldBindingResolution | null;