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

package/dist/server/flow-schema-registry/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/dist/server/flow-schema-registry/flow-schema-registry/utils.js

@@ -0,0 +1,278 @@
+/**
+ * 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 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";
+}
+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);
+}
+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");
+}
+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;
+  });
+}
+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);
+}
+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;
+}
+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;
+}
+function normalizeSchemaHints(hints) {
+  return Array.isArray(hints) ? import_lodash.default.uniqBy(
+    hints.map((item) => normalizeFlowHint(item)),
+    (item) => `${item.kind}:${item.path || ""}:${item.message}`
+  ) : [];
+}
+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)
+  };
+}
+function normalizeStringArray(values) {
+  if (!Array.isArray(values)) {
+    return [];
+  }
+  return import_lodash.default.uniq(values.map((item) => String(item || "").trim()).filter(Boolean));
+}
+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;
+}
+function collectAllowedUses(slot) {
+  if (!slot) {
+    return [];
+  }
+  if (Array.isArray(slot.uses)) {
+    return slot.uses.filter(Boolean);
+  }
+  return slot.use ? [slot.use] : [];
+}
+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;
+}
+function toSchemaTitle(input, fallback) {
+  if (typeof input === "string") {
+    return input;
+  }
+  if (typeof input === "number" || typeof input === "boolean") {
+    return String(input);
+  }
+  return fallback;
+}
+// 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/dist/server/flow-schema-registry/index.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/dist/server/flow-schema-registry/index.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 flow_schema_registry_exports = {};
+module.exports = __toCommonJS(flow_schema_registry_exports);
+__reExport(flow_schema_registry_exports, require("./types"), module.exports);
+__reExport(flow_schema_registry_exports, require("./FlowSchemaRegistry"), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ...require("./types"),
+  ...require("./FlowSchemaRegistry")
+});

package/dist/server/flow-schema-registry/types.d.ts

@@ -0,0 +1,244 @@
+/**
+ * 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 { ActionDefinition as BaseActionDefinition, FlowContext, FlowModel, FlowModelMeta as BaseFlowModelMeta, ModelConstructor as BaseModelConstructor, StepDefinition as BaseStepDefinition } from '@nocobase/flow-engine';
+export type FlowJsonSchema = Record<string, any> & {
+    $schema?: string;
+    $id?: string;
+};
+export interface FlowDynamicHintMetadata {
+    slotRules?: {
+        slotKey?: string;
+        type?: 'object' | 'array';
+        allowedUses?: string[];
+    };
+    contextRequirements?: string[];
+    unresolvedReason?: string;
+    recommendedFallback?: any;
+}
+export interface FlowDynamicHint {
+    kind: 'dynamic-ui-schema' | 'dynamic-children' | 'custom-component' | 'x-reactions' | 'unresolved-action' | 'manual-schema-required' | 'unresolved-model';
+    path?: string;
+    message: string;
+    'x-flow'?: FlowDynamicHintMetadata;
+}
+export interface FlowSchemaCoverage {
+    status: 'auto' | 'manual' | 'mixed' | 'unresolved';
+    source: 'official' | 'plugin' | 'third-party';
+    strict?: boolean;
+    issues?: string[];
+}
+export type FlowModelSchemaExposure = 'public' | 'internal';
+export interface FlowSchemaPattern {
+    title: string;
+    description?: string;
+    snippet?: any;
+}
+export interface FlowSchemaDocs {
+    description?: string;
+    examples?: any[];
+    minimalExample?: any;
+    commonPatterns?: FlowSchemaPattern[];
+    antiPatterns?: FlowSchemaPattern[];
+    dynamicHints?: FlowDynamicHint[];
+}
+export interface FlowFieldBindingConditions {
+    association?: boolean;
+    fieldTypes?: string[];
+    targetCollectionTemplateIn?: string[];
+    targetCollectionTemplateNotIn?: string[];
+}
+export interface FlowFieldBindingContextContribution {
+    name: string;
+    inherits?: string[];
+}
+export interface FlowFieldBindingContribution {
+    context: string;
+    use: string;
+    interfaces: string[];
+    isDefault?: boolean;
+    order?: number;
+    conditions?: FlowFieldBindingConditions;
+    defaultProps?: any;
+}
+export interface FlowFieldModelCompatibility {
+    context: string;
+    interfaces: string[];
+    isDefault?: boolean;
+    order?: number;
+    association?: boolean;
+    fieldTypes?: string[];
+    targetCollectionTemplateIn?: string[];
+    targetCollectionTemplateNotIn?: string[];
+    inheritParentFieldBinding?: boolean;
+}
+export interface FlowSchemaBundleSlotCatalog {
+    type: 'object' | 'array';
+    required?: boolean;
+    minItems?: number;
+    open?: boolean;
+    candidates: FlowSchemaBundleNode[];
+}
+export interface FlowSchemaBundleNode {
+    use: string;
+    title?: string;
+    compatibility?: FlowFieldModelCompatibility;
+    subModelCatalog?: Record<string, FlowSchemaBundleSlotCatalog>;
+}
+export type FlowSchemaBundleItem = FlowSchemaBundleNode;
+export interface FlowSchemaBundleDocument {
+    items: FlowSchemaBundleNode[];
+}
+export interface FlowSchemaContextEdge {
+    parentUse: string;
+    slotKey: string;
+    childUse: string;
+}
+export interface FlowSubModelContextPathStep {
+    slotKey: string;
+    use?: string | string[];
+}
+export interface FlowModelSchemaPatch {
+    stepParamsSchema?: FlowJsonSchema;
+    flowRegistrySchema?: FlowJsonSchema;
+    subModelSlots?: Record<string, FlowSubModelSlotSchema>;
+    flowRegistrySchemaPatch?: FlowJsonSchema;
+    docs?: FlowSchemaDocs;
+    examples?: any[];
+    skeleton?: any;
+    dynamicHints?: FlowDynamicHint[];
+}
+export interface FlowDescendantSchemaPatch {
+    path: FlowSubModelContextPathStep[];
+    patch: FlowModelSchemaPatch;
+}
+export interface FlowSubModelSlotSchema {
+    type: 'object' | 'array';
+    use?: string;
+    uses?: string[];
+    required?: boolean;
+    minItems?: number;
+    dynamic?: boolean;
+    schema?: FlowJsonSchema;
+    fieldBindingContext?: string;
+    childSchemaPatch?: FlowModelSchemaPatch | Record<string, FlowModelSchemaPatch>;
+    descendantSchemaPatches?: FlowDescendantSchemaPatch[];
+    description?: string;
+}
+export interface FlowModelSchemaMeta {
+    stepParamsSchema?: FlowJsonSchema;
+    flowRegistrySchema?: FlowJsonSchema;
+    subModelSlots?: Record<string, FlowSubModelSlotSchema>;
+    flowRegistrySchemaPatch?: FlowJsonSchema;
+    docs?: FlowSchemaDocs;
+    examples?: any[];
+    skeleton?: any;
+    dynamicHints?: FlowDynamicHint[];
+    source?: FlowSchemaCoverage['source'];
+    strict?: boolean;
+    exposure?: FlowModelSchemaExposure;
+    abstract?: boolean;
+    allowDirectUse?: boolean;
+    suggestedUses?: string[];
+}
+export type FlowModelMeta = BaseFlowModelMeta & {
+    schema?: FlowModelSchemaMeta;
+};
+export type ModelConstructor<T extends FlowModel<any> = FlowModel<any>> = BaseModelConstructor<T> & {
+    meta?: FlowModelMeta;
+};
+export type ActionDefinition<TModel extends FlowModel = FlowModel, TCtx extends FlowContext = FlowContext> = BaseActionDefinition<TModel, TCtx> & {
+    paramsSchema?: FlowJsonSchema;
+    paramsSchemaPatch?: FlowJsonSchema;
+    schemaDocs?: FlowSchemaDocs;
+};
+export type StepDefinition<TModel extends FlowModel = FlowModel> = BaseStepDefinition<TModel> & {
+    paramsSchemaPatch?: FlowJsonSchema;
+    paramsSchemaOverride?: FlowJsonSchema;
+    schemaDocs?: FlowSchemaDocs;
+};
+export interface FlowActionSchemaContribution {
+    name: string;
+    title?: string;
+    paramsSchema?: FlowJsonSchema;
+    docs?: FlowSchemaDocs;
+    source?: FlowSchemaCoverage['source'];
+    strict?: boolean;
+}
+export interface FlowModelSchemaContribution {
+    use: string;
+    title?: string;
+    stepParamsSchema?: FlowJsonSchema;
+    flowRegistrySchema?: FlowJsonSchema;
+    subModelSlots?: Record<string, FlowSubModelSlotSchema>;
+    flowRegistrySchemaPatch?: FlowJsonSchema;
+    docs?: FlowSchemaDocs;
+    examples?: any[];
+    skeleton?: any;
+    dynamicHints?: FlowDynamicHint[];
+    source?: FlowSchemaCoverage['source'];
+    strict?: boolean;
+    exposure?: FlowModelSchemaExposure;
+    abstract?: boolean;
+    allowDirectUse?: boolean;
+    suggestedUses?: string[];
+}
+export interface FlowSchemaContributionDefaults {
+    source?: FlowSchemaCoverage['source'];
+    strict?: boolean;
+}
+export interface FlowSchemaSlotUseExpansion {
+    parentUse: string;
+    slotKey: string;
+    uses: string[];
+}
+export interface FlowSchemaInventoryContribution {
+    publicTreeRoots?: string[];
+    slotUseExpansions?: FlowSchemaSlotUseExpansion[];
+}
+export interface FlowSchemaContribution {
+    models?: FlowModelSchemaContribution[] | Record<string, FlowModelSchemaContribution>;
+    actions?: FlowActionSchemaContribution[] | Record<string, FlowActionSchemaContribution>;
+    fieldBindingContexts?: FlowFieldBindingContextContribution[] | Record<string, FlowFieldBindingContextContribution>;
+    fieldBindings?: FlowFieldBindingContribution[] | Record<string, FlowFieldBindingContribution | FlowFieldBindingContribution[]>;
+    inventory?: FlowSchemaInventoryContribution;
+    defaults?: FlowSchemaContributionDefaults;
+}
+export interface FlowSchemaContributionProvider {
+    getFlowSchemaContributions(): FlowSchemaContribution | undefined | Promise<FlowSchemaContribution | undefined>;
+}
+export interface FlowSchemaDocument {
+    use: string;
+    title?: string;
+    jsonSchema: FlowJsonSchema;
+    coverage: FlowSchemaCoverage;
+    dynamicHints: FlowDynamicHint[];
+    examples: any[];
+    minimalExample?: any;
+    commonPatterns: FlowSchemaPattern[];
+    antiPatterns: FlowSchemaPattern[];
+    skeleton: any;
+    hash: string;
+    source: FlowSchemaCoverage['source'];
+}
+export type FlowSchemaDetail = 'compact' | 'full';
+export interface FlowSchemaPublicDocument {
+    use: string;
+    title?: string;
+    jsonSchema: FlowJsonSchema;
+    dynamicHints: FlowDynamicHint[];
+    minimalExample?: any;
+    commonPatterns: FlowSchemaPattern[];
+    antiPatterns: FlowSchemaPattern[];
+    hash: string;
+    source: FlowSchemaCoverage['source'];
+}
+export type FlowSchemaActionDefinition<TModel extends FlowModel = FlowModel, TCtx extends FlowContext = FlowContext> = ActionDefinition<TModel, TCtx>;
+export type FlowSchemaStepDefinition<TModel extends FlowModel = FlowModel> = StepDefinition<TModel>;
+export type FlowSchemaModelMeta = FlowModelMeta;
+export type FlowSchemaModelConstructor<T extends FlowModel<any> = FlowModel<any>> = ModelConstructor<T>;

package/dist/server/flow-schema-registry/types.js

@@ -0,0 +1,24 @@
+/**
+ * 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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var types_exports = {};
+module.exports = __toCommonJS(types_exports);

package/dist/server/flow-schema-service.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 { FlowSchemaRegistry, type ActionDefinition, type FlowActionSchemaContribution, type FlowFieldBindingContextContribution, type FlowFieldBindingContribution, type FlowSchemaInventoryContribution, type FlowModelSchemaContribution, type FlowSchemaBundleDocument, type FlowSchemaContextEdge, type FlowSchemaDocument, type FlowSchemaDetail, type FlowSchemaPublicDocument, type ModelConstructor } from '@nocobase/flow-engine/server';
+import { FlowSchemaRegistry, type ActionDefinition, type FlowActionSchemaContribution, type FlowFieldBindingContextContribution, type FlowFieldBindingContribution, type FlowSchemaInventoryContribution, type FlowModelSchemaContribution, type FlowSchemaBundleDocument, type FlowSchemaContextEdge, type FlowSchemaDocument, type FlowSchemaDetail, type FlowSchemaPublicDocument, type ModelConstructor } from './flow-schema-registry';
 export interface FlowSchemaValidationIssue {
     level: 'error' | 'warning';
     jsonPointer: string;

package/dist/server/flow-schema-service.js

@@ -41,7 +41,7 @@ __export(flow_schema_service_exports, {
 module.exports = __toCommonJS(flow_schema_service_exports);
 var import_ajv = __toESM(require("ajv"));
 var import_utils = require("@nocobase/utils");
-var import_server = require("@nocobase/flow-engine/server");
+var import_flow_schema_registry = require("./flow-schema-registry");
 const MODEL_SHELL_SCHEMA = {
   $schema: "http://json-schema.org/draft-07/schema#",
   type: "object",
@@ -130,7 +130,7 @@ function readFieldBindingUse(value) {
   return String(((_b = (_a = value == null ? void 0 : value.stepParams) == null ? void 0 : _a.fieldBinding) == null ? void 0 : _b.use) || "").trim();
 }
 class FlowSchemaService {
-  registry = new import_server.FlowSchemaRegistry();
+  registry = new import_flow_schema_registry.FlowSchemaRegistry();
   ajv = new import_ajv.default({
     allErrors: true
   });

package/dist/server/plugin.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 type { FlowSchemaContribution } from '@nocobase/flow-engine';
+import type { FlowSchemaContribution } from './flow-schema-registry';
 import PluginUISchemaStorageServer from './server';
 export declare class PluginFlowEngineServer extends PluginUISchemaStorageServer {
     private globalContext;

package/dist/server/repository.d.ts

@@ -48,6 +48,7 @@ interface InsertAdjacentOptions extends removeParentOptions {
 export declare function transaction(transactionAbleArgPosition?: number): (target: any, propertyKey: string, descriptor: PropertyDescriptor) => PropertyDescriptor;
 export declare class FlowModelRepository extends Repository {
     cache: Cache;
+    emitTransactionRollback(transaction?: Transaction): Promise<void>;
     get flowModelsTableName(): any;
     get flowModelTreePathTableName(): any;
     static schemaToSingleNodes(schema: any, carry?: SchemaNode[], childOptions?: ChildOptions): SchemaNode[];