@stacksjs/defaults 0.74.33 → 0.74.34

package/ai/skills/stacks-auto-imports/SKILL.md

@@ -66,7 +66,7 @@ globalThis.toggleDark = toggleDark
 - **Custom Functions**: From `resources/functions/` (counter, dark mode, GPX, geo utilities)
 
 ### Server Auto-Imports (100+)
-- **All ORM Models**: User, Post, Author, Product, Order, Payment, Customer, etc. (100 models)
+- **All ORM Models**: User, Post, Author, Product, Order, Payment, Customer, etc. (102 models)
 - **Request Models**: UserRequest, PostRequest, OrderRequest, etc.
 - **Actions**: Action types and helpers
 - **Schema**: validation schema builder

package/ai/skills/stacks-dashboard/SKILL.md

@@ -61,6 +61,66 @@ dashboard data Actions.
 - `/content/comments` - comment moderation
 - `/content/files`, `/content/blog`, `/content/seo` - files, blog operations, and SEO
 
+### The file manager's two layers (stacksjs/stacks#2577)
+
+Worth knowing before adding anything to it, because the split is not obvious
+from the endpoints:
+
+- **Storage operations** map to a `StorageAdapter` method and go straight to the
+  disk: list, upload, create folder, rename, visibility, duplicate, delete.
+- **Metadata** - favourites and tags - has nowhere to live on a disk (extended
+  attributes do not survive a copy; S3 object metadata is set at write time, so
+  starring a 2 GB video would rewrite 2 GB). It lives in `storage_items`, keyed
+  by `(disk, path)`, written by `PUT /files/favorite` and `PUT /files/tags`.
+
+**The disk is authoritative and the table is advisory.** The listing comes from
+the disk and rows are joined onto it, so a path with no row is a file with
+nothing recorded - which is most files. Renames and deletes made THROUGH the
+dashboard reconcile eagerly (a folder is a prefix update, because moving a
+folder moves everything under it); a completed listing sweeps rows for paths it
+did not see, which is free because the walk already enumerated them. A TRUNCATED
+listing sweeps nothing - it has not proved a path is absent.
+
+A file renamed outside the dashboard loses its metadata, and that is by design:
+a rename and a copy-then-delete are the same two events to a bucket listing, so
+reconciling would be guessing.
+
+### The media pipeline (stacksjs/stacks#2578)
+
+None of the three things an upload might need can happen inside the request: a
+transcode is minutes, a vision call is a round trip to a third party. So an
+upload dispatches and the dashboard shows state.
+
+- `storage_item_tasks`, one row per `(disk, path, kind)`, kind being
+  `optimize` (images, via `ts-images`), `transcode` (video, via `ts-videos`) or
+  `tag` (a vision model). They succeed and fail independently, which is why this
+  is not a column on `storage_items` - a video whose transcode finished and
+  whose tagging failed is a normal state.
+- `dispatchDashboardFileTasks` decides from the CONTENT TYPE what a file needs.
+  Most uploads are documents and get nothing. A transcode waits for a video
+  profile, because the ladder is derived from the source dimensions.
+- A dispatch failure is RECORDED, not thrown: a queue that is down leaves a
+  visible failure rather than an upload that fails or a file that is silently
+  never processed.
+- `runTask` owns the queued -> running -> done/failed transitions so the three
+  jobs cannot disagree about them. It rethrows after recording, because the row
+  and the queue answer different questions - the queue decides whether to retry,
+  the row is what somebody looking at the file sees.
+- `POST /files/reprocess` re-runs everything, or the kinds you name.
+
+Derivatives are written back to the same disk under `.variants/<path>/`. The
+leading dot keeps them out of the listing, which skips hidden components - a
+folder of thirty derivatives beside every photo makes the browser useless.
+
+**There is no ffmpeg.** #2578 asked whether video was in scope given the
+external binary, its licensing and its provisioning; `@stacksjs/video` is built
+on `ts-videos`, which encodes itself, so that question was already answered.
+
+Tags go through `taggables` + `taggable_models` with `taggable_type =
+'storage_items'` - the trait the CMS already uses. Do NOT declare a
+`belongsToMany` to the `Tag` model for this: `taggable_models.tag_id` resolves
+against `taggables`, which is a different table from `tags`.
+
 ### Data Management
 - `/data/dashboard` - data overview
 - `/data/users` - user management

package/ai/skills/stacks-orm/SKILL.md

