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

package/dist/server/index.d.ts

@@ -8,3 +8,4 @@
  */
 export { default } from './plugin';
 export { FlowModelRepository } from './repository';
+export { FlowSchemaService } from './flow-schema-service';

package/dist/server/index.js

@@ -37,12 +37,15 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var server_exports = {};
 __export(server_exports, {
   FlowModelRepository: () => import_repository.FlowModelRepository,
+  FlowSchemaService: () => import_flow_schema_service.FlowSchemaService,
   default: () => import_plugin.default
 });
 module.exports = __toCommonJS(server_exports);
 var import_plugin = __toESM(require("./plugin"));
 var import_repository = require("./repository");
+var import_flow_schema_service = require("./flow-schema-service");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  FlowModelRepository
+  FlowModelRepository,
+  FlowSchemaService
 });

package/dist/server/plugin.d.ts

@@ -6,10 +6,12 @@
  * 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 PluginUISchemaStorageServer from './server';
 export declare class PluginFlowEngineServer extends PluginUISchemaStorageServer {
     private globalContext;
     afterAdd(): Promise<void>;
+    getFlowSchemaContributions(): FlowSchemaContribution;
     beforeLoad(): Promise<void>;
     getDatabaseByDataSourceKey(dataSourceKey?: string): import("@nocobase/database").default;
     load(): Promise<void>;

package/dist/server/plugin.js

@@ -41,15 +41,19 @@ __export(plugin_exports, {
 });
 module.exports = __toCommonJS(plugin_exports);
 var import_utils = require("@nocobase/utils");
-var import_server2 = __toESM(require("./server"));
+var import_flow_schema_contributions = require("./flow-schema-contributions");
+var import_server = __toESM(require("./server"));
 var import_contexts = require("./template/contexts");
 var import_resolver = require("./template/resolver");
 var import_registry = require("./variables/registry");
 var import_utils2 = require("./variables/utils");
-class PluginFlowEngineServer extends import_server2.default {
+class PluginFlowEngineServer extends import_server.default {
   globalContext;
   async afterAdd() {
   }
+  getFlowSchemaContributions() {
+    return import_flow_schema_contributions.flowSchemaContribution;
+  }
   async beforeLoad() {
     await super.beforeLoad();
   }

package/dist/server/repository.d.ts

@@ -18,6 +18,16 @@ export interface GetPropertiesOptions {
     readFromCache?: boolean;
     transaction?: Transaction;
 }
+export interface FlowModelNodeRecord {
+    uid: string;
+    name?: string | null;
+    options?: unknown;
+    depth?: number | null;
+    type?: string | null;
+    async?: boolean | null;
+    parent?: string | null;
+    sort?: number | null;
+}
 export type FlowModelAttachPosition = 'first' | 'last' | TargetPosition;
 export interface FlowModelAttachOptions {
     parentId: string;
@@ -78,9 +88,16 @@ export declare class FlowModelRepository extends Repository {
     }): Promise<void>;
     remove(uid: string, options?: Transactionable & removeParentOptions): Promise<void>;
     insertAdjacent(position: 'beforeBegin' | 'afterBegin' | 'beforeEnd' | 'afterEnd', target: string, schema: any, options?: InsertAdjacentOptions): Promise<any>;
-    duplicate(modelUid: string, options?: Transactionable): Promise<any>;
+    duplicate(modelUid: string, options?: Transactionable): Promise<{
+        subModels?: Record<string, any>;
+        async: boolean;
+        uid: any;
+    }>;
     private dedupeNodesForDuplicate;
     private replaceStepParamsModelUids;
+    private sortNodesForDuplicate;
+    private prepareNodesForDuplicate;
+    private cloneNodesWithUidMap;
     insert(schema: any, options?: Transactionable): Promise<any>;
     insertNewSchema(schema: any, options?: Transactionable & {
         returnNode?: boolean;
@@ -103,7 +120,7 @@ export declare class FlowModelRepository extends Repository {
     protected insertAfterEnd(targetUid: string, schema: any, options?: InsertAdjacentOptions): Promise<any>;
     protected insertNodes(nodes: SchemaNode[], options?: Transactionable): Promise<any[]>;
     private doGetProperties;
-    findNodesById(uid: string, options?: GetJsonSchemaOptions): Promise<unknown[]>;
+    findNodesById(uid: string, options?: GetJsonSchemaOptions): Promise<FlowModelNodeRecord[]>;
     private doGetJsonSchema;
     private ignoreSchemaProperties;
     private breakOnMatched;
@@ -112,16 +129,57 @@ export declare class FlowModelRepository extends Repository {
     private insertSchemaRecord;
     private prepareSingleNodeForInsert;
     static modelToSingleNodes(model: any, parentChildOptions?: any): SchemaNode[];
-    static nodeToModel(node: any): any;
-    static nodesToModel(nodes: any[], rootUid: string): any;
-    insertModel(model: any, options?: Transactionable): Promise<any>;
+    static nodeToModel(node: any): {
+        async: boolean;
+        uid: any;
+    };
+    static nodesToModel(nodes: any[], rootUid: string): {
+        subModels?: Record<string, any>;
+        async: boolean;
+        uid: any;
+    };
+    insertModel(model: any, options?: Transactionable): Promise<{
+        subModels?: Record<string, any>;
+        async: boolean;
+        uid: any;
+    }>;
     updateSingleNode(node: SchemaNode, options?: Transactionable): Promise<boolean>;
     upsertModel(model: any, options?: Transactionable): Promise<string>;
-    findModelById(uid: string, options?: GetJsonSchemaOptions): Promise<any>;
+    findModelById(uid: string, options?: GetJsonSchemaOptions): Promise<{
+        subModels?: Record<string, any>;
+        async: boolean;
+        uid: any;
+    }>;
     findModelByParentId(parentUid: string, options?: GetJsonSchemaOptions & {
         subKey?: string;
-    }): Promise<any>;
-    attach(uid: string, attachOptions: FlowModelAttachOptions, options?: Transactionable): Promise<any>;
-    move(options: any): Promise<any>;
+    }): Promise<{
+        subModels?: Record<string, any>;
+        async: boolean;
+        uid: any;
+    }>;
+    ensureModel(values: any, options?: Transactionable & {
+        includeAsyncNode?: boolean;
+    }): Promise<{
+        subModels?: Record<string, any>;
+        async: boolean;
+        uid: any;
+    }>;
+    attach(uid: string, attachOptions: FlowModelAttachOptions, options?: Transactionable): Promise<{
+        subModels?: Record<string, any>;
+        async: boolean;
+        uid: any;
+    }>;
+    duplicateWithTargetUid(modelUid: string, targetUid: string, options?: Transactionable & {
+        includeAsyncNode?: boolean;
+    }): Promise<{
+        subModels?: Record<string, any>;
+        async: boolean;
+        uid: any;
+    }>;
+    move(moveOptions: {
+        sourceId: string;
+        targetId: string;
+        position: 'before' | 'after';
+    }, options?: Transactionable): Promise<any>;
 }
 export default FlowModelRepository;