@modern-admin/feature-upload 0.1.0

package/src/providers/local.ts

@@ -0,0 +1,63 @@
+/**
+ * LocalUploadProvider — stores files on the local filesystem.
+ *
+ * Files are written to `uploadDir` with a UUID-based filename to avoid
+ * collisions. Set `baseUrl` to the public URL prefix where the directory is
+ * served as static files (e.g. `'/uploads'` or `'http://localhost:3000/uploads'`).
+ *
+ * @example
+ * new LocalUploadProvider({ uploadDir: './public/uploads', baseUrl: '/uploads' })
+ */
+
+import { mkdir, writeFile, unlink } from 'node:fs/promises'
+import { join, extname, dirname } from 'node:path'
+import { uuidv7 } from '@modern-admin/core'
+import type { IUploadProvider, UploadedFile } from '../types.js'
+
+export interface LocalUploadOptions {
+  /**
+   * Absolute or process-relative path to the directory where files are stored.
+   * Created automatically on first upload.
+   */
+  uploadDir: string
+  /**
+   * Public URL prefix (without trailing slash) where uploaded files can be
+   * accessed. Used to construct the `url` returned by the upload endpoint and
+   * the `urlTemplate` for the frontend.
+   *
+   * @example '/uploads'
+   * @example 'https://static.example.com/uploads'
+   */
+  baseUrl?: string
+}
+
+export class LocalUploadProvider implements IUploadProvider {
+  constructor(private readonly options: LocalUploadOptions) {}
+
+  async upload(file: UploadedFile, key?: string): Promise<string> {
+    const resolvedKey = key ?? `${uuidv7()}${extname(file.originalName)}`
+    const dest = join(this.options.uploadDir, resolvedKey)
+    // Create the full directory tree (handles nested keys like 'avatars/2024/01/uuid.jpg').
+    await mkdir(dirname(dest), { recursive: true })
+    await writeFile(dest, file.buffer)
+    return resolvedKey
+  }
+
+  getUrl(key: string): string {
+    const base = this.options.baseUrl ?? '/uploads'
+    return `${base}/${key}`
+  }
+
+  async delete(key: string): Promise<void> {
+    try {
+      await unlink(join(this.options.uploadDir, key))
+    } catch (err) {
+      if ((err as NodeJS.ErrnoException).code !== 'ENOENT') throw err
+    }
+  }
+
+  urlTemplate(): string {
+    const base = this.options.baseUrl ?? '/uploads'
+    return `${base}/{key}`
+  }
+}

package/src/providers/s3.ts

