@nocobase/plugin-flow-engine 3.0.0-alpha.1 → 3.0.0-alpha.11

package/dist/server/variables/record-slot-policy.d.ts

@@ -0,0 +1,23 @@
+/**
+ * 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 { Application } from '@nocobase/server';
+import type { AnalyzedTemplate } from '../template/variable-expression';
+import { type RecordSlotResolved, type RecordSlotResolverInput, type RecordSlotResolverRegistration } from './record-slot-resolvers';
+export type RecordSlotPolicy = RecordSlotResolved;
+export type RecordSlotPolicies = ReadonlyMap<string, RecordSlotPolicy>;
+export type FlowModelVariableContract = Readonly<{
+    allowedPaths: ReadonlySet<string>;
+    recordSlots: RecordSlotPolicies;
+}>;
+export type CompileRecordSlotPoliciesOptions = Omit<RecordSlotResolverInput, 'path'> & Readonly<{
+    app: Application;
+}>;
+export declare function createBuiltInRecordSlotResolvers(): readonly RecordSlotResolverRegistration[];
+export declare function compileRecordSlotPolicies(analysis: Pick<AnalyzedTemplate, 'paths'>, options: CompileRecordSlotPoliciesOptions): Promise<RecordSlotPolicies>;
+export declare function createFlowModelVariableContract(analysis: AnalyzedTemplate, options: CompileRecordSlotPoliciesOptions): Promise<FlowModelVariableContract>;

package/dist/server/variables/record-slot-policy.js

@@ -0,0 +1,100 @@
+/**
+ * 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 record_slot_policy_exports = {};
+__export(record_slot_policy_exports, {
+  compileRecordSlotPolicies: () => compileRecordSlotPolicies,
+  createBuiltInRecordSlotResolvers: () => createBuiltInRecordSlotResolvers,
+  createFlowModelVariableContract: () => createFlowModelVariableContract
+});
+module.exports = __toCommonJS(record_slot_policy_exports);
+var import_record_slot_resolvers = require("./record-slot-resolvers");
+function resolved(slot) {
+  return { status: "resolved", slot };
+}
+function createBuiltInRecordSlotResolvers() {
+  return [
+    ...["record", "responseRecord", "clickedRowRecord"].map(
+      (varName) => ({
+        owner: "@nocobase/plugin-flow-engine",
+        id: `direct:${varName}`,
+        match: (path) => path.varName === varName,
+        resolve: () => resolved([])
+      })
+    ),
+    {
+      owner: "@nocobase/plugin-flow-engine",
+      id: "view:record",
+      match: (path) => path.varName === "view" && path.runtimeSegments[0] === "record",
+      resolve: () => resolved(["record"])
+    },
+    {
+      owner: "@nocobase/plugin-flow-engine",
+      id: "popup:record",
+      match: (path) => {
+        if (path.varName !== "popup") return false;
+        let index = 0;
+        while (path.runtimeSegments[index] === "parent") index += 1;
+        return path.runtimeSegments[index] === "record" || path.runtimeSegments[index] === "sourceRecord";
+      },
+      resolve: ({ path }) => {
+        let index = 0;
+        while (path.runtimeSegments[index] === "parent") index += 1;
+        return resolved(path.runtimeSegments.slice(0, index + 1));
+      }
+    }
+  ];
+}
+function samePolicy(left, right) {
+  return left.slot.length === right.slot.length && left.slot.every((segment, index) => segment === right.slot[index]);
+}
+async function compileRecordSlotPolicies(analysis, options) {
+  const registry = (0, import_record_slot_resolvers.getRecordSlotResolverRegistry)(options.app);
+  const occurrences = /* @__PURE__ */ new Map();
+  for (const path of analysis.paths) {
+    const policies = occurrences.get(path.canonicalKey) || [];
+    policies.push(await registry.resolve({ ...options, path }));
+    occurrences.set(path.canonicalKey, policies);
+  }
+  const result = /* @__PURE__ */ new Map();
+  for (const [canonicalKey, policies] of occurrences) {
+    const first = policies[0];
+    if (first && policies.every((policy) => !!policy && samePolicy(policy, first))) result.set(canonicalKey, first);
+  }
+  return result;
+}
+async function createFlowModelVariableContract(analysis, options) {
+  return Object.freeze({
+    allowedPaths: new Set(analysis.paths.map((path) => path.canonicalKey)),
+    recordSlots: await compileRecordSlotPolicies(analysis, options)
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  compileRecordSlotPolicies,
+  createBuiltInRecordSlotResolvers,
+  createFlowModelVariableContract
+});

package/dist/server/variables/record-slot-resolvers.d.ts

@@ -0,0 +1,46 @@
+/**
+ * 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 type { Application } from '@nocobase/server';
+import type { PathSegment, VariablePathRef } from '../template/variable-expression';
+type MaybePromise<T> = T | Promise<T>;
+export type RecordSlotResolved = Readonly<{
+    status: 'resolved';
+    slot: readonly PathSegment[];
+}>;
+export type RecordSlotResolverResult = RecordSlotResolved | Readonly<{
+    status: 'deny' | 'abstain';
+}>;
+export type RecordSlotResolverInput = Readonly<{
+    path: VariablePathRef;
+    currentNode?: unknown;
+    loadAncestors?: () => Promise<readonly unknown[]>;
+    ctx?: ResourcerContext;
+    getCollection?: (dataSourceKey: string, collection: string) => unknown;
+}>;
+export type RecordSlotResolverRegistration = Readonly<{
+    owner: string;
+    id: string;
+    needsAncestors?: boolean;
+    match: (path: VariablePathRef) => boolean;
+    resolve: (input: RecordSlotResolverInput) => MaybePromise<RecordSlotResolverResult>;
+}>;
+export declare class RecordSlotResolverRegistry {
+    private readonly registrations;
+    has(owner: string, id: string): boolean;
+    register(registration: RecordSlotResolverRegistration): () => void;
+    resolve(input: RecordSlotResolverInput): Promise<RecordSlotResolved | undefined>;
+}
+export declare function getRecordSlotResolverRegistry(app: Application): RecordSlotResolverRegistry;
+export declare function createNestedRecordSlotResolver(registration: Readonly<{
+    owner: string;
+    id: string;
+    varName: string;
+}>): RecordSlotResolverRegistration;
+export {};

package/dist/server/variables/record-slot-resolvers.js

@@ -0,0 +1,115 @@
+/**
+ * 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 record_slot_resolvers_exports = {};
+__export(record_slot_resolvers_exports, {
+  RecordSlotResolverRegistry: () => RecordSlotResolverRegistry,
+  createNestedRecordSlotResolver: () => createNestedRecordSlotResolver,
+  getRecordSlotResolverRegistry: () => getRecordSlotResolverRegistry
+});
+module.exports = __toCommonJS(record_slot_resolvers_exports);
+function normalizeResolved(result) {
+  if (result.status !== "resolved" || !Array.isArray(result.slot)) return void 0;
+  if (result.slot.some(
+    (segment) => typeof segment !== "string" && typeof segment !== "number" || typeof segment === "string" && segment.includes("*") || typeof segment === "number" && (!Number.isSafeInteger(segment) || segment < 0)
+  )) {
+    return void 0;
+  }
+  return Object.freeze({ status: "resolved", slot: Object.freeze([...result.slot]) });
+}
+function sameResolved(left, right) {
+  return left.slot.length === right.slot.length && left.slot.every((segment, index) => segment === right.slot[index]);
+}
+class RecordSlotResolverRegistry {
+  registrations = /* @__PURE__ */ new Map();
+  has(owner, id) {
+    var _a;
+    return ((_a = this.registrations.get(owner.trim())) == null ? void 0 : _a.has(id.trim())) === true;
+  }
+  register(registration) {
+    const owner = registration.owner.trim();
+    const id = registration.id.trim();
+    if (!owner || !id) throw new TypeError("Record Slot resolver owner and id are required");
+    const entry = Object.freeze({ ...registration, owner, id });
+    let owned = this.registrations.get(owner);
+    if (!owned) {
+      owned = /* @__PURE__ */ new Map();
+      this.registrations.set(owner, owned);
+    }
+    owned.set(id, entry);
+    return () => {
+      const current = this.registrations.get(owner);
+      if ((current == null ? void 0 : current.get(id)) !== entry) return;
+      current.delete(id);
+      if (!current.size) this.registrations.delete(owner);
+    };
+  }
+  async resolve(input) {
+    const resolutions = [];
+    for (const owned of this.registrations.values()) {
+      for (const registration of owned.values()) {
+        try {
+          if (!registration.match(input.path)) continue;
+          const result = await registration.resolve(
+            registration.needsAncestors ? input : { ...input, loadAncestors: void 0 }
+          );
+          if (result.status === "deny") return void 0;
+          if (result.status === "abstain") continue;
+          const normalized = normalizeResolved(result);
+          if (!normalized) return void 0;
+          resolutions.push(normalized);
+        } catch (_) {
+          return void 0;
+        }
+      }
+    }
+    const first = resolutions[0];
+    return first && resolutions.every((resolution) => sameResolved(resolution, first)) ? first : void 0;
+  }
+}
+const registries = /* @__PURE__ */ new WeakMap();
+function getRecordSlotResolverRegistry(app) {
+  let registry = registries.get(app);
+  if (!registry) {
+    registry = new RecordSlotResolverRegistry();
+    registries.set(app, registry);
+  }
+  return registry;
+}
+function createNestedRecordSlotResolver(registration) {
+  return Object.freeze({
+    owner: registration.owner,
+    id: registration.id,
+    match: (path) => path.varName === registration.varName && path.runtimeSegments[0] === "record",
+    resolve: () => ({ status: "resolved", slot: ["record"] })
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  RecordSlotResolverRegistry,
+  createNestedRecordSlotResolver,
+  getRecordSlotResolverRegistry
+});

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

@@ -6,7 +6,54 @@
  * 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 { Collection, RelationRepository, Repository } from '@nocobase/database';
+import type { IRepository } from '@nocobase/data-source-manager';
+import type { ResourcerContext } from '@nocobase/resourcer';
 type FilterTargetKey = string | string[] | undefined;
+type RecordRepository = IRepository | Repository | RelationRepository;
+export type RecordParams = {
+    associationName?: string;
+    collection: string;
+    dataSourceKey?: string;
+    filterByTk: unknown;
+    sourceId?: unknown;
+    fields?: string[];
+    appends?: string[];
+};
+export type RecordTarget = {
+    repository: RecordRepository;
+    dataSourceKey: string;
+    collection: Collection;
+    collectionName: string;
+    filterTargetKey: FilterTargetKey;
+    pkAttr?: string;
+    pkIsValid: boolean;
+    rawAttributes?: Record<string, unknown>;
+    cacheIdentity: Readonly<{
+        ds: string;
+        c: string;
+        assoc?: string;
+        sid?: unknown;
+    }>;
+};
+export type RecordQuery = RecordTarget & {
+    filterByTk: unknown;
+    fields?: string[];
+    appends?: string[];
+    preferFullRecord: boolean;
+    strictSelects: boolean;
+    cacheKey: string;
+};
+export declare function isRecordParams(value: unknown): value is RecordParams;
+export declare function resolveRecordTarget(koaCtx: ResourcerContext, params: RecordParams): RecordTarget | undefined;
+export declare function prepareRecordQuery(koaCtx: ResourcerContext, target: RecordTarget, filterByTk: unknown, fields?: string[], appends?: string[], strictSelects?: boolean, preferFullRecord?: boolean): RecordQuery;
+export declare function getRecordRequestCache(koaCtx: ResourcerContext): Map<string, unknown>;
+export declare function setRecordRequestCache(cache: Map<string, unknown>, query: RecordQuery, value: unknown): Map<string, unknown>;
+export declare function findRecordRequestCacheValue(cache: Map<string, unknown>, query: RecordQuery): {
+    hit: boolean;
+    value: unknown;
+};
+export declare function fetchRecordWithRequestCache(koaCtx: ResourcerContext, params: RecordParams, fields?: string[], appends?: string[], strictSelects?: boolean, preferFullRecord?: boolean): Promise<unknown>;
 /**
  * 为了：
  * - 关联加载/缓存：fields 模式下确保包含主键
@@ -26,7 +73,7 @@ export declare function mergeFieldsWithExtras(fields?: string[], extras?: string
  * - 单值：返回 object | undefined
  * - 数组：返回 array（空数组时返回 []，不会退化为无条件查询）
  */
-export declare function fetchRecordOrRecordsJson(repo: any, params: {
+export declare function fetchRecordOrRecordsJson(repo: RecordRepository, params: {
     filterByTk: unknown;
     preferFullRecord?: boolean;
     fields?: string[];
@@ -34,5 +81,5 @@ export declare function fetchRecordOrRecordsJson(repo: any, params: {
     filterTargetKey?: FilterTargetKey;
     pkAttr?: string;
     pkIsValid?: boolean;
-}): Promise<unknown>;
+}, context: ResourcerContext): Promise<unknown>;
 export {};