@nocobase/client-v2 2.1.0-alpha.4 → 2.1.0-alpha.45

package/src/data-source/__tests__/ExtendCollectionsProvider.test.tsx

@@ -0,0 +1,264 @@
+/**
+ * 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 { CollectionOptions } from '@nocobase/flow-engine';
+import { FlowEngineProvider } from '@nocobase/flow-engine';
+import { act, render } from '@testing-library/react';
+import React, { useState } from 'react';
+import { describe, expect, it } from 'vitest';
+import { createMockClient } from '../../MockApplication';
+import { ExtendCollectionsProvider } from '../ExtendCollectionsProvider';
+
+// `MockApplication` isn't exported as a named type, so infer from the factory.
+type AppInstance = ReturnType<typeof createMockClient>;
+
+function makeApp(): AppInstance {
+  const app = createMockClient();
+  // The mock client wires a lazy `appInfo` getter to `GET app:getInfo`; any
+  // proxy iteration of the FlowEngineContext can trip it. Pre-stub so a 404
+  // doesn't surface as an unhandled axios rejection during the test run.
+  app.apiMock.onGet('app:getInfo').reply(200, { data: { version: 'test' } });
+  return app;
+}
+
+const LOCKED: CollectionOptions = {
+  name: 'lockedUsers',
+  fields: [{ name: 'id', type: 'integer', interface: 'integer' }],
+};
+
+const USERS: CollectionOptions = {
+  name: 'users',
+  fields: [{ name: 'username', type: 'string', interface: 'input' }],
+};
+
+const POSTS: CollectionOptions = {
+  name: 'posts',
+  fields: [{ name: 'title', type: 'string', interface: 'input' }],
+};
+
+function mountWith(app: AppInstance, node: React.ReactNode) {
+  return render(<FlowEngineProvider engine={app.flowEngine}>{node}</FlowEngineProvider>);
+}
+
+function getMain(app: AppInstance) {
+  return app.dataSourceManager.getDataSource('main');
+}
+
+describe('ExtendCollectionsProvider', () => {
+  // The defining contract: a page-inner that reads `getCollection(name)` in its
+  // own render body (the LockedUsersPage pattern at LockedUsersPage.tsx:156-157)
+  // must see the registered collection on its FIRST render, with no extra tick.
+  it('lets children read the registered collection during their first render', () => {
+    const app = makeApp();
+    let firstRenderResult: { name?: string } | undefined;
+
+    const Child: React.FC = () => {
+      // Read synchronously during render — this is the contract that forces
+      // the provider to register collections in render-phase rather than in
+      // an effect.
+      const found = getMain(app)?.getCollection?.(LOCKED.name);
+      firstRenderResult = found ? { name: found.name } : undefined;
+      return <div>child</div>;
+    };
+
+    mountWith(
+      app,
+      <ExtendCollectionsProvider collections={[LOCKED]}>
+        <Child />
+      </ExtendCollectionsProvider>,
+    );
+
+    expect(firstRenderResult).toEqual({ name: LOCKED.name });
+  });
+
+  it('removes only the collections it added when unmounted', () => {
+    const app = makeApp();
+    // Pre-existing collection in the data source — provider must not touch it.
+    getMain(app).addCollection(USERS);
+
+    const { unmount } = mountWith(
+      app,
+      <ExtendCollectionsProvider collections={[LOCKED]}>
+        <span>inside</span>
+      </ExtendCollectionsProvider>,
+    );
+
+    expect(getMain(app).getCollection(LOCKED.name)?.name).toBe(LOCKED.name);
+    expect(getMain(app).getCollection(USERS.name)?.name).toBe(USERS.name);
+
+    unmount();
+
+    expect(getMain(app).getCollection(LOCKED.name)).toBeUndefined();
+    // The provider didn't add USERS, so it must leave it alone.
+    expect(getMain(app).getCollection(USERS.name)?.name).toBe(USERS.name);
+  });
+
+  // Direct regression for the lazy-ref idempotency: even when the provider
+  // re-renders many times (which is what StrictMode dev's double-render and
+  // any caller-driven re-render look like to the provider), it must not
+  // re-register the same collection or accumulate duplicate ownership.
+  it('only calls addCollection once across many re-renders of the same mount', () => {
+    const app = makeApp();
+    let addCount = 0;
+    const origAdd = getMain(app).addCollection.bind(getMain(app));
+    getMain(app).addCollection = (c: CollectionOptions) => {
+      addCount += 1;
+      origAdd(c);
+    };
+
+    const Host: React.FC = () => {
+      const [, setTick] = useState(0);
+      // Force a render burst on mount — covers StrictMode dev's second render
+      // and any other parent-driven re-renders. The lazy-ref guard in the
+      // provider must hold across all of them.
+      React.useEffect(() => {
+        setTick((n) => n + 1);
+        setTick((n) => n + 1);
+      }, []);
+      return (
+        <ExtendCollectionsProvider collections={[LOCKED]}>
+          <span>inside</span>
+        </ExtendCollectionsProvider>
+      );
+    };
+
+    const { unmount } = mountWith(app, <Host />);
+
+    expect(addCount).toBe(1);
+    expect(getMain(app).getCollection(LOCKED.name)?.name).toBe(LOCKED.name);
+
+    unmount();
+    expect(getMain(app).getCollection(LOCKED.name)).toBeUndefined();
+  });
+
+  // Default semantics: "static-at-mount". Caller's prop changes are ignored.
+  describe('with syncOnChange={false} (default)', () => {
+    it('ignores a `collections` prop reference change after mount', () => {
+      const app = makeApp();
+
+      const Host: React.FC = () => {
+        const [list, setList] = useState<CollectionOptions[]>([LOCKED]);
+        return (
+          <>
+            <button type="button" onClick={() => setList([LOCKED, POSTS])}>
+              add posts
+            </button>
+            <ExtendCollectionsProvider collections={list}>
+              <span>inside</span>
+            </ExtendCollectionsProvider>
+          </>
+        );
+      };
+
+      const { getByText } = mountWith(app, <Host />);
+      expect(getMain(app).getCollection(LOCKED.name)?.name).toBe(LOCKED.name);
+      expect(getMain(app).getCollection(POSTS.name)).toBeUndefined();
+
+      act(() => {
+        getByText('add posts').click();
+      });
+
+      // POSTS must NOT have been registered — syncOnChange is off.
+      expect(getMain(app).getCollection(POSTS.name)).toBeUndefined();
+      expect(getMain(app).getCollection(LOCKED.name)?.name).toBe(LOCKED.name);
+    });
+  });
+
+  describe('with syncOnChange={true}', () => {
+    it('adds collections newly added to the prop and removes ones dropped from it', () => {
+      const app = makeApp();
+
+      const Host: React.FC = () => {
+        const [list, setList] = useState<CollectionOptions[]>([LOCKED, POSTS]);
+        return (
+          <>
+            <button type="button" onClick={() => setList([POSTS, USERS])}>
+              swap
+            </button>
+            <ExtendCollectionsProvider collections={list} syncOnChange>
+              <span>inside</span>
+            </ExtendCollectionsProvider>
+          </>
+        );
+      };
+
+      const { getByText } = mountWith(app, <Host />);
+      expect(getMain(app).getCollection(LOCKED.name)?.name).toBe(LOCKED.name);
+      expect(getMain(app).getCollection(POSTS.name)?.name).toBe(POSTS.name);
+      expect(getMain(app).getCollection(USERS.name)).toBeUndefined();
+
+      act(() => {
+        getByText('swap').click();
+      });
+
+      // LOCKED was dropped from the prop → removed.
+      expect(getMain(app).getCollection(LOCKED.name)).toBeUndefined();
+      // POSTS was in both lists → kept.
+      expect(getMain(app).getCollection(POSTS.name)?.name).toBe(POSTS.name);
+      // USERS is new → added.
+      expect(getMain(app).getCollection(USERS.name)?.name).toBe(USERS.name);
+    });
+
+    it('still leaves pre-existing collections it never owned alone after diff', () => {
+      const app = makeApp();
+      // Pre-existing in the data source before the provider mounts.
+      getMain(app).addCollection(USERS);
+
+      const Host: React.FC = () => {
+        const [list, setList] = useState<CollectionOptions[]>([LOCKED, USERS]);
+        return (
+          <>
+            <button type="button" onClick={() => setList([LOCKED])}>
+              drop users
+            </button>
+            <ExtendCollectionsProvider collections={list} syncOnChange>
+              <span>inside</span>
+            </ExtendCollectionsProvider>
+          </>
+        );
+      };
+
+      const { getByText } = mountWith(app, <Host />);
+      // USERS was already there, so the provider never owned it.
+      expect(getMain(app).getCollection(USERS.name)?.name).toBe(USERS.name);
+
+      act(() => {
+        getByText('drop users').click();
+      });
+
+      // The prop dropped USERS, but the provider doesn't own it — must not
+      // accidentally remove it.
+      expect(getMain(app).getCollection(USERS.name)?.name).toBe(USERS.name);
+      expect(getMain(app).getCollection(LOCKED.name)?.name).toBe(LOCKED.name);
+    });
+  });
+
+  // Mid-session reload: the data source manager wipes everything and reloads
+  // from the server; client-only entries this provider registered would be
+  // gone. The `dataSource:loaded` event handler re-adds owned entries.
+  it('re-registers owned collections after a dataSource:loaded event', () => {
+    const app = makeApp();
+
+    mountWith(
+      app,
+      <ExtendCollectionsProvider collections={[LOCKED]}>
+        <span>inside</span>
+      </ExtendCollectionsProvider>,
+    );
+    expect(getMain(app).getCollection(LOCKED.name)?.name).toBe(LOCKED.name);
+
+    // Simulate the data source manager wiping then re-broadcasting the event.
+    act(() => {
+      getMain(app).removeCollection(LOCKED.name);
+      app.eventBus.dispatchEvent(new CustomEvent('dataSource:loaded', { detail: { dataSourceKey: 'main' } }));
+    });
+
+    expect(getMain(app).getCollection(LOCKED.name)?.name).toBe(LOCKED.name);
+  });
+});

package/src/data-source/index.ts

@@ -0,0 +1,10 @@
+/**
+ * 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.
+ */
+
+export * from './ExtendCollectionsProvider';

