@pilotiq/pilotiq 0.24.1 → 0.24.2

package/src/actions/ActionGroup.test.ts

@@ -1,112 +0,0 @@
-import { describe, it, beforeEach } from 'node:test'
-import assert from 'node:assert/strict'
-
-import { Action } from './Action.js'
-import { ActionGroup } from './ActionGroup.js'
-import { resolveSchema, _resetResolverRegistry } from '../schema/resolveSchema.js'
-
-beforeEach(() => _resetResolverRegistry())
-
-describe('ActionGroup builder', () => {
-  it('emits type=actionGroup with sensible defaults', () => {
-    const meta = ActionGroup.make('manage').toMeta()
-    assert.equal(meta.type,      'actionGroup')
-    assert.equal(meta.name,      'manage')
-    assert.equal(meta.label,     'Manage')  // auto-derived
-    assert.equal(meta.placement, 'inline')
-  })
-
-  it('label() / icon() / tooltip() round-trip', () => {
-    const meta = ActionGroup.make('m').label('More').icon('more-horizontal').tooltip('More actions').toMeta()
-    assert.equal(meta.label,   'More')
-    assert.equal(meta.icon,    'more-horizontal')
-    assert.equal(meta.tooltip, 'More actions')
-  })
-
-  it('placement helpers', () => {
-    assert.equal(ActionGroup.make('a').header().toMeta().placement, 'header')
-    assert.equal(ActionGroup.make('a').row().toMeta().placement,    'row')
-    assert.equal(ActionGroup.make('a').bulk().toMeta().placement,   'bulk')
-  })
-
-  it('cosmetic builders round-trip', () => {
-    const meta = ActionGroup.make('a').color('success').size('lg').outlined().iconButton().toMeta()
-    assert.equal(meta.color,    'success')
-    assert.equal(meta.size,     'lg')
-    assert.equal(meta.outlined, true)
-    assert.equal(meta.iconOnly, true)
-  })
-
-  it('actions() stores the children', () => {
-    const g = ActionGroup.make('m').actions([
-      Action.make('export'),
-      Action.make('archive'),
-    ])
-    const children = g.getActions()
-    assert.deepEqual(children.map(a => a.name), ['export', 'archive'])
-  })
-
-  it('actions() flattens nested ActionGroups', () => {
-    const inner = ActionGroup.make('inner').actions([Action.make('a'), Action.make('b')])
-    const outer = ActionGroup.make('outer').actions([Action.make('c'), inner])
-    assert.deepEqual(outer.getActions().map(a => a.name), ['c', 'a', 'b'])
-  })
-
-  it('hasVisibilityRules detects any rule', () => {
-    assert.equal(ActionGroup.make('a').hasVisibilityRules(), false)
-    assert.equal(ActionGroup.make('a').visible(true).hasVisibilityRules(), true)
-  })
-
-  it('evaluate combines visible and hidden via AND', async () => {
-    const g = ActionGroup.make('a').visible(true).hidden(({ user }) => (user as { admin?: boolean })?.admin === false)
-    assert.equal((await g.evaluate({ user: { admin: true  } })).visible, true)
-    assert.equal((await g.evaluate({ user: { admin: false } })).visible, false)
-  })
-
-  it('toMeta emits conditional:true when rules exist', () => {
-    assert.equal(ActionGroup.make('a').toMeta().conditional, undefined)
-    assert.equal(ActionGroup.make('a').visible(true).toMeta().conditional, true)
-  })
-})
-
-describe('ActionGroup through resolveSchema', () => {
-  it('drops the group when its rule resolves to !visible', async () => {
-    const tree = [ActionGroup.make('hidden').visible(false).actions([Action.make('a')])]
-    const result = await resolveSchema(tree)
-    assert.equal(result.length, 0)
-  })
-
-  it('serializes children as meta.children', async () => {
-    const tree = [
-      ActionGroup.make('m').actions([
-        Action.make('export'),
-        Action.make('delete').destructive(),
-      ]),
-    ]
-    const result = await resolveSchema(tree)
-    assert.equal(result[0]!.type, 'actionGroup')
-    assert.equal(result[0]!.children?.length, 2)
-    assert.equal(result[0]!.children![0]!['name'], 'export')
-    assert.equal(result[0]!.children![1]!['destructive'], true)
-  })
-
-  it('child Action visibility rules still apply', async () => {
-    const tree = [
-      ActionGroup.make('m').actions([
-        Action.make('shown'),
-        Action.make('hidden').visible(false),
-      ]),
-    ]
-    const result = await resolveSchema(tree)
-    assert.equal(result[0]!.children?.length, 1)
-    assert.equal(result[0]!.children![0]!['name'], 'shown')
-  })
-
-  it('stamps disabled:true on the group when its disabled rule matches', async () => {
-    const tree = [
-      ActionGroup.make('m').disabled(true).actions([Action.make('a')]),
-    ]
-    const result = await resolveSchema(tree)
-    assert.equal(result[0]!['disabled'], true)
-  })
-})