@@ -11,7 +11,7 @@ allowed-tools: Read Edit Write Bash Grep Glob
 ## Key Paths
 - Core ORM package: `storage/framework/core/orm/src/`
 - ORM implementation: `storage/framework/orm/`
-- Model definitions: `storage/framework/defaults/app/Models/` (100 models)
+- Model definitions: `storage/framework/defaults/app/Models/` (102 models)
 - Application models: `app/Models/`
 - Default model templates: `storage/framework/defaults/app/Models/`
 - ORM type globals: `storage/framework/types/orm-globals.d.ts`

package/ai/skills/stacks-storage/SKILL.md

@@ -8,7 +8,7 @@ allowed-tools: Read Edit Write Bash Grep Glob
 
 # Stacks Storage
 
-File system abstraction with a Laravel-style Storage facade, local/S3 adapters, file upload handling, and low-level file utilities.
+File system abstraction with a Laravel-style Storage facade, local/S3/Azure adapters, file upload handling, and low-level file utilities.
 
 ## Key Paths
 - Core package: `storage/framework/core/storage/src/`
@@ -18,6 +18,8 @@ File system abstraction with a Laravel-style Storage facade, local/S3 adapters,
 - Filesystem config types: `storage/framework/core/storage/src/types/filesystem.ts`
 - Local adapter: `storage/framework/core/storage/src/adapters/local.ts`
 - S3 adapter: `storage/framework/core/storage/src/adapters/s3.ts`
+- Azure adapter: `storage/framework/core/storage/src/adapters/azure.ts`
+- Azure request signing: `storage/framework/core/storage/src/azure-signing.ts`
 - Memory adapter: `storage/framework/core/storage/src/adapters/memory.ts`
 - Bun adapter: `storage/framework/core/storage/src/adapters/bun.ts`
 - File utilities: `storage/framework/core/storage/src/files.ts`
@@ -45,7 +47,7 @@ import { createLocalStorage, LocalStorageAdapter } from '@stacksjs/storage'
 import { createS3Storage, S3StorageAdapter } from '@stacksjs/storage'
 
 // Config helpers
-import { localDisk, s3Disk, configFromEnv } from '@stacksjs/storage'
+import { localDisk, s3Disk, azureDisk, r2Disk, gcsDisk, filebaseDisk, backblazeDisk, hetznerDisk, configFromEnv } from '@stacksjs/storage'
 
 // Types
 import type { StorageAdapter, FileContents, StatEntry, DirectoryEntry, DirectoryListing } from '@stacksjs/storage'