@@ -0,0 +1,226 @@
+/**
+ * S3UploadProvider — stores files in an AWS S3 bucket (or any S3-compatible
+ * service such as MinIO, Cloudflare R2, DigitalOcean Spaces, etc.).
+ *
+ * Requires `@aws-sdk/client-s3` to be installed in the host project.
+ * For streaming multipart upload of large files, also install `@aws-sdk/lib-storage`.
+ * For pre-signed URLs (private buckets), install `@aws-sdk/s3-request-presigner`.
+ *
+ * @example AWS S3 — public bucket
+ * new S3UploadProvider({ bucket: 'my-bucket', region: 'us-east-1', acl: 'public-read' })
+ *
+ * @example AWS S3 — private bucket with pre-signed URLs (60 min expiry)
+ * new S3UploadProvider({ bucket: 'my-bucket', region: 'us-east-1', signed: { expiresIn: 3600 } })
+ *
+ * @example MinIO / custom endpoint
+ * new S3UploadProvider({
+ *   bucket: 'my-bucket',
+ *   region: 'us-east-1',
+ *   endpoint: 'http://localhost:9000',
+ *   forcePathStyle: true,
+ *   publicBaseUrl: 'http://localhost:9000/my-bucket',
+ * })
+ *
+ * @example Inject a pre-configured S3Client (share across providers)
+ * const s3 = new S3Client({ region: 'us-east-1' })
+ * new S3UploadProvider({ bucket: 'my-bucket', region: 'us-east-1' }, s3)
+ */
+
+import { extname } from 'node:path'
+import { uuidv7 } from '@modern-admin/core'
+import type { IUploadProvider, UploadedFile } from '../types.js'
+
+export interface S3UploadOptions {
+  /** S3 bucket name. */
+  bucket: string
+  /** AWS region (e.g. `'us-east-1'`). */
+  region: string
+  /** AWS access key id. Falls back to environment / credential chain. */
+  accessKeyId?: string
+  /** AWS secret access key. Falls back to environment / credential chain. */
+  secretAccessKey?: string
+  /**
+   * Custom endpoint for S3-compatible services.
+   * @example 'http://localhost:9000'
+   * @example 'https://nyc3.digitaloceanspaces.com'
+   */
+  endpoint?: string
+  /** Force path-style URLs (required for some MinIO / custom endpoint setups). */
+  forcePathStyle?: boolean
+  /** Optional key prefix / "folder". Without trailing slash. */
+  prefix?: string
+  /**
+   * Canned ACL applied to every uploaded object, e.g. `'public-read'`.
+   * Omit for private buckets — use `signed` instead.
+   */
+  acl?: string
+  /**
+   * Override the public base URL used for `getUrl()` and `urlTemplate()`.
+   * Useful when files are served via CloudFront or a custom CDN.
+   * Without trailing slash.
+   * @example 'https://cdn.example.com'
+   */
+  publicBaseUrl?: string
+  /**
+   * Generate pre-signed URLs instead of public URLs.
+   * Required for private S3 buckets. Needs `@aws-sdk/s3-request-presigner`.
+   *
+   * - `true` uses the default expiry (3600 s / 1 hour).
+   * - Pass `{ expiresIn: seconds }` to customise.
+   *
+   * When `signed` is set, `urlTemplate()` is not implemented (each URL is
+   * unique and time-limited) and `getUrl()` is async.
+   *
+   * @example
+   * signed: true          // 1-hour pre-signed URLs
+   * signed: { expiresIn: 60 * 60 * 24 }  // 24-hour pre-signed URLs
+   */
+  signed?: boolean | { expiresIn?: number }
+}
+
+export class S3UploadProvider implements IUploadProvider {
+
+  private _client: any = null
+
+  constructor(
+    private readonly options: S3UploadOptions,
+    // Accept a pre-configured S3Client instance (share across providers /
+    // inject in tests). When omitted the provider creates its own client.
+
+    private readonly injectedClient?: any,
+  ) {}
+
+
+  private async client(): Promise<any> {
+    if (this.injectedClient) return this.injectedClient
+    if (this._client) return this._client
+    let S3Client: unknown
+    try {
+      const mod = await import('@aws-sdk/client-s3' as string)
+      S3Client = (mod as { S3Client: unknown }).S3Client
+    } catch {
+      throw new Error(
+        '[modern-admin/feature-upload] S3UploadProvider requires @aws-sdk/client-s3. ' +
+          'Install it: bun add @aws-sdk/client-s3',
+      )
+    }
+    const cfg: Record<string, unknown> = {
+      region: this.options.region,
+      ...(this.options.endpoint ? { endpoint: this.options.endpoint } : {}),
+      ...(this.options.forcePathStyle ? { forcePathStyle: true } : {}),
+    }
+    if (this.options.accessKeyId && this.options.secretAccessKey) {
+      cfg.credentials = {
+        accessKeyId: this.options.accessKeyId,
+        secretAccessKey: this.options.secretAccessKey,
+      }
+    }
+    this._client = new (S3Client as new (cfg: Record<string, unknown>) => unknown)(cfg)
+    return this._client
+  }
+
+  async upload(file: UploadedFile, key?: string): Promise<string> {
+    const c = await this.client()
+    const ext = extname(file.originalName)
+    const prefix = this.options.prefix ? `${this.options.prefix}/` : ''
+    const resolvedKey = key ?? `${prefix}${uuidv7()}${ext}`
+
+    // Prefer @aws-sdk/lib-storage for streaming multipart uploads (large files).
+    // Fall back to PutObjectCommand if lib-storage is not installed.
+    try {
+      const libStorage = await import('@aws-sdk/lib-storage' as string)
+      const Upload = (libStorage as { Upload: new (i: Record<string, unknown>) => { done(): Promise<unknown> } }).Upload
+      const input: Record<string, unknown> = {
+        Bucket: this.options.bucket,
+        Key: resolvedKey,
+        Body: file.buffer,
+        ContentType: file.mimeType,
+      }
+      if (this.options.acl) input.ACL = this.options.acl
+      const uploader = new Upload({ client: c, params: input })
+      await uploader.done()
+    } catch (err) {
+      // lib-storage not installed — fall back to PutObjectCommand.
+      if ((err as { code?: string }).code === 'ERR_MODULE_NOT_FOUND' ||
+          String(err).includes('Cannot find module')) {
+        const sdk = await import('@aws-sdk/client-s3' as string)
+        const PutObjectCommand = (sdk as { PutObjectCommand: new (i: Record<string, unknown>) => unknown }).PutObjectCommand
+        const input: Record<string, unknown> = {
+          Bucket: this.options.bucket,
+          Key: resolvedKey,
+          Body: file.buffer,
+          ContentType: file.mimeType,
+          ContentLength: file.size,
+        }
+        if (this.options.acl) input.ACL = this.options.acl
+        await (c as { send: (cmd: unknown) => Promise<void> }).send(new PutObjectCommand(input))
+      } else {
+        throw err
+      }
+    }
+
+    return resolvedKey
+  }
+
+  async getUrl(key: string): Promise<string> {
+    if (this.options.signed) {
+      return this.signedUrl(key)
+    }
+    return `${this.publicBaseUrl()}/${key}`
+  }
+
+  async delete(key: string): Promise<void> {
+    try {
+      const sdk = await import('@aws-sdk/client-s3' as string)
+      const c = await this.client()
+      const DeleteObjectCommand = (sdk as { DeleteObjectCommand: new (i: Record<string, unknown>) => unknown }).DeleteObjectCommand
+      await (c as { send: (cmd: unknown) => Promise<void> }).send(
+        new DeleteObjectCommand({ Bucket: this.options.bucket, Key: key }),
+      )
+    } catch {
+      // Ignore — file may not exist.
+    }
+  }
+
+  /**
+   * URL template for the frontend. Only available when `signed` is NOT set
+   * (public buckets). For private buckets each URL is unique + time-limited,
+   * so the frontend must call the upload endpoint to get a fresh URL.
+   */
+  urlTemplate(): string | undefined {
+    if (this.options.signed) return undefined
+    return `${this.publicBaseUrl()}/{key}`
+  }
+
+  private async signedUrl(key: string): Promise<string> {
+    let getSignedUrl: unknown
+    try {
+      const mod = await import('@aws-sdk/s3-request-presigner' as string)
+      getSignedUrl = (mod as { getSignedUrl: unknown }).getSignedUrl
+    } catch {
+      throw new Error(
+        '[modern-admin/feature-upload] Signed URLs require @aws-sdk/s3-request-presigner. ' +
+          'Install it: bun add @aws-sdk/s3-request-presigner',
+      )
+    }
+    const sdk = await import('@aws-sdk/client-s3' as string)
+    const c = await this.client()
+    const GetObjectCommand = (sdk as { GetObjectCommand: new (i: Record<string, unknown>) => unknown }).GetObjectCommand
+    const expiresIn =
+      typeof this.options.signed === 'object'
+        ? (this.options.signed.expiresIn ?? 3600)
+        : 3600
+
+    return (getSignedUrl as (
+      client: unknown,
+      command: unknown,
+      opts: { expiresIn: number },
+    ) => Promise<string>)(c, new GetObjectCommand({ Bucket: this.options.bucket, Key: key }), { expiresIn })
+  }
+
+  private publicBaseUrl(): string {
+    if (this.options.publicBaseUrl) return this.options.publicBaseUrl
+    if (this.options.endpoint) return `${this.options.endpoint}/${this.options.bucket}`
+    return `https://${this.options.bucket}.s3.${this.options.region}.amazonaws.com`
+  }
+}

