@nocobase/client-v2 2.1.0-alpha.30 → 2.1.0-alpha.32

package/src/flow/admin-shell/__tests__/AdminLayoutRouteCoordinator.test.ts

@@ -0,0 +1,117 @@
+/**
+ * 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 { FlowEngine } from '@nocobase/flow-engine';
+import { describe, expect, it, vi, beforeEach } from 'vitest';
+import { getViewDiffAndUpdateHidden } from '../../getViewDiffAndUpdateHidden';
+import { getOpenViewStepParams } from '../../flows/openViewFlow';
+import { resolveViewParamsToViewList } from '../../resolveViewParamsToViewList';
+import { AdminLayoutRouteCoordinator } from '../AdminLayoutRouteCoordinator';
+import { RouteModel } from '../../models/base/RouteModel';
+
+vi.mock('../../resolveViewParamsToViewList', () => ({
+  resolveViewParamsToViewList: vi.fn(),
+  updateViewListHidden: vi.fn(),
+}));
+
+vi.mock('../../getViewDiffAndUpdateHidden', () => ({
+  getViewDiffAndUpdateHidden: vi.fn(),
+  getKey: vi.fn((viewItem) => viewItem.params.viewUid),
+}));
+
+vi.mock('../../flows/openViewFlow', async (importOriginal) => {
+  const actual = await importOriginal();
+  return {
+    ...(actual as any),
+    getOpenViewStepParams: vi.fn(),
+  };
+});
+
+const mockResolveViewParamsToViewList = vi.mocked(resolveViewParamsToViewList);
+const mockGetViewDiffAndUpdateHidden = vi.mocked(getViewDiffAndUpdateHidden);
+const mockGetOpenViewStepParams = vi.mocked(getOpenViewStepParams);
+
+function setupRouteReplay(viewParams: Record<string, any>) {
+  const engine = new FlowEngine();
+  engine.registerModels({ RouteModel });
+  engine.context.defineProperty('route', {
+    value: {
+      params: { name: 'test-route' },
+      pathname: '/admin/popup/filterbytk/member',
+    },
+  });
+  engine.context.defineProperty('routeRepository', {
+    value: {
+      getRouteBySchemaUid: vi.fn(() => ({})),
+    },
+  });
+
+  const dispatchEvent = vi.fn(() => Promise.resolve());
+  const viewItem = {
+    params: {
+      viewUid: 'popup',
+      filterByTk: 'member',
+      ...viewParams,
+    },
+    modelUid: 'popup',
+    model: { uid: 'popup', dispatchEvent } as any,
+    hidden: { value: false },
+    index: 0,
+  };
+
+  mockResolveViewParamsToViewList.mockReturnValue([viewItem]);
+  mockGetViewDiffAndUpdateHidden.mockReturnValue({
+    viewsToClose: [],
+    viewsToOpen: [viewItem],
+  });
+  mockGetOpenViewStepParams.mockReturnValue({
+    collectionName: 'roles',
+    associationName: 'users.roles',
+    dataSourceKey: 'main',
+  } as any);
+
+  const coordinator = new AdminLayoutRouteCoordinator(engine);
+  coordinator.registerPage('test-route', {
+    active: true,
+    layoutContentElement: document.createElement('div'),
+  });
+
+  return { dispatchEvent };
+}
+
+describe('AdminLayoutRouteCoordinator', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it('drops configured associationName during route replay when sourceId is absent', () => {
+    const { dispatchEvent } = setupRouteReplay({});
+
+    expect(dispatchEvent.mock.calls[0][1]).toMatchObject({
+      collectionName: 'roles',
+      associationName: null,
+      dataSourceKey: 'main',
+      filterByTk: 'member',
+      triggerByRouter: true,
+    });
+  });
+
+  it('keeps configured associationName during route replay when sourceId is present', () => {
+    const { dispatchEvent } = setupRouteReplay({ sourceId: '1' });
+
+    expect(dispatchEvent.mock.calls[0][1]).toMatchObject({
+      collectionName: 'roles',
+      associationName: 'users.roles',
+      dataSourceKey: 'main',
+      filterByTk: 'member',
+      sourceId: '1',
+      triggerByRouter: true,
+    });
+  });
+});

package/src/flow/components/FieldAssignValueInput.tsx

@@ -485,6 +485,7 @@ type AssignValueFieldSource = {
 const ASSIGN_VALUE_IGNORED_PROP_KEYS = new Set([
   'value',
   'defaultValue',
+  'hidden',
   'onChange',
   'onClick',
   'open',

package/src/flow/components/filter/LinkageFilterItem.tsx

@@ -8,7 +8,7 @@
  */
 
 import React, { useCallback, useEffect, useMemo, useRef, useState } from 'react';
