@nixxie-cms/core 1.0.3 → 2.0.0

package/src/list-features.ts

@@ -0,0 +1,476 @@
+/**
+ * Declarative collection features compiled into hooks + access-control filters by
+ * `defineCollection()`: computed fields, constraints, default filters, state machines,
+ * policies, events, search indexing and version snapshots.
+ *
+ * Everything here builds on the public hook/access surface — no resolver internals —
+ * so the features compose with mixins and user hooks via the same merge pipeline.
+ */
+import type { CollectionHooks } from './types'
+import type { MaybePromise } from './types/utils'
+
+type AnyArgs = any
+
+// ── Option types ──
+
+/**
+ * Persisted derived fields, recalculated on every create/update after all other
+ * `resolveInput` hooks have run. The target keys must be real fields on the collection
+ * (unlike `virtual()` fields, computed values are stored — so they can be filtered and
+ * sorted). `merged` is the item's prospective state (existing values + this write).
+ *
+ * @example
+ * computed: { total: ({ merged }) => merged.price * merged.quantity }
+ */
+export type ComputedConfig = Record<
+  string,
+  (args: {
+    operation: 'create' | 'update'
+    resolvedData: Record<string, any>
+    /** Existing item values overlaid with this operation's resolved data. */
+    merged: Record<string, any>
+    item: Record<string, any> | undefined
+    context: any
+  }) => MaybePromise<unknown>
+>
+
+/**
+ * Data-integrity rules checked before every create/update.
+ *
+ * - `uniqueTogether`: compound uniqueness over scalar fields (e.g. `[['tenant', 'slug']]`).
+ *   Checked with a query, so add a DB index for hot paths.
+ * - `checks`: named cross-field rules; return an error message to reject the write.
+ *
+ * @example
+ * constraints: {
+ *   uniqueTogether: [['translationKey', 'locale']],
+ *   checks: { dates: ({ merged }) => merged.endDate <= merged.startDate ? 'endDate must be after startDate' : undefined },
+ * }
+ */
+export type ConstraintsConfig = {
+  uniqueTogether?: string[][]
+  checks?: Record<
+    string,
+    (args: {
+      operation: 'create' | 'update'
+      resolvedData: Record<string, any>
+      merged: Record<string, any>
+      item: Record<string, any> | undefined
+      context: any
+    }) => MaybePromise<string | undefined | void>
+  >
+}
+
+/**
+ * A where-filter automatically ANDed into every query/update/delete — including the
+ * Admin UI, which respects access filters. This is what makes `withSoftDelete()` real:
+ *
+ * @example
+ * defaultFilter: { deletedAt: null }
+ * @example
+ * defaultFilter: ({ session }) => session?.data?.isAdmin ? true : { status: { equals: 'published' } }
+ */
+export type DefaultFilterConfig =
+  | Record<string, unknown>
+  | ((args: { session?: any; context: any }) => MaybePromise<boolean | Record<string, unknown>>)
+
+/**
+ * Enforce legal status transitions on a select field at the mutation layer.
+ *
+ * @example
+ * stateMachine: {
+ *   field: 'status',
+ *   transitions: { draft: ['review'], review: ['published', 'draft'], published: ['archived'] },
+ *   guards: { 'review->published': ({ session }) => session?.data?.role === 'editor' || 'Only editors can publish' },
+ * }
+ */
+export type StateMachineConfig = {
+  /** The (select) field holding the state. */
+  field: string
+  /** Allowed transitions: from-state → list of reachable states. */
+  transitions: Record<string, string[]>
+  /**
+   * Optional guards keyed `"from->to"`. Return `false` to block (generic message)
+   * or a string to block with that message.
+   */
+  guards?: Record<
+    string,
+    (args: {
+      item: Record<string, any>
+      resolvedData: Record<string, any>
+      context: any
+      session?: any
+    }) => MaybePromise<boolean | string>
+  >
+  /** States allowed on create. Omit to allow any state on create. */
+  initial?: string | string[]
+}
+
+/** One row-level access rule: the first rule whose `when` matches decides the filter. */
+export type PolicyRule = {
+  /** Does this rule apply to the session? (e.g. `session => session?.data?.role === 'editor'`) */
+  when: (session: any) => boolean
+  /** `true` = unrestricted, `false` = no access, object = where-filter, function = computed filter. */
+  filter:
+    | boolean
+    | Record<string, unknown>
+    | ((session: any) => boolean | Record<string, unknown>)
+}
+
+/**
+ * Declarative row-level access: per operation, rules are evaluated in order and the
+ * first matching `when` supplies the filter; no match means no access. ANDed with any
+ * explicit `access.filter` you also configure. Pairs naturally with @nixxie-cms/rbac.
+ *
+ * @example
+ * policies: {
+ *   query: [
+ *     { when: s => s?.data?.role === 'admin', filter: true },
+ *     { when: s => !!s, filter: s => ({ author: { id: { equals: s.itemId } } }) },
+ *   ],
+ * }
+ */
+export type PoliciesConfig = Partial<Record<'query' | 'update' | 'delete', PolicyRule[]>>
+
+/**
+ * Emit lifecycle events through `context.services.webhooks` after every write:
+ * `<prefix>.created` / `.updated` / `.deleted` (prefix defaults to the list key).
+ * No-op when the webhooks service is not configured.
+ */
+export type EventsConfig =
+  | true
+  | {
+      /** Event name prefix. @default the list key */
+      prefix?: string
+      operations?: ('create' | 'update' | 'delete')[]
+      /** Customise the event payload. @default { listKey, id, item } */
+      payload?: (args: AnyArgs) => unknown
+    }
+
+/**
+ * Keep a search index in sync through `context.services.search`: documents are indexed
+ * after create/update and removed after delete. No-op when search is not configured.
+ */
+export type SearchableConfig =
+  | true
+  | {
+      /** Index name. @default the list key lowercased */
+      index?: string
+      /** Item fields copied into the document. @default all scalar values on the item */
+      fields?: string[]
+    }
+
+/**
+ * Snapshot every create/update into `context.services.versioning` (resource = list key).
+ * No-op when versioning is not configured.
+ */
+export type VersionedConfig =
+  | true
+  | {
+      /** Optional label for each snapshot. */
+      label?: (args: AnyArgs) => string | undefined
+    }
+
+export type ListFeaturesConfig = {
+  computed?: ComputedConfig
+  constraints?: ConstraintsConfig
+  defaultFilter?: DefaultFilterConfig
+  stateMachine?: StateMachineConfig
+  policies?: PoliciesConfig
+  events?: EventsConfig
+  searchable?: SearchableConfig
+  versioned?: VersionedConfig
+}
+
+// ── Compilation to hooks ──
+
+const mergedView = (args: AnyArgs): Record<string, any> => ({
+  ...(args.item ?? {}),
+  ...(args.resolvedData ?? {}),
+})
+
+function computedHooks(computed: ComputedConfig): Partial<CollectionHooks<any>> {
+  return {
+    resolveInput: async (args: AnyArgs) => {
+      const out = { ...args.resolvedData }
+      for (const [field, fn] of Object.entries(computed)) {
+        out[field] = await fn({
+          operation: args.operation,
+          resolvedData: out,
+          merged: { ...(args.item ?? {}), ...out },
+          item: args.item,
+          context: args.context,
+        })
+      }
+      return out
+    },
+  }
+}
+
+function constraintsHooks(constraints: ConstraintsConfig): Partial<CollectionHooks<any>> {
+  return {
+    validate: async (args: AnyArgs) => {
+      const { operation, addValidationError } = args
+      if (operation === 'delete') return
+      const merged = mergedView(args)
+
+      for (const tuple of constraints.uniqueTogether ?? []) {
+        const values = tuple.map(field => merged[field])
+        // Incomplete tuples (a NULL member) are not checked — same semantics as SQL unique indexes.
+        if (values.some(value => value === undefined || value === null)) continue
+        const where: Record<string, any> = {}
+        tuple.forEach((field, i) => (where[field] = { equals: values[i] }))
+        try {
+          const clashes = await args.context.sudo().db[args.listKey].findMany({ where, take: 2 })
+          const other = clashes.find(
+            (clash: any) => !args.item || String(clash.id) !== String(args.item.id)
+          )
+          if (other) {
+            addValidationError(`Another item already exists with the same ${tuple.join(' + ')}`)
+          }
+        } catch (err) {
+          // A malformed tuple (unknown/non-scalar field) should fail loudly, not silently pass.
+          addValidationError(
+            `uniqueTogether check for (${tuple.join(', ')}) failed: ${err instanceof Error ? err.message : err}`
+          )
+        }
+      }
+
+      for (const check of Object.values(constraints.checks ?? {})) {
+        const message = await check({
+          operation: args.operation,
+          resolvedData: args.resolvedData,
+          merged,
+          item: args.item,
+          context: args.context,
+        })
+        if (typeof message === 'string' && message.length > 0) addValidationError(message)
+      }
+    },
+  }
+}
+
+function stateMachineHooks(machine: StateMachineConfig): Partial<CollectionHooks<any>> {
+  const { field, transitions, guards = {} } = machine
+  const initial =
+    machine.initial === undefined
+      ? undefined
+      : Array.isArray(machine.initial)
+        ? machine.initial
+        : [machine.initial]
+  return {
+    validate: async (args: AnyArgs) => {
+      const { operation, resolvedData, item, addValidationError } = args
+      if (operation === 'delete') return
+      const next = resolvedData?.[field]
+      if (next === undefined) return
+
+      if (operation === 'create') {
+        if (initial && next != null && !initial.includes(next)) {
+          addValidationError(
+            `"${field}" cannot start as "${next}" (allowed: ${initial.join(', ')})`
+          )
+        }
+        return
+      }
+
+      const previous = item?.[field]
+      if (next === previous) return
+      const allowed = transitions[previous] ?? []
+      if (!allowed.includes(next)) {
+        addValidationError(
+          `"${field}" cannot change from "${previous}" to "${next}"` +
+            (allowed.length ? ` (allowed: ${allowed.join(', ')})` : ' (no transitions from this state)')
+        )
+        return
+      }
+      const guard = guards[`${previous}->${next}`]
+      if (guard) {
+        const verdict = await guard({
+          item,
+          resolvedData,
+          context: args.context,
+          session: args.context?.session,
+        })
+        if (verdict !== true) {
+          addValidationError(
+            typeof verdict === 'string'
+              ? verdict
+              : `"${field}" transition "${previous}" → "${next}" was blocked`
+          )
+        }
+      }
+    },
+  }
+}
+
+const pastTense = { create: 'created', update: 'updated', delete: 'deleted' } as const
+
+function eventsHooks(events: EventsConfig): Partial<CollectionHooks<any>> {
+  const options = events === true ? {} : events
+  const operations = options.operations ?? ['create', 'update', 'delete']
+  return {
+    afterOperation: async (args: AnyArgs) => {
+      if (!operations.includes(args.operation)) return
+      const webhooks = args.context?.services?.webhooks
+      if (!webhooks) return
+      try {
+        const subject = args.item ?? args.originalItem
+        const event = `${options.prefix ?? args.listKey}.${pastTense[args.operation as keyof typeof pastTense]}`
+        const payload = options.payload
+          ? await options.payload(args)
+          : { listKey: args.listKey, id: subject?.id != null ? String(subject.id) : undefined, item: subject }
+        await webhooks.trigger(event, payload)
+      } catch (err) {
+        console.error(`[nixxie] events: failed to emit for ${args.listKey}:`, err)
+      }
+    },
+  }
+}
+
+/** Copy the indexable scalar values off an item (used when `fields` is not specified). */
+function scalarDocument(item: Record<string, any>): Record<string, unknown> {
+  const doc: Record<string, unknown> = {}
+  for (const [key, value] of Object.entries(item)) {
+    if (key.startsWith('__')) continue
+    if (value === null) doc[key] = null
+    else if (value instanceof Date) doc[key] = value.toISOString()
+    else if (['string', 'number', 'boolean'].includes(typeof value)) doc[key] = value
+  }
+  return doc
+}
+
+function searchableHooks(searchable: SearchableConfig): Partial<CollectionHooks<any>> {
+  const options = searchable === true ? {} : searchable
+  return {
+    afterOperation: async (args: AnyArgs) => {
+      const search = args.context?.services?.search
+      if (!search) return
+      const indexName = options.index ?? String(args.listKey).toLowerCase()
+      try {
+        if (args.operation === 'delete') {
+          await search.remove(indexName, String(args.originalItem.id))
+          return
+        }
+        const item = args.item
+        const picked = options.fields
+          ? Object.fromEntries(
+              options.fields.map(field => [
+                field,
+                item[field] instanceof Date ? item[field].toISOString() : item[field],
+              ])
+            )
+          : scalarDocument(item)
+        await search.index(indexName, { ...picked, id: String(item.id) })
+      } catch (err) {
+        console.error(`[nixxie] searchable: failed to sync index "${indexName}":`, err)
+      }
+    },
+  }
+}
+
+function versionedHooks(versioned: VersionedConfig): Partial<CollectionHooks<any>> {
+  const options = versioned === true ? {} : versioned
+  return {
+    afterOperation: async (args: AnyArgs) => {
+      if (args.operation === 'delete') return
+      const versioning = args.context?.services?.versioning
+      if (!versioning) return
+      try {
+        const session = args.context?.session
+        await versioning.snapshot({
+          resource: args.listKey,
+          resourceId: String(args.item.id),
+          data: scalarSafe(args.item),
+          label: options.label?.(args),
+          actor: session?.itemId != null ? { id: String(session.itemId) } : undefined,
+        })
+      } catch (err) {
+        console.error(`[nixxie] versioned: failed to snapshot ${args.listKey}:`, err)
+      }
+    },
+  }
+}
+
+/** Snapshot-safe clone: keeps JSON-representable values, ISO-stringifies dates. */
+function scalarSafe(item: Record<string, any>): Record<string, unknown> {
+  const out: Record<string, unknown> = {}
+  for (const [key, value] of Object.entries(item)) {
+    if (value instanceof Date) out[key] = value.toISOString()
+    else if (typeof value === 'bigint') out[key] = value.toString()
+    else if (typeof value !== 'function' && typeof value !== 'symbol') out[key] = value
+  }
+  return out
+}
+
+/** Compile the declarative features into hook fragments, in a deliberate order. */
+export function compileFeatureHooks(features: ListFeaturesConfig): Array<Partial<CollectionHooks<any>>> {
+  const hooks: Array<Partial<CollectionHooks<any>>> = []
+  if (features.computed) hooks.push(computedHooks(features.computed))
+  if (features.constraints) hooks.push(constraintsHooks(features.constraints))
+  if (features.stateMachine) hooks.push(stateMachineHooks(features.stateMachine))
+  if (features.events) hooks.push(eventsHooks(features.events))
+  if (features.searchable) hooks.push(searchableHooks(features.searchable))
+  if (features.versioned) hooks.push(versionedHooks(features.versioned))
+  return hooks
+}
+
+// ── Compilation to access filters ──
+
+type FilterValue = boolean | Record<string, unknown>
+type FilterLike = FilterValue | ((args: any) => MaybePromise<FilterValue>)
+
+/** AND two access filters; `true`/missing means unrestricted, `false` wins outright. */
+function andFilters(a: FilterLike | undefined, b: FilterLike): FilterLike {
+  if (a === undefined) return b
+  return async (args: any) => {
+    const ra = typeof a === 'function' ? await a(args) : a
+    const rb = typeof b === 'function' ? await b(args) : b
+    if (ra === false || rb === false) return false
+    if (ra === true) return rb
+    if (rb === true) return ra
+    return { AND: [ra, rb] }
+  }
+}
+
+function policyFilter(rules: PolicyRule[]): FilterLike {
+  return ({ session }: any) => {
+    for (const rule of rules) {
+      if (!rule.when(session)) continue
+      return typeof rule.filter === 'function' ? rule.filter(session) : rule.filter
+    }
+    return false
+  }
+}
+
+/**
+ * Merge `defaultFilter` and `policies` into an access-control object. Existing filters
+ * are preserved and ANDed with the feature filters.
+ */
+export function applyAccessFeatures(
+  access: any,
+  features: Pick<ListFeaturesConfig, 'defaultFilter' | 'policies'>
+): any {
+  const { defaultFilter, policies } = features
+  if (!defaultFilter && !policies) return access
+
+  const filter = { ...(access?.filter ?? {}) }
+  for (const operation of ['query', 'update', 'delete'] as const) {
+    let merged: FilterLike | undefined = filter[operation]
+    if (defaultFilter) {
+      merged = andFilters(
+        merged,
+        typeof defaultFilter === 'function'
+          ? (args: any) => defaultFilter({ session: args.session, context: args.context })
+          : (defaultFilter as Record<string, unknown>)
+      )
+    }
+    const rules = policies?.[operation]
+    if (rules?.length) {
+      merged = andFilters(merged, policyFilter(rules))
+    }
+    if (merged !== undefined) filter[operation] = merged
+  }
+
+  return { ...(access ?? {}), filter }
+}

