@nocobase/plugin-flow-engine 2.0.0-alpha.2

package/dist/server/plugin.js

@@ -0,0 +1,270 @@
+/**
+ * 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 plugin_exports = {};
+__export(plugin_exports, {
+  PluginFlowEngineServer: () => PluginFlowEngineServer,
+  default: () => plugin_default
+});
+module.exports = __toCommonJS(plugin_exports);
+var import_server2 = __toESM(require("./server"));
+var import_contexts = require("./template/contexts");
+var import_resolver = require("./template/resolver");
+var import_registry = require("./variables/registry");
+class PluginFlowEngineServer extends import_server2.default {
+  globalContext;
+  async afterAdd() {
+  }
+  async beforeLoad() {
+    await super.beforeLoad();
+  }
+  getDatabaseByDataSourceKey(dataSourceKey = "main") {
+    const dataSource = this.app.dataSourceManager.get(dataSourceKey);
+    const cm = dataSource.collectionManager;
+    if (!cm.db) {
+      throw new Error("no db");
+    }
+    return cm.db;
+  }
+  // 预取：构建“同记录”的字段/关联并集，一次查询写入 ctx.state.__varResolveBatchCache，供后续解析复用
+  async prefetchRecordsForResolve(koaCtx, items) {
+    var _a;
+    try {
+      const groupMap = /* @__PURE__ */ new Map();
+      const ensureGroup = (dataSourceKey, collection, filterByTk) => {
+        const groupKey = JSON.stringify({ ds: dataSourceKey, collection, tk: filterByTk });
+        let group = groupMap.get(groupKey);
+        if (!group) {
+          group = { dataSourceKey, collection, filterByTk, fields: /* @__PURE__ */ new Set(), appends: /* @__PURE__ */ new Set() };
+          groupMap.set(groupKey, group);
+        }
+        return group;
+      };
+      const normalizeNestedSeg = (segment) => /^\d+$/.test(segment) ? `[${segment}]` : segment;
+      const toFirstSeg = (path) => {
+        const m = path.match(/^([^.[]+|\[[^\]]+\])([\s\S]*)$/);
+        const segment = m ? m[1] : "";
+        const rest = m ? m[2] : "";
+        return { segment, hasDeep: rest.includes(".") || rest.includes("[") || rest.length > 0 };
+      };
+      for (const it of items) {
+        const template = (it == null ? void 0 : it.template) ?? {};
+        const contextParams = (it == null ? void 0 : it.contextParams) || {};
+        const usage = import_registry.variables.extractUsage(template);
+        for (const [cpKey, recordParams] of Object.entries(contextParams)) {
+          const parts = String(cpKey).split(".");
+          const varName = parts[0];
+          const nestedSeg = parts.slice(1).join(".");
+          const paths = (usage == null ? void 0 : usage[varName]) || [];
+          if (!paths.length) continue;
+          const segNorm = nestedSeg ? normalizeNestedSeg(nestedSeg) : "";
+          const remainders = [];
+          for (const p of paths) {
+            if (!segNorm) remainders.push(p);
+            else if (p === segNorm) remainders.push("");
+            else if (p.startsWith(`${segNorm}.`) || p.startsWith(`${segNorm}[`))
+              remainders.push(p.slice(segNorm.length + 1));
+          }
+          if (!remainders.length) continue;
+          const dataSourceKey = (recordParams == null ? void 0 : recordParams.dataSourceKey) || "main";
+          const collection = recordParams == null ? void 0 : recordParams.collection;
+          const filterByTk = recordParams == null ? void 0 : recordParams.filterByTk;
+          if (!collection || typeof filterByTk === "undefined") continue;
+          const group = ensureGroup(dataSourceKey, collection, filterByTk);
+          for (const r of remainders) {
+            const { segment, hasDeep } = toFirstSeg(r);
+            if (!segment) continue;
+            const key = segment.replace(/^\[(.+)\]$/, "$1");
+            if (hasDeep) group.appends.add(key);
+            else group.fields.add(key);
+          }
+        }
+      }
+      if (!groupMap.size) return;
+      const stateObj = koaCtx.state;
+      if (stateObj && !stateObj["__varResolveBatchCache"]) {
+        stateObj["__varResolveBatchCache"] = /* @__PURE__ */ new Map();
+      }
+      const cache = (_a = koaCtx.state) == null ? void 0 : _a["__varResolveBatchCache"];
+      for (const { dataSourceKey, collection, filterByTk, fields, appends } of groupMap.values()) {
+        try {
+          const dataSource = this.app.dataSourceManager.get(dataSourceKey);
+          const cm = dataSource.collectionManager;
+          if (!(cm == null ? void 0 : cm.db)) continue;
+          const repo = cm.db.getRepository(collection);
+          const fld = fields.size ? Array.from(fields) : void 0;
+          const app = appends.size ? Array.from(appends) : void 0;
+          const rec = await repo.findOne({ filterByTk, fields: fld, appends: app });
+          const json = rec ? rec.toJSON() : void 0;
+          if (cache) {
+            const key = JSON.stringify({ ds: dataSourceKey, c: collection, tk: filterByTk, f: fld, a: app });
+            cache.set(key, json);
+          }
+        } catch {
+        }
+      }
+    } catch {
+    }
+  }
+  transformSQL(template) {
+    let index = 1;
+    const bind = {};
+    const sql = template.replace(/{{\s*([^}]+)\s*}}/g, (_, expr) => {
+      const key = `__var${index}`;
+      bind[key] = `{{${expr.trim()}}}`;
+      index++;
+      return `$${key}`;
+    });
+    return { sql, bind };
+  }
+  async load() {
+    var _a, _b;
+    await super.load();
+    this.globalContext = new import_contexts.GlobalContext((_b = (_a = this.app.environment) == null ? void 0 : _a.getVariables) == null ? void 0 : _b.call(_a));
+    this.app.acl.allow("flowSql", "runById", "loggedIn");
+    this.app.acl.allow("variables", "resolve", "loggedIn");
+    this.app.acl.allow("fieldAssignments", "apply", "loggedIn");
+    this.app.resourceManager.define({
+      name: "variables",
+      actions: {
+        // 解析 JSON 模板中的 ctx 变量
+        resolve: async (ctx, next) => {
+          var _a2, _b2;
+          const raw = ((_b2 = (_a2 = ctx.action) == null ? void 0 : _a2.params) == null ? void 0 : _b2.values) ?? {};
+          const values = typeof (raw == null ? void 0 : raw.values) !== "undefined" ? raw.values : raw;
+          if (Array.isArray(values == null ? void 0 : values.batch)) {
+            const batchItems = values.batch;
+            await this.prefetchRecordsForResolve(
+              ctx,
+              batchItems.map((it) => ({
+                template: it.template,
+                contextParams: it.contextParams || {}
+              }))
+            );
+            const results = [];
+            for (const item of batchItems) {
+              const template2 = (item == null ? void 0 : item.template) ?? {};
+              const contextParams2 = (item == null ? void 0 : item.contextParams) || {};
+              const requestCtx2 = new import_contexts.HttpRequestContext(ctx);
+              requestCtx2.delegate(this.globalContext);
+              await import_registry.variables.attachUsedVariables(requestCtx2, ctx, template2, contextParams2);
+              const resolved2 = await (0, import_resolver.resolveJsonTemplate)(template2, requestCtx2);
+              results.push({ id: item == null ? void 0 : item.id, data: resolved2 });
+            }
+            ctx.body = { results };
+            await next();
+            return;
+          }
+          if (typeof (values == null ? void 0 : values.template) === "undefined") {
+            ctx.throw(400, {
+              code: "INVALID_PAYLOAD",
+              message: "values.template is required when batch is not provided"
+            });
+          }
+          const template = values.template;
+          const contextParams = (values == null ? void 0 : values.contextParams) || {};
+          await this.prefetchRecordsForResolve(ctx, [{ template, contextParams }]);
+          const requestCtx = new import_contexts.HttpRequestContext(ctx);
+          requestCtx.delegate(this.globalContext);
+          await import_registry.variables.attachUsedVariables(requestCtx, ctx, template, contextParams);
+          const resolved = await (0, import_resolver.resolveJsonTemplate)(template, requestCtx);
+          ctx.body = resolved;
+          await next();
+        }
+      }
+    });
+    this.app.acl.registerSnippet({
+      name: "ui.flowSql",
+      actions: ["flowSql:*"]
+    });
+    this.app.resourceManager.registerActionHandlers({
+      "flowSql:runById": async (ctx, next) => {
+        const { uid, type, filter, bind, dataSourceKey = "main" } = ctx.action.params.values;
+        const r = this.db.getRepository("flowSql");
+        const record = await r.findOne({
+          filter: { uid }
+        });
+        const db = this.getDatabaseByDataSourceKey(record.dataSourceKey || dataSourceKey);
+        const result = this.transformSQL(record.sql);
+        ctx.body = await db.runSQL(result.sql, {
+          type,
+          filter,
+          bind
+        });
+        await next();
+      },
+      "flowSql:getBind": async (ctx, next) => {
+        const { uid } = ctx.action.params;
+        const r = this.db.getRepository("flowSql");
+        const record = await r.findOne({
+          filter: { uid }
+        });
+        const { bind } = this.transformSQL(record.sql);
+        ctx.body = bind;
+        await next();
+      },
+      "flowSql:save": async (ctx, next) => {
+        const { uid, sql, dataSourceKey } = ctx.action.params.values;
+        const r = this.db.getRepository("flowSql");
+        await r.updateOrCreate({
+          filterKeys: ["uid"],
+          values: { uid, sql, dataSourceKey }
+        });
+        ctx.body = "ok";
+        await next();
+      },
+      "flowSql:run": async (ctx, next) => {
+        const { sql, type, filter, bind, dataSourceKey } = ctx.action.params.values;
+        const db = this.getDatabaseByDataSourceKey(dataSourceKey);
+        ctx.body = await db.runSQL(sql, { type, filter, bind });
+        await next();
+      }
+    });
+  }
+  async install() {
+  }
+  async afterEnable() {
+  }
+  async afterDisable() {
+  }
+  async remove() {
+  }
+}
+var plugin_default = PluginFlowEngineServer;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  PluginFlowEngineServer
+});