package/src/registry.ts

@@ -0,0 +1,39 @@
+/**
+ * Process-level upload provider registry.
+ *
+ * `uploadFeature()` registers upload configs here (keyed by a generated id) at
+ * feature application time. The NestJS `UploadController` looks up configs by
+ * the id stored in the property's `custom.uploadProviderId` field.
+ *
+ * The registry is intentionally a module-level singleton so it is available
+ * before the NestJS DI container is initialised — the same pattern used by
+ * `ModernAdminFeatureRegistry` in `@modern-admin/nest`.
+ */
+
+import type { IUploadProvider } from './types.js'
+
+/** Everything stored per upload property registration. */
+export interface RegisteredUploadConfig {
+  provider: IUploadProvider
+  /** Optional custom key generator (from `UploadPropertyConfig.uploadPath`). */
+  uploadPath?: (filename: string) => string
+  /** True for multi-file properties — controller will accept N files per request. */
+  isArray?: boolean
+}
+
+const _registry = new Map<string, RegisteredUploadConfig>()
+
+export const UploadProviderRegistry = {
+  register(id: string, config: RegisteredUploadConfig): void {
+    _registry.set(id, config)
+  },
+
+  get(id: string): RegisteredUploadConfig | undefined {
+    return _registry.get(id)
+  },
+
+  /** For test cleanup. */
+  clear(): void {
+    _registry.clear()
+  },
+}