package/src/schema.ts

@@ -1,26 +1,80 @@
 import type { ListenOptions } from 'node:net'
 
+import { validateEnv } from './lib/env'
 import { idFieldType } from './lib/id-field'
 import type {
   Action,
   ActionArgsConfig,
   BaseFields,
   BaseNixxieTypeInfo,
-  BaseListTypeInfo,
+  BaseCollectionTypeInfo,
   DeclaredAction,
   IdFieldConfig,
   NixxieConfig,
   NixxieConfigPre,
   NixxieContext,
-  ListConfig,
+  CollectionConfig,
   MaybeItemFunctionWithFilter,
   MaybeSessionFunction,
   MaybeSessionFunctionWithFilter,
 } from './types'
 
+/**
+ * Fold `config.plugins` into the config: merge plugin collections (key conflicts throw),
+ * run each plugin's `extendConfig`, and chain plugin `onConnect`s before `db.onConnect`.
+ */
+function applyPlugins<TypeInfo extends BaseNixxieTypeInfo>(
+  config: NixxieConfigPre<TypeInfo>
+): NixxieConfigPre<TypeInfo> {
+  const plugins = config.plugins ?? []
+  if (!plugins.length) return config
+
+  const seen = new Set<string>()
+  for (const plugin of plugins) {
+    if (!plugin.name) throw new Error('Every plugin must have a `name`')
+    if (seen.has(plugin.name)) throw new Error(`Duplicate plugin name "${plugin.name}"`)
+    seen.add(plugin.name)
+  }
+
+  let next: NixxieConfigPre<TypeInfo> = { ...config, collections: { ...config.collections } }
+  for (const plugin of plugins) {
+    for (const [key, collection] of Object.entries(plugin.collections ?? {})) {
+      if (key in next.collections) {
+        throw new Error(
+          `Plugin "${plugin.name}" adds the collection "${key}", but a collection with that key already exists`
+        )
+      }
+      next.collections[key] = collection
+    }
+    if (plugin.extendConfig) {
+      next = plugin.extendConfig(next)
+      if (!next) {
+        throw new Error(`Plugin "${plugin.name}".extendConfig must return the config`)
+      }
+    }
+  }
+
+  const onConnects = plugins.flatMap(plugin => (plugin.onConnect ? [plugin.onConnect] : []))
+  if (onConnects.length) {
+    const userOnConnect = next.db.onConnect
+    next = {
+      ...next,
+      db: {
+        ...next.db,
+        onConnect: async context => {
+          for (const fn of onConnects) await fn(context)
+          await userOnConnect?.(context)
+        },
+      },
+    }
+  }
+
+  return next
+}
+
 function listsWithDefaults(config: NixxieConfigPre, defaultIdField: IdFieldConfig) {
   // some error checking
-  for (const [listKey, list] of Object.entries(config.lists)) {
+  for (const [listKey, list] of Object.entries(config.collections)) {
     if (list.fields.id) {
       throw new Error(
         `"fields.id" is reserved by Nixxie, use "db.idField" for the "${listKey}" list`
@@ -34,7 +88,7 @@ function listsWithDefaults(config: NixxieConfigPre, defaultIdField: IdFieldConfi
 
   return Object.fromEntries([
     ...(function* () {
-      for (const [listKey, list] of Object.entries(config.lists)) {
+      for (const [listKey, list] of Object.entries(config.collections)) {
         yield [
           listKey,
           {
@@ -42,6 +96,7 @@ function listsWithDefaults(config: NixxieConfigPre, defaultIdField: IdFieldConfi
             defaultIsFilterable: true, // TODO: move to access control?
             defaultIsOrderable: true, // TODO: move to access control?
             isSingleton: false,
+            cascade: [],
             ...list,
             db: {
               ...list.db,
@@ -86,9 +141,12 @@ function identity<T>(x: T) {
   return x
 }
 
-export function config<TypeInfo extends BaseNixxieTypeInfo>(
+export function buildConfig<TypeInfo extends BaseNixxieTypeInfo>(
   config: NixxieConfigPre<TypeInfo>
 ): NixxieConfig<TypeInfo> {
+  if (config.env) validateEnv(config.env)
+  config = applyPlugins(config)
+
   if (!['postgresql', 'sqlite', 'mysql'].includes(config.db.provider)) {
     throw new TypeError(`"db.provider" only supports "sqlite", "postgresql" or "mysql"`)
   }
@@ -162,6 +220,12 @@ export function config<TypeInfo extends BaseNixxieTypeInfo>(
     search: config.search,
     notifications: config.notifications,
     ai: config.ai,
+    aiRag: config.aiRag,
+    versioning: config.versioning,
+    workflow: config.workflow,
+    apiKeys: config.apiKeys,
+    logger: config.logger,
+    backup: config.backup,
     telemetry: config.telemetry ?? true,
     ui: {
       ...config.ui,
@@ -177,34 +241,38 @@ export function config<TypeInfo extends BaseNixxieTypeInfo>(
 
 let i = 0
 
-export type GroupInfo<ListTypeInfo extends BaseListTypeInfo> = {
+export type GroupInfo<CollectionTypeInfo extends BaseCollectionTypeInfo> = {
   fields: string[]
   label: string
   description: string
-  ui: GroupUIConfig<ListTypeInfo> | undefined
+  ui: GroupUIConfig<CollectionTypeInfo> | undefined
 }
 
-type GroupUIConfig<ListTypeInfo extends BaseListTypeInfo> = {
+type GroupUIConfig<CollectionTypeInfo extends BaseCollectionTypeInfo> = {
   createView?: {
-    defaultFieldMode?: MaybeSessionFunctionWithFilter<'hidden' | 'edit', 'hidden', ListTypeInfo>
+    defaultFieldMode?: MaybeSessionFunctionWithFilter<
+      'hidden' | 'edit',
+      'hidden',
+      CollectionTypeInfo
+    >
   }
   itemView?: {
     defaultFieldMode?: MaybeItemFunctionWithFilter<
       'edit' | 'hidden' | 'read',
       'hidden' | 'read',
-      ListTypeInfo
+      CollectionTypeInfo
     >
   }
   listView?: {
-    defaultFieldMode?: MaybeSessionFunction<'read' | 'hidden', ListTypeInfo>
+    defaultFieldMode?: MaybeSessionFunction<'read' | 'hidden', CollectionTypeInfo>
   }
 }
 
-export function group<ListTypeInfo extends BaseListTypeInfo>(config: {
+export function fieldGroup<CollectionTypeInfo extends BaseCollectionTypeInfo>(config: {
   label: string
   description?: string
-  ui?: GroupUIConfig<ListTypeInfo>
-  fields: BaseFields<ListTypeInfo>
+  ui?: GroupUIConfig<CollectionTypeInfo>
+  fields: BaseFields<CollectionTypeInfo>
 }) {
   const keys = Object.keys(config.fields)
   if (keys.some(key => key.startsWith('__group'))) {
@@ -217,21 +285,23 @@ export function group<ListTypeInfo extends BaseListTypeInfo>(config: {
       label: config.label,
       description: config.description ?? '',
       ui: config.ui,
-    } satisfies GroupInfo<ListTypeInfo>,
+    } satisfies GroupInfo<CollectionTypeInfo>,
     ...config.fields,
-  } as BaseFields<ListTypeInfo> // TODO: FIXME, see initialise-lists.ts:getListsWithInitialisedFields
+  } as BaseFields<CollectionTypeInfo> // TODO: FIXME, see initialise-lists.ts:getListsWithInitialisedFields
 }
 
-export function list<ListTypeInfo extends BaseListTypeInfo>(listConfig: ListConfig<ListTypeInfo>) {
+export function collection<CollectionTypeInfo extends BaseCollectionTypeInfo>(
+  listConfig: CollectionConfig<CollectionTypeInfo>
+) {
   return { ...listConfig }
 }
 
-export function action<
-  ListTypeInfo extends BaseListTypeInfo,
-  Args extends ActionArgsConfig<ListTypeInfo> | undefined = undefined,
->(action: Action<ListTypeInfo, Args>): DeclaredAction<ListTypeInfo> {
+export function createAction<
+  CollectionTypeInfo extends BaseCollectionTypeInfo,
+  Args extends ActionArgsConfig<CollectionTypeInfo> | undefined = undefined,
+>(action: Action<CollectionTypeInfo, Args>): DeclaredAction<CollectionTypeInfo> {
   return {
     ...action,
     ___defineActionsWithActionFunction: true,
-  } as unknown as DeclaredAction<ListTypeInfo>
+  } as unknown as DeclaredAction<CollectionTypeInfo>
 }