package/dist/server/repository.d.ts

@@ -0,0 +1,116 @@
+/**
+ * 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 { Cache } from '@nocobase/cache';
+import { Repository, Transaction, Transactionable } from '@nocobase/database';
+import { ChildOptions, SchemaNode } from './dao/ui_schema_node_dao';
+export interface GetJsonSchemaOptions {
+    includeAsyncNode?: boolean;
+    readFromCache?: boolean;
+    transaction?: Transaction;
+}
+export interface GetPropertiesOptions {
+    readFromCache?: boolean;
+    transaction?: Transaction;
+}
+type BreakRemoveOnType = {
+    [key: string]: any;
+};
+export interface removeParentOptions extends Transactionable {
+    removeParentsIfNoChildren?: boolean;
+    breakRemoveOn?: BreakRemoveOnType;
+}
+interface InsertAdjacentOptions extends removeParentOptions {
+    wrap?: any;
+}
+export declare function transaction(transactionAbleArgPosition?: number): (target: any, propertyKey: string, descriptor: PropertyDescriptor) => PropertyDescriptor;
+export declare class FlowModelRepository extends Repository {
+    cache: Cache;
+    get flowModelsTableName(): any;
+    get flowModelTreePathTableName(): any;
+    static schemaToSingleNodes(schema: any, carry?: SchemaNode[], childOptions?: ChildOptions): SchemaNode[];
+    setCache(cache: Cache): void;
+    /**
+     * clear cache with xUid which in flowModelTreePath's Path
+     * @param {string} xUid
+     * @param {Transaction} transaction
+     * @returns {Promise<void>}
+     */
+    clearXUidPathCache(xUid: string, transaction: Transaction): Promise<void>;
+    tableNameAdapter(tableName: any): any;
+    sqlAdapter(sql: string): string;
+    getProperties(uid: string, options?: GetPropertiesOptions): Promise<Partial<{
+        uid: any;
+        "x-async": boolean;
+    }>>;
+    getParentJsonSchema(uid: string, options?: GetJsonSchemaOptions): Promise<any>;
+    getParentProperty(uid: string, options?: GetPropertiesOptions): Promise<any>;
+    getJsonSchema(uid: string, options?: GetJsonSchemaOptions): Promise<any>;
+    nodesToSchema(nodes: any, rootUid: any): {
+        uid: any;
+        "x-async": boolean;
+    };
+    clearAncestor(uid: string, options?: Transactionable): Promise<void>;
+    emitAfterSaveEvent(s: any, options: any): Promise<void>;
+    patch(newSchema: any, options?: any): Promise<void>;
+    initializeActionContext(newSchema: any, options?: any): Promise<void>;
+    batchPatch(schemas: any[], options?: any): Promise<void>;
+    removeEmptyParents(options: Transactionable & {
+        uid: string;
+        breakRemoveOn?: BreakRemoveOnType;
+    }): Promise<void>;
+    recursivelyRemoveIfNoChildren(options: Transactionable & {
+        uid: string;
+        breakRemoveOn?: BreakRemoveOnType;
+    }): 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(uid: string, options?: Transactionable): Promise<any>;
+    insert(schema: any, options?: Transactionable): Promise<any>;
+    insertNewSchema(schema: any, options?: Transactionable & {
+        returnNode?: boolean;
+    }): Promise<any>;
+    insertSingleNode(schema: SchemaNode, options: Transactionable & removeParentOptions): Promise<any>;
+    protected updateNode(uid: string, schema: any, transaction?: Transaction): Promise<void>;
+    protected childrenCount(uid: any, transaction: any): Promise<number>;
+    protected isLeafNode(uid: any, transaction: any): Promise<boolean>;
+    protected findParentUid(uid: any, transaction?: any): Promise<string>;
+    protected findNodeSchemaWithParent(uid: any, transaction: any): Promise<{
+        parentUid: string;
+        schema: any;
+    }>;
+    protected isSingleChild(uid: any, transaction: any): Promise<any>;
+    protected insertBeside(targetUid: string, schema: any, side: 'before' | 'after', options?: InsertAdjacentOptions): Promise<any>;
+    protected insertInner(targetUid: string, schema: any, position: 'first' | 'last', options?: InsertAdjacentOptions): Promise<any>;
+    protected insertAfterBegin(targetUid: string, schema: any, options?: InsertAdjacentOptions): Promise<any>;
+    protected insertBeforeEnd(targetUid: string, schema: any, options?: InsertAdjacentOptions): Promise<any>;
+    protected insertBeforeBegin(targetUid: string, schema: any, options?: InsertAdjacentOptions): Promise<any>;
+    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[]>;
+    private doGetJsonSchema;
+    private ignoreSchemaProperties;
+    private breakOnMatched;
+    private schemaExists;
+    private regenerateUid;
+    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>;
+    updateSingleNode(node: SchemaNode, options?: Transactionable): Promise<boolean>;
+    upsertModel(model: any, options?: Transactionable): Promise<string>;
+    findModelById(uid: string, options?: GetJsonSchemaOptions): Promise<any>;
+    findModelByParentId(parentUid: string, options?: GetJsonSchemaOptions & {
+        subKey?: string;
+    }): Promise<any>;
+    move(options: any): Promise<any>;
+}
+export default FlowModelRepository;