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

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

@@ -0,0 +1,302 @@
+/**
+ * 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");
+const FLOW_ENGINE_LOCALE_NAMESPACE = "flow-engine";
+const FLOW_SURFACE_LOCALE_FALLBACK_NAMESPACES = [
+  FLOW_ENGINE_LOCALE_NAMESPACE,
+  "@nocobase/flow-engine",
+  "@nocobase/plugin-flow-engine",
+  "client"
+];
+const FLOW_SURFACE_LOCAL_TRANSLATIONS = {
+  "zh-CN": {
+    "Popup for Add New": "\u65B0\u589E\u5F39\u7A97",
+    "Popup for Edit": "\u7F16\u8F91\u5F39\u7A97",
+    "Popup for Details": "\u8BE6\u60C5\u5F39\u7A97",
+    "Auto generated": "\u81EA\u52A8\u751F\u6210",
+    'Automatically generated popup template for collection "{{collectionLabel}}" ({{popupLabel}}).': "\u4E3A\u6570\u636E\u8868\u201C{{collectionLabel}}\u201D\u81EA\u52A8\u751F\u6210\u7684\u5F39\u7A97\u6A21\u677F\uFF08{{popupLabel}}\uFF09\u3002",
+    'Automatically generated popup template for relation field "{{associationFieldLabel}}" in collection "{{sourceCollectionLabel}}", targeting "{{targetCollectionLabel}}" ({{popupLabel}}).': "\u4E3A\u6570\u636E\u8868\u201C{{sourceCollectionLabel}}\u201D\u4E2D\u7684\u5173\u7CFB\u5B57\u6BB5\u201C{{associationFieldLabel}}\u201D\u81EA\u52A8\u751F\u6210\u7684\u5F39\u7A97\u6A21\u677F\uFF0C\u76EE\u6807\u6570\u636E\u8868\u4E3A\u201C{{targetCollectionLabel}}\u201D\uFF08{{popupLabel}}\uFF09\u3002"
+  }
+};
+function getValues(ctx) {
+  var _a, _b, _c, _d, _e;
+  const values = ((_b = (_a = ctx.action) == null ? void 0 : _a.params) == null ? void 0 : _b.values) ?? ((_c = ctx.action) == null ? void 0 : _c.params) ?? {};
+  const actionName = (_d = ctx.action) == null ? void 0 : _d.actionName;
+  if (isInvalidFlowSurfaceWritePayload(values) && actionName && !((_e = import_constants.FLOW_SURFACE_ACTION_DEFINITIONS[actionName]) == null ? void 0 : _e.read)) {
+    throw new import_errors.FlowSurfaceBadRequestError(getFlowSurfaceWritePayloadMessage(actionName));
+  }
+  return values;
+}
+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 isFlowSurfaceWriteActionName(value) {
+  return Object.prototype.hasOwnProperty.call(import_constants.FLOW_SURFACE_ACTION_DEFINITIONS, value);
+}
+function getFlowSurfaceRequestActionName(ctx) {
+  var _a, _b;
+  const actionName = String(((_a = ctx.action) == null ? void 0 : _a.actionName) || "").trim();
+  if (isFlowSurfaceWriteActionName(actionName)) {
+    return actionName;
+  }
+  const path = String(ctx.path || ((_b = ctx.request) == null ? void 0 : _b.path) || "").trim();
+  const match = path.match(/(?:^|\/)flowSurfaces:([^/?#]+)$/);
+  const rawActionName = String((match == null ? void 0 : match[1]) || "").trim();
+  return isFlowSurfaceWriteActionName(rawActionName) ? rawActionName : void 0;
+}
+function isFlowSurfaceWriteRequest(ctx) {
+  var _a;
+  if (String(((_a = ctx.request) == null ? void 0 : _a.method) || "").toUpperCase() !== "POST") {
+    return false;
+  }
+  const actionName = getFlowSurfaceRequestActionName(ctx);
+  return !!actionName && import_constants.FLOW_SURFACE_ACTION_DEFINITIONS[actionName].read === false;
+}
+function isInvalidFlowSurfaceWritePayload(value) {
+  if (!value || typeof value !== "object") {
+    return true;
+  }
+  return Array.isArray(value);
+}
+function getFlowSurfaceWritePayloadMessage(actionName) {
+  const noun = actionName === "applyBlueprint" || actionName === "applyApprovalBlueprint" ? "payload" : "values";
+  return `flowSurfaces ${actionName} ${noun} must be an object`;
+}
+function isFlowSurfaceWriteBodyParserShapeError(error) {
+  const parserError = error;
+  return error instanceof SyntaxError && parserError.status === 400 && parserError.message === "invalid JSON, only supports object and array";
+}
+async function runFlowSurfaceWriteBodyParserErrorWrapper(ctx, next) {
+  try {
+    await next();
+  } catch (error) {
+    if (!isFlowSurfaceWriteRequest(ctx) || !isFlowSurfaceWriteBodyParserShapeError(error)) {
+      throw error;
+    }
+    const actionName = getFlowSurfaceRequestActionName(ctx);
+    if (!actionName) {
+      throw error;
+    }
+    writeFlowSurfaceErrorResponse(ctx, new import_errors.FlowSurfaceBadRequestError(getFlowSurfaceWritePayloadMessage(actionName)));
+  }
+}
+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 invokeFlowSurfaceServiceAction(service, actionName, values, options = {}) {
+  const handler = service[actionName];
+  return handler.call(service, values, options);
+}
+function interpolateTranslation(value, options) {
+  return value.replace(/\{\{\s*([^}\s]+)\s*\}\}/g, (_match, name) => {
+    const replacement = options == null ? void 0 : options[name];
+    return replacement === null || typeof replacement === "undefined" ? "" : String(replacement);
+  });
+}
+function getResourceTranslation(ctx, key, options) {
+  var _a, _b, _c, _d;
+  const locale = ((_a = ctx.getCurrentLocale) == null ? void 0 : _a.call(ctx)) || ((_b = ctx.i18n) == null ? void 0 : _b.language);
+  const i18n = (_c = ctx.app) == null ? void 0 : _c.i18n;
+  if (!locale || !i18n) {
+    return void 0;
+  }
+  for (const ns of FLOW_SURFACE_LOCALE_FALLBACK_NAMESPACES) {
+    const value = (_d = i18n.getResource) == null ? void 0 : _d.call(i18n, locale, ns, key);
+    if (typeof value === "string") {
+      return interpolateTranslation(value, options);
+    }
+  }
+  return void 0;
+}
+function getLocalTranslation(ctx, key, options) {
+  var _a, _b;
+  const locale = String(((_a = ctx.getCurrentLocale) == null ? void 0 : _a.call(ctx)) || ((_b = ctx.i18n) == null ? void 0 : _b.language) || "").trim();
+  const resources = FLOW_SURFACE_LOCAL_TRANSLATIONS[locale];
+  const value = resources == null ? void 0 : resources[key];
+  return typeof value === "string" ? interpolateTranslation(value, options) : void 0;
+}
+function getFlowSurfaceTranslate(ctx) {
+  var _a, _b, _c;
+  const translate = ((_b = (_a = ctx.i18n) == null ? void 0 : _a.t) == null ? void 0 : _b.bind(ctx.i18n)) || ((_c = ctx.t) == null ? void 0 : _c.bind(ctx));
+  if (typeof translate !== "function") {
+    return void 0;
+  }
+  return (key, options) => {
+    const resourceValue = getResourceTranslation(ctx, key, options);
+    if (typeof resourceValue === "string") {
+      return resourceValue;
+    }
+    const localValue = getLocalTranslation(ctx, key, options);
+    if (typeof localValue === "string") {
+      return localValue;
+    }
+    return translate(key, {
+      ns: [FLOW_ENGINE_LOCALE_NAMESPACE, "client"],
+      nsMode: "fallback",
+      ...options || {}
+    });
+  };
+}
+function registerFlowSurfacesResource(plugin) {
+  const service = new import_service.FlowSurfacesService(plugin);
+  const actions = Object.fromEntries(
+    import_constants.FLOW_SURFACES_ACTION_NAMES.map((actionName) => [
+      actionName,
+      async (ctx, next) => {
+        await runFlowSurfaceAction(ctx, next, async () => {
+          const definition = import_constants.FLOW_SURFACE_ACTION_DEFINITIONS[actionName];
+          const values = definition.valueSource === "read" ? getReadValues(ctx) : getValues(ctx);
+          const t = getFlowSurfaceTranslate(ctx);
+          if (definition.transaction) {
+            return service.transaction(
+              (transaction) => invokeFlowSurfaceServiceAction(service, actionName, values, { transaction, t })
+            );
+          }
+          return invokeFlowSurfaceServiceAction(service, actionName, values, { t });
+        });
+      }
+    ])
+  );
+  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.use(runFlowSurfaceWriteBodyParserErrorWrapper, {
+    tag: "flow-surfaces-write-body-errors",
+    before: "bodyParser"
+  });
+  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;
+}

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

@@ -0,0 +1,240 @@
+/**
+ * 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 locator_exports = {};
+__export(locator_exports, {
+  SurfaceLocator: () => SurfaceLocator
+});
+module.exports = __toCommonJS(locator_exports);
+var import_lodash = __toESM(require("lodash"));
+var import_approval = require("./approval");
+var import_chart_config = require("./chart-config");
+var import_errors = require("./errors");
+class SurfaceLocator {
+  constructor(db, repository) {
+    this.db = db;
+    this.repository = repository;
+  }
+  async resolve(target, options = {}) {
+    var _a;
+    const transaction = options.transaction;
+    if (target.uid) {
+      return this.resolveByUid(target.uid, target, transaction);
+    }
+    if ("tabSchemaUid" in target && target.tabSchemaUid) {
+      return this.resolveByUid(target.tabSchemaUid, target, transaction);
+    }
+    if ("pageSchemaUid" in target && target.pageSchemaUid) {
+      return this.resolvePageSchemaUid(target.pageSchemaUid, target, transaction);
+    }
+    if ("routeId" in target && target.routeId) {
+      const route = await this.db.getRepository("desktopRoutes").findOne({
+        filterByTk: String(target.routeId),
+        transaction
+      });
+      if (isPageRoute(route)) {
+        return this.resolvePageSchemaUid(route.get("schemaUid"), target, transaction);
+      }
+      if ((_a = route == null ? void 0 : route.get) == null ? void 0 : _a.call(route, "schemaUid")) {
+        return this.resolveByUid(route.get("schemaUid"), target, transaction);
+      }
+    }
+    throw new import_errors.FlowSurfaceBadRequestError("flowSurfaces target not found");
+  }
+  async findParentUid(uid, transaction) {
+    var _a;
+    const parentPath = await this.db.getRepository("flowModelTreePath").findOne({
+      filter: {
+        descendant: uid,
+        depth: 1
+      },
+      transaction
+    });
+    return ((_a = parentPath == null ? void 0 : parentPath.get) == null ? void 0 : _a.call(parentPath, "ancestor")) || null;
+  }
+  async findRouteBySchemaUid(schemaUid, transaction) {
+    return this.db.getRepository("desktopRoutes").findOne({
+      filter: {
+        schemaUid
+      },
+      transaction
+    });
+  }
+  async resolveCollectionContext(uid, transaction) {
+    let cursor = uid;
+    while (cursor) {
+      const model = await this.repository.findModelById(cursor, { transaction, includeAsyncNode: true });
+      const resourceInit = import_lodash.default.get(model, ["stepParams", "resourceSettings", "init"]) || import_lodash.default.get(model, ["stepParams", "TriggerChildPageSettings", "init"]) || import_lodash.default.get(model, ["stepParams", "ApprovalChildPageSettings", "init"]) || ((model == null ? void 0 : model.use) === "ChartBlockModel" ? (0, import_chart_config.getChartBuilderResourceInit)(import_lodash.default.get(model, ["stepParams", "chartSettings", "configure"])) : null);
+      if ((resourceInit == null ? void 0 : resourceInit.dataSourceKey) && (resourceInit == null ? void 0 : resourceInit.collectionName)) {
+        return {
+          ownerUid: cursor,
+          model,
+          resourceInit
+        };
+      }
+      const fieldInit = import_lodash.default.get(model, ["stepParams", "fieldSettings", "init"]);
+      if ((fieldInit == null ? void 0 : fieldInit.dataSourceKey) && (fieldInit == null ? void 0 : fieldInit.collectionName)) {
+        return {
+          ownerUid: cursor,
+          model,
+          resourceInit: {
+            dataSourceKey: fieldInit.dataSourceKey,
+            collectionName: fieldInit.collectionName,
+            associationPathName: fieldInit.associationPathName
+          }
+        };
+      }
+      cursor = await this.findParentUid(cursor, transaction);
+    }
+    return null;
+  }
+  async resolveByUid(uid, target, transaction) {
+    var _a, _b, _c, _d, _e;
+    const node = await this.repository.findModelById(uid, { transaction, includeAsyncNode: true });
+    const route = await this.findRouteBySchemaUid(uid, transaction);
+    if (!(node == null ? void 0 : node.uid) && !route) {
+      throw new import_errors.FlowSurfaceBadRequestError(`flowSurfaces uid '${uid}' not found`);
+    }
+    let pageRoute = null;
+    let tabRoute = null;
+    if (((_a = route == null ? void 0 : route.get) == null ? void 0 : _a.call(route, "type")) === "tabs") {
+      tabRoute = route;
+      pageRoute = route.get("parentId") ? await this.db.getRepository("desktopRoutes").findOne({
+        filterByTk: String(route.get("parentId")),
+        transaction
+      }) : null;
+    } else if (((_b = route == null ? void 0 : route.get) == null ? void 0 : _b.call(route, "type")) === "flowPage" || ((_c = route == null ? void 0 : route.get) == null ? void 0 : _c.call(route, "type")) === "page") {
+      pageRoute = route;
+    } else if (node == null ? void 0 : node.uid) {
+      pageRoute = await this.findPageRouteFromModel(node.uid, transaction).catch(() => {
+        return null;
+      }) || null;
+      tabRoute = await this.findRouteBySchemaUid(node.uid, transaction);
+      if (((_d = tabRoute == null ? void 0 : tabRoute.get) == null ? void 0 : _d.call(tabRoute, "type")) !== "tabs") {
+        tabRoute = null;
+      }
+    }
+    return {
+      target,
+      uid: (node == null ? void 0 : node.uid) || uid,
+      kind: ((_e = tabRoute == null ? void 0 : tabRoute.get) == null ? void 0 : _e.call(tabRoute, "type")) === "tabs" ? "tab" : isPageRoute(pageRoute) ? "page" : inferKind(node == null ? void 0 : node.use),
+      node,
+      route,
+      pageRoute,
+      tabRoute
+    };
+  }
+  async resolvePageSchemaUid(pageSchemaUid, target, transaction) {
+    var _a;
+    const pageModel = await this.repository.findModelByParentId(pageSchemaUid, {
+      transaction,
+      subKey: "page",
+      includeAsyncNode: true
+    });
+    const route = await this.db.getRepository("desktopRoutes").findOne({
+      filter: {
+        schemaUid: pageSchemaUid
+      },
+      transaction
+    });
+    if (pageModel == null ? void 0 : pageModel.uid) {
+      return {
+        target,
+        uid: pageModel.uid,
+        kind: "page",
+        node: pageModel,
+        route,
+        pageRoute: route,
+        pageModel
+      };
+    }
+    if ((_a = route == null ? void 0 : route.get) == null ? void 0 : _a.call(route, "schemaUid")) {
+      return {
+        target,
+        uid: route.get("schemaUid"),
+        kind: "page",
+        route,
+        pageRoute: route,
+        pageModel
+      };
+    }
+    throw new import_errors.FlowSurfaceBadRequestError("flowSurfaces target not found");
+  }
+  async findPageRouteFromModel(uid, transaction) {
+    var _a, _b;
+    let cursor = uid;
+    while (cursor) {
+      const route = await this.findRouteBySchemaUid(cursor, transaction);
+      if (((_a = route == null ? void 0 : route.get) == null ? void 0 : _a.call(route, "type")) === "flowPage" || ((_b = route == null ? void 0 : route.get) == null ? void 0 : _b.call(route, "type")) === "page") {
+        return route;
+      }
+      const parentUid = await this.findParentUid(cursor, transaction);
+      if (!parentUid) {
+        return null;
+      }
+      cursor = parentUid;
+    }
+    return null;
+  }
+}
+function inferKind(use) {
+  const normalized = (0, import_approval.normalizeApprovalSemanticUse)(use);
+  if (normalized === "RouteModel") {
+    return "node";
+  }
+  if (normalized === "RootPageModel" || normalized === "ChildPageModel") {
+    return "page";
+  }
+  if (normalized === "RootPageTabModel" || normalized === "ChildPageTabModel") {
+    return "tab";
+  }
+  if (/GridModel$/.test(normalized || "")) {
+    return "grid";
+  }
+  if (/BlockModel$/.test(normalized || "")) {
+    return "block";
+  }
+  return "node";
+}
+function isPageRoute(route) {
+  var _a;
+  const type = ((_a = route == null ? void 0 : route.get) == null ? void 0 : _a.call(route, "type")) || (route == null ? void 0 : route.type);
+  return type === "flowPage" || type === "page";
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  SurfaceLocator
+});

package/dist/server/flow-surfaces/node-use-sets.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 COLLECTION_BLOCK_USES: Set<string>;
+export declare const STATIC_CONTENT_BLOCK_USES: Set<string>;
+export declare const FIELD_WRAPPER_USES: Set<string>;
+export declare const CREATABLE_STANDALONE_FIELD_USES: Set<string>;
+export declare const STANDALONE_FIELD_NODE_USES: Set<string>;
+export declare const ACTION_BUTTON_USES: Set<string>;
+export declare const JS_BLOCK_USES: Set<string>;