@nocobase/flow-engine 2.1.0-alpha.10 → 2.1.0-alpha.12

package/lib/flow-schema-registry/schemaInference.js

@@ -0,0 +1,207 @@
+/**
+ * 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 __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+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 schemaInference_exports = {};
+__export(schemaInference_exports, {
+  inferParamsSchemaFromUiSchema: () => inferParamsSchemaFromUiSchema
+});
+module.exports = __toCommonJS(schemaInference_exports);
+var import_lodash = __toESM(require("lodash"));
+var import_utils = require("./utils");
+function inferSchemaFromUiSchemaValue(name, uiSchema, path, hints) {
+  if (!uiSchema || typeof uiSchema !== "object" || Array.isArray(uiSchema)) {
+    return { type: "object", additionalProperties: true };
+  }
+  const xComponent = uiSchema["x-component"];
+  if (typeof xComponent === "function") {
+    hints.push(
+      (0, import_utils.createFlowHint)(
+        {
+          kind: "custom-component",
+          path,
+          message: `${name} uses a custom component and needs manual schema review.`
+        },
+        {
+          unresolvedReason: "function-x-component",
+          recommendedFallback: { type: "object", additionalProperties: true }
+        }
+      )
+    );
+  }
+  const reactions = uiSchema["x-reactions"];
+  if (reactions && (Array.isArray(reactions) && reactions.some((item) => typeof item === "function") || typeof reactions === "function")) {
+    hints.push(
+      (0, import_utils.createFlowHint)(
+        {
+          kind: "x-reactions",
+          path,
+          message: `${name} contains function-based x-reactions and only static schema is generated.`
+        },
+        {
+          unresolvedReason: "function-x-reactions"
+        }
+      )
+    );
+  }
+  const schema = {};
+  const type = uiSchema.type;
+  if (type) {
+    schema.type = type;
+  }
+  if (uiSchema.description) {
+    schema.description = uiSchema.description;
+  }
+  if (uiSchema.default !== void 0) {
+    schema.default = import_lodash.default.cloneDeep(uiSchema.default);
+  }
+  if (uiSchema.enum) {
+    if (Array.isArray(uiSchema.enum) && uiSchema.enum.every((item) => import_lodash.default.isPlainObject(item) && "value" in item)) {
+      schema.enum = uiSchema.enum.map((item) => item.value);
+    } else {
+      schema.enum = import_lodash.default.cloneDeep(uiSchema.enum);
+    }
+  }
+  if (uiSchema.const !== void 0) {
+    schema.const = import_lodash.default.cloneDeep(uiSchema.const);
+  }
+  if (uiSchema.required === true) {
+    schema.__required = true;
+  }
+  const validator = uiSchema["x-validator"];
+  if (import_lodash.default.isPlainObject(validator)) {
+    if (validator.minimum !== void 0) schema.minimum = validator.minimum;
+    if (validator.maximum !== void 0) schema.maximum = validator.maximum;
+    if (validator.minLength !== void 0) schema.minLength = validator.minLength;
+    if (validator.maxLength !== void 0) schema.maxLength = validator.maxLength;
+    if (validator.pattern !== void 0) schema.pattern = validator.pattern;
+  } else if (Array.isArray(validator)) {
+    for (const item of validator) {
+      if (import_lodash.default.isPlainObject(item)) {
+        Object.assign(schema, import_lodash.default.pick(item, ["minimum", "maximum", "minLength", "maxLength", "pattern"]));
+      }
+    }
+  } else if (typeof validator === "string") {
+    if (validator === "integer") schema.type = "integer";
+    if (validator === "email") schema.format = "email";
+    if (validator === "url") schema.format = "uri";
+    if (validator === "uid") schema.pattern = "^[A-Za-z0-9_-]+$";
+  }
+  if (uiSchema.properties && import_lodash.default.isPlainObject(uiSchema.properties)) {
+    schema.type = schema.type || "object";
+    schema.properties = {};
+    const required = [];
+    for (const [propName, propValue] of Object.entries(uiSchema.properties)) {
+      const childSchema = inferSchemaFromUiSchemaValue(propName, propValue, `${path}.${propName}`, hints);
+      if (childSchema.__required) {
+        required.push(propName);
+        delete childSchema.__required;
+      }
+      schema.properties[propName] = childSchema;
+    }
+    if (required.length) {
+      schema.required = required;
+    }
+    schema.additionalProperties = false;
+  }
+  if (uiSchema.items) {
+    schema.type = schema.type || "array";
+    if (import_lodash.default.isPlainObject(uiSchema.items)) {
+      schema.items = inferSchemaFromUiSchemaValue(`${name}.items`, uiSchema.items, `${path}.items`, hints);
+    } else if (Array.isArray(uiSchema.items)) {
+      schema.items = uiSchema.items.map(
+        (item, index) => inferSchemaFromUiSchemaValue(`${name}.items[${index}]`, item, `${path}.items[${index}]`, hints)
+      );
+    }
+  }
+  if (!schema.type) {
+    schema.type = "object";
+    schema.additionalProperties = true;
+  }
+  return schema;
+}
+__name(inferSchemaFromUiSchemaValue, "inferSchemaFromUiSchemaValue");
+function inferParamsSchemaFromUiSchema(name, uiSchema, path) {
+  const hints = [];
+  if (!uiSchema) {
+    return { schema: void 0, hints, coverage: "unresolved" };
+  }
+  if (typeof uiSchema === "function") {
+    hints.push(
+      (0, import_utils.createFlowHint)(
+        {
+          kind: "dynamic-ui-schema",
+          path,
+          message: `${name} uses function-based uiSchema and requires manual schema patch.`
+        },
+        {
+          unresolvedReason: "function-ui-schema",
+          recommendedFallback: { type: "object", additionalProperties: true }
+        }
+      )
+    );
+    return {
+      schema: { type: "object", additionalProperties: true },
+      hints,
+      coverage: "unresolved"
+    };
+  }
+  const properties = {};
+  const required = [];
+  for (const [key, value] of Object.entries(uiSchema)) {
+    const childSchema = inferSchemaFromUiSchemaValue(key, value, `${path}.${key}`, hints);
+    if (childSchema.__required) {
+      required.push(key);
+      delete childSchema.__required;
+    }
+    properties[key] = childSchema;
+  }
+  return {
+    schema: {
+      type: "object",
+      properties,
+      ...required.length ? { required } : {},
+      additionalProperties: false
+    },
+    hints,
+    coverage: hints.length ? "mixed" : "auto"
+  };
+}
+__name(inferParamsSchemaFromUiSchema, "inferParamsSchemaFromUiSchema");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  inferParamsSchemaFromUiSchema
+});

package/lib/flow-schema-registry/utils.d.ts

@@ -0,0 +1,25 @@
+/**
+ * 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 { FlowDynamicHint, FlowJsonSchema, FlowSchemaDocs, FlowSubModelSlotSchema } from '../types';
+export declare const JSON_SCHEMA_DRAFT_07 = "http://json-schema.org/draft-07/schema#";
+export declare function stableStringify(input: any): string;
+export declare function deepFreezePlainGraph<T>(input: T, seen?: WeakSet<object>): T;
+export declare function hashString(input: string): string;
+export declare function deepMergeReplaceArrays<T>(base: T, patch: any): T;
+export declare function mergeSchemas(base?: FlowJsonSchema, patch?: FlowJsonSchema): FlowJsonSchema | undefined;
+export declare function normalizeSchemaHints(hints?: FlowDynamicHint[]): FlowDynamicHint[];
+export declare function normalizeSchemaDocs(docs?: FlowSchemaDocs): FlowSchemaDocs;
+export declare function normalizeStringArray(values?: string[]): string[];
+export declare function createFlowHint(hint: FlowDynamicHint, metadata?: FlowDynamicHint['x-flow']): FlowDynamicHint;
+export declare function collectAllowedUses(slot?: FlowSubModelSlotSchema): string[];
+export declare function buildSkeletonFromSchema(schema?: FlowJsonSchema, options?: {
+    propertyName?: string;
+    depth?: number;
+}): any;
+export declare function toSchemaTitle(input: any, fallback: string): string;

package/lib/flow-schema-registry/utils.js

@@ -0,0 +1,293 @@
+/**
+ * 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 __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+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 utils_exports = {};
+__export(utils_exports, {
+  JSON_SCHEMA_DRAFT_07: () => JSON_SCHEMA_DRAFT_07,
+  buildSkeletonFromSchema: () => buildSkeletonFromSchema,
+  collectAllowedUses: () => collectAllowedUses,
+  createFlowHint: () => createFlowHint,
+  deepFreezePlainGraph: () => deepFreezePlainGraph,
+  deepMergeReplaceArrays: () => deepMergeReplaceArrays,
+  hashString: () => hashString,
+  mergeSchemas: () => mergeSchemas,
+  normalizeSchemaDocs: () => normalizeSchemaDocs,
+  normalizeSchemaHints: () => normalizeSchemaHints,
+  normalizeStringArray: () => normalizeStringArray,
+  stableStringify: () => stableStringify,
+  toSchemaTitle: () => toSchemaTitle
+});
+module.exports = __toCommonJS(utils_exports);
+var import_lodash = __toESM(require("lodash"));
+const JSON_SCHEMA_DRAFT_07 = "http://json-schema.org/draft-07/schema#";
+function stableStringify(input) {
+  if (Array.isArray(input)) {
+    return `[${input.map((item) => stableStringify(item)).join(",")}]`;
+  }
+  if (import_lodash.default.isPlainObject(input)) {
+    const entries = Object.entries(input).sort(([a], [b]) => a.localeCompare(b)).map(([key, value]) => `${JSON.stringify(key)}:${stableStringify(value)}`);
+    return `{${entries.join(",")}}`;
+  }
+  return JSON.stringify(input) ?? "null";
+}
+__name(stableStringify, "stableStringify");
+function deepFreezePlainGraph(input, seen = /* @__PURE__ */ new WeakSet()) {
+  if (Array.isArray(input)) {
+    if (seen.has(input)) {
+      return input;
+    }
+    seen.add(input);
+    for (const item of input) {
+      deepFreezePlainGraph(item, seen);
+    }
+    return Object.freeze(input);
+  }
+  if (!import_lodash.default.isPlainObject(input)) {
+    return input;
+  }
+  const objectValue = input;
+  if (seen.has(objectValue)) {
+    return input;
+  }
+  seen.add(objectValue);
+  for (const value of Object.values(objectValue)) {
+    deepFreezePlainGraph(value, seen);
+  }
+  return Object.freeze(objectValue);
+}
+__name(deepFreezePlainGraph, "deepFreezePlainGraph");
+function hashString(input) {
+  let hash = 0;
+  for (let index = 0; index < input.length; index++) {
+    hash = hash * 31 + input.charCodeAt(index) >>> 0;
+  }
+  return hash.toString(16).padStart(8, "0");
+}
+__name(hashString, "hashString");
+function deepMergeReplaceArrays(base, patch) {
+  if (typeof patch === "undefined") {
+    return import_lodash.default.cloneDeep(base);
+  }
+  if (typeof base === "undefined") {
+    return import_lodash.default.cloneDeep(patch);
+  }
+  return import_lodash.default.mergeWith({}, import_lodash.default.cloneDeep(base), import_lodash.default.cloneDeep(patch), (_objValue, srcValue) => {
+    if (Array.isArray(srcValue)) {
+      return import_lodash.default.cloneDeep(srcValue);
+    }
+    return void 0;
+  });
+}
+__name(deepMergeReplaceArrays, "deepMergeReplaceArrays");
+function mergeSchemas(base, patch) {
+  if (!base && !patch) return void 0;
+  if (!base) return import_lodash.default.cloneDeep(patch);
+  if (!patch) return import_lodash.default.cloneDeep(base);
+  return deepMergeReplaceArrays(base, patch);
+}
+__name(mergeSchemas, "mergeSchemas");
+function normalizeFlowHintMetadata(metadata) {
+  if (!metadata || typeof metadata !== "object" || Array.isArray(metadata)) {
+    return void 0;
+  }
+  const slotRules = metadata.slotRules && typeof metadata.slotRules === "object" && !Array.isArray(metadata.slotRules) ? import_lodash.default.pickBy(
+    {
+      slotKey: metadata.slotRules.slotKey,
+      type: metadata.slotRules.type,
+      allowedUses: Array.isArray(metadata.slotRules.allowedUses) ? metadata.slotRules.allowedUses.filter(Boolean) : metadata.slotRules.allowedUses
+    },
+    (value) => value !== void 0
+  ) : void 0;
+  const normalized = import_lodash.default.pickBy(
+    {
+      slotRules: slotRules && Object.keys(slotRules).length > 0 ? slotRules : void 0,
+      contextRequirements: Array.isArray(metadata.contextRequirements) ? metadata.contextRequirements.filter(Boolean) : metadata.contextRequirements,
+      unresolvedReason: metadata.unresolvedReason,
+      recommendedFallback: metadata.recommendedFallback
+    },
+    (value) => value !== void 0
+  );
+  return Object.keys(normalized).length > 0 ? normalized : void 0;
+}
+__name(normalizeFlowHintMetadata, "normalizeFlowHintMetadata");
+function normalizeFlowHint(hint) {
+  const normalizedHint = { ...hint };
+  const flowMetadata = normalizeFlowHintMetadata(hint["x-flow"]);
+  if (flowMetadata) {
+    normalizedHint["x-flow"] = flowMetadata;
+  } else {
+    delete normalizedHint["x-flow"];
+  }
+  return normalizedHint;
+}
+__name(normalizeFlowHint, "normalizeFlowHint");
+function normalizeSchemaHints(hints) {
+  return Array.isArray(hints) ? import_lodash.default.uniqBy(
+    hints.map((item) => normalizeFlowHint(item)),
+    (item) => `${item.kind}:${item.path || ""}:${item.message}`
+  ) : [];
+}
+__name(normalizeSchemaHints, "normalizeSchemaHints");
+function normalizeSchemaDocs(docs) {
+  return {
+    description: docs == null ? void 0 : docs.description,
+    examples: Array.isArray(docs == null ? void 0 : docs.examples) ? import_lodash.default.cloneDeep(docs.examples) : [],
+    minimalExample: (docs == null ? void 0 : docs.minimalExample) === void 0 ? void 0 : import_lodash.default.cloneDeep(docs.minimalExample),
+    commonPatterns: Array.isArray(docs == null ? void 0 : docs.commonPatterns) ? import_lodash.default.cloneDeep(docs.commonPatterns) : [],
+    antiPatterns: Array.isArray(docs == null ? void 0 : docs.antiPatterns) ? import_lodash.default.cloneDeep(docs.antiPatterns) : [],
+    dynamicHints: normalizeSchemaHints(docs == null ? void 0 : docs.dynamicHints)
+  };
+}
+__name(normalizeSchemaDocs, "normalizeSchemaDocs");
+function normalizeStringArray(values) {
+  if (!Array.isArray(values)) {
+    return [];
+  }
+  return import_lodash.default.uniq(values.map((item) => String(item || "").trim()).filter(Boolean));
+}
+__name(normalizeStringArray, "normalizeStringArray");
+function createFlowHint(hint, metadata) {
+  const result = { ...hint };
+  const flowMetadata = normalizeFlowHintMetadata({
+    ...hint["x-flow"] || {},
+    ...metadata || {}
+  });
+  if (flowMetadata) {
+    result["x-flow"] = flowMetadata;
+  } else {
+    delete result["x-flow"];
+  }
+  return result;
+}
+__name(createFlowHint, "createFlowHint");
+function collectAllowedUses(slot) {
+  if (!slot) {
+    return [];
+  }
+  if (Array.isArray(slot.uses)) {
+    return slot.uses.filter(Boolean);
+  }
+  return slot.use ? [slot.use] : [];
+}
+__name(collectAllowedUses, "collectAllowedUses");
+function buildSkeletonFromSchema(schema, options = {}) {
+  var _a, _b;
+  if (!schema) return void 0;
+  if (schema.default !== void 0) return import_lodash.default.cloneDeep(schema.default);
+  if (schema.const !== void 0) return import_lodash.default.cloneDeep(schema.const);
+  if (Array.isArray(schema.enum) && schema.enum.length > 0) return import_lodash.default.cloneDeep(schema.enum[0]);
+  const depth = options.depth || 0;
+  if (depth > 4) {
+    return void 0;
+  }
+  const type = Array.isArray(schema.type) ? schema.type[0] : schema.type;
+  if (type === "object" || !type && import_lodash.default.isPlainObject(schema.properties)) {
+    const result = {};
+    const properties = schema.properties || {};
+    const required = new Set(schema.required || []);
+    for (const [key, value] of Object.entries(properties)) {
+      const child = buildSkeletonFromSchema(value, {
+        propertyName: key,
+        depth: depth + 1
+      });
+      const includeOptionalTopLevelShell = depth === 0 && ["stepParams", "subModels", "flowRegistry"].includes(key) && child !== void 0 && (import_lodash.default.isPlainObject(child) && Object.keys(child).length > 0 || Array.isArray(child));
+      if (!includeOptionalTopLevelShell && !required.has(key) && value.default === void 0 && value.const === void 0) {
+        continue;
+      }
+      if (child !== void 0) {
+        result[key] = child;
+      }
+    }
+    return result;
+  }
+  if (type === "array") {
+    return [];
+  }
+  if (type === "boolean") {
+    return false;
+  }
+  if (type === "integer" || type === "number") {
+    return 0;
+  }
+  if (type === "string") {
+    const propertyName = options.propertyName || "value";
+    if (propertyName === "uid") {
+      return "todo-uid";
+    }
+    return "";
+  }
+  if ((_a = schema.oneOf) == null ? void 0 : _a.length) {
+    return buildSkeletonFromSchema(schema.oneOf[0], {
+      propertyName: options.propertyName,
+      depth: depth + 1
+    });
+  }
+  if ((_b = schema.anyOf) == null ? void 0 : _b.length) {
+    return buildSkeletonFromSchema(schema.anyOf[0], {
+      propertyName: options.propertyName,
+      depth: depth + 1
+    });
+  }
+  return void 0;
+}
+__name(buildSkeletonFromSchema, "buildSkeletonFromSchema");
+function toSchemaTitle(input, fallback) {
+  if (typeof input === "string") {
+    return input;
+  }
+  if (typeof input === "number" || typeof input === "boolean") {
+    return String(input);
+  }
+  return fallback;
+}
+__name(toSchemaTitle, "toSchemaTitle");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  JSON_SCHEMA_DRAFT_07,
+  buildSkeletonFromSchema,
+  collectAllowedUses,
+  createFlowHint,
+  deepFreezePlainGraph,
+  deepMergeReplaceArrays,
+  hashString,
+  mergeSchemas,
+  normalizeSchemaDocs,
+  normalizeSchemaHints,
+  normalizeStringArray,
+  stableStringify,
+  toSchemaTitle
+});