package/src/types.ts

@@ -0,0 +1,137 @@
+/**
+ * Core types for the upload feature plugin.
+ *
+ * `IUploadProvider` is the single port contract that upload backends must
+ * implement. `LocalUploadProvider` and `S3UploadProvider` ship as built-in
+ * adapters; custom providers only need to implement these four methods.
+ */
+
+/** Parsed file data received from a multipart request. */
+export interface UploadedFile {
+  /** Original filename from the client. */
+  originalName: string
+  /** MIME type reported by the client (e.g. 'image/jpeg'). */
+  mimeType: string
+  /** File size in bytes. */
+  size: number
+  /** Raw file bytes. */
+  buffer: Buffer
+}
+
+/** Metadata returned by the upload endpoint. */
+export interface UploadedFileInfo {
+  /** Storage key (relative path or object key). Stored in the DB field. */
+  key: string
+  /** Public URL for browser display / download. */
+  url: string
+  /** Original filename. */
+  name: string
+  /** Size in bytes. */
+  size: number
+  /** MIME type. */
+  mimeType: string
+}
+
+/**
+ * Upload provider port. Implement this interface to add a new storage backend.
+ *
+ * @example
+ * class GcsUploadProvider implements IUploadProvider {
+ *   async upload(file) { ... }
+ *   getUrl(key) { ... }
+ *   async delete(key) { ... }
+ * }
+ */
+export interface IUploadProvider {
+  /**
+   * Upload a file and return its storage key.
+   * The key is the value that will be persisted in the database field.
+   *
+   * @param file  Parsed file data from the multipart request.
+   * @param key   Optional pre-computed storage key (from `uploadPath`). When
+   *              omitted the provider generates a key internally (UUID + extension).
+   */
+  upload(file: UploadedFile, key?: string): Promise<string>
+
+  /**
+   * Compute the public URL for a stored key. May be sync or async.
+   * Used both by the upload endpoint (to return the URL) and by the frontend
+   * URL template when `urlTemplate()` is not implemented.
+   */
+  getUrl(key: string): string | Promise<string>
+
+  /**
+   * Delete the file identified by `key`. Must not throw if the file does not
+   * exist (e.g. was already deleted or was never stored).
+   */
+  delete(key: string): Promise<void>
+
+  /**
+   * Optional URL template string for the frontend to construct display URLs
+   * from stored keys without calling the backend.
+   * Use `{key}` as the placeholder, e.g. `'https://cdn.example.com/{key}'`.
+   * Return `undefined` (or omit the method) when URLs cannot be statically
+   * computed (e.g. signed/pre-signed S3 URLs — each URL is unique and time-limited).
+   */
+  urlTemplate?(): string | undefined
+}
+
+/** Per-property upload configuration passed to `uploadFeature()`. */
+export interface UploadPropertyConfig {
+  /** Storage provider for this property. */
+  provider: IUploadProvider
+  /**
+   * Allowed MIME type patterns (same syntax as the HTML `accept` attribute).
+   * Examples: `['image/*']`, `['image/jpeg', 'application/pdf']`.
+   * Enforcement is advisory on the frontend; the controller does not re-validate.
+   */
+  mimeTypes?: string[]
+  /** Maximum upload size in bytes. Advisory (frontend warning only). */
+  maxSize?: number
+  /**
+   * Treat the property as an array of file keys (multi-file upload).
+   * When true, the property is stored as `string[]`, the editor allows
+   * uploading multiple files (a single multipart request can include several),
+   * and the action hooks diff arrays on edit and delete every key on delete.
+   */
+  isArray?: boolean
+  /**
+   * Custom storage key generator. Receives the original filename from the
+   * client and returns the key to use for storage.
+   *
+   * Use this to organise files into sub-directories, include the resource
+   * name, add timestamps, etc.  The provider's internal UUID generator is
+   * used when this is omitted.
+   *
+   * @example
+   * // avatars/2024/01/uuid.jpg
+   * uploadPath: (filename) => {
+   *   const ext = filename.split('.').pop()
+   *   const d = new Date()
+   *   return `avatars/${d.getFullYear()}/${String(d.getMonth()+1).padStart(2,'0')}/${uuidv7()}.${ext}`
+   * }
+   *
+   * @example
+   * // resource-specific prefix
+   * uploadPath: (filename) => `products/images/${uuidv7()}-${filename}`
+   */
+  uploadPath?: (filename: string) => string
+}
+
+/** Options passed to `uploadFeature()`. */
+export interface UploadFeatureOptions {
+  /**
+   * Map from property path to its upload configuration.
+   * Each entry makes the property a `type: 'file'` field wired to the
+   * specified provider.
+   *
+   * @example
+   * uploadFeature({
+   *   properties: {
+   *     avatar: { provider: new LocalUploadProvider({ uploadDir: './uploads', baseUrl: '/uploads' }) },
+   *     resume: { provider: new S3UploadProvider({ bucket: 'my-bucket', region: 'us-east-1' }), mimeTypes: ['application/pdf'] },
+   *   },
+   * })
+   */
+  properties: Record<string, UploadPropertyConfig>
+}

