@nocobase/flow-engine 2.2.0-alpha.1 → 2.2.0-alpha.11

package/src/utils/__tests__/openViewRouteState.test.ts

@@ -0,0 +1,40 @@
+/**
+ * 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 { decodeOpenViewRouteState, encodeOpenViewRouteState, isOpenViewRouteStateToken } from '../openViewRouteState';
+
+describe('openViewRouteState', () => {
+  it('encodes route state as an 8-letter view-bound token', () => {
+    const token = encodeOpenViewRouteState('popup', { mode: 'dialog', size: 'large' });
+
+    expect(token).toMatch(/^[A-Za-z]{8}$/);
+    expect(isOpenViewRouteStateToken(token)).toBe(true);
+    expect(decodeOpenViewRouteState('popup', token)).toEqual({ mode: 'dialog', size: 'large' });
+    expect(decodeOpenViewRouteState('other-popup', token)).toBeUndefined();
+  });
+
+  it('can encode mode without leaking a default size', () => {
+    const token = encodeOpenViewRouteState('popup', { mode: 'embed' });
+
+    expect(token).toMatch(/^[A-Za-z]{8}$/);
+    expect(decodeOpenViewRouteState('popup', token)).toEqual({ mode: 'embed' });
+  });
+
+  it('generates distinct tokens for supported route state combinations', () => {
+    const modes = [undefined, 'drawer', 'dialog', 'embed'] as const;
+    const sizes = [undefined, 'small', 'medium', 'large'] as const;
+    const tokens = modes.flatMap((mode) =>
+      sizes
+        .map((size) => encodeOpenViewRouteState('popup', { mode, size }))
+        .filter((token): token is string => !!token),
+    );
+
+    expect(new Set(tokens).size).toBe(tokens.length);
+  });
+});

package/src/utils/__tests__/parsePathnameToViewParams.test.ts

@@ -8,6 +8,7 @@
  */
 
 import { parsePathnameToViewParams } from '../parsePathnameToViewParams';
