@nocobase/app-template-default 1.0.0-beta.72 → 1.0.0-beta.74

package/client/locales/system/settings-en-US.ts

@@ -1,8 +1,78 @@
 const settings = {
+  permissionManagement: 'Permission management',
+  defaultAccess: {
+    noResourcesShort: 'No configurable objects available',
+    scopeInvalid:
+      'Choose a valid data scope or complete its filter conditions.',
+
+    deleteChanged:
+      'This rule changed or was removed. The list was refreshed; review it before deleting.',
+    filterDescription:
+      'Apply conditions to this rule draft, then save the rule to make them effective.',
+    fieldLabels: { name: 'Name', id: 'ID' },
+    delete: 'Delete',
+    title: 'Default data scopes',
+    description:
+      'Adds data access for users with operation permission, combined with role-granted scopes and subject to restriction rules.',
+    manage: 'Manage default data scopes',
+    new: 'New default scope',
+    edit: 'Default scope details',
+    resource: 'Business object',
+    chooseResource: 'Choose a business object',
+    action: 'Operation',
+    scope: 'Data scope',
+    scopes: 'Operations and data scopes',
+    none: 'No default scope',
+    all: 'All records',
+    custom: 'Custom filter',
+    records: 'Selected records ({{count}})',
+    retained: 'Retain existing configuration',
+    search: 'Search business objects or keys',
+    empty: 'No default data scopes',
+    emptyHint:
+      'Create a rule to configure baseline access for a business object.',
+    readOnlyEmpty: 'Ask an administrator to configure baseline data access.',
+    noResources:
+      'Every available business object already has a default rule, or no configurable objects are registered.',
+    unsupported:
+      'This rule includes configuration absent from the current plugin catalog. It is preserved and shown read-only.',
+    changed:
+      'This rule changed or was removed while you were editing. Reload it before saving. Your draft has not been saved.',
+    duplicate:
+      'This key or business object already has a default rule. Use a different key or edit the existing rule.',
+    invalid:
+      'The configuration is not accepted. Check the business object, operation and data scope.',
+    keyRequired: 'Enter a key other than options, subjects or records.',
+    resourceRequired: 'Choose a business object.',
+    reload: 'Reload rule',
+    saved: 'Saved default scope “{{name}}”',
+    deleted: 'Deleted default scope “{{name}}”',
+    deleteTitle: 'Delete default scope “{{name}}”?',
+    deleteHint:
+      'This removes the baseline access supplied by this rule. Existing role grants and other rules remain. This cannot be undone.',
+    back: 'Back to default scopes',
+    open: 'View / edit',
+  },
+  scopeHintFor: 'About the data range for {{name}}',
+  scopeExplanation:
+    'Each range applies to its corresponding data. The operation must also pass its authorization checks.',
+  noAdditionalScopeHint:
+    'This action grants no additional record access here. Default access, sharing and restriction rules still determine actual access.',
+  systemToolsHint:
+    'Manage system configuration and tools. Review the capabilities each action includes before granting access.',
+  userAccountsHint:
+    'Manage user information, account security and role assignments. Review each permission separately.',
+  businessOperationsHint:
+    'Choose the operations this role can perform and the data each operation can use.',
+  pageAccessHint:
+    'Controls which pages this role can open. Data and actions on each page require their own permissions.',
+  roleAssignment: 'Role assignment',
+  accountSecurity: 'Account security',
+  userInformation: 'User information',
   unnamedPage: 'Unnamed page ({{path}})',
   revokeRoles: 'Revoke roles',
   keyConflict: 'This role key is already in use.',
-  userPermissions: 'User management',
+  userPermissions: 'Users and accounts',
   readUsers: 'View users',
   createUsers: 'Create users',
   updateUsers: 'Edit users',
@@ -95,10 +165,11 @@ const settings = {
   noPermissions: 'No permissions to configure',
   permissionCategories: 'Permission categories',
   selectAllPermissions: 'All',
+  dataRanges: 'Data ranges ({{count}})',
   selectVisiblePermissions: 'Select visible permissions in {{name}}',
   permissionSummary: '{{enabled}} of {{total}} enabled',
   preservedRecordScope: 'Keep existing configuration',
-  noRecordScope: 'No records (not authorized)',
+  noRecordScope: 'No additional record access',
   permissionFilter: {
     limit: 'Up to 20 conditions',
     configure: 'Conditions',

package/client/locales/system/settings-zh-CN.ts

@@ -1,8 +1,70 @@
 const settings = {
+  permissionManagement: '权限管理',
+  defaultAccess: {
+    noResourcesShort: '暂无可配置的业务对象',
+    scopeInvalid: '请重新选择有效的数据范围或完善筛选条件。',
+
+    deleteChanged: '此规则已被修改或删除，列表已刷新，请重新确认后再删除。',
+    filterDescription: '将条件应用到当前规则草稿，保存规则后生效。',
+    fieldLabels: { name: '名称', id: '标识' },
+    delete: '删除',
+    title: '默认数据范围',
+    description:
+      '为已有操作权限的用户补充数据范围，与角色授权范围合并，最终仍受限制规则约束。',
+    manage: '管理默认数据范围',
+    new: '新建默认范围',
+    edit: '默认范围详情',
+    resource: '业务对象',
+    chooseResource: '请选择业务对象',
+    action: '操作',
+    scope: '数据范围',
+    scopes: '操作与数据范围',
+    none: '不设置默认范围',
+    all: '所有记录',
+    custom: '自定义筛选',
+    records: '指定记录（{{count}} 条）',
+    retained: '保留现有配置',
+    search: '搜索业务对象或标识',
+    empty: '暂无默认数据范围',
+    emptyHint: '新建规则，为业务对象配置基础数据访问范围。',
+    readOnlyEmpty: '请联系管理员配置基础数据访问范围。',
+    noResources: '可用业务对象均已配置默认规则，或当前没有可配置的业务对象。',
+    unsupported:
+      '此规则包含当前插件目录中不存在的配置，已保留原值并以只读方式展示。',
+    changed:
+      '此规则在编辑期间已被修改或删除，请重新加载后再保存。当前草稿未保存。',
+    duplicate: '此标识或业务对象已有默认规则，请更换标识或编辑已有规则。',
+    invalid: '配置未通过校验，请检查业务对象、操作和数据范围。',
+    keyRequired: '请填写标识，不能使用 options、subjects 或 records。',
+    resourceRequired: '请选择业务对象。',
+    reload: '重新加载规则',
+    saved: '已保存默认范围“{{name}}”',
+    deleted: '已删除默认范围“{{name}}”',
+    deleteTitle: '删除默认范围“{{name}}”？',
+    deleteHint:
+      '删除后，此规则提供的基础访问范围将失效；已有角色授权和其他规则保留。此操作无法撤销。',
+    back: '返回默认数据范围',
+    open: '查看或编辑',
+  },
+  scopeHintFor: '关于“{{name}}”的数据范围',
+  scopeExplanation:
+    '每项范围分别约束对应数据，实际操作还需通过相应的权限检查。',
+  noAdditionalScopeHint:
+    '此操作在这里不额外授予数据访问权限，实际可访问范围仍取决于默认数据范围、共享与限制规则。',
+  systemToolsHint: '管理系统配置与工具，授权前请确认每项操作包含的能力。',
+  userAccountsHint:
+    '管理用户资料、账号安全和角色分配，请逐项确认需要授予的权限。',
+  businessOperationsHint:
+    '设置此角色可以执行的业务操作，以及每项操作可使用的数据范围。',
+  pageAccessHint:
+    '控制此角色可以进入哪些页面。页面中的数据和操作仍需单独授权。',
+  roleAssignment: '角色分配',
+  accountSecurity: '账号安全',
+  userInformation: '用户资料',
   unnamedPage: '未命名页面（{{path}}）',
   revokeRoles: '撤销角色',
   keyConflict: '此角色标识已被使用。',
-  userPermissions: '用户管理',
+  userPermissions: '用户与账号',
   readUsers: '查看用户',
   createUsers: '创建用户',
   updateUsers: '编辑用户',
@@ -92,9 +154,10 @@ const settings = {
   noPermissions: '暂无可配置权限',
   permissionCategories: '权限分类',
   selectAllPermissions: '全选',
+  dataRanges: '数据范围（{{count}}）',
   selectVisiblePermissions: '选择“{{name}}”中显示的权限',
   permissionSummary: '已授权 {{enabled}} / {{total}}',
-  noRecordScope: '不允许访问数据',
+  noRecordScope: '不额外授权数据范围',
   preservedRecordScope: '保留现有配置',
   permissionFilter: {
     limit: '最多支持 20 个条件',

package/client/pages/settings/default-access-form.tsx

@@ -0,0 +1,499 @@
+import { ApiClientError, useApiClient, useToaster } from '@nocobase/app-client';
+import {
+  useCan,
+  type AuthorizationOptionsResponse,
+  type LocalizedText,
+} from '@nocobase/app-plugin-authorization/client';
+import { useTranslation } from '@nocobase/i18n/client';
+import { useRef, useState, type ReactElement } from 'react';
+import {
+  useLocation,
+  useNavigate,
+  useOutletContext,
+  useParams,
+} from 'react-router';
+import { PageContainer } from '#components/page-container';
+import { PageHeader } from '#components/page-header';
+import { RouteChildPage } from '#components/route-child-page';
+import {
+  DefaultAccessEditor,
+  type DefaultAccessScopeControl,
+} from '#components/default-access-editor';
+import { PermissionFilter } from '#components/permission-filter';
+import { Button } from '#components/ui/button';
+import { Alert, AlertDescription } from '#components/ui/alert';
+import { SettingsError, SettingsLoading } from './shared.js';
+import { useSettingsData, useSettingsLeave } from './hooks.js';
+import { permissionFilterLabels } from './permission-filters.js';
+import {
+  actionKey,
+  resourceKey,
+  ruleResources,
+  ruleScopes,
+  replaceRuleScope,
+  editableRule,
+  type DefaultAccessRule,
+  type ScopeSelection,
+} from './default-access-model.js';
+
+function DefaultAccessFormBody(): ReactElement {
+  const { key } = useParams();
+  const creating = key === undefined;
+  const { t } = useTranslation();
+  const api = useApiClient();
+  const toaster = useToaster();
+  const navigate = useNavigate();
+  const location = useLocation();
+  const parent = useOutletContext<{
+    reload: () => void;
+    saved: (rule: DefaultAccessRule) => void;
+  }>();
+  const rules = useSettingsData<{ data: readonly DefaultAccessRule[] }>(
+    'authorization/defaultAccess',
+  );
+  const catalog = useSettingsData<{ data: AuthorizationOptionsResponse }>(
+    'authorization/defaultAccess/options',
+  );
+  const canWrite = useCan({
+    resource: { type: 'settings', id: 'authorization.default-access' },
+    action: creating ? 'create' : 'update',
+  }).can;
+  const [draft, setDraft] = useState<DefaultAccessRule>();
+  const [busy, setBusy] = useState(false);
+  const [error, setError] = useState<unknown>();
+  const [message, setMessage] = useState<string>();
+  const [submitted, setSubmitted] = useState(false);
+  const [fieldErrors, setFieldErrors] = useState<{
+    key?: string;
+    resource?: string;
+  }>({});
+  const [scopeErrors, setScopeErrors] = useState<Record<string, string>>({});
+  const [editing, setEditing] = useState<string>();
+  const formRef = useRef<HTMLFormElement>(null);
+  const initial = creating
+    ? undefined
+    : rules.data?.data.find((rule) => rule.key === key);
+  const value = draft ??
+    initial ?? { key: '', resource: { type: '', id: '' }, actions: [] };
+  const dirty =
+    draft !== undefined && JSON.stringify(draft) !== JSON.stringify(initial);
+  const leave = useSettingsLeave(dirty, busy);
+  const close = () => {
+    void navigate({ pathname: '/default-access', search: location.search });
+  };
+  const text = (value: LocalizedText): string =>
+    typeof value === 'string'
+      ? value
+      : t(value.key, {
+          ns: value.ns,
+          defaultValue: value.defaultValue ?? value.key,
+        });
+  const resources = catalog.data ? ruleResources(catalog.data.data) : [];
+  const resource = resources.find(
+    (entry) => resourceKey(entry) === resourceKey(value.resource),
+  );
+  const scopes = catalog.data ? ruleScopes(resource, catalog.data.data) : [];
+  const supported = creating
+    ? scopes.length > 0
+    : Boolean(catalog.data && editableRule(value, scopes, catalog.data.data));
+  const readOnly = !canWrite || busy || (!creating && !supported);
+  const options = resources
+    .filter(
+      (entry) =>
+        !creating ||
+        !rules.data?.data.some(
+          (rule) => resourceKey(rule.resource) === resourceKey(entry),
+        ),
+    )
+    .map((entry) => ({ value: resourceKey(entry), label: text(entry.title) }));
+  if (
+    !creating &&
+    !options.some((option) => option.value === resourceKey(value.resource))
+  )
+    options.push({
+      value: resourceKey(value.resource),
+      label: value.resource.id,
+    });
+  const invalidKey =
+    !value.key.trim() ||
+    ['options', 'subjects', 'records'].includes(value.key.trim());
+  const fieldLabels: Record<string, string> = {
+    name: t('settings.defaultAccess.fieldLabels.name'),
+    id: t('settings.defaultAccess.fieldLabels.id'),
+  };
+  const labels = {
+    ...permissionFilterLabels((label, fallback) =>
+      t(label, { defaultValue: fallback ?? label }),
+    ),
+    description: t('settings.defaultAccess.filterDescription'),
+  };
+  const controls: DefaultAccessScopeControl[] = scopes.map((scope) => {
+    const selected = value.actions.find(
+      (entry) => actionKey(entry) === scope.id,
+    )?.selection;
+    const selectedValue = selected ? JSON.stringify(selected) : '';
+    const choices = [
+      { value: '', label: t('settings.defaultAccess.none') },
+      ...(!scope.recordAccess.includes('allRecords')
+        ? [
+            {
+              value: JSON.stringify({ type: 'all' }),
+              label: t('settings.defaultAccess.all'),
+            },
+          ]
+        : []),
+      ...scope.recordAccess.map((preset) => ({
+        value: JSON.stringify({ type: 'recordAccess', key: preset }),
+        label: text(
+          catalog.data?.data.recordAccess.find((entry) => entry.key === preset)
+            ?.title ?? preset,
+        ),
+      })),
+    ];
+    if (selected && !choices.some((choice) => choice.value === selectedValue))
+      choices.push({
+        value: selectedValue,
+        label:
+          selected.type === 'all'
+            ? t('settings.defaultAccess.all')
+            : selected.type === 'records'
+              ? t('settings.defaultAccess.records', {
+                  count: selected.ids.length,
+                })
+              : selected.key === 'customFilter'
+                ? t('settings.defaultAccess.custom')
+                : t('settings.defaultAccess.retained'),
+      });
+    const custom =
+      selected?.type === 'recordAccess' && selected.key === 'customFilter';
+    const params =
+      custom && selected.params && typeof selected.params === 'object'
+        ? (Reflect.get(selected.params, 'filter') as unknown)
+        : undefined;
+    return {
+      id: scope.id,
+      error: scopeErrors[scope.id],
+      action: text(scope.actionTitle),
+      scope: text(scope.title),
+      value: selectedValue,
+      options: choices,
+      configuration:
+        custom || editing === scope.id ? (
+          <PermissionFilter
+            open={editing === scope.id}
+            onOpenChange={(open) => setEditing(open ? scope.id : undefined)}
+            value={params}
+            fields={scope.fields.map((field) => ({
+              value: field,
+              label: fieldLabels[field] ?? field,
+            }))}
+            labels={labels}
+            disabled={readOnly}
+            onApply={(filter) => {
+              setDraft(
+                replaceRuleScope(value, scope, {
+                  type: 'recordAccess',
+                  key: 'customFilter',
+                  params: { filter },
+                }),
+              );
+              setScopeErrors((old) => ({ ...old, [scope.id]: '' }));
+              setEditing(undefined);
+            }}
+          />
+        ) : undefined,
+    };
+  });
+  // Never discard entries no longer present in the live plugin catalog.
+  for (const action of value.actions)
+    if (!scopes.some((scope) => scope.id === actionKey(action)))
+      controls.push({
+        id: actionKey(action),
+        action: action.action,
+        scope: action.scopeKey ?? value.resource.id,
+        value: JSON.stringify(action.selection),
+        options: [
+          {
+            value: JSON.stringify(action.selection),
+            label: t('settings.defaultAccess.retained'),
+          },
+        ],
+      });
+  const save = async () => {
+    setSubmitted(true);
+    setFieldErrors({});
+    setScopeErrors({});
+    setMessage(undefined);
+    setError(undefined);
+    if (invalidKey || !resource || !supported || !canWrite || busy) {
+      requestAnimationFrame(() =>
+        formRef.current
+          ?.querySelector<HTMLElement>('[aria-invalid="true"]')
+          ?.focus(),
+      );
+      return;
+    }
+    setBusy(true);
+    try {
+      const latest = await api.request<{ data: readonly DefaultAccessRule[] }>({
+        path: 'authorization/defaultAccess',
+      });
+      if (
+        !creating &&
+        JSON.stringify(latest.data.find((rule) => rule.key === key)) !==
+          JSON.stringify(initial)
+      ) {
+        setMessage(t('settings.defaultAccess.changed'));
+        return;
+      }
+      const saved = await api.request<{ data: DefaultAccessRule }>({
+        path: creating
+          ? 'authorization/defaultAccess'
+          : `authorization/defaultAccess/${encodeURIComponent(key ?? '')}`,
+        method: creating ? 'POST' : 'PATCH',
+        json: creating
+          ? { ...value, key: value.key.trim() }
+          : { actions: value.actions },
+      });
+      toaster.show({
+        type: 'success',
+        title: t('settings.defaultAccess.saved', { name: value.key }),
+      });
+      leave.allow();
+      parent.saved(saved.data);
+      close();
+    } catch (next) {
+      if (
+        next instanceof ApiClientError &&
+        next.payload &&
+        typeof next.payload === 'object'
+      ) {
+        const detail: unknown = Reflect.get(next.payload, 'error');
+        const violations: unknown =
+          detail && typeof detail === 'object'
+            ? Reflect.get(detail, 'fieldViolations')
+            : undefined;
+        if (Array.isArray(violations)) {
+          const errors: { key?: string; resource?: string } = {};
+          const scopeErrors: Record<string, string> = {};
+          for (const violation of violations) {
+            const field: unknown =
+              violation && typeof violation === 'object'
+                ? Reflect.get(violation, 'field')
+                : undefined;
+            if (field === 'key')
+              errors.key = t('settings.defaultAccess.keyRequired');
+            else if (typeof field === 'string' && field.startsWith('resource'))
+              errors.resource = t('settings.defaultAccess.resourceRequired');
+            else if (typeof field === 'string') {
+              const index = /^actions\.(\d+)(?:\.|$)/.exec(field);
+              const entry = index ? value.actions[Number(index[1])] : undefined;
+              if (entry)
+                scopeErrors[actionKey(entry)] = t(
+                  'settings.defaultAccess.scopeInvalid',
+                );
+            }
+          }
+          setFieldErrors(errors);
+          setScopeErrors(scopeErrors);
+          requestAnimationFrame(() =>
+            formRef.current
+              ?.querySelector<HTMLElement>('[aria-invalid="true"]')
+              ?.focus(),
+          );
+        }
+      }
+      const reason: unknown =
+        next && typeof next === 'object'
+          ? Reflect.get(next, 'reason')
+          : undefined;
+      if (
+        reason === 'DEFAULT_ACCESS_CONFLICT' ||
+        reason === 'RULE_ALREADY_EXISTS'
+      )
+        setMessage(t('settings.defaultAccess.duplicate'));
+      else if (
+        reason === 'INVALID_AUTHORIZATION_INPUT' ||
+        reason === 'INVALID_INPUT'
+      )
+        setMessage(t('settings.defaultAccess.invalid'));
+      else setError(next);
+    } finally {
+      setBusy(false);
+    }
+  };
+  return (
+    <PageContainer className='max-w-4xl'>
+      <PageHeader
+        title={t(
+          creating
+            ? 'settings.defaultAccess.new'
+            : 'settings.defaultAccess.edit',
+        )}
+        description={t('settings.defaultAccess.description')}
+      />
+      <SettingsError
+        error={rules.error || catalog.error}
+        retry={() => {
+          rules.reload();
+          catalog.reload();
+        }}
+      />
+      {(rules.loading && !rules.data) || (catalog.loading && !catalog.data) ? (
+        <SettingsLoading />
+      ) : (
+        !rules.error &&
+        !catalog.error && (
+          <>
+            {!creating && !initial ? (
+              <p role='status'>{t('settings.missing')}</p>
+            ) : (
+              <form
+                ref={formRef}
+                noValidate
+                className='flex flex-col gap-6'
+                onSubmit={(event) => {
+                  event.preventDefault();
+                  void save();
+                }}
+              >
+                <SettingsError error={error} />
+                {message && (
+                  <Alert variant='destructive'>
+                    <AlertDescription>
+                      {message}
+                      {!creating && (
+                        <Button
+                          type='button'
+                          variant='outline'
+                          onClick={() => {
+                            setDraft(undefined);
+                            setMessage(undefined);
+                            rules.reload();
+                          }}
+                        >
+                          {t('settings.defaultAccess.reload')}
+                        </Button>
+                      )}
+                    </AlertDescription>
+                  </Alert>
+                )}
+                {!creating && !supported && (
+                  <p className='text-sm text-muted-foreground'>
+                    {t('settings.defaultAccess.unsupported')}
+                  </p>
+                )}
+                {creating && !options.length && (
+                  <p className='text-sm text-muted-foreground'>
+                    {t('settings.defaultAccess.noResources')}
+                  </p>
+                )}
+                <DefaultAccessEditor
+                  ruleKey={value.key}
+                  resource={
+                    value.resource.type ? resourceKey(value.resource) : ''
+                  }
+                  resources={options}
+                  scopes={controls}
+                  existing={!creating}
+                  readOnly={readOnly}
+                  keyError={
+                    submitted && invalidKey
+                      ? t('settings.defaultAccess.keyRequired')
+                      : fieldErrors.key
+                  }
+                  resourceError={
+                    submitted && !resource
+                      ? t('settings.defaultAccess.resourceRequired')
+                      : fieldErrors.resource
+                  }
+                  labels={{
+                    key: t('settings.key'),
+                    resource: t('settings.defaultAccess.resource'),
+                    chooseResource: t('settings.defaultAccess.chooseResource'),
+                    action: t('settings.defaultAccess.action'),
+                    scope: t('settings.defaultAccess.scope'),
+                    noScopes: t('settings.defaultAccess.chooseResource'),
+                  }}
+                  onKeyChange={(key) => {
+                    setDraft({ ...value, key });
+                    setFieldErrors((old) => {
+                      const { key: _key, ...next } = old;
+                      return next;
+                    });
+                  }}
+                  onResourceChange={(selected) => {
+                    const resource = resources.find(
+                      (entry) => resourceKey(entry) === selected,
+                    );
+                    if (resource) {
+                      setDraft({
+                        ...value,
+                        resource: { type: resource.type, id: resource.id },
+                        actions: [],
+                      });
+                      setEditing(undefined);
+                      setFieldErrors({});
+                      setScopeErrors({});
+                    }
+                  }}
+                  onScopeChange={(id, next) => {
+                    const scope = scopes.find((scope) => scope.id === id);
+                    if (!scope) return;
+                    setScopeErrors((old) => ({ ...old, [id]: '' }));
+                    const selection = next
+                      ? (JSON.parse(next) as ScopeSelection)
+                      : undefined;
+                    if (
+                      selection?.type === 'recordAccess' &&
+                      selection.key === 'customFilter' &&
+                      !('params' in selection)
+                    )
+                      setEditing(id);
+                    else setDraft(replaceRuleScope(value, scope, selection));
+                  }}
+                />
+                <div className='flex justify-end gap-2 border-t pt-4'>
+                  <Button
+                    type='button'
+                    variant='outline'
+                    disabled={busy}
+                    onClick={() => {
+                      void Promise.resolve(leave.guard()).then((allowed) => {
+                        if (allowed) close();
+                      });
+                    }}
+                  >
+                    {t('settings.cancel')}
+                  </Button>
+                  {canWrite && (
+                    <Button
+                      type='submit'
+                      disabled={busy || !dirty || !supported}
+                    >
+                      {t(busy ? 'settings.saving' : 'settings.save')}
+                    </Button>
+                  )}
+                </div>
+              </form>
+            )}
+            {!creating && !initial && (
+              <Button variant='outline' onClick={close}>
+                {t('settings.defaultAccess.back')}
+              </Button>
+            )}
+          </>
+        )
+      )}
+      {leave.dialog}
+    </PageContainer>
+  );
+}
+export default function DefaultAccessForm(): ReactElement {
+  const { key } = useParams();
+  return (
+    <RouteChildPage>
+      <DefaultAccessFormBody key={key ?? 'create'} />
+    </RouteChildPage>
+  );
+}