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

package/dist/server/server.d.ts

@@ -7,17 +7,10 @@
  * For more information, please refer to: https://www.nocobase.com/agreement.
  */
 import { Plugin } from '@nocobase/server';
-import { FlowSchemaContributionCollector, RegisterFlowSchemasOptions } from './flow-models/schema-contribution-collector';
-import { FlowModelValidationFacade } from './flow-models/validation-facade';
-import { FlowSchemaService } from './flow-schema-service';
 export declare const compile: (title: string) => string;
 export declare class PluginUISchemaStorageServer extends Plugin {
-    protected readonly flowSchemaService: FlowSchemaService;
-    protected createFlowSchemaContributionCollector(): FlowSchemaContributionCollector;
-    protected createFlowModelValidationFacade(): FlowModelValidationFacade;
     registerRepository(): void;
     beforeLoad(): Promise<void>;
     load(): Promise<void>;
-    registerFlowSchemas(options: RegisterFlowSchemasOptions): void;
 }
 export default PluginUISchemaStorageServer;

package/dist/server/server.js

@@ -44,11 +44,6 @@ module.exports = __toCommonJS(server_exports);
 var import_database = require("@nocobase/database");
 var import_server = require("@nocobase/server");
 var import_utils = require("@nocobase/utils");
-var import_action_handlers = require("./flow-models/action-handlers");
-var import_mutate_executor = require("./flow-models/mutate-executor");
-var import_schema_contribution_collector = require("./flow-models/schema-contribution-collector");
-var import_validation_facade = require("./flow-models/validation-facade");
-var import_flow_schema_service = require("./flow-schema-service");
 var import_model = require("./model");
 var import_repository = __toESM(require("./repository"));
 const compile = (title) => (title || "").replace(/{{\s*t\(["|'|`](.*)["|'|`]\)\s*}}/g, "$1");
@@ -73,13 +68,6 @@ function extractFields(obj) {
   return fields.filter((value) => value !== void 0 && value !== "");
 }
 class PluginUISchemaStorageServer extends import_server.Plugin {
-  flowSchemaService = new import_flow_schema_service.FlowSchemaService();
-  createFlowSchemaContributionCollector() {
-    return new import_schema_contribution_collector.FlowSchemaContributionCollector(this.app, this.flowSchemaService);
-  }
-  createFlowModelValidationFacade() {
-    return new import_validation_facade.FlowModelValidationFacade(this.flowSchemaService, this.app);
-  }
   registerRepository() {
     this.app.db.registerRepositories({
       FlowModelRepository: import_repository.default
@@ -88,10 +76,8 @@ class PluginUISchemaStorageServer extends import_server.Plugin {
   async beforeLoad() {
     const db = this.app.db;
     const pm = this.app.pm;
-    this.flowSchemaService.setApp(this.app);
     this.app.db.registerModels({ MagicAttributeModel: import_database.MagicAttributeModel, FlowSchemaModel: import_model.FlowSchemaModel });
     this.registerRepository();
-    await this.createFlowSchemaContributionCollector().collectPluginFlowSchemaContributions();
     this.app.acl.registerSnippet({
       name: "ui.flowModels",
       actions: ["flowModels:*"]
@@ -137,15 +123,62 @@ class PluginUISchemaStorageServer extends import_server.Plugin {
       const uiSchemaRepository = db.getCollection("flowModels").repository;
       await uiSchemaRepository.remove(model.get("name"), { transaction });
     });
-    this.app.resourceManager.use((0, import_mutate_executor.createFlowModelsMutateTransactionMiddleware)());
     this.app.resourceManager.define({
       name: "flowModels",
-      actions: (0, import_action_handlers.createFlowModelActions)({
-        flowSchemaService: this.flowSchemaService,
-        validationFacade: this.createFlowModelValidationFacade()
-      })
+      actions: {
+        findOne: async (ctx, next) => {
+          const { uid: uid2, parentId, subKey, includeAsyncNode = false } = ctx.action.params;
+          const repository = ctx.db.getRepository("flowModels");
+          if (uid2) {
+            ctx.body = await repository.findModelById(uid2, { includeAsyncNode });
+          } else if (parentId) {
+            ctx.body = await repository.findModelByParentId(parentId, { subKey, includeAsyncNode });
+          }
+          await next();
+        },
+        duplicate: async (ctx, next) => {
+          const { uid: uid2 } = ctx.action.params;
+          const repository = ctx.db.getRepository("flowModels");
+          const duplicated = await repository.duplicate(uid2);
+          ctx.body = duplicated;
+          await next();
+        },
+        attach: async (ctx, next) => {
+          const { uid: uid2, parentId, subKey, subType, position } = ctx.action.params;
+          const repository = ctx.db.getRepository("flowModels");
+          const attached = await repository.attach(String(uid2 || "").trim(), {
+            parentId: String(parentId || "").trim(),
+            subKey: String(subKey || "").trim(),
+            subType,
+            position
+          });
+          ctx.body = attached;
+          await next();
+        },
+        move: async (ctx, next) => {
+          const { sourceId, targetId, position } = ctx.action.params;
+          const repository = ctx.db.getRepository("flowModels");
+          await repository.move({ sourceId, targetId, position });
+          ctx.body = "ok";
+          await next();
+        },
+        save: async (ctx, next) => {
+          const { values } = ctx.action.params;
+          const repository = ctx.db.getRepository("flowModels");
+          const uid2 = await repository.upsertModel(values);
+          ctx.body = uid2;
+          await next();
+        },
+        destroy: async (ctx, next) => {
+          const { filterByTk } = ctx.action.params;
+          const repository = ctx.db.getRepository("flowModels");
+          await repository.remove(filterByTk);
+          ctx.body = "ok";
+          await next();
+        }
+      }
     });
-    this.app.acl.allow("flowModels", ["findOne", "schema", "schemas", "schemaBundle"], "loggedIn");
+    this.app.acl.allow("flowModels", ["findOne"], "loggedIn");
   }
   async load() {
     const getSourceAndTargetForRemoveAction = async (ctx) => {
@@ -175,9 +208,6 @@ class PluginUISchemaStorageServer extends import_server.Plugin {
       { name: "flowModels:patch", getSourceAndTarget: getSourceAndTargetForPatchAction }
     ]);
   }
-  registerFlowSchemas(options) {
-    this.createFlowSchemaContributionCollector().registerFlowSchemas(options);
-  }
 }
 var server_default = PluginUISchemaStorageServer;
 // Annotate the CommonJS export names for ESM import in node:

package/dist/server/variables/resolve.d.ts

@@ -0,0 +1,21 @@
+/**
+ * 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 { ResourcerContext } from '@nocobase/resourcer';
+import { JSONValue } from '../template/resolver';
+type ResolveBatchItem = {
+    id?: string | number;
+    template: JSONValue;
+    contextParams?: Record<string, unknown>;
+};
+export declare function resolveVariablesTemplate(ctx: ResourcerContext, template: JSONValue, contextParams?: Record<string, unknown>): Promise<any>;
+export declare function resolveVariablesBatch(ctx: ResourcerContext, items: ResolveBatchItem[]): Promise<{
+    id?: string | number;
+    data: unknown;
+}[]>;
+export {};

package/dist/server/variables/resolve.js

@@ -0,0 +1,79 @@
+/**
+ * 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 resolve_exports = {};
+__export(resolve_exports, {
+  resolveVariablesBatch: () => resolveVariablesBatch,
+  resolveVariablesTemplate: () => resolveVariablesTemplate
+});
+module.exports = __toCommonJS(resolve_exports);
+var import_contexts = require("../template/contexts");
+var import_resolver = require("../template/resolver");
+var import_registry = require("./registry");
+var import_utils = require("./utils");
+const GLOBAL_CONTEXT_KEY = Symbol.for("nocobase.flow-engine.variables.global-context");
+function getGlobalContext(ctx) {
+  var _a, _b;
+  const app = ctx.app;
+  if (!app[GLOBAL_CONTEXT_KEY]) {
+    app[GLOBAL_CONTEXT_KEY] = new import_contexts.GlobalContext((_b = (_a = app.environment) == null ? void 0 : _a.getVariables) == null ? void 0 : _b.call(_a));
+  }
+  return app[GLOBAL_CONTEXT_KEY];
+}
+async function resolveVariablesTemplate(ctx, template, contextParams = {}) {
+  await (0, import_utils.prefetchRecordsForResolve)(ctx, [{ template, contextParams }]);
+  return resolveVariablesTemplateWithPrefetchedRecords(ctx, template, contextParams);
+}
+async function resolveVariablesTemplateWithPrefetchedRecords(ctx, template, contextParams = {}) {
+  const requestCtx = new import_contexts.HttpRequestContext(ctx);
+  requestCtx.delegate(getGlobalContext(ctx));
+  await import_registry.variables.attachUsedVariables(requestCtx, ctx, template, contextParams);
+  return (0, import_resolver.resolveJsonTemplate)(template, requestCtx);
+}
+async function resolveVariablesBatch(ctx, items) {
+  await (0, import_utils.prefetchRecordsForResolve)(
+    ctx,
+    items.map((item) => ({
+      template: (item == null ? void 0 : item.template) ?? {},
+      contextParams: (item == null ? void 0 : item.contextParams) || {}
+    }))
+  );
+  const results = [];
+  for (const item of items) {
+    const data = await resolveVariablesTemplateWithPrefetchedRecords(
+      ctx,
+      (item == null ? void 0 : item.template) ?? {},
+      (item == null ? void 0 : item.contextParams) || {}
+    );
+    results.push({ id: item == null ? void 0 : item.id, data });
+  }
+  return results;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  resolveVariablesBatch,
+  resolveVariablesTemplate
+});