+import { encodeOpenViewRouteState } from '../openViewRouteState';
 
 describe('parsePathnameToViewParams', () => {
   test('should return single view param for basic admin path', () => {
@@ -48,6 +49,41 @@ describe('parsePathnameToViewParams', () => {
     expect(result).toEqual([{ viewUid: 'xxx' }, { viewUid: 'yyy', filterByTk: '1', sourceId: '1' }]);
   });
 
+  test('should parse RunJS openView route state without losing route params', () => {
+    const token = encodeOpenViewRouteState('yyy', { mode: 'dialog', size: 'large' });
+    if (!token) {
+      throw new Error('Expected openView route state token.');
+    }
+    const result = parsePathnameToViewParams(`/admin/xxx/view/yyy/opts/${token}/filterbytk/1/sourceid/2`);
+
+    expect(result).toEqual([
+      { viewUid: 'xxx' },
+      {
+        viewUid: 'yyy',
+        openViewRouteState: { mode: 'dialog', size: 'large' },
+        filterByTk: '1',
+        sourceId: '2',
+      },
+    ]);
+  });
+
+  test('should ignore invalid RunJS openView opts and keep following params', () => {
+    const result = parsePathnameToViewParams('/admin/xxx/view/yyy/opts/AbCdEfGh/filterbytk/1');
+
+    expect(result).toEqual([{ viewUid: 'xxx' }, { viewUid: 'yyy', filterByTk: '1' }]);
+  });
+
+  test('should not parse bare RunJS openView route state token segments', () => {
+    const token = encodeOpenViewRouteState('yyy', { mode: 'dialog', size: 'large' });
+    if (!token) {
+      throw new Error('Expected openView route state token.');
+    }
+    const result = parsePathnameToViewParams(`/admin/xxx/view/yyy/${token}/filterbytk/1`);
+
+    expect(result[1]).toMatchObject({ viewUid: 'yyy' });
+    expect(result[1]?.openViewRouteState).toBeUndefined();
+  });
+
   test('should handle multiple views with different filterByTk and sourceId', () => {
     const result = parsePathnameToViewParams(
       '/admin/xxx/view/yyy/filterbytk/1/sourceid/1/view/zzz/filterbytk/2/sourceid/2',

package/src/utils/dataSourceDirty.ts

@@ -0,0 +1,126 @@
+/**
+ * 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 { FlowEngine } from '../flowEngine';
+import { DATA_SOURCE_DIRTY_EVENT } from '../views/viewEvents';
+
+type MarkDataSourceDirtyOptions = {
+  engine?: FlowEngine;
+  dataSourceKey?: unknown;
+  resourceName?: unknown;
+  includePreviousEngines?: boolean;
+};
+
+export function getHeaderValue(headers: unknown, name: string): unknown {
+  if (!headers || typeof headers !== 'object') {
+    return undefined;
+  }
+
+  const maybeHeaders = headers as { get?: (key: string) => unknown };
+  if (typeof maybeHeaders.get === 'function') {
+    const value = maybeHeaders.get(name);
+    if (value != null && value !== '') {
+      return value;
+    }
+  }
+
+  const lowerName = name.toLowerCase();
+  for (const [key, value] of Object.entries(headers as Record<string, unknown>)) {
+    if (key.toLowerCase() === lowerName) {
+      return value;
+    }
+  }
+
+  return undefined;
+}
+
+export function getDataSourceKeyFromHeaders(headers: unknown): string {
+  const value = getHeaderValue(headers, 'x-data-source');
+  if (Array.isArray(value)) {
+    return String(value[0] || 'main');
+  }
+  return value == null || value === '' ? 'main' : String(value);
+}
+
+export function getAffectedResourceNames(resourceName: unknown): string[] {
+  const name = String(resourceName || '').trim();
+  if (!name) {
+    return [];
+  }
+
+  const names = new Set<string>([name]);
+  if (name.includes('.')) {
+    names.add(name.split('.')[0]);
+  }
+  return Array.from(names);
+}
+
+function getDirtyTargetEngines(engine: FlowEngine, includePreviousEngines?: boolean): FlowEngine[] {
+  if (!includePreviousEngines) {
+    return [engine];
+  }
+
+  const engines: FlowEngine[] = [];
+  const seen = new Set<FlowEngine>();
+  let current: FlowEngine | undefined = engine;
+  let guard = 0;
+
+  while (current && guard++ < 50) {
+    if (!seen.has(current)) {
+      engines.push(current);
+      seen.add(current);
+    }
+    current = current.previousEngine;
+  }
+
+  return engines;
+}
+
+export function markDataSourceDirty(options: MarkDataSourceDirtyOptions): string[] {
+  const { engine, resourceName, includePreviousEngines } = options;
+  if (!engine?.markDataSourceDirty) {
+    return [];
+  }
+
+  const resourceNames = getAffectedResourceNames(resourceName);
+  if (!resourceNames.length) {
+    return [];
+  }
+
+  const dataSourceKey = String(options.dataSourceKey || 'main');
+  const targetEngines = getDirtyTargetEngines(engine, includePreviousEngines);
+  const beforeVersions = new Map<FlowEngine, Map<string, number>>();
+
+  for (const targetEngine of targetEngines) {
+    const versions = new Map<string, number>();
+    beforeVersions.set(targetEngine, versions);
+    for (const name of resourceNames) {
+      versions.set(name, targetEngine.getDataSourceDirtyVersion?.(dataSourceKey, name) || 0);
+    }
+  }
+
+  for (const targetEngine of targetEngines) {
+    const versions = beforeVersions.get(targetEngine);
+    for (const name of resourceNames) {
+      const before = versions?.get(name) || 0;
+      const current = targetEngine.getDataSourceDirtyVersion?.(dataSourceKey, name) || 0;
+      if (current !== before) {
+        continue;
+      }
+      targetEngine.markDataSourceDirty(dataSourceKey, name);
+    }
+  }
+
+  engine.emitter?.emit?.(DATA_SOURCE_DIRTY_EVENT, {
+    dataSourceKey,
+    resourceNames,
+  });
+
+  return resourceNames;
+}