package/src/actions/ActionGroup.ts

@@ -1,173 +0,0 @@
-import { Element, type ElementMeta } from '../schema/Element.js'
-import {
-  Action,
-  type ActionColor,
-  type ActionSize,
-  type ActionPlacement,
-  type ActionVisibilityContext,
-  type VisibilityRule,
-} from './Action.js'
-
-export interface ActionGroupMeta extends ElementMeta {
-  type:        'actionGroup'
-  name:        string
-  label:       string
-  placement:   ActionPlacement
-  icon?:       string
-  tooltip?:    string
-  color?:      ActionColor
-  size?:       ActionSize
-  outlined?:   boolean
-  iconOnly?:   boolean
-  /** True when the group itself has visibility rules. The renderer checks
-   * `disabled` separately. */
-  conditional?: boolean
-  disabled?:   boolean
-}
-
-/**
- * `ActionGroup` — a labelled trigger that opens a dropdown of related
- * actions. Lives wherever a single `Action` can live (header slot,
- * inline in a Card, etc). Children are `Action[]` (nesting groups inside
- * groups is supported but renders flat — the inner group's actions are
- * folded into the parent dropdown).
- *
- * Visibility evaluation: each child Action's own `.visible()`/`.hidden()`
- * rules still apply at render time. The group itself can also opt-in to
- * group-level visibility via the same builders. When ALL children would
- * be hidden the group falls back to the disabled-ghost state so the
- * trigger doesn't disappear unexpectedly — the renderer handles that.
- */
-export class ActionGroup extends Element {
-  readonly name: string
-
-  protected _label: string
-  protected _icon?: string
-  protected _tooltip?: string
-  protected _placement: ActionPlacement = 'inline'
-
-  // Trigger styling
-  protected _color?: ActionColor
-  protected _size?: ActionSize
-  protected _outlined = false
-  protected _iconOnly = false
-
-  // Visibility
-  protected _visible?: VisibilityRule
-  protected _hidden?: VisibilityRule
-  protected _isDisabled?: VisibilityRule
-
-  private constructor(name: string) {
-    super()
-    this.name = name
-    this._label = name.charAt(0).toUpperCase() + name.slice(1)
-  }
-
-  static make(name: string): ActionGroup {
-    return new ActionGroup(name)
-  }
-
-  // ─── Children ─────────────────────────────────────────
-
-  /** Set the actions inside this group. Accepts plain `Action`s; nested
-   * `ActionGroup`s are accepted but flatten in v1 (their children get
-   * pulled up into this group's dropdown). */
-  actions(items: Array<Action | ActionGroup>): this {
-    const flat: Action[] = []
-    for (const item of items) {
-      if (item instanceof ActionGroup) {
-        flat.push(...item.getActions())
-      } else {
-        flat.push(item)
-      }
-    }
-    this._children = flat
-    return this
-  }
-
-  /** Convenience: the `Action` children only. */
-  getActions(): Action[] {
-    return (this._children ?? []).filter((c): c is Action => c instanceof Action)
-  }
-
-  // ─── Trigger config ───────────────────────────────────
-
-  label(l: string): this { this._label = l; return this }
-  icon(i: string): this  { this._icon  = i; return this }
-  tooltip(t: string): this { this._tooltip = t; return this }
-  color(c: ActionColor): this { this._color = c; return this }
-  size(s: ActionSize): this { this._size = s; return this }
-  outlined(v = true): this { this._outlined = v; return this }
-  iconButton(v = true): this { this._iconOnly = v; return this }
-
-  // ─── Placement ────────────────────────────────────────
-
-  placement(p: ActionPlacement): this { this._placement = p; return this }
-  inline(): this { return this.placement('inline') }
-  row(): this    { return this.placement('row') }
-  bulk(): this   { return this.placement('bulk') }
-  header(): this { return this.placement('header') }
-
-  // ─── Visibility ───────────────────────────────────────
-
-  visible(rule: VisibilityRule): this { this._visible = rule; return this }
-  hidden(rule: VisibilityRule): this  { this._hidden = rule; return this }
-  disabled(rule: VisibilityRule): this { this._isDisabled = rule; return this }
-  authorize(rule: VisibilityRule): this { return this.visible(rule) }
-
-  async evaluate(ctx: ActionVisibilityContext = {}): Promise<{ visible: boolean; disabled: boolean }> {
-    const evalRule = async (rule: VisibilityRule | undefined, fallback: boolean): Promise<boolean> => {
-      if (rule === undefined) return fallback
-      if (typeof rule !== 'function') return rule
-      try {
-        return await rule(ctx)
-      } catch {
-        return !fallback
-      }
-    }
-    const [visibleRaw, hiddenRaw, disabledRaw] = await Promise.all([
-      evalRule(this._visible, true),
-      evalRule(this._hidden, false),
-      evalRule(this._isDisabled, false),
-    ])
-    return {
-      visible:  visibleRaw && !hiddenRaw,
-      disabled: disabledRaw,
-    }
-  }
-
-  hasVisibilityRules(): boolean {
-    return this._visible !== undefined || this._hidden !== undefined || this._isDisabled !== undefined
-  }
-
-  // ─── Getters ──────────────────────────────────────────
-
-  getLabel():     string             { return this._label }
-  getIcon():      string | undefined { return this._icon }
-  getTooltip():   string | undefined { return this._tooltip }
-  getPlacement(): ActionPlacement    { return this._placement }
-  getColor():     ActionColor | undefined { return this._color }
-  getSize():      ActionSize | undefined  { return this._size }
-  isOutlined():   boolean { return this._outlined }
-  isIconOnly():   boolean { return this._iconOnly }
-
-  // ─── Element contract ────────────────────────────────
-
-  override getType(): string { return 'actionGroup' }
-
-  override toMeta(): ActionGroupMeta {
-    return {
-      type:      'actionGroup',
-      name:      this.name,
-      label:     this._label,
-      placement: this._placement,
-      ...(this._icon     ? { icon:     this._icon     } : {}),
-      ...(this._tooltip  ? { tooltip:  this._tooltip  } : {}),
-      ...(this._color    ? { color:    this._color    } : {}),
-      ...(this._size     ? { size:     this._size     } : {}),
-      ...(this._outlined ? { outlined: true           } : {}),
-      ...(this._iconOnly ? { iconOnly: true           } : {}),
-      ...(this.hasVisibilityRules() ? { conditional: true } : {}),
-    }
-  }
-}