@@ -233,6 +235,46 @@ const s3 = new S3StorageAdapter(client, { bucket: 'my-bucket', region: 'us-east-
 - `list()` supports pagination via continuation tokens; `deep: true` uses `listAllObjects()`
 - `fileExists()` uses `headObject()` and catches 404/NoSuchKey/NotFound errors
 
+Every S3-COMPATIBLE provider is an `s3` disk with a different endpoint, and has
+a preset that fills it in: `r2Disk(bucket, accountId)`, `gcsDisk(bucket)`,
+`filebaseDisk(bucket)`, `backblazeDisk(bucket, region)`,
+`hetznerDisk(bucket, location)`. R2 additionally needs `url` set, because its
+API host never serves public objects.
+
+### Azure Adapter (`AzureBlobStorageAdapter`)
+
+```typescript
+import { azureDisk, AzureBlobStorageAdapter } from '@stacksjs/storage'
+
+const azure = new AzureBlobStorageAdapter({
+  account: 'mystorageaccount',
+  accountKey: process.env.AZURE_STORAGE_ACCOUNT_KEY,
+  container: 'uploads',
+  prefix: 'tenant-7',
+})
+```
+
+Its own driver rather than an `s3` disk with an endpoint, because Azure is the
+one provider with no S3-compatible API.
+
+- Speaks the blob REST API over `fetch`; no SDK, and no lazy-client dance
+- Shared Key authorization for server-side calls, service SAS for signed URLs,
+  both in `azure-signing.ts` and tested there directly
+- `changeVisibility()` THROWS -- Azure has no per-blob ACL. Public access is a
+  container property, so `visibility()` reports the container's level, and a
+  per-object grant is `signedUrl()`
+- `putStream()` stages blocks (Put Block) and commits one Put Block List, so the
+  write is atomic; block ids are zero-padded to a fixed width because Azure
+  rejects unequal-length ids
+- `getStream()` is genuinely incremental, unlike the S3 adapter's buffered one
+- `createDirectory()` is a no-op and `deleteDirectory()` deletes by prefix, same
+  as S3
+- `endpoint` defaults to `https://<account>.blob.core.windows.net`; point it at
+  `http://127.0.0.1:10000/devstoreaccount1` for Azurite
+- A `sasToken` disk can read and write but cannot sign URLs -- minting a SAS
+  needs the account key, and re-serving the configured token would hand out its
+  full grant
+
 ## File Uploads (UploadedFile)
 
 ```typescript
@@ -490,8 +532,8 @@ interface ChecksumOptions {
 }
 
 // Filesystem config types
-type FilesystemDriver = 'local' | 's3'
-type DiskConfig = LocalDiskConfig | S3DiskConfig
+type FilesystemDriver = 'local' | 's3' | 'azure'
+type DiskConfig = LocalDiskConfig | S3DiskConfig | AzureDiskConfig
 
 interface LocalDiskConfig {
   driver: 'local'
@@ -512,6 +554,18 @@ interface S3DiskConfig {
   visibility?: 'public' | 'private'
 }
 
+interface AzureDiskConfig {
+  driver: 'azure'
+  account: string
+  container: string
+  accountKey?: string
+  sasToken?: string
+  prefix?: string
+  url?: string
+  endpoint?: string
+  visibility?: 'public' | 'private'
+}
+
 interface FilesystemConfig {
   default: string
   disks: Record<string, DiskConfig>

package/app/Actions/Dashboard/Content/FileFavoriteAction.ts

@@ -0,0 +1,25 @@
+import type { RequestInstance } from '@stacksjs/types'
+import { Action } from '@stacksjs/actions'
+import { response } from '@stacksjs/router'
+import { DashboardFileError, setDashboardFileFavorite } from './file-manager'
+
+export default new Action({
+  name: 'FileFavoriteAction',
+  description: 'Stars or unstars a file or directory on a configured storage disk.',
+  method: 'PUT',
+  async handle(request: RequestInstance) {
+    try {
+      const result = await setDashboardFileFavorite({
+        disk: String(request.get('disk', 'public')),
+        path: request.get('path'),
+        favorite: request.get('favorite'),
+      })
+      return response.json(result)
+    }
+    catch (error) {
+      if (error instanceof DashboardFileError)
+        return response.json({ message: error.message, fields: error.fields }, error.status)
+      throw error
+    }
+  },
+})

package/app/Actions/Dashboard/Content/FileReprocessAction.ts

@@ -0,0 +1,31 @@
+import type { RequestInstance } from '@stacksjs/types'
+import { Action } from '@stacksjs/actions'
+import { response } from '@stacksjs/router'
+import { DashboardFileError, reprocessDashboardFile } from './file-manager'
+
+export default new Action({
+  name: 'FileReprocessAction',
+  description: 'Re-runs the background processing for a file: image variants, video renditions, AI tags.',
+  method: 'POST',
+  async handle(request: RequestInstance) {
+    try {
+      const result = await reprocessDashboardFile({
+        disk: String(request.get('disk', 'public')),
+        path: request.get('path'),
+        // Omit to run every kind the file's content type calls for; name kinds
+        // to re-run just one, which is what a failed transcode beside a
+        // successful tagging wants.
+        kinds: request.get('kinds'),
+        // A transcode derives its ladder from the source dimensions, so it only
+        // runs when the caller supplies them.
+        videoProfile: request.get('profile'),
+      })
+      return response.json(result)
+    }
+    catch (error) {
+      if (error instanceof DashboardFileError)
+        return response.json({ message: error.message, fields: error.fields }, error.status)
+      throw error
+    }
+  },
+})

package/app/Actions/Dashboard/Content/FileTagsAction.ts

@@ -0,0 +1,27 @@
+import type { RequestInstance } from '@stacksjs/types'
+import { Action } from '@stacksjs/actions'
+import { response } from '@stacksjs/router'
+import { DashboardFileError, setDashboardFileTags } from './file-manager'
+
+export default new Action({
+  name: 'FileTagsAction',
+  description: 'Replaces the tags on a file or directory on a configured storage disk.',
+  method: 'PUT',
+  async handle(request: RequestInstance) {
+    try {
+      const result = await setDashboardFileTags({
+        disk: String(request.get('disk', 'public')),
+        path: request.get('path'),
+        // The whole set, not a delta: a UI that can add a tag can also remove
+        // one, and there is no separate signal for a removal.
+        tags: request.get('tags'),
+      })
+      return response.json(result)
+    }
+    catch (error) {
+      if (error instanceof DashboardFileError)
+        return response.json({ message: error.message, fields: error.fields }, error.status)
+      throw error
+    }
+  },
+})

package/app/Actions/Dashboard/Content/file-manager.test.ts

@@ -3,6 +3,7 @@ import { mkdir, mkdtemp, rm } from 'node:fs/promises'
 import { tmpdir } from 'node:os'
 import { join } from 'node:path'
 import { StorageManager } from '@stacksjs/storage'
+import { createMemoryMetadataStore } from './file-metadata'
 import {
   createDashboardDirectory,
   deleteDashboardFile,
@@ -18,8 +19,27 @@ import {
 
 let root = ''
 let manager: StorageManager
+/**
+ * The metadata layer, in memory (stacksjs/stacks#2577).
+ *
+ * These tests build a real disk in a temp directory; the metadata store is the
+ * one collaborator that would otherwise pull a database in, so it is injected
+ * the same way the storage manager already is.
+ */
+let store = createMemoryMetadataStore()
+/**
+ * A dispatcher that records instead of queueing (stacksjs/stacks#2578). These
+ * tests are about the storage operations, not the pipeline, and a real queue
+ * would make them depend on a worker.
+ */
+let dispatched: Array<{ job: string, payload: Record<string, unknown> }> = []
+const dispatch = async (job: string, payload: Record<string, unknown>): Promise<void> => {
+  dispatched.push({ job, payload })
+}
 
 beforeEach(async () => {
+  store = createMemoryMetadataStore()
+  dispatched = []
   root = await mkdtemp(join(tmpdir(), 'stacks-dashboard-files-'))
   await mkdir(join(root, 'public'), { recursive: true })
   manager = new StorageManager().init({
@@ -47,7 +67,7 @@ describe('dashboard file manager', () => {
     await disk.write('images/logo.png', new Uint8Array([137, 80, 78, 71]))
     await disk.write('.hidden/secret.txt', 'not listed')
 
-    const snapshot = await getDashboardFileSnapshot({}, manager)
+    const snapshot = await getDashboardFileSnapshot({}, manager, store)
     const documents = snapshot.root.items?.find(item => item.path === 'documents')
     const readme = documents?.items?.find(item => item.path === 'documents/readme.txt')
 
@@ -74,7 +94,7 @@ describe('dashboard file manager', () => {
     await manager.disk('public').write('one.txt', '1')
     await manager.disk('public').write('two.txt', '2')
 
-    const snapshot = await getDashboardFileSnapshot({ maxEntries: 1 }, manager)
+    const snapshot = await getDashboardFileSnapshot({ maxEntries: 1 }, manager, store)
 
     expect(snapshot.truncated).toBe(true)
     expect(snapshot.stats.files).toBe(1)
@@ -94,7 +114,7 @@ describe('dashboard file manager', () => {
       throw new Error('metadata unavailable')
     }
 
-    await expect(getDashboardFileSnapshot({}, manager))
+    await expect(getDashboardFileSnapshot({}, manager, store))
       .rejects
       .toThrow('Metadata for storage file "unreadable.txt" could not be read')
   })
@@ -106,7 +126,7 @@ describe('dashboard file manager', () => {
       throw new Error('URL unavailable')
     }
 
-    const snapshot = await getDashboardFileSnapshot({}, manager)
+    const snapshot = await getDashboardFileSnapshot({}, manager, store)
     expect(snapshot.stats.files).toBe(1)
     expect(snapshot.warnings).toEqual(['Public URL for "document.txt" could not be resolved.'])
   })
@@ -116,10 +136,10 @@ describe('dashboard file manager', () => {
     expect(await manager.disk('public').directoryExists('Product shots')).toBe(true)
 
     await manager.disk('public').write('Product shots/photo.jpg', 'photo')
-    await deleteDashboardFile({ path: 'Product shots/photo.jpg' }, manager)
+    await deleteDashboardFile({ path: 'Product shots/photo.jpg' }, manager, store)
     expect(await manager.disk('public').fileExists('Product shots/photo.jpg')).toBe(false)
 
-    await deleteDashboardFile({ path: 'Product shots' }, manager)
+    await deleteDashboardFile({ path: 'Product shots' }, manager, store)
     expect(await manager.disk('public').directoryExists('Product shots')).toBe(false)
   })
 
@@ -130,14 +150,14 @@ describe('dashboard file manager', () => {
       bytes: async () => new TextEncoder().encode(contents),
     })
 
-    const uploaded = await uploadDashboardFiles({ path: 'documents', files: [file('first')] }, manager)
+    const uploaded = await uploadDashboardFiles({ path: 'documents', files: [file('first')] }, manager, store, dispatch)
     expect(uploaded[0]).toMatchObject({
       path: 'documents/release_notes.txt',
       url: '/storage/documents/release_notes.txt',
       size: 5,
     })
 
-    await expect(uploadDashboardFiles({ path: 'documents', files: [file('second')] }, manager))
+    await expect(uploadDashboardFiles({ path: 'documents', files: [file('second')] }, manager, store, dispatch))
       .rejects
       .toThrow('File already exists: documents/release_notes.txt')
     expect(await manager.disk('public').readToString('documents/release_notes.txt')).toBe('first')
@@ -153,7 +173,7 @@ describe('dashboard file manager', () => {
 
     await expect(uploadDashboardFiles({
       files: [file('new.txt', 'new'), file('duplicate.txt', 'replacement')],
-    }, manager)).rejects.toThrow('No files from this upload were kept')
+    }, manager, store, dispatch)).rejects.toThrow('No files from this upload were kept')
 
     expect(await manager.disk('public').fileExists('new.txt')).toBe(false)
     expect(await manager.disk('public').readToString('duplicate.txt')).toBe('existing')
@@ -172,7 +192,7 @@ describe('renameDashboardFile', () => {
     const disk = manager.disk('public')
     await disk.write('documents/readme.txt', 'hello')
 
-    const result = await renameDashboardFile({ path: 'documents/readme.txt', name: 'guide.txt' }, manager)
+    const result = await renameDashboardFile({ path: 'documents/readme.txt', name: 'guide.txt' }, manager, store)
 
     expect(result).toEqual({ from: 'documents/readme.txt', to: 'documents/guide.txt', type: 'file', moved: 1 })
     expect(await disk.fileExists('documents/guide.txt')).toBe(true)
@@ -184,7 +204,7 @@ describe('renameDashboardFile', () => {
     const disk = manager.disk('public')
     await disk.write('notes.txt', 'top level')
 
-    expect(await renameDashboardFile({ path: 'notes.txt', name: 'todo.txt' }, manager))
+    expect(await renameDashboardFile({ path: 'notes.txt', name: 'todo.txt' }, manager, store))
       .toEqual({ from: 'notes.txt', to: 'todo.txt', type: 'file', moved: 1 })
     expect(await disk.readToString('todo.txt')).toBe('top level')
   })
@@ -197,9 +217,9 @@ describe('renameDashboardFile', () => {
   test('refuses a name that is really a path', async () => {
     await manager.disk('public').write('a/b.txt', 'x')
 
-    await expect(renameDashboardFile({ path: 'a/b.txt', name: '../escaped.txt' }, manager))
+    await expect(renameDashboardFile({ path: 'a/b.txt', name: '../escaped.txt' }, manager, store))
       .rejects.toMatchObject({ status: 422 })
-    await expect(renameDashboardFile({ path: 'a/b.txt', name: 'nested/deep.txt' }, manager))
+    await expect(renameDashboardFile({ path: 'a/b.txt', name: 'nested/deep.txt' }, manager, store))
       .rejects.toMatchObject({ status: 422 })
   })
 
@@ -208,7 +228,7 @@ describe('renameDashboardFile', () => {
     await disk.write('images/logo.png', 'a')
     await disk.write('images/icons/favicon.png', 'b')
 
-    const result = await renameDashboardFile({ path: 'images', name: 'media' }, manager)
+    const result = await renameDashboardFile({ path: 'images', name: 'media' }, manager, store)
 
     expect(result).toEqual({ from: 'images', to: 'media', type: 'directory', moved: 2 })
     expect(await disk.readToString('media/logo.png')).toBe('a')
@@ -222,7 +242,7 @@ describe('renameDashboardFile', () => {
     await disk.write('documents/readme.txt', 'keep me')
     await disk.write('documents/guide.txt', 'me too')
 
-    await expect(renameDashboardFile({ path: 'documents/readme.txt', name: 'guide.txt' }, manager))
+    await expect(renameDashboardFile({ path: 'documents/readme.txt', name: 'guide.txt' }, manager, store))
       .rejects.toMatchObject({ status: 409 })
     // Neither side moved: a refused rename is not a partial one.
     expect(await disk.readToString('documents/readme.txt')).toBe('keep me')
@@ -232,12 +252,12 @@ describe('renameDashboardFile', () => {
   test('says so rather than silently doing nothing when the name is unchanged', async () => {
     await manager.disk('public').write('a.txt', 'x')
 
-    await expect(renameDashboardFile({ path: 'a.txt', name: 'a.txt' }, manager))
+    await expect(renameDashboardFile({ path: 'a.txt', name: 'a.txt' }, manager, store))
       .rejects.toMatchObject({ status: 422 })
   })
 
   test('is a 404 when the item does not exist', async () => {
-    await expect(renameDashboardFile({ path: 'nope.txt', name: 'yes.txt' }, manager))
+    await expect(renameDashboardFile({ path: 'nope.txt', name: 'yes.txt' }, manager, store))
       .rejects.toMatchObject({ status: 404 })
   })
 })
@@ -301,7 +321,7 @@ describe('duplicateDashboardFile', () => {
     const disk = manager.disk('public')
     await disk.write('documents/readme.txt', 'hello')
 
-    const result = await duplicateDashboardFile({ path: 'documents/readme.txt' }, manager)
+    const result = await duplicateDashboardFile({ path: 'documents/readme.txt' }, manager, store)
 
     // `readme.txt copy` is a file whose type the OS, the browser and this
     // dashboard's own type grouping would all read as unknown.
@@ -314,18 +334,18 @@ describe('duplicateDashboardFile', () => {
     const disk = manager.disk('public')
     await disk.write('a.txt', 'x')
 
-    expect((await duplicateDashboardFile({ path: 'a.txt' }, manager)).to).toBe('a copy.txt')
-    expect((await duplicateDashboardFile({ path: 'a.txt' }, manager)).to).toBe('a copy 2.txt')
-    expect((await duplicateDashboardFile({ path: 'a.txt' }, manager)).to).toBe('a copy 3.txt')
+    expect((await duplicateDashboardFile({ path: 'a.txt' }, manager, store)).to).toBe('a copy.txt')
+    expect((await duplicateDashboardFile({ path: 'a.txt' }, manager, store)).to).toBe('a copy 2.txt')
+    expect((await duplicateDashboardFile({ path: 'a.txt' }, manager, store)).to).toBe('a copy 3.txt')
   })
 
   test('takes an explicit name when given one', async () => {
     await manager.disk('public').write('a.txt', 'x')
 
-    expect((await duplicateDashboardFile({ path: 'a.txt', name: 'b.txt' }, manager)).to).toBe('b.txt')
-    await expect(duplicateDashboardFile({ path: 'a.txt', name: 'b.txt' }, manager))
+    expect((await duplicateDashboardFile({ path: 'a.txt', name: 'b.txt' }, manager, store)).to).toBe('b.txt')
+    await expect(duplicateDashboardFile({ path: 'a.txt', name: 'b.txt' }, manager, store))
       .rejects.toMatchObject({ status: 409 })
-    await expect(duplicateDashboardFile({ path: 'a.txt', name: '../escaped.txt' }, manager))
+    await expect(duplicateDashboardFile({ path: 'a.txt', name: '../escaped.txt' }, manager, store))
       .rejects.toMatchObject({ status: 422 })
   })
 
@@ -334,7 +354,7 @@ describe('duplicateDashboardFile', () => {
     await disk.write('images/logo.png', 'a')
     await disk.write('images/icons/favicon.png', 'b')
 
-    const result = await duplicateDashboardFile({ path: 'images' }, manager)
+    const result = await duplicateDashboardFile({ path: 'images' }, manager, store)
 
     expect(result).toEqual({ from: 'images', to: 'images copy', type: 'directory', copied: 2 })
     expect(await disk.readToString('images copy/logo.png')).toBe('a')
@@ -352,12 +372,12 @@ describe('duplicateDashboardFile', () => {
     await disk.write('media/one.txt', '1')
     await disk.write('media/two.txt', '2')
 
-    expect((await duplicateDashboardFile({ path: 'media' }, manager)).copied).toBe(2)
+    expect((await duplicateDashboardFile({ path: 'media' }, manager, store)).copied).toBe(2)
     expect(await disk.fileExists('media copy/media copy/one.txt')).toBe(false)
   })
 
   test('is a 404 when the item does not exist', async () => {
-    await expect(duplicateDashboardFile({ path: 'nope.txt' }, manager))
+    await expect(duplicateDashboardFile({ path: 'nope.txt' }, manager, store))
       .rejects.toMatchObject({ status: 404 })
   })
 })