package/src/flow/FlowModelRepository.ts

@@ -0,0 +1,222 @@
+/**
+ * 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 { FlowModel, IFlowModelRepository } from '@nocobase/flow-engine';
+import type { BaseApplication } from '../BaseApplication';
+import _ from 'lodash';
+
+export class MockFlowModelRepository implements IFlowModelRepository<FlowModel> {
+  constructor(protected prefix = '') {}
+  get models() {
+    const models = new Map();
+    for (let i = 0; i < localStorage.length; i++) {
+      const key = localStorage.key(i);
+      if (key && key.startsWith(`${this.prefix}flow-model:`)) {
+        const data = localStorage.getItem(key);
+        if (data) {
+          const model = JSON.parse(data);
+          models.set(model.uid, model);
+        }
+      }
+    }
+    return models;
+  }
+
+  async findOne(query) {
+    const { uid, parentId } = query;
+    if (uid) {
+      return this.load(uid);
+    } else if (parentId) {
+      return this.loadByParentId(parentId);
+    }
+    return null;
+  }
+
+  async loadByParentId(parentId: string) {
+    for (const model of this.models.values()) {
+      if (model.parentId == parentId) {
+        console.log('Loading model by parentId:', parentId, model);
+        return this.load(model.uid);
+      }
+    }
+    return null;
+  }
+
+  // 从本地存储加载模型数据
+  async load(uid: string) {
+    const data = localStorage.getItem(`${this.prefix}flow-model:${uid}`);
+    if (!data) {
+      console.warn(`Model with uid ${uid} not found in localStorage.`);
+      return null;
+    }
+    const json = JSON.parse(data);
+    for (const model of [...this.models.values()]) {
+      if (model.parentId === uid) {
+        json.subModels = json.subModels || {};
+        if (model.subType === 'array') {
+          json.subModels[model.subKey] = json.subModels[model.subKey] || [];
+          const subModel = await this.load(model.uid);
+          json.subModels[model.subKey].push(subModel);
+        } else if (model.subType === 'object') {
+          const subModel = await this.load(model.uid);
+          if (subModel) {
+            json.subModels[model.subKey] = subModel;
+          }
+        }
+      }
+    }
+    console.log('Loading model:', uid, JSON.stringify(json, null, 2));
+    return json;
+  }
+
+  // 将模型数据保存到本地存储
+  async save(model: FlowModel) {
+    const data = model.serialize();
+    const currentData = _.omit(data, ['subModels', 'flowEngine']);
+    localStorage.setItem(`${this.prefix}flow-model:${model.uid}`, JSON.stringify(currentData));
+    console.log('Saving model:', model.uid, currentData);
+    for (const subModelKey of Object.keys(model.subModels || {})) {
+      const subModelValue = model.subModels[subModelKey];
+      if (!subModelValue) continue;
+      if (Array.isArray(subModelValue)) {
+        for (const subModel of subModelValue) {
+          await this.save(subModel);
+        }
+      } else if (subModelValue instanceof FlowModel) {
+        await this.save(subModelValue);
+      }
+    }
+    return data;
+  }
+
+  // 从本地存储中删除模型数据
+  async destroy(uid: string) {
+    localStorage.removeItem(`${this.prefix}flow-model:${uid}`);
+    return true;
+  }
+
+  async clear() {
+    for (const key of Object.keys(localStorage)) {
+      if (key.startsWith(`${this.prefix}flow-model:`)) {
+        localStorage.removeItem(key);
+      }
+    }
+    return true;
+  }
+
+  async move(sourceId: string, targetId: string, position: 'before' | 'after' = 'after') {
+    // TODO
+  }
+
+  async duplicate(uid: string) {
+    const source = await this.load(uid);
+    if (!source) return null;
+
+    const genUid = () => `dup_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 8)}`;
+
+    const cloneTree = (node: any, newParentUid?: string): any => {
+      const { subModels, flowEngine, ...rest } = node || {};
+      const cloned: any = { ...rest };
+      cloned.uid = genUid();
+      if (newParentUid) cloned.parentId = newParentUid;
+
+      if (subModels && typeof subModels === 'object') {
+        cloned.subModels = {} as Record<string, any>;
+        for (const key of Object.keys(subModels)) {
+          const value = (subModels as any)[key];
+          if (Array.isArray(value)) {
+            cloned.subModels[key] = value.map((child) => cloneTree(child, cloned.uid));
+          } else if (value && typeof value === 'object') {
+            cloned.subModels[key] = cloneTree(value, cloned.uid);
+          }
+        }
+      }
+      return cloned;
+    };
+
+    // 返回深拷贝的模型树（不直接写入本地存储）
+    return cloneTree(source);
+  }
+}
+
+export class FlowModelRepository implements IFlowModelRepository<FlowModel> {
+  constructor(private app: BaseApplication) {}
+
+  private inFlightFindOne = new Map<string, Promise<any>>();
+
+  private buildFindOneKey(query: any) {
+    const uid = query?.uid ?? '';
+    const parentId = query?.parentId ?? '';
+    const subKey = query?.subKey ?? '';
+    return `uid:${uid}|parentId:${parentId}|subKey:${subKey}`;
+  }
+
+  async findOne(query) {
+    const key = this.buildFindOneKey(query);
+    const existing = this.inFlightFindOne.get(key);
+    if (existing) {
+      const data = await existing;
+      return data ? _.cloneDeep(data) : data;
+    }
+
+    const promise = this.app.apiClient
+      .request({
+        url: 'flowModels:findOne',
+        params: _.pick(query, ['uid', 'parentId', 'subKey']),
+      })
+      .then((response) => response.data?.data)
+      .finally(() => {
+        this.inFlightFindOne.delete(key);
+      });
+
+    this.inFlightFindOne.set(key, promise);
+    const data = await promise;
+    return data ? _.cloneDeep(data) : data;
+  }
+
+  async save(model: FlowModel, options?: { onlyStepParams?: boolean }) {
+    const data = model.serialize();
+    if (options?.onlyStepParams) {
+      delete data.subModels;
+    }
+    const response = await this.app.apiClient.request({
+      method: 'POST',
+      url: 'flowModels:save',
+      data,
+    });
+    return response.data?.data;
+  }
+
+  async destroy(uid: string) {
+    await this.app.apiClient.request({
+      method: 'POST',
+      url: 'flowModels:destroy',
+      params: { filterByTk: uid },
+    });
+    return true;
+  }
+
+  async move(sourceId: string, targetId: string, position: 'before' | 'after' = 'after') {
+    const response = await this.app.apiClient.request({
+      method: 'POST',
+      url: 'flowModels:move',
+      params: { sourceId, targetId, position },
+    });
+    return response.data?.data;
+  }
+
+  async duplicate(uid: string) {
+    const response = await this.app.apiClient.request({
+      method: 'POST',
+      url: 'flowModels:duplicate',
+      params: { uid },
+    });
+    return response.data?.data;
+  }
+}

package/src/flow/FlowPage.tsx

@@ -0,0 +1,146 @@
+/**
+ * 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 {
+  FlowModelRenderer,
+  isInheritedFrom,
+  useFlowEngine,
+  useFlowModelById,
+  useFlowViewContext,
+} from '@nocobase/flow-engine';
+import type { FlowModel, FlowModelRendererProps, ModelConstructor } from '@nocobase/flow-engine';
+import { useRequest } from 'ahooks';
+import React from 'react';
+import FlowRoute from './components/FlowRoute';
+import { SkeletonFallback } from './components/SkeletonFallback';
+import { ChildPageModel } from './models';
+
+const defaultPageFlowSettings: FlowModelRendererProps['showFlowSettings'] = {
+  showBackground: false,
+  showBorder: false,
+};
+
+function InternalFlowPage({
+  uid,
+  showFlowSettings,
+  ...props
+}: { uid: string; showFlowSettings?: FlowModelRendererProps['showFlowSettings'] } & Record<string, unknown>) {
+  const model = useFlowModelById(uid);
+  const resolvedShowFlowSettings = showFlowSettings ?? model?.props?.showFlowSettings ?? defaultPageFlowSettings;
+
+  return (
+    <FlowModelRenderer
+      model={model}
+      fallback={
+        <SkeletonFallback
+          style={{ margin: model?.context.isMobileLayout ? 8 : model?.context.themeToken.marginBlock }}
+        />
+      }
+      hideRemoveInSettings
+      showFlowSettings={resolvedShowFlowSettings}
+      {...props}
+    />
+  );
+}
+
+type FlowPageProps = {
+  pageModelClass?: string;
+  parentId?: string;
+  onModelLoaded?: (uid: string, model: FlowModel) => void;
+  defaultTabTitle?: string;
+  showFlowSettings?: FlowModelRendererProps['showFlowSettings'];
+};
+
+export const FlowPage = React.memo((props: FlowPageProps & Record<string, unknown>) => {
+  const { pageModelClass = 'ChildPageModel', parentId, onModelLoaded, defaultTabTitle, ...rest } = props;
+  const flowEngine = useFlowEngine();
+  const ctx = useFlowViewContext();
+  const { loading, data, error } = useRequest(
+    async () => {
+      const ModelClass = await flowEngine.getModelClassAsync(pageModelClass);
+      if (!ModelClass) {
+        throw new Error(`[NocoBase] Page model class '${pageModelClass}' is not registered.`);
+      }
+      const shouldInjectDefaultChildTab =
+        ModelClass === ChildPageModel || isInheritedFrom(ModelClass as ModelConstructor, ChildPageModel);
+      const options = {
+        async: true,
+        parentId,
+        subKey: 'page',
+        subType: 'object',
+        use: pageModelClass,
+      };
+      if (shouldInjectDefaultChildTab) {
+        const tabTitle = defaultTabTitle || flowEngine.translate?.('Details');
+        options['subModels'] = {
+          tabs: [
+            {
+              use: 'ChildPageTabModel',
+              stepParams: {
+                pageTabSettings: {
+                  tab: {
+                    title: tabTitle,
+                  },
+                },
+              },
+            },
+          ],
+        };
+        // 弹窗或者子页面中，默认显示 tab
+        options['stepParams'] = {
+          pageSettings: {
+            general: {
+              displayTitle: false,
+              enableTabs: true,
+            },
+          },
+        };
+      }
+      const data = await flowEngine.loadOrCreateModel(options, { skipSave: !flowEngine.context.flowSettingsEnabled });
+      if (data?.uid && onModelLoaded) {
+        data.context.addDelegate(ctx);
+        data.removeParentDelegate();
+        onModelLoaded(data.uid, data);
+      }
+      return data;
+    },
+    {
+      refreshDeps: [parentId, pageModelClass, defaultTabTitle],
+    },
+  );
+  if (error) {
+    throw error;
+  }
+  if (loading || !data?.uid) {
+    return <SkeletonFallback style={{ margin: ctx?.isMobileLayout ? 8 : ctx?.themeToken.marginBlock }} />;
+  }
+  return <InternalFlowPage uid={data.uid} {...rest} />;
+});
+
+FlowPage.displayName = 'FlowPage';
+
+export const RemoteFlowModelRenderer = (props) => {
+  const { uid, parentId, subKey, ...rest } = props;
+  const flowEngine = useFlowEngine();
+  const { loading, data } = useRequest(
+    async () => {
+      const data = await flowEngine.loadModel({ uid, parentId, subKey });
+      return data;
+    },
+    {
+      refreshDeps: [uid, parentId, subKey],
+    },
+  );
+  if (loading || !data?.uid) {
+    return <SkeletonFallback style={{ margin: 16 }} />;
+  }
+  return <InternalFlowPage uid={data.uid} {...rest} />;
+};
+
+export { FlowRoute };

package/src/flow/__tests__/FlowModelRepository.test.ts

@@ -0,0 +1,61 @@
+/**
+ * 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 { describe, it, expect, vi } from 'vitest';
+import { FlowModelRepository } from '../FlowModelRepository';
+
+describe('FlowModelRepository', () => {
+  it('dedupes concurrent findOne requests with same key', async () => {
+    const request = vi.fn(async () => {
+      await new Promise((resolve) => setTimeout(resolve, 10));
+      return {
+        data: {
+          data: {
+            uid: 'u1',
+            stepParams: { a: 1, nested: { b: 2 } },
+            subModels: { grid: { uid: 'g1', stepParams: { c: 3 } } },
+          },
+        },
+      };
+    });
+
+    const repo = new FlowModelRepository({ apiClient: { request } } as any);
+    const [a, b] = await Promise.all([repo.findOne({ uid: 'u1' }), repo.findOne({ uid: 'u1', foo: 'bar' })]);
+
+    expect(request).toHaveBeenCalledTimes(1);
+    expect(a).toEqual(b);
+    expect(a).not.toBe(b);
+    expect(a.stepParams).not.toBe(b.stepParams);
+    expect(a.stepParams.nested).not.toBe(b.stepParams.nested);
+  });
+
+  it('does not cache after the in-flight promise resolves', async () => {
+    const request = vi.fn(async () => ({ data: { data: { uid: 'u1', stepParams: { a: 1 } } } }));
+    const repo = new FlowModelRepository({ apiClient: { request } } as any);
+
+    await repo.findOne({ uid: 'u1' });
+    await repo.findOne({ uid: 'u1' });
+
+    expect(request).toHaveBeenCalledTimes(2);
+  });
+
+  it('clears in-flight entry when request rejects', async () => {
+    const request = vi
+      .fn()
+      .mockRejectedValueOnce(new Error('boom'))
+      .mockResolvedValueOnce({ data: { data: { uid: 'u1' } } });
+
+    const repo = new FlowModelRepository({ apiClient: { request } } as any);
+
+    await expect(repo.findOne({ uid: 'u1' })).rejects.toThrow('boom');
+    await expect(repo.findOne({ uid: 'u1' })).resolves.toEqual({ uid: 'u1' });
+
+    expect(request).toHaveBeenCalledTimes(2);
+  });
+});