package/src/upload-feature.ts

@@ -0,0 +1,208 @@
+/**
+ * `uploadFeature` — resource plugin that wires file upload into any resource.
+ *
+ * Returns a `FeatureFn` that, when applied to a resource's `ResourceOptions`,
+ * marks the configured properties as `type: 'file'` (with `isArray` when
+ * configured), registers the upload providers in `UploadProviderRegistry`, and
+ * installs action hooks that:
+ *
+ *   - on `new.after` / `edit.after` — confirm freshly-uploaded keys against
+ *     `PendingUploadsRegistry` so the orphan sweeper leaves them alone;
+ *   - on `edit.after` — delete files whose key was replaced or removed
+ *     (single-value: old !== new; array: keys present in old but missing
+ *     from new);
+ *   - on `delete.after` — delete every file referenced by the deleted record.
+ *
+ * Hooks are **chained**, not replaced: if the incoming `ResourceOptions`
+ * already has hooks (e.g. from another feature), the upload hooks are
+ * appended so all hooks run in order.
+ *
+ * @example
+ * uploadFeature({
+ *   properties: {
+ *     thumbnail: { provider: localProvider, mimeTypes: ['image/*'] },
+ *     gallery:   { provider: localProvider, isArray: true, mimeTypes: ['image/*'] },
+ *   },
+ * })
+ */
+
+import { uuidv7, type ActionRequest, type ActionResponse, type FeatureFn, type ResourceOptions } from '@modern-admin/core'
+import type { UploadFeatureOptions, UploadPropertyConfig } from './types.js'
+import { UploadProviderRegistry } from './registry.js'
+import { PendingUploadsRegistry } from './pending-registry.js'
+
+interface RegisteredProp {
+  providerId: string
+  config: UploadPropertyConfig
+}
+
+// ─── Hook chaining ────────────────────────────────────────────────────────────
+
+type HookFn = (
+  response: ActionResponse,
+  request: ActionRequest,
+  context: unknown,
+) => ActionResponse | Promise<ActionResponse>
+
+/** Normalise a hook value (fn | fn[] | undefined) into an array. */
+function toArray(hook: unknown): HookFn[] {
+  if (!hook) return []
+  return Array.isArray(hook) ? (hook as HookFn[]) : [hook as HookFn]
+}
+
+/**
+ * Merge `after` hooks from an existing action override with new hooks,
+ * producing an array that runs all of them in order.
+ * If `existing` already defines `after`, the new hooks are appended.
+ */
+function mergeAfterHook(
+  existing: Record<string, unknown> | undefined,
+  newHook: HookFn,
+): HookFn[] {
+  const existing_after = toArray(existing?.after)
+  return [...existing_after, newHook]
+}
+
+// ─── Value helpers ────────────────────────────────────────────────────────────
+
+/** Return non-empty file keys for the given value (handles single + array). */
+function toKeys(value: unknown): string[] {
+  if (value == null || value === '') return []
+  if (Array.isArray(value)) {
+    return value.flatMap((v) => (v == null || v === '' ? [] : [String(v)]))
+  }
+  return [String(value)]
+}
+
+// ─── Feature function ─────────────────────────────────────────────────────────
+
+export function uploadFeature(options: UploadFeatureOptions): FeatureFn {
+  // Register configs immediately — before the FeatureFn is called.
+  const registered = new Map<string, RegisteredProp>()
+
+  for (const [propPath, config] of Object.entries(options.properties)) {
+    const providerId = `up_${uuidv7().replace(/-/g, '')}`
+    UploadProviderRegistry.register(providerId, {
+      provider: config.provider,
+      uploadPath: config.uploadPath,
+      isArray: config.isArray ?? false,
+    })
+    registered.set(propPath, { providerId, config })
+  }
+
+  return (resourceOptions: ResourceOptions): ResourceOptions => {
+    // --- Property overrides ---
+    const propOverrides: ResourceOptions['properties'] = {}
+    for (const [propPath, { providerId, config }] of registered) {
+      // S3 with signed URLs has no static URL template.
+      const urlTmpl = config.provider.urlTemplate?.() ?? null
+      propOverrides[propPath] = {
+        type: 'file',
+        ...(config.isArray ? { isArray: true } : {}),
+        custom: {
+          uploadProviderId: providerId,
+          uploadUrlTemplate: urlTmpl,
+          uploadMimeTypes: config.mimeTypes ?? null,
+          uploadMaxSize: config.maxSize ?? null,
+        },
+      }
+    }
+
+    // --- Action hooks ---
+
+    // After new: confirm every freshly-uploaded key against the pending registry.
+    const newAfterHook: HookFn = (
+      response: ActionResponse,
+      _request: ActionRequest,
+      _context: unknown,
+    ): ActionResponse => {
+      const rec = response as { record?: { params?: Record<string, unknown> } }
+      const params = rec.record?.params ?? {}
+      const newKeys: string[] = []
+      for (const propPath of registered.keys()) {
+        newKeys.push(...toKeys(params[propPath]))
+      }
+      if (newKeys.length > 0) PendingUploadsRegistry.confirm(newKeys)
+      return response
+    }
+
+    // After edit: delete keys that disappeared and confirm keys that arrived.
+    const editAfterHook: HookFn = async (
+      response: ActionResponse,
+      _request: ActionRequest,
+      context: unknown,
+    ): Promise<ActionResponse> => {
+      const ctx = context as { record?: { get(path: string): unknown } }
+      const rec = response as { record?: { params?: Record<string, unknown> } }
+      const params = rec.record?.params ?? {}
+      for (const [propPath, { config }] of registered) {
+        const oldKeys = new Set(toKeys(ctx.record?.get(propPath)))
+        const newKeys = toKeys(params[propPath])
+        // Confirm new keys (possibly fresh uploads).
+        if (newKeys.length > 0) PendingUploadsRegistry.confirm(newKeys)
+        // Delete keys that were present before and are gone now.
+        const newSet = new Set(newKeys)
+        for (const k of oldKeys) {
+          if (!newSet.has(k)) {
+            try {
+              await config.provider.delete(k)
+            } catch {
+              // Non-fatal — don't break the action response.
+            }
+          }
+        }
+      }
+      return response
+    }
+
+    // After delete: delete every file referenced by the (now-removed) record.
+    const deleteAfterHook: HookFn = async (
+      response: ActionResponse,
+      _request: ActionRequest,
+      context: unknown,
+    ): Promise<ActionResponse> => {
+      const ctx = context as { record?: { get(path: string): unknown } }
+      for (const [propPath, { config }] of registered) {
+        const keys = toKeys(ctx.record?.get(propPath))
+        for (const k of keys) {
+          try {
+            await config.provider.delete(k)
+          } catch {
+            // Non-fatal.
+          }
+        }
+      }
+      return response
+    }
+
+    // Retrieve any existing action overrides so we can chain, not replace.
+    const existingActions = resourceOptions.actions as Record<string, Record<string, unknown>> | undefined
+    const existingNew = existingActions?.['new']
+    const existingEdit = existingActions?.['edit']
+    const existingDelete = existingActions?.['delete']
+
+    const actionOverrides = {
+      new: {
+        ...existingNew,
+        after: mergeAfterHook(existingNew, newAfterHook),
+      },
+      edit: {
+        ...existingEdit,
+        after: mergeAfterHook(existingEdit, editAfterHook),
+      },
+      delete: {
+        ...existingDelete,
+        after: mergeAfterHook(existingDelete, deleteAfterHook),
+      },
+    } as ResourceOptions['actions']
+
+    return {
+      ...resourceOptions,
+      properties: { ...resourceOptions.properties, ...propOverrides },
+      actions: {
+        ...(resourceOptions.actions ?? {}),
+        ...actionOverrides,
+      },
+    }
+  }
+}