package/src/actions/attachFactory.ts

@@ -1,172 +0,0 @@
-import type { Element } from '../schema/Element.js'
-import type { ResourceClass } from '../Resource.js'
-import type { ModelLike, ModelQuery } from '../orm/modelDefaults.js'
-import { getPrimaryKey } from '../orm/modelDefaults.js'
-import { SelectField } from '../fields/SelectField.js'
-
-/** Minimum shape required on the parent record to read related rows
- *  via the rudder ORM convention. The candidate-picker side uses this
- *  directly instead of `resolveRelatedQuery` because it doesn't need
- *  the `ModelLike.relatedQuery` override slot — the override only
- *  matters at table render time, not for "what's already attached?"
- *  filtering. */
-interface ParentWithRelated {
-  related(name: string): { paginate(page: number, perPage: number): Promise<{ data: unknown[]; total: number }> }
-}
-
-/**
- * Internals for `Action.relationAttach / relationDetach /
- * relationBulkDetach`. Lives in its own module so the relation-manager
- * factory side of `Action.ts` can call into the M2M-specific helpers
- * (candidate picker query, attach modal schema) without dragging
- * `SelectField` / model-defaults imports into the main file. Mirrors
- * the `importFactory.ts` / `exportFactory.ts` split.
- *
- * The picker is intentionally simple in v1 — fetch up to 50 candidates
- * client-resolved at page render time, filter out already-attached ids
- * server-side. Document the cap; users with high-cardinality relations
- * reach for `Resource.globalSearch` semantics or hand-roll an
- * `Action.handler` with a custom picker UI.
- */
-
-export interface AttachableRow {
-  /** Stringified primary key of the candidate record. */
-  value: string
-  /** Title text rendered in the picker. Resolved via the related
-   *  Resource's `recordTitleAttribute` chain. */
-  label: string
-}
-
-/**
- * Read the parent's already-attached ids under `relationship`. Used by
- * the candidate picker to filter them out (so a user can't accidentally
- * re-attach the same row). Reads through the parent's `related()`
- * accessor — not through the related model's `query()` — because the
- * accessor automatically scopes to the pivot rows for this parent.
- *
- * Returns `Set<string>` of stringified primary keys for fast lookup.
- * Quietly returns an empty set on failure (the picker still works,
- * just shows everything — the attach route's own duplicate handling
- * would pick up the dupe).
- */
-export async function loadAttachedIds(
-  parent:       unknown,
-  relationship: string,
-  relatedModel: ModelLike,
-): Promise<Set<string>> {
-  const p = parent as Partial<ParentWithRelated>
-  if (typeof p?.related !== 'function') return new Set()
-  try {
-    const q   = (p as ParentWithRelated).related(relationship)
-    const pk  = getPrimaryKey(relatedModel)
-    const out = await q.paginate(1, 1000)
-    const ids = new Set<string>()
-    for (const row of out.data) {
-      const id = (row as Record<string, unknown>)[pk]
-      if (id !== undefined && id !== null) ids.add(String(id))
-    }
-    return ids
-  } catch {
-    return new Set()
-  }
-}
-
-/**
- * Build the candidate list for the Attach modal's SelectField. Loads
- * up to `limit` rows from the related model (default 50), filters out
- * any that are already attached to the parent, and maps each to
- * `{ value, label }` using the related Resource's record-title chain.
- *
- * `recordTitleAttr` is resolved from the related Resource (or falls
- * back through the standard `name → title → id` chain). The PK comes
- * from `relatedModel`'s introspection.
- */
-export async function loadAttachableCandidates(
-  parent:         unknown,
-  relationship:   string,
-  relatedModel:   ModelLike,
-  recordTitleAttr: string | undefined,
-  limit:          number = 50,
-): Promise<AttachableRow[]> {
-  const attached = await loadAttachedIds(parent, relationship, relatedModel)
-
-  // Use the related model's own query (not the relation accessor) so
-  // we see all attachable rows, then subtract attached ids in memory.
-  // For implicit Prisma pivots the accessor doesn't expose a
-  // whereNotIn-on-pivot-keys helper, and even when it does the cost
-  // of fetching ≤ 50 rows + a Set lookup is negligible.
-  const q = (relatedModel as { query?: () => ModelQuery }).query?.()
-  if (!q) return []
-
-  const result = await q.paginate(1, limit + attached.size).catch(() => null)
-  if (!result) return []
-
-  const pk = getPrimaryKey(relatedModel)
-
-  const rows: AttachableRow[] = []
-  for (const row of result.data) {
-    const r  = row as Record<string, unknown>
-    const id = r[pk]
-    if (id === undefined || id === null) continue
-    const idStr = String(id)
-    if (attached.has(idStr)) continue
-    rows.push({ value: idStr, label: deriveLabel(r, recordTitleAttr, idStr) })
-    if (rows.length >= limit) break
-  }
-  return rows
-}
-
-function deriveLabel(
-  record: Record<string, unknown>,
-  attr:   string | undefined,
-  fallback: string,
-): string {
-  const explicit = attr && typeof record[attr] === 'string' ? (record[attr] as string) : undefined
-  if (explicit && explicit.length > 0) return explicit
-  for (const key of ['name', 'title', 'label']) {
-    const v = record[key]
-    if (typeof v === 'string' && v.length > 0) return v
-  }
-  return fallback
-}
-
-/**
- * Build the modal-form schema for `Action.relationAttach`. A single
- * `SelectField` named `_attachId` populated by an async resolver that
- * defers to `loadAttachableCandidates` at render time. Server-side the
- * resolver runs while the table is being resolved (the parent record
- * lives on `RenderContext.record` because the manager's list-page mode
- * stamps it there).
- *
- * `recordTitleAttr` defaults to `'name'` when neither the manager nor
- * the related Resource has set it explicitly. The candidate query
- * limit is fixed at 50 in v1 — see plan doc for rationale.
- */
-export function buildAttachModalSchema(deps: {
-  Related:         ResourceClass
-  relationship:    string
-  recordTitleAttr: string | undefined
-  labelSingular:   string
-}): Element[] {
-  const { Related, relationship, recordTitleAttr, labelSingular } = deps
-
-  const select = SelectField.make('_attachId')
-    .label(labelSingular)
-    .required()
-    .options(async (ctx) => {
-      // The resolver runs at schema-resolve time. For a header action
-      // on a manager list page the parent record is at `ctx.record`.
-      const parent = ctx.record
-      if (!parent) return []
-      if (!Related.model) return []
-      const rows = await loadAttachableCandidates(
-        parent,
-        relationship,
-        Related.model,
-        recordTitleAttr,
-      )
-      return rows
-    })
-
-  return [select]
-}