package/lib/flowEngine.js

@@ -1140,7 +1140,10 @@ const _FlowEngine = class _FlowEngine {
     if (hydrated) {
       return hydrated;
     }
-    const data = await this._modelRepository.findOne(options);
+    const shouldUseEnsure = !(extra == null ? void 0 : extra.skipSave) && !uid && !!parentId && !!subKey && (options == null ? void 0 : options.subType) === "object";
+    const data = shouldUseEnsure ? await this._modelRepository.ensure(options, {
+      includeAsyncNode: !!((options == null ? void 0 : options.includeAsyncNode) || (options == null ? void 0 : options.async))
+    }) ?? await this._modelRepository.findOne(options) : await this._modelRepository.findOne(options);
     let model = null;
     if (data == null ? void 0 : data.uid) {
       model = await this.createModelAsync(data, extra);

package/lib/index.d.ts

@@ -34,5 +34,6 @@ export { getSnippetBody, listSnippetsForContext, registerRunJSSnippet } from './
 export * from './views';
 export { DATA_SOURCE_DIRTY_EVENT, ENGINE_SCOPE_KEY, getEmitterViewActivatedVersion, VIEW_ACTIVATED_EVENT, VIEW_ACTIVATED_VERSION, VIEW_ENGINE_SCOPE, } from './views/viewEvents';
 export * from './FlowDefinition';
+export * from './FlowSchemaRegistry';
 export { createViewScopedEngine } from './ViewScopedFlowEngine';
 export { createBlockScopedEngine } from './BlockScopedFlowEngine';

package/lib/index.js

@@ -75,6 +75,7 @@ var import_snippets = require("./runjs-context/snippets");
 __reExport(src_exports, require("./views"), module.exports);
 var import_viewEvents = require("./views/viewEvents");
 __reExport(src_exports, require("./FlowDefinition"), module.exports);
+__reExport(src_exports, require("./FlowSchemaRegistry"), module.exports);
 var import_ViewScopedFlowEngine = require("./ViewScopedFlowEngine");
 var import_BlockScopedFlowEngine = require("./BlockScopedFlowEngine");
 // Annotate the CommonJS export names for ESM import in node:
@@ -116,5 +117,6 @@ var import_BlockScopedFlowEngine = require("./BlockScopedFlowEngine");
   ...require("./FlowContextProvider"),
   ...require("./JSRunner"),
   ...require("./views"),
-  ...require("./FlowDefinition")
+  ...require("./FlowDefinition"),
+  ...require("./FlowSchemaRegistry")
 });