-import { lazy } from '../../../flow-compat';
+import { getFlowFieldInterfaceOptions, lazy } from '../../../flow-compat';
 import { Input, InputNumber, Select, Space, Switch } from 'antd';
 import merge from 'lodash/merge';
 import uniqBy from 'lodash/uniqBy';
@@ -227,11 +227,12 @@ export const LinkageFilterItem: React.FC<LinkageFilterItemProps> = observer((pro
 
   const operatorMetadataList: OperatorMeta[] = useMemo(() => {
     if (leftFieldMeta) {
-      const dataSourceManager = model.context.app.dataSourceManager;
       const fieldInterface = leftFieldMeta.interface
-        ? (dataSourceManager.collectionFieldInterfaceManager.getFieldInterface(
+        ? (getFlowFieldInterfaceOptions(
             leftFieldMeta.interface,
-          ) as FieldInterfaceDef)
+            model.context.dataSourceManager,
+            model.context.app?.dataSourceManager,
+          ) as FieldInterfaceDef | undefined)
         : undefined;
       const schemaOperators = (leftFieldMeta as any)?.uiSchema?.['x-filter-operators'] as
         | Array<OperatorMeta & { visible?: (meta: MetaTreeNode) => boolean }>
@@ -392,7 +393,7 @@ export const LinkageFilterItem: React.FC<LinkageFilterItemProps> = observer((pro
     const base = Array.isArray(tree) ? tree : [];
     const merged = mergeExtraMetaTreeWithBase(base, extraMetaTree);
     const getFieldInterface = (name: string) =>
-      model.context.app?.dataSourceManager?.collectionFieldInterfaceManager?.getFieldInterface?.(name) as
+      getFlowFieldInterfaceOptions(name, model.context.dataSourceManager, model.context.app?.dataSourceManager) as
         | FieldInterfaceDef
         | undefined;
     return await enhanceMetaTreeWithFilterableChildren(merged, getFieldInterface);

package/src/flow/components/filter/VariableFilterItem.tsx

@@ -9,7 +9,7 @@
 
 import React, { useState, useMemo, useCallback, useEffect } from 'react';
 import { Cascader, Checkbox, Input, InputNumber, Radio, Select, Space, Switch } from 'antd';
-import { lazy } from '../../../flow-compat';
+import { getFlowFieldInterfaceOptions, lazy } from '../../../flow-compat';
 import merge from 'lodash/merge';
 import type { ISchema } from '@formily/json-schema';
 import {
@@ -286,18 +286,24 @@ export const VariableFilterItem: React.FC<VariableFilterItemProps> = observer(
         children?: Array<{ name: string; title?: string; schema?: ISchema; operators?: OperatorMeta[] }>;
       };
     };
+    const getFieldInterface = useCallback(
+      (interfaceName: string | undefined) =>
+        getFlowFieldInterfaceOptions(
+          interfaceName,
+          model.context.dataSourceManager,
+          model.context.app?.dataSourceManager,
+        ) as FieldInterfaceDef | undefined,
+      [model],
+    );
 
     // 基于字段接口的动态操作符元数据（优先使用子菜单 schema 中自定义的 operators，其次再用接口默认 operators）
     const operatorMetaList: OperatorMeta[] = useMemo(() => {
       if (!leftMeta) return [];
-      const dm = model.context.app?.dataSourceManager;
-      const fi = leftMeta.interface
-        ? (dm?.collectionFieldInterfaceManager?.getFieldInterface(leftMeta.interface) as FieldInterfaceDef | undefined)
-        : undefined;
+      const fi = leftMeta.interface ? getFieldInterface(leftMeta.interface) : undefined;
       const schemaOps: OperatorMeta[] | undefined = (leftMeta as any)?.uiSchema?.['x-filter-operators'];
       const baseOps = (Array.isArray(schemaOps) && schemaOps.length ? schemaOps : fi?.filterable?.operators) || [];
       return baseOps.filter((op) => !op.visible || op.visible(leftMeta));
-    }, [leftMeta, model]);
+    }, [getFieldInterface, leftMeta]);
 
     useEffect(() => {
       if (!operatorMetaList.length) return;
@@ -578,16 +584,11 @@ export const VariableFilterItem: React.FC<VariableFilterItemProps> = observer(
     const enhancedMetaTree = useMemo(() => {
       type MetaTreeProvider = () => MetaTreeNode[] | Promise<MetaTreeNode[]>;
       return async () => {
-        const dm = model.context.app?.dataSourceManager;
-        const fiMgr = dm?.collectionFieldInterfaceManager;
-
         // 优先复用已注入 meta；否则在本组件范围内临时构建
         const nodes: MetaTreeNode[] = await buildCollectionLeftMetaTreeLocal(model.context);
 
         const enhanceNode = async (node: MetaTreeNode): Promise<MetaTreeNode> => {
-          const fi = node.interface
-            ? (fiMgr?.getFieldInterface(node.interface) as FieldInterfaceDef | undefined)
-            : undefined;
+          const fi = node.interface ? getFieldInterface(node.interface) : undefined;
           const extraChildren: MetaTreeNode[] = [];
           const filterable = fi?.filterable;
           const childrenDefs = filterable?.children as
@@ -634,7 +635,7 @@ export const VariableFilterItem: React.FC<VariableFilterItemProps> = observer(
         }
         return out;
       };
-    }, [model]);
+    }, [getFieldInterface, model]);
 
     return (
       <Space wrap style={{ width: '100%' }}>

package/src/flow/components/filter/__tests__/LinkageFilterItem.test.tsx

@@ -110,6 +110,39 @@ describe('LinkageFilterItem', () => {
     expect(screen.queryByText('[object Object]')).toBeNull();
   });
 
+  it('uses scoped context dataSourceManager when app dataSourceManager has no field interface manager', async () => {
+    const value = observable({ path: '', operator: '', value: '' }) as any;
+    const { model, app } = createModel();
+    const getRuntimeFieldInterface = vi.fn((name: string) => ({
+      name,
+      filterable: {
+        operators: [{ value: '$eq', label: 'Equals', selected: true }],
+      },
+    }));
+    model.context.dataSourceManager.setCollectionFieldInterfaceManager({
+      getFieldInterface: getRuntimeFieldInterface,
+    });
+    (app as any).dataSourceManager = {};
+
+    (globalThis as any).__TEST_PATH__ = 'assignee';
+    (globalThis as any).__TEST_META__ = {
+      interface: 'belongsTo',
+      uiSchema: { 'x-component': 'RecordPicker' },
+      paths: ['collection', 'assignee'],
+      name: 'assignee',
+      title: 'Assignee',
+      type: 'object',
+    };
+
+    render(<LinkageFilterItem value={value} model={model} />);
+    fireEvent.click(screen.getByTestId('variable-input'));
+
+    await waitFor(() => {
+      expect(value.operator).toBe('$eq');
+      expect(getRuntimeFieldInterface).toHaveBeenCalledWith('belongsTo');
+    });
+  });
+
   it('renders operator schema component for multi-keyword constants', async () => {
     const value = observable({ path: '', operator: '', value: 'foo\nbar' }) as any;
     const { model, app } = createModel();

package/src/flow/components/filter/__tests__/VariableFilterItem.test.tsx

@@ -121,6 +121,8 @@ describe('VariableFilterItem', () => {
     // Ensure document body for antd portals if needed
     document.body.innerHTML = '';
     delete (globalThis as any).__LAST_VARIABLE_INPUT_PROPS__;
+    delete (globalThis as any).__TEST_PATH__;
+    delete (globalThis as any).__TEST_META__;
   });
 
   it('returns undefined path for empty left value in converter', () => {
@@ -153,9 +155,53 @@ describe('VariableFilterItem', () => {
     expect(value.value).toBe('abc');
   });
 
+  it('uses scoped context dataSourceManager when app dataSourceManager has no field interface manager', async () => {
+    const value = observable({ path: '', operator: '', value: '' }) as any;
+    const model = CreateModel();
+    const getRuntimeFieldInterface = vi.fn((name: string) => ({
+      name,
+      filterable: {
+        operators: [{ value: '$eq', label: 'Equals' }],
+        children: [
+          {
+            name: 'runtimeChild',
+            title: 'Runtime child',
+            schema: { 'x-component': 'Input' },
+            operators: [{ value: '$includes', label: 'contains' }],
+          },
+        ],
+      },
+    }));
+
+    model.context.dataSourceManager.setCollectionFieldInterfaceManager({
+      getFieldInterface: getRuntimeFieldInterface,
+    });
+    (model.context.app as any).dataSourceManager = {};
+    (globalThis as any).__TEST_PATH__ = 'assignee';
+    (globalThis as any).__TEST_META__ = {
+      interface: 'belongsTo',
+      uiSchema: { 'x-component': 'RecordPicker' },
+      paths: ['collection', 'assignee'],
+      name: 'assignee',
+      title: 'Assignee',
+      type: 'object',
+    };
+
+    render(<VariableFilterItem value={value} model={model} rightAsVariable={false} />);
+    const leftVariableInputProps = (globalThis as any).__LAST_VARIABLE_INPUT_PROPS__;
+    const metaTree = await leftVariableInputProps.metaTree();
+    const nameNode = metaTree.find((node: any) => node.name === 'name');
+    expect(nameNode?.children?.some((child: any) => child.name === 'runtimeChild')).toBe(true);
+
+    fireEvent.click(screen.getByTestId('variable-input'));
+
+    await waitFor(() => {
+      expect(value.operator).toBe('$eq');
+      expect(getRuntimeFieldInterface).toHaveBeenCalledWith('belongsTo');
+    });
+  });
+
   it('keeps numeric string when x-component uses InputNumber with stringMode', async () => {
-    const prevMeta = (globalThis as any).__TEST_META__;
-    const prevPath = (globalThis as any).__TEST_PATH__;
     (globalThis as any).__TEST_PATH__ = 'price';
     (globalThis as any).__TEST_META__ = {
       interface: 'input',
@@ -177,9 +223,6 @@ describe('VariableFilterItem', () => {
       expect(input.value).toBe('123.45');
       expect(value.value).toBe('123.45');
     });
-
-    (globalThis as any).__TEST_META__ = prevMeta;
-    (globalThis as any).__TEST_PATH__ = prevPath;
   });
 
   it('normalizes synthetic event value when formula field renders Input from app components', async () => {

package/src/flow/index.ts

@@ -104,5 +104,6 @@ export * from './admin-shell/AdminLayoutRouteCoordinator';
 export * from '../settings-center';
 export { openViewFlow } from './flows/openViewFlow';
 export { editMarkdownFlow } from './flows/editMarkdownFlow';
+export { resolveDynamicNamePath } from './models/blocks/form/value-runtime/path';
 
 export { TextAreaWithContextSelector } from './components/TextAreaWithContextSelector';

package/src/flow/internal/utils/__tests__/titleFieldQuickSync.test.ts

@@ -26,6 +26,7 @@ describe('titleFieldQuickSync', () => {
     expect(isTitleUsableField(dm, { interface: 'formula' } as any)).toBe(false);
     expect(isTitleUsableField(dm, { interface: 'unknown' } as any)).toBe(false);
     expect(isTitleUsableField(undefined, { interface: 'input' } as any)).toBe(false);
+    expect(isTitleUsableField({} as any, { interface: 'input' } as any)).toBe(false);
   });
 
   it('syncs title field to main data source collection', async () => {

package/src/flow/internal/utils/titleFieldQuickSync.ts

@@ -7,7 +7,7 @@
  * For more information, please refer to: https://www.nocobase.com/agreement.
  */
 
-import { DataSourceManager } from '@nocobase/flow-engine';
+import { DataSourceManager, getCollectionFieldInterface } from '@nocobase/flow-engine';
 import type { CollectionFieldOptions } from '../../../flow-compat';
 import { DEFAULT_DATA_SOURCE_KEY } from '../../../flow-compat';
 
@@ -33,7 +33,7 @@ export function isTitleUsableField(
 ): boolean {
   const ifaceName = typeof field?.interface === 'string' ? field.interface : undefined;
   if (!dm || !ifaceName) return false;
-  return !!dm.collectionFieldInterfaceManager.getFieldInterface(ifaceName)?.titleUsable;
+  return !!getCollectionFieldInterface(ifaceName, dm)?.titleUsable;
 }
 
 function resolveDataSourceKey(targetCollection: CollectionLike | null | undefined): string {

package/src/flow/models/actions/AssociateActionModel.tsx

@@ -0,0 +1,196 @@
+/**
+ * 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, FlowModelRenderer, tExpr, useFlowViewContext } from '@nocobase/flow-engine';
+import { useRequest } from 'ahooks';
+import { Button } from 'antd';
+import type { ButtonProps } from 'antd';
+import React from 'react';
+import { SkeletonFallback } from '../../components/SkeletonFallback';
+import { ActionModel, ActionSceneEnum } from '../base';
+import {
+  applyAssociateAction,
+  getAssociationTargetResourceSettings,
+  isAssociationBlockContext,
+} from './AssociationActionUtils';
+
+function AssociateSelectorGridRenderer({ options }: { options: any }) {
+  const ctx = useFlowViewContext();
+  const { data, loading } = useRequest(
+    async () => {
+      return await ctx.engine.loadOrCreateModel(options, {
+        delegateToParent: false,
+        delegate: ctx,
+        skipSave: !ctx.flowSettingsEnabled,
+      });
+    },
+    {
+      refreshDeps: [ctx, options],
+    },
+  );
+
+  if (loading || !data?.uid) {
+    return <SkeletonFallback style={{ margin: 16 }} />;
+  }
+  return <FlowModelRenderer model={data as FlowModel} fallback={<SkeletonFallback style={{ margin: 16 }} />} />;
+}
+
+function AssociateSelectorContent({ model }: { model: AssociateActionModel }) {
+  const ctx = useFlowViewContext();
+  const { Header, Footer, type } = ctx.view;
+  return (
+    <div>
+      <Header
+        title={
+          type === 'dialog' ? (
+            <div
+              style={{
+                padding: `${ctx.themeToken.paddingLG}px ${ctx.themeToken.paddingLG}px 0`,
+                marginBottom: -ctx.themeToken.marginSM,
+                backgroundColor: 'var(--colorBgLayout)',
+              }}
+            >
+              {ctx.t('Select record')}
+            </div>
+          ) : (
+            ctx.t('Select record')
+          )
+        }
+      />
+      <AssociateSelectorGridRenderer
+        options={{
+          parentId: ctx.view.inputArgs.parentId,
+          subKey: 'associate-selector-grid',
+          async: true,
+          delegateToParent: false,
+          subType: 'object',
+          use: 'BlockGridModel',
+        }}
+      />
+      <Footer>
+        {type === 'dialog' ? (
+          <div style={{ padding: `0 ${ctx.themeToken.paddingLG}px ${ctx.themeToken.paddingLG}px` }}>
+            <Button
+              type="primary"
+              onClick={async () => {
+                await model.associateSelectedRows();
+                ctx.view.close();
+              }}
+            >
+              {ctx.t('Submit')}
+            </Button>
+          </div>
+        ) : (
+          <Button
+            type="primary"
+            onClick={async () => {
+              await model.associateSelectedRows();
+              ctx.view.close();
+            }}
+          >
+            {ctx.t('Submit')}
+          </Button>
+        )}
+      </Footer>
+    </div>
+  );
+}
+
+export class AssociateActionModel extends ActionModel {
+  static scene = ActionSceneEnum.collection;
+  static capabilityActionName = 'update';
+
+  defaultPopupTitle = tExpr('Select record');
+  selectedRows: any[] = [];
+
+  defaultProps: ButtonProps = {
+    title: tExpr('Associate'),
+    icon: 'LinkOutlined',
+  };
+
+  getAclActionName() {
+    return 'update';
+  }
+
+  async associateSelectedRows() {
+    await applyAssociateAction(this.context, this.selectedRows);
+    this.selectedRows = [];
+  }
+}
+
+AssociateActionModel.define({
+  label: tExpr('Associate'),
+  sort: 15,
+  hide(ctx) {
+    return !isAssociationBlockContext(ctx);
+  },
+});
+
+AssociateActionModel.registerFlow({
+  key: 'associateSettings',
+  title: tExpr('Associate settings'),
+  on: 'click',
+  steps: {
+    openSelector: {
+      async handler(ctx, params) {
+        const blockModel = ctx.blockModel;
+        const targetResourceSettings = getAssociationTargetResourceSettings(ctx);
+        const openMode = ctx.inputArgs?.isMobileLayout ? 'embed' : ctx.inputArgs?.mode || params?.mode || 'drawer';
+        const size = ctx.inputArgs?.size || params?.size || 'medium';
+        const sizeToWidthMap: Record<string, Record<string, string | undefined>> = {
+          drawer: {
+            small: '30%',
+            medium: '50%',
+            large: '70%',
+          },
+          dialog: {
+            small: '40%',
+            medium: '50%',
+            large: '80%',
+          },
+          embed: {},
+        };
+
+        ctx.model.selectedRows = [];
+        await ctx.viewer.open({
+          type: openMode,
+          width: sizeToWidthMap[openMode][size],
+          inheritContext: false,
+          target: ctx.layoutContentElement,
+          inputArgs: {
+            parentId: ctx.model.uid,
+            scene: 'select',
+            dataSourceKey: targetResourceSettings.dataSourceKey,
+            collectionName: targetResourceSettings.collectionName,
+            rowSelectionProps: {
+              type: 'checkbox',
+              defaultSelectedRows: () => blockModel?.resource?.getData?.() || [],
+              renderCell: undefined,
+              selectedRowKeys: undefined,
+              onChange: (_, selectedRows) => {
+                ctx.model.selectedRows = selectedRows || [];
+              },
+            },
+          },
+          content: () => <AssociateSelectorContent model={ctx.model as AssociateActionModel} />,
+          styles: {
+            content: {
+              padding: 0,
+              backgroundColor: ctx.model.flowEngine.context.themeToken.colorBgLayout,
+              ...(openMode === 'embed' ? { position: 'absolute', top: 0, left: 0, right: 0, bottom: 0 } : {}),
+            },
+            body: {
+              padding: 0,
+            },
+          },
+        });
+      },
+    },
+  },
+});

package/src/flow/models/actions/AssociationActionUtils.ts

@@ -0,0 +1,90 @@
+/**
+ * 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 { FlowModelContext } from '@nocobase/flow-engine';
+
+export const getAssociationBlockResourceSettings = (ctx: FlowModelContext | any) => {
+  const blockModel = ctx?.blockModel || ctx?.model?.context?.blockModel;
+  return (
+    blockModel?.getResourceSettingsInitParams?.() ||
+    blockModel?.getStepParams?.('resourceSettings', 'init') ||
+    ctx?.model?.getStepParams?.('resourceSettings', 'init')
+  );
+};
+
+export const isAssociationBlockContext = (ctx: FlowModelContext | any) => {
+  return !!getAssociationBlockResourceSettings(ctx)?.associationName;
+};
+
+export const getAssociationTargetResourceSettings = (ctx: FlowModelContext | any) => {
+  const resourceSettings = getAssociationBlockResourceSettings(ctx);
+  const association = ctx?.blockModel?.association || ctx?.model?.context?.blockModel?.association;
+  const targetCollection = association?.targetCollection;
+
+  return {
+    dataSourceKey: targetCollection?.dataSourceKey || resourceSettings?.dataSourceKey,
+    collectionName: targetCollection?.name || association?.target || resourceSettings?.collectionName,
+  };
+};
+
+const callAssociationResourceAction = async (resource: any, action: 'add' | 'remove', values: any[]) => {
+  if (typeof resource?.[action] === 'function') {
+    return await resource[action]({ values });
+  }
+
+  return await resource?.runAction?.(action, {
+    data: values,
+  });
+};
+
+export const applyDisassociateAction = async (ctx: FlowModelContext | any) => {
+  const resource = ctx?.blockModel?.resource || ctx?.resource;
+  const collection = ctx?.blockModel?.collection || ctx?.collection;
+
+  if (!isAssociationBlockContext(ctx)) {
+    ctx.message?.error?.(ctx.t('No association block selected'));
+    return;
+  }
+  if (!resource) {
+    ctx.message?.error?.(ctx.t('No resource selected for disassociation'));
+    return;
+  }
+  if (!ctx.record) {
+    ctx.message?.error?.(ctx.t('No record selected for disassociation'));
+    return;
+  }
+
+  const filterByTk = collection?.getFilterByTK?.(ctx.record);
+  await callAssociationResourceAction(resource, 'remove', [filterByTk]);
+  await resource.refresh?.();
+  ctx.message?.success?.(ctx.t('Record disassociated successfully'));
+};
+
+export const applyAssociateAction = async (ctx: FlowModelContext | any, selectedRows: any[]) => {
+  const resource = ctx?.blockModel?.resource || ctx?.resource;
+  const collection = ctx?.blockModel?.collection || ctx?.collection;
+
+  if (!isAssociationBlockContext(ctx)) {
+    ctx.message?.error?.(ctx.t('No association block selected'));
+    return;
+  }
+  if (!resource) {
+    ctx.message?.error?.(ctx.t('No resource selected for association'));
+    return;
+  }
+  if (!selectedRows?.length) {
+    ctx.message?.warning?.(ctx.t('Please select at least one record'));
+    return;
+  }
+
+  const values = selectedRows.map((row) => collection?.getFilterByTK?.(row) ?? row).filter((value) => value != null);
+  await callAssociationResourceAction(resource, 'add', values);
+  await resource.refresh?.();
+  ctx.message?.success?.(ctx.t('Record associated successfully'));
+};