package/src/actions/bulkFactories.ts

@@ -1,168 +0,0 @@
-/**
- * Bulk-placement Action factories — `bulkDelete / bulkRestore /
- * bulkForceDelete / bulkReplicate`. Handler-style: iterate
- * `ctx.records`, run policy per-row (parallelized via
- * `forEachAllowed`), call the matching Resource / Model method. No new
- * routes — the existing `/_action/:actionName` dispatcher already
- * handles bulk via `ctx.records`.
- *
- * Drop into `bulkActions([...])` from inside `Resource.table()`. Each
- * returns a notification with the count succeeded; rows whose policy
- * denied (or whose call threw) are silently skipped — surface them
- * via your own logging if needed. When no rows succeed (empty
- * selection, all denied, all threw) the handler emits a `'warning'`
- * toast instead of misleading "0 X deleted" success.
- *
- * See `docs/plans/action-split.md` for the split plan.
- */
-
-import { Action, type ReplicateOptions, type ResourceLike } from './Action.js'
-import { buildReplica, callPredicate, forEachAllowed } from './factoryHelpers.js'
-
-/** Pick the right label form for a count — `labelSingular` for 1,
- *  `label` (plural, lowercased) for any other count. Fall back to a
- *  naive `${labelSingular}s` when no plural label is set. Used by bulk
- *  notification copy so we don't ship "1 posts moved to trash". */
-function labelForCount(R: ResourceLike, n: number): string {
-  if (n === 1) return R.labelSingular.toLowerCase()
-  const plural = R.label?.toLowerCase()
-  return plural ?? `${R.labelSingular.toLowerCase()}s`
-}
-
-/** Bulk delete — calls `R.deleteRecord(id)` per row. On a
- *  soft-delete resource that hits `Model.delete()` which writes
- *  `deletedAt`. Notification: "N posts moved to trash" / "N posts
- *  deleted" depending on `R.softDeletes`. */
-export function bulkDeleteAction(R: ResourceLike, _basePath: string): Action {
-  return Action.make('bulkDelete')
-    .label('Delete selected')
-    .destructive()
-    .bulk()
-    .confirm(`Delete the selected ${labelForCount(R, 0)}?`)
-    .handler(async (ctx) => {
-      const records = ctx.records ?? []
-      const Rfull = R as ResourceLike & { deleteRecord(id: string): Promise<void> }
-      const verb = R.softDeletes ? 'moved to trash' : 'deleted'
-      const n = await forEachAllowed(
-        records,
-        (record) => callPredicate(R.canDelete, ctx.user, record),
-        async (id) => { await Rfull.deleteRecord(id) },
-      )
-      if (n === 0) {
-        return { notify: { title: `Nothing to delete (no permitted rows)`, type: 'warning' } as never }
-      }
-      return { notify: { title: `${n} ${labelForCount(R, n)} ${verb}`, type: 'success' } as never }
-    })
-}
-
-/** Bulk restore — calls `R.model.restore(id)` per row. Visible only
- *  on soft-delete resources (the entire bulk-restore concept is
- *  specific to them). */
-export function bulkRestoreAction(R: ResourceLike, _basePath: string): Action {
-  return Action.make('bulkRestore')
-    .label('Restore selected')
-    .color('success')
-    .bulk()
-    .confirm(`Restore the selected ${labelForCount(R, 0)}?`)
-    .handler(async (ctx) => {
-      const Rfull = R as ResourceLike & { model?: { restore?(id: string | number): Promise<unknown> } }
-      const restore = Rfull.model?.restore
-      if (!restore) {
-        return { notify: { title: 'Restore not configured', type: 'error' } as never }
-      }
-      const records = ctx.records ?? []
-      const n = await forEachAllowed(
-        records,
-        (record) => callPredicate(R.canRestore, ctx.user, record),
-        async (id) => { await restore(id) },
-      )
-      if (n === 0) {
-        return { notify: { title: `Nothing to restore (no permitted rows)`, type: 'warning' } as never }
-      }
-      return { notify: { title: `${n} ${labelForCount(R, n)} restored`, type: 'success' } as never }
-    })
-}
-
-/** Bulk force-delete — calls `R.model.forceDelete(id)` per row. Same
- *  destructive confirm as the per-row variant. Visible only on
- *  soft-delete resources. */
-export function bulkForceDeleteAction(R: ResourceLike, _basePath: string): Action {
-  return Action.make('bulkForceDelete')
-    .label('Delete forever')
-    .destructive()
-    .bulk()
-    .confirm(`Permanently delete the selected ${labelForCount(R, 0)}? This cannot be undone.`)
-    .handler(async (ctx) => {
-      const Rfull = R as ResourceLike & { model?: { forceDelete?(id: string | number): Promise<void> } }
-      const forceDelete = Rfull.model?.forceDelete
-      if (!forceDelete) {
-        return { notify: { title: 'Force-delete not configured', type: 'error' } as never }
-      }
-      const records = ctx.records ?? []
-      const n = await forEachAllowed(
-        records,
-        (record) => callPredicate(R.canForceDelete, ctx.user, record),
-        async (id) => { await forceDelete(id) },
-      )
-      if (n === 0) {
-        return { notify: { title: `Nothing to delete (no permitted rows)`, type: 'warning' } as never }
-      }
-      return { notify: { title: `${n} ${labelForCount(R, n)} permanently deleted`, type: 'success' } as never }
-    })
-}
-
-/**
- * Bulk replicate — calls `R.model.create(...)` once per selected row
- * with the source row's attributes minus PK / soft-delete column /
- * `opts.excludeAttributes`. Optional `opts.beforeReplicaSaved(replica,
- * source)` runs per-row. Rows that throw during create are skipped
- * silently so a single bad row doesn't abort the batch (the user sees
- * the success count on the toast). Visibility delegates to
- * `R.canCreate(user)`.
- *
- * Sibling of `replicateAction` — same options bag, same strip set,
- * same authorization gate. Stays on the list page (no per-row
- * redirect possible for N rows).
- */
-export function bulkReplicateAction(
-  R:        ResourceLike,
-  _basePath: string,
-  opts:     ReplicateOptions = {},
-): Action {
-  return Action.make('bulkReplicate')
-    .label('Replicate selected')
-    .bulk()
-    .confirm(`Replicate the selected ${labelForCount(R, 0)}?`)
-    .handler(async (ctx) => {
-      const M = R.model
-      if (!M || typeof M.create !== 'function') {
-        return { notify: { title: 'Replicate not configured (resource has no model.create)', type: 'error' } as never }
-      }
-      const records = ctx.records ?? []
-      // Per-row predicate eval preserved — `canCreate` ignores the record
-      // in the common case, but users may write stateful predicates that
-      // gate per-attempt.
-      const n = await forEachAllowed(
-        records,
-        () => callPredicate(R.canCreate, ctx.user),
-        async (_id, source) => {
-          const { replica } = await buildReplica(source, M, {
-            excludeAttributes:  opts.excludeAttributes,
-            deletedAtColumn:    R.deletedAtColumn,
-            beforeReplicaSaved: opts.beforeReplicaSaved,
-          })
-          await M.create(replica)
-        },
-      )
-      if (n === 0) {
-        return { notify: { title: `Nothing to replicate (no permitted rows)`, type: 'warning' } as never }
-      }
-      const defaultTitle = `${n} ${labelForCount(R, n)} replicated`
-      const overrideTitle = opts.getCreatedNotificationTitle
-        ? await opts.getCreatedNotificationTitle({ count: n, records })
-        : undefined
-      const title = overrideTitle !== undefined ? overrideTitle : defaultTitle
-      return { notify: { title, type: 'success' } as never }
-    })
-    .visible(({ user }) => callPredicate(R.canCreate, user))
-}