package/lib/models/DisplayItemModel.d.ts

@@ -6,7 +6,7 @@
  * 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 { DefaultStructure } from '@nocobase/flow-engine';
+import { DefaultStructure } from '../types';
 import { CollectionFieldModel } from './CollectionFieldModel';
 export declare class DisplayItemModel<T extends DefaultStructure = DefaultStructure> extends CollectionFieldModel<T> {
 }

package/lib/models/EditableItemModel.d.ts

@@ -6,7 +6,7 @@
  * 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 { DefaultStructure } from '@nocobase/flow-engine';
+import { DefaultStructure } from '../types';
 import { CollectionFieldModel } from './CollectionFieldModel';
 export declare class EditableItemModel<T extends DefaultStructure = DefaultStructure> extends CollectionFieldModel<T> {
 }

package/lib/models/FilterableItemModel.d.ts

@@ -6,7 +6,7 @@
  * 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 { DefaultStructure } from '@nocobase/flow-engine';
+import { DefaultStructure } from '../types';
 import { CollectionFieldModel } from './CollectionFieldModel';
 export declare class FilterableItemModel<T extends DefaultStructure = DefaultStructure> extends CollectionFieldModel<T> {
 }

package/lib/runjs-context/setup.js

@@ -73,6 +73,7 @@ async function setupRunJSContexts() {
     import_registry.RunJSContextRegistry.register(version, "JSFieldModel", JSFieldRunJSContext, { scenes: ["detail"] });
     import_registry.RunJSContextRegistry.register(version, "JSEditableFieldModel", JSEditableFieldRunJSContext, { scenes: ["form"] });
     import_registry.RunJSContextRegistry.register(version, "JSItemModel", JSItemRunJSContext, { scenes: ["form"] });
+    import_registry.RunJSContextRegistry.register(version, "JSItemActionModel", JSItemRunJSContext, { scenes: ["table"] });
     import_registry.RunJSContextRegistry.register(version, "JSColumnModel", JSColumnRunJSContext, { scenes: ["table"] });
     import_registry.RunJSContextRegistry.register(version, "FormJSFieldItemModel", FormJSFieldItemRunJSContext, { scenes: ["form"] });
     import_registry.RunJSContextRegistry.register(version, "JSRecordActionModel", JSRecordActionRunJSContext, { scenes: ["table"] });

package/lib/server.d.ts

@@ -0,0 +1,10 @@
+/**
+ * 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 * from './types';
+export * from './FlowSchemaRegistry';

package/lib/server.js

@@ -0,0 +1,32 @@
+/**
+ * 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 __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 __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var server_exports = {};
+module.exports = __toCommonJS(server_exports);
+__reExport(server_exports, require("./types"), module.exports);
+__reExport(server_exports, require("./FlowSchemaRegistry"), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ...require("./types"),
+  ...require("./FlowSchemaRegistry")
+});