@sanity/cli 6.0.0-alpha.4 → 6.0.0-alpha.5

package/dist/commands/documents/__tests__/create.test.js

@@ -3,7 +3,7 @@ import fs from 'node:fs/promises';
 import os from 'node:os';
 import path from 'node:path';
 import { runCommand } from '@oclif/test';
-import { getCliConfig, getProjectCliClient } from '@sanity/cli-core';
+import { getProjectCliClient } from '@sanity/cli-core';
 import { testCommand } from '@sanity/cli-test';
 import { watch as chokidarWatch } from 'chokidar';
 import { execa, execaSync } from 'execa';
@@ -23,24 +23,13 @@ vi.mock('node:crypto', async ()=>{
         randomUUID: vi.fn()
     };
 });
-vi.mock('../../../../../cli-core/src/config/findProjectRoot.js', ()=>({
-        findProjectRoot: vi.fn().mockResolvedValue({
-            directory: '/test/path',
-            root: '/test/path',
-            type: 'studio'
-        })
-    }));
-vi.mock('../../../../../cli-core/src/config/cli/getCliConfig.js', ()=>({
-        getCliConfig: vi.fn()
-    }));
-vi.mock('../../../../../cli-core/src/services/getCliToken.js', ()=>({
-        getCliToken: vi.fn().mockResolvedValue('test-token')
-    }));
-vi.mock('../../../../../cli-core/src/services/apiClient.js', ()=>({
+vi.mock('@sanity/cli-core', async ()=>{
+    const actual = await vi.importActual('@sanity/cli-core');
+    return {
+        ...actual,
         getProjectCliClient: vi.fn()
-    }));
-const mockGetCliConfig = vi.mocked(getCliConfig);
-const mockGetProjectCliClient = vi.mocked(getProjectCliClient);
+    };
+});
 const mockFs = vi.mocked(fs);
 const mockOs = vi.mocked(os);
 const mockChokidarWatch = vi.mocked(chokidarWatch);
@@ -48,6 +37,7 @@ const mockExeca = vi.mocked(execa);
 const mockExecaSync = vi.mocked(execaSync);
 const mockJson5 = vi.mocked(json5);
 const mockRandomUUID = vi.mocked(randomUUID);
+const mockGetProjectCliClient = vi.mocked(getProjectCliClient);
 const testProjectId = 'test-project';
 const testDataset = 'production';
 // Helper to set environment variable for tests
@@ -68,32 +58,17 @@ const baseConfig = {
         projectId: testProjectId
     }
 };
-// Helper functions moved to outer scope to fix linting
-const setupBaseMocks = (additionalConfig = {})=>{
-    mockGetCliConfig.mockResolvedValue({
-        ...baseConfig,
-        ...additionalConfig
-    });
-};
-const setupMocks = ()=>{
-    setupBaseMocks();
-    const mockClient = {
-        transaction: vi.fn().mockReturnValue({
-            commit: vi.fn().mockResolvedValue({
-                results: [
-                    {
-                        id: 'test-doc',
-                        operation: 'create'
-                    }
-                ]
-            })
-        })
-    };
-    mockGetProjectCliClient.mockResolvedValue(mockClient);
-    return mockClient;
+const defaultMocks = {
+    cliConfig: baseConfig,
+    projectRoot: {
+        directory: '/test/path',
+        path: '/test/path/sanity.config.ts',
+        type: 'studio'
+    },
+    token: 'test-token'
 };
+// Helper functions
 const setupEditorMocks = ()=>{
-    setupBaseMocks();
     mockOs.tmpdir.mockReturnValue('/tmp');
     mockFs.mkdir.mockResolvedValue(undefined);
     mockFs.writeFile.mockResolvedValue(undefined);
@@ -101,7 +76,6 @@ const setupEditorMocks = ()=>{
     mockExecaSync.mockReturnValue(undefined);
 };
 const setupWatchMocks = ()=>{
-    setupBaseMocks();
     mockOs.tmpdir.mockReturnValue('/tmp');
     mockFs.mkdir.mockResolvedValue(undefined);
     mockFs.writeFile.mockResolvedValue(undefined);
@@ -171,7 +145,7 @@ describe('#documents:create', ()=>{
             _type: 'post',
             title: 'Test Post'
         };
-        const mockTransaction = {
+        const mockTransaction = vi.fn().mockReturnValue({
             commit: vi.fn().mockResolvedValue({
                 results: [
                     {
@@ -180,26 +154,23 @@ describe('#documents:create', ()=>{
                     }
                 ]
             })
-        };
-        mockGetCliConfig.mockResolvedValue({
-            api: {
-                dataset: testDataset,
-                projectId: testProjectId
-            }
         });
-        const mockClient = {
-            transaction: vi.fn().mockReturnValue(mockTransaction)
-        };
-        mockGetProjectCliClient.mockResolvedValue(mockClient);
+        mockGetProjectCliClient.mockResolvedValue({
+            transaction: mockTransaction
+        });
         mockFs.readFile.mockResolvedValue(JSON.stringify(mockDoc));
         mockJson5.parse.mockReturnValue(mockDoc);
         const { stdout } = await testCommand(CreateDocumentCommand, [
             'test-doc.json'
-        ]);
+        ], {
+            mocks: {
+                ...defaultMocks
+            }
+        });
         expect(stdout).toContain('Created:');
         expect(stdout).toContain('test-doc');
         expect(mockFs.readFile).toHaveBeenCalledWith(path.resolve(process.cwd(), 'test-doc.json'), 'utf8');
-        expect(mockClient.transaction).toHaveBeenCalledWith([
+        expect(mockTransaction).toHaveBeenCalledWith([
             {
                 create: mockDoc
             }
@@ -211,7 +182,7 @@ describe('#documents:create', ()=>{
             _type: 'post',
             title: 'Test Post'
         };
-        const mockTransaction = {
+        const mockTransaction = vi.fn().mockReturnValue({
             commit: vi.fn().mockResolvedValue({
                 results: [
                     {
@@ -220,26 +191,23 @@ describe('#documents:create', ()=>{
                     }
                 ]
             })
-        };
-        mockGetCliConfig.mockResolvedValue({
-            api: {
-                dataset: testDataset,
-                projectId: testProjectId
-            }
         });
-        const mockClient = {
-            transaction: vi.fn().mockReturnValue(mockTransaction)
-        };
-        mockGetProjectCliClient.mockResolvedValue(mockClient);
+        mockGetProjectCliClient.mockResolvedValue({
+            transaction: mockTransaction
+        });
         mockFs.readFile.mockResolvedValue(JSON.stringify(mockDoc));
         mockJson5.parse.mockReturnValue(mockDoc);
         const { stdout } = await testCommand(CreateDocumentCommand, [
             'test-doc.json',
             '--replace'
-        ]);
+        ], {
+            mocks: {
+                ...defaultMocks
+            }
+        });
         expect(stdout).toContain('Upserted:');
         expect(stdout).toContain('test-doc');
-        expect(mockClient.transaction).toHaveBeenCalledWith([
+        expect(mockTransaction).toHaveBeenCalledWith([
             {
                 createOrReplace: mockDoc
             }
@@ -251,7 +219,7 @@ describe('#documents:create', ()=>{
             _type: 'post',
             title: 'Test Post'
         };
-        const mockTransaction = {
+        const mockTransaction = vi.fn().mockReturnValue({
             commit: vi.fn().mockResolvedValue({
                 results: [
                     {
@@ -260,64 +228,55 @@ describe('#documents:create', ()=>{
                     }
                 ]
             })
-        };
-        mockGetCliConfig.mockResolvedValue({
-            api: {
-                dataset: testDataset,
-                projectId: testProjectId
-            }
         });
-        const mockClient = {
-            transaction: vi.fn().mockReturnValue(mockTransaction)
-        };
-        mockGetProjectCliClient.mockResolvedValue(mockClient);
+        mockGetProjectCliClient.mockResolvedValue({
+            transaction: mockTransaction
+        });
         mockFs.readFile.mockResolvedValue(JSON.stringify(mockDoc));
         mockJson5.parse.mockReturnValue(mockDoc);
         const { stdout } = await testCommand(CreateDocumentCommand, [
             'test-doc.json',
             '--missing'
-        ]);
+        ], {
+            mocks: {
+                ...defaultMocks
+            }
+        });
         expect(stdout).toContain('Skipped (already exists):');
         expect(stdout).toContain('test-doc');
-        expect(mockClient.transaction).toHaveBeenCalledWith([
+        expect(mockTransaction).toHaveBeenCalledWith([
             {
                 createIfNotExists: mockDoc
             }
         ]);
     });
     test('opens editor when no file specified and creates document from editor content', withEditorEnv(async ()=>{
-        mockGetCliConfig.mockResolvedValue({
-            api: {
-                dataset: testDataset,
-                projectId: testProjectId
-            }
+        const mockTransaction = vi.fn().mockReturnValue({
+            commit: vi.fn().mockResolvedValue({
+                results: [
+                    {
+                        id: 'generated-id',
+                        operation: 'create'
+                    }
+                ]
+            })
         });
-        const mockClient = {
+        mockGetProjectCliClient.mockResolvedValue({
             getDocument: vi.fn().mockResolvedValue(null),
-            transaction: vi.fn().mockReturnValue({
-                commit: vi.fn().mockResolvedValue({
-                    results: [
-                        {
-                            id: 'generated-id',
-                            operation: 'create'
-                        }
-                    ]
-                })
-            })
-        };
-        mockGetProjectCliClient.mockResolvedValue(mockClient);
-        mockOs.tmpdir.mockReturnValue('/tmp');
-        mockFs.mkdir.mockResolvedValue(undefined);
-        mockFs.writeFile.mockResolvedValue(undefined);
+            transaction: mockTransaction
+        });
+        setupEditorMocks();
         mockFs.readFile.mockResolvedValue('{"_id": "generated-id", "_type": "updated-type"}');
-        mockFs.unlink.mockResolvedValue(undefined);
         mockJson5.stringify.mockReturnValue('{"_id": "generated-id", "_type": "specify-me"}');
         mockJson5.parse.mockReturnValue({
             _id: 'generated-id',
             _type: 'updated-type'
         });
-        mockExecaSync.mockReturnValue(undefined);
-        const { stdout } = await testCommand(CreateDocumentCommand, []);
+        const { stdout } = await testCommand(CreateDocumentCommand, [], {
+            mocks: {
+                ...defaultMocks
+            }
+        });
         expect(stdout).toContain('Created:');
         expect(mockFs.mkdir).toHaveBeenCalledWith('/tmp/sanity-cli', {
             mode: 0o700,
@@ -331,76 +290,104 @@ describe('#documents:create', ()=>{
             _type: 'post',
             title: 'Test Post'
         };
-        setupMocks();
+        const mockTransaction = vi.fn().mockReturnValue({
+            commit: vi.fn().mockResolvedValue({
+                results: [
+                    {
+                        id: 'test-doc',
+                        operation: 'create'
+                    }
+                ]
+            })
+        });
+        mockGetProjectCliClient.mockResolvedValue({
+            transaction: mockTransaction
+        });
         mockFs.readFile.mockResolvedValue(JSON.stringify(mockDoc));
         mockJson5.parse.mockReturnValue(mockDoc);
         const { stdout } = await testCommand(CreateDocumentCommand, [
             'test-doc.json',
             '--dataset',
             'staging'
-        ]);
+        ], {
+            mocks: {
+                ...defaultMocks
+            }
+        });
         expect(stdout).toContain('Created:');
         expect(mockGetProjectCliClient).toHaveBeenCalledWith(expect.objectContaining({
             dataset: 'staging'
         }));
     });
     test('throws error when both --replace and --missing flags are used', async ()=>{
-        setupBaseMocks();
         const { error } = await testCommand(CreateDocumentCommand, [
             'test-doc.json',
             '--replace',
             '--missing'
-        ]);
+        ], {
+            mocks: defaultMocks
+        });
         expect(error).toBeInstanceOf(Error);
         expect(error?.message).toContain('Cannot use both --replace and --missing');
         expect(error?.oclif?.exit).toBe(1);
     });
     test('throws error when --id and file path are both provided', async ()=>{
-        setupBaseMocks();
         const { error } = await testCommand(CreateDocumentCommand, [
             'test-doc.json',
             '--id',
             'myDocId'
-        ]);
+        ], {
+            mocks: defaultMocks
+        });
         expect(error).toBeInstanceOf(Error);
         expect(error?.message).toContain('Cannot use --id when specifying a file path');
         expect(error?.oclif?.exit).toBe(1);
     });
     test('throws error when no project ID is configured', async ()=>{
-        mockGetCliConfig.mockResolvedValue({
-            api: {
-                dataset: 'production',
-                projectId: undefined
-            }
-        });
         const { error } = await testCommand(CreateDocumentCommand, [
             'test-doc.json'
-        ]);
+        ], {
+            mocks: {
+                ...defaultMocks,
+                cliConfig: {
+                    api: {
+                        dataset: 'production',
+                        projectId: undefined
+                    }
+                }
+            }
+        });
         expect(error).toBeInstanceOf(Error);
         expect(error?.message).toEqual(NO_PROJECT_ID);
         expect(error?.oclif?.exit).toBe(1);
     });
     test('throws error when no dataset is configured and none provided', async ()=>{
-        mockGetCliConfig.mockResolvedValue({
-            api: {
-                dataset: undefined,
-                projectId: testProjectId
-            }
-        });
         const { error } = await testCommand(CreateDocumentCommand, [
             'test-doc.json'
-        ]);
+        ], {
+            mocks: {
+                ...defaultMocks,
+                cliConfig: {
+                    api: {
+                        dataset: undefined,
+                        projectId: testProjectId
+                    }
+                }
+            }
+        });
         expect(error).toBeInstanceOf(Error);
         expect(error?.message).toContain('No dataset specified');
         expect(error?.oclif?.exit).toBe(1);
     });
     test('displays error message when file cannot be read', async ()=>{
-        setupBaseMocks();
-        mockGetProjectCliClient.mockResolvedValue({});
         mockFs.readFile.mockRejectedValue(new Error('File not found'));
         const { error } = await testCommand(CreateDocumentCommand, [
             'nonexistent.json'
-        ]);
+        ], {
+            mocks: {
+                ...defaultMocks
+            }
+        });
         expect(error).toBeInstanceOf(Error);
         expect(error?.message).toContain('Failed to create documents');
         expect(error?.oclif?.exit).toBe(1);
@@ -410,52 +397,48 @@ describe('#documents:create', ()=>{
             title: 'Test Post'
         } // Missing _type
         ;
-        setupBaseMocks();
-        mockGetProjectCliClient.mockResolvedValue({});
         mockFs.readFile.mockResolvedValue(JSON.stringify(invalidDoc));
         mockJson5.parse.mockReturnValue(invalidDoc);
         const { error } = await testCommand(CreateDocumentCommand, [
             'invalid-doc.json'
-        ]);
+        ], {
+            mocks: {
+                ...defaultMocks
+            }
+        });
         expect(error).toBeInstanceOf(Error);
         expect(error?.message).toContain('Failed to create documents');
         expect(error?.oclif?.exit).toBe(1);
     });
     test('uses JSON5 when --json5 flag is provided', withEditorEnv(async ()=>{
-        mockGetCliConfig.mockResolvedValue({
-            api: {
-                dataset: testDataset,
-                projectId: testProjectId
-            }
+        const mockTransaction = vi.fn().mockReturnValue({
+            commit: vi.fn().mockResolvedValue({
+                results: [
+                    {
+                        id: 'generated-id',
+                        operation: 'create'
+                    }
+                ]
+            })
         });
-        const mockClient = {
+        mockGetProjectCliClient.mockResolvedValue({
             getDocument: vi.fn().mockResolvedValue(null),
-            transaction: vi.fn().mockReturnValue({
-                commit: vi.fn().mockResolvedValue({
-                    results: [
-                        {
-                            id: 'generated-id',
-                            operation: 'create'
-                        }
-                    ]
-                })
-            })
-        };
-        mockGetProjectCliClient.mockResolvedValue(mockClient);
-        mockOs.tmpdir.mockReturnValue('/tmp');
-        mockFs.mkdir.mockResolvedValue(undefined);
-        mockFs.writeFile.mockResolvedValue(undefined);
+            transaction: mockTransaction
+        });
+        setupEditorMocks();
         mockFs.readFile.mockResolvedValue('{"_id": "generated-id", "_type": "updated-type"}');
-        mockFs.unlink.mockResolvedValue(undefined);
         mockJson5.stringify.mockReturnValue('{"_id": "generated-id", "_type": "specify-me"}');
         mockJson5.parse.mockReturnValue({
             _id: 'generated-id',
             _type: 'updated-type'
         });
-        mockExecaSync.mockReturnValue(undefined);
         await testCommand(CreateDocumentCommand, [
             '--json5'
-        ]);
+        ], {
+            mocks: {
+                ...defaultMocks
+            }
+        });
         expect(mockJson5.stringify).toHaveBeenCalled();
         expect(mockFs.writeFile).toHaveBeenCalledWith(expect.stringContaining('.json5'), expect.any(String), {
             encoding: 'utf8',
@@ -528,12 +511,28 @@ describe('#documents:create', ()=>{
                 'Document _id cannot be longer than 200 characters'
             ]
         ])('validates %s', async (description, doc, expectedErrorSubstring)=>{
-            setupMocks();
+            const mockTransaction = vi.fn().mockReturnValue({
+                commit: vi.fn().mockResolvedValue({
+                    results: [
+                        {
+                            id: 'test-doc',
+                            operation: 'create'
+                        }
+                    ]
+                })
+            });
+            mockGetProjectCliClient.mockResolvedValue({
+                transaction: mockTransaction
+            });
             mockFs.readFile.mockResolvedValue(JSON.stringify(doc));
             mockJson5.parse.mockReturnValue(doc);
             const { error } = await testCommand(CreateDocumentCommand, [
                 'invalid-doc.json'
-            ]);
+            ], {
+                mocks: {
+                    ...defaultMocks
+                }
+            });
             expect(error).toBeInstanceOf(Error);
             expect(error?.message).toContain(expectedErrorSubstring);
             expect(error?.oclif?.exit).toBe(1);
@@ -566,12 +565,28 @@ describe('#documents:create', ()=>{
                 'Document at index 1 must have a `_type` property of type string'
             ]
         ])('validates %s', async (description, docs, expectedErrorSubstring)=>{
-            setupMocks();
+            const mockTransaction = vi.fn().mockReturnValue({
+                commit: vi.fn().mockResolvedValue({
+                    results: [
+                        {
+                            id: 'test-doc',
+                            operation: 'create'
+                        }
+                    ]
+                })
+            });
+            mockGetProjectCliClient.mockResolvedValue({
+                transaction: mockTransaction
+            });
             mockFs.readFile.mockResolvedValue(JSON.stringify(docs));
             mockJson5.parse.mockReturnValue(docs);
             const { error } = await testCommand(CreateDocumentCommand, [
                 'invalid-docs.json'
-            ]);
+            ], {
+                mocks: {
+                    ...defaultMocks
+                }
+            });
             expect(error).toBeInstanceOf(Error);
             expect(error?.message).toContain(expectedErrorSubstring);
             expect(error?.oclif?.exit).toBe(1);
@@ -585,29 +600,32 @@ describe('#documents:create', ()=>{
                 _updatedAt: '2024-01-02T00:00:00Z',
                 title: 'Test Post'
             };
-            setupMocks();
-            const mockClient = {
-                transaction: vi.fn().mockReturnValue({
-                    commit: vi.fn().mockResolvedValue({
-                        results: [
-                            {
-                                id: 'test-doc',
-                                operation: 'create'
-                            }
-                        ]
-                    })
+            const mockTransaction = vi.fn().mockReturnValue({
+                commit: vi.fn().mockResolvedValue({
+                    results: [
+                        {
+                            id: 'test-doc',
+                            operation: 'create'
+                        }
+                    ]
                 })
-            };
-            mockGetProjectCliClient.mockResolvedValue(mockClient);
+            });
+            mockGetProjectCliClient.mockResolvedValue({
+                transaction: mockTransaction
+            });
             mockFs.readFile.mockResolvedValue(JSON.stringify(docWithReservedFields));
             mockJson5.parse.mockReturnValue(docWithReservedFields);
             // Should not throw error, but should proceed with document creation
             const { stdout } = await testCommand(CreateDocumentCommand, [
                 'doc.json'
-            ]);
+            ], {
+                mocks: {
+                    ...defaultMocks
+                }
+            });
             expect(stdout).toContain('Created:');
             expect(stdout).toContain('test-doc');
-            expect(mockClient.transaction).toHaveBeenCalledWith([
+            expect(mockTransaction).toHaveBeenCalledWith([
                 {
                     create: docWithReservedFields
                 }
@@ -615,12 +633,28 @@ describe('#documents:create', ()=>{
         });
         test('validates empty document array throws error', async ()=>{
             const emptyArray = [];
-            setupMocks();
+            const mockTransaction = vi.fn().mockReturnValue({
+                commit: vi.fn().mockResolvedValue({
+                    results: [
+                        {
+                            id: 'test-doc',
+                            operation: 'create'
+                        }
+                    ]
+                })
+            });
+            mockGetProjectCliClient.mockResolvedValue({
+                transaction: mockTransaction
+            });
             mockFs.readFile.mockResolvedValue(JSON.stringify(emptyArray));
             mockJson5.parse.mockReturnValue(emptyArray);
             const { error } = await testCommand(CreateDocumentCommand, [
                 'empty-docs.json'
-            ]);
+            ], {
+                mocks: {
+                    ...defaultMocks
+                }
+            });
             expect(error).toBeInstanceOf(Error);
             expect(error?.message).toContain('No documents provided');
             expect(error?.oclif?.exit).toBe(1);
@@ -656,7 +690,7 @@ describe('#documents:create', ()=>{
                     title: 'Post 2'
                 }
             ];
-            const mockTransaction = {
+            const mockTransaction = vi.fn().mockReturnValue({
                 commit: vi.fn().mockResolvedValue({
                     results: [
                         {
@@ -669,26 +703,28 @@ describe('#documents:create', ()=>{
                         }
                     ]
                 })
-            };
-            setupMocks();
-            const mockClient = {
-                transaction: vi.fn().mockReturnValue(mockTransaction)
-            };
-            mockGetProjectCliClient.mockResolvedValue(mockClient);
+            });
+            mockGetProjectCliClient.mockResolvedValue({
+                transaction: mockTransaction
+            });
             mockFs.readFile.mockResolvedValue(JSON.stringify(mockDocs));
             mockJson5.parse.mockReturnValue(mockDocs);
             const args = [
                 'docs.json'
             ];
             if (flag !== 'create') args.push(`--${flag}`);
-            const { stdout } = await testCommand(CreateDocumentCommand, args);
+            const { stdout } = await testCommand(CreateDocumentCommand, args, {
+                mocks: {
+                    ...defaultMocks
+                }
+            });
             expect(stdout).toContain(expectedMessage);
             expect(stdout).toContain('doc1');
             expect(stdout).toContain('doc2');
             const expectedMutations = mockDocs.map((doc)=>({
                     [operation]: doc
                 }));
-            expect(mockClient.transaction).toHaveBeenCalledWith(expectedMutations);
+            expect(mockTransaction).toHaveBeenCalledWith(expectedMutations);
         });
         test('handles mixed results for createIfNotExists', async ()=>{
             const mockDocs = [
@@ -708,7 +744,7 @@ describe('#documents:create', ()=>{
                     title: 'Post 3'
                 }
             ];
-            const mockTransaction = {
+            const mockTransaction = vi.fn().mockReturnValue({
                 commit: vi.fn().mockResolvedValue({
                     results: [
                         {
@@ -725,18 +761,20 @@ describe('#documents:create', ()=>{
                         }
                     ]
                 })
-            };
-            setupMocks();
-            const mockClient = {
-                transaction: vi.fn().mockReturnValue(mockTransaction)
-            };
-            mockGetProjectCliClient.mockResolvedValue(mockClient);
+            });
+            mockGetProjectCliClient.mockResolvedValue({
+                transaction: mockTransaction
+            });
             mockFs.readFile.mockResolvedValue(JSON.stringify(mockDocs));
             mockJson5.parse.mockReturnValue(mockDocs);
             const { stdout } = await testCommand(CreateDocumentCommand, [
                 'docs.json',
                 '--missing'
-            ]);
+            ], {
+                mocks: {
+                    ...defaultMocks
+                }
+            });
             expect(stdout).toContain('Created:');
             expect(stdout).toContain('doc1');
             expect(stdout).toContain('doc3');
@@ -751,20 +789,21 @@ describe('#documents:create', ()=>{
                 _type: 'post',
                 title: 'Existing Post'
             };
-            const mockClient = {
-                getDocument: vi.fn().mockResolvedValue(existingDoc),
-                transaction: vi.fn().mockReturnValue({
-                    commit: vi.fn().mockResolvedValue({
-                        results: [
-                            {
-                                id: 'existing-doc',
-                                operation: 'update'
-                            }
-                        ]
-                    })
+            const mockTransaction = vi.fn().mockReturnValue({
+                commit: vi.fn().mockResolvedValue({
+                    results: [
+                        {
+                            id: 'existing-doc',
+                            operation: 'update'
+                        }
+                    ]
                 })
-            };
-            mockGetProjectCliClient.mockResolvedValue(mockClient);
+            });
+            const mockGetDocument = vi.fn().mockResolvedValue(existingDoc);
+            mockGetProjectCliClient.mockResolvedValue({
+                getDocument: mockGetDocument,
+                transaction: mockTransaction
+            });
             setupEditorMocks();
             mockFs.readFile.mockResolvedValue(JSON.stringify({
                 ...existingDoc,
@@ -778,19 +817,23 @@ describe('#documents:create', ()=>{
             const { stdout } = await testCommand(CreateDocumentCommand, [
                 '--id',
                 'existing-doc'
-            ]);
-            expect(mockClient.getDocument).toHaveBeenCalledWith('existing-doc');
+            ], {
+                mocks: {
+                    ...defaultMocks
+                }
+            });
+            expect(mockGetDocument).toHaveBeenCalledWith('existing-doc');
             expect(mockFs.writeFile).toHaveBeenCalledWith(expect.stringContaining('existing-doc.json'), JSON.stringify(existingDoc, null, 2), expect.objectContaining({
                 mode: 0o600
             }));
             expect(stdout).toContain('Created:');
         }));
         test('handles no changes made in editor', withEditorEnv(async ()=>{
-            const mockClient = {
+            const mockTransaction = vi.fn();
+            mockGetProjectCliClient.mockResolvedValue({
                 getDocument: vi.fn().mockResolvedValue(null),
-                transaction: vi.fn()
-            };
-            mockGetProjectCliClient.mockResolvedValue(mockClient);
+                transaction: mockTransaction
+            });
             setupEditorMocks();
             // Set up a predictable UUID so the test can verify no changes were made
             const testUuid = '123e4567-e89b-12d3-a456-426614174000';
@@ -806,9 +849,13 @@ describe('#documents:create', ()=>{
             mockFs.readFile.mockResolvedValue(writeFileContent);
             // Return the exact same object structure that was written
             mockJson5.parse.mockReturnValue(defaultDoc);
-            await testCommand(CreateDocumentCommand, []);
+            await testCommand(CreateDocumentCommand, [], {
+                mocks: {
+                    ...defaultMocks
+                }
+            });
             // The key test - transaction should not have been called since no changes were made
-            expect(mockClient.transaction).not.toHaveBeenCalled();
+            expect(mockTransaction).not.toHaveBeenCalled();
         }));
         test('handles write error with already exists hint', withEditorEnv(async ()=>{
             const mockDoc = {
@@ -816,13 +863,13 @@ describe('#documents:create', ()=>{
                 _type: 'post',
                 title: 'Test Post'
             };
-            const mockClient = {
+            const mockTransaction = vi.fn().mockReturnValue({
+                commit: vi.fn().mockRejectedValue(new Error('Document already exists'))
+            });
+            mockGetProjectCliClient.mockResolvedValue({
                 getDocument: vi.fn().mockResolvedValue(null),
-                transaction: vi.fn().mockReturnValue({
-                    commit: vi.fn().mockRejectedValue(new Error('Document already exists'))
-                })
-            };
-            mockGetProjectCliClient.mockResolvedValue(mockClient);
+                transaction: mockTransaction
+            });
             setupEditorMocks();
             mockFs.readFile.mockResolvedValue(JSON.stringify(mockDoc));
             mockJson5.parse.mockReturnValue(mockDoc);
@@ -830,7 +877,11 @@ describe('#documents:create', ()=>{
                 _id: 'test-doc',
                 _type: 'specify-me'
             }, null, 2));
-            const { error } = await testCommand(CreateDocumentCommand, []);
+            const { error } = await testCommand(CreateDocumentCommand, [], {
+                mocks: {
+                    ...defaultMocks
+                }
+            });
             expect(error).toBeInstanceOf(Error);
             expect(error?.message).toContain('Failed to write documents: Document already exists');
             expect(error?.message).toContain('Perhaps you want to use `--replace` or `--missing`?');
@@ -842,20 +893,20 @@ describe('#documents:create', ()=>{
                 _type: 'post',
                 title: 'Test Post'
             };
-            const mockClient = {
-                getDocument: vi.fn().mockResolvedValue(null),
-                transaction: vi.fn().mockReturnValue({
-                    commit: vi.fn().mockResolvedValue({
-                        results: [
-                            {
-                                id: 'test-doc',
-                                operation: 'create'
-                            }
-                        ]
-                    })
+            const mockTransaction = vi.fn().mockReturnValue({
+                commit: vi.fn().mockResolvedValue({
+                    results: [
+                        {
+                            id: 'test-doc',
+                            operation: 'create'
+                        }
+                    ]
                 })
-            };
-            mockGetProjectCliClient.mockResolvedValue(mockClient);
+            });
+            mockGetProjectCliClient.mockResolvedValue({
+                getDocument: vi.fn().mockResolvedValue(null),
+                transaction: mockTransaction
+            });
             setupEditorMocks();
             // Mock unlink to throw an error (should be caught silently)
             mockFs.unlink.mockRejectedValue(new Error('Permission denied'));
@@ -865,7 +916,11 @@ describe('#documents:create', ()=>{
                 _id: 'test-doc',
                 _type: 'specify-me'
             }, null, 2));
-            const { stdout } = await testCommand(CreateDocumentCommand, []);
+            const { stdout } = await testCommand(CreateDocumentCommand, [], {
+                mocks: {
+                    ...defaultMocks
+                }
+            });
             // Should still succeed despite file cleanup error
             expect(stdout).toContain('Created:');
             expect(stdout).toContain('test-doc');
@@ -878,20 +933,20 @@ describe('#documents:create', ()=>{
                 on: vi.fn().mockReturnThis()
             };
             mockChokidarWatch.mockReturnValue(mockWatcher);
-            const mockClient = {
-                getDocument: vi.fn().mockResolvedValue(null),
-                transaction: vi.fn().mockReturnValue({
-                    commit: vi.fn().mockResolvedValue({
-                        results: [
-                            {
-                                id: 'test-doc',
-                                operation: 'create'
-                            }
-                        ]
-                    })
+            const mockTransaction = vi.fn().mockReturnValue({
+                commit: vi.fn().mockResolvedValue({
+                    results: [
+                        {
+                            id: 'test-doc',
+                            operation: 'create'
+                        }
+                    ]
                 })
-            };
-            mockGetProjectCliClient.mockResolvedValue(mockClient);
+            });
+            mockGetProjectCliClient.mockResolvedValue({
+                getDocument: vi.fn().mockResolvedValue(null),
+                transaction: mockTransaction
+            });
             setupWatchMocks();
             mockJson5.stringify.mockReturnValue(JSON.stringify({
                 _id: 'test-doc',
@@ -900,7 +955,11 @@ describe('#documents:create', ()=>{
             mockExeca.mockResolvedValue({});
             const { stdout } = await testCommand(CreateDocumentCommand, [
                 '--watch'
-            ]);
+            ], {
+                mocks: {
+                    ...defaultMocks
+                }
+            });
             expect(stdout).toContain('Watch mode:');
             expect(stdout).toContain('Will write documents on each save.');
             expect(stdout).toContain('Press Ctrl + C to cancel watch mode.');
@@ -926,20 +985,20 @@ describe('#documents:create', ()=>{
                 })
             };
             mockChokidarWatch.mockReturnValue(mockWatcher);
-            const mockClient = {
-                getDocument: vi.fn().mockResolvedValue(null),
-                transaction: vi.fn().mockReturnValue({
-                    commit: vi.fn().mockResolvedValue({
-                        results: [
-                            {
-                                id: 'test-doc',
-                                operation: 'create'
-                            }
-                        ]
-                    })
+            const mockTransaction = vi.fn().mockReturnValue({
+                commit: vi.fn().mockResolvedValue({
+                    results: [
+                        {
+                            id: 'test-doc',
+                            operation: 'create'
+                        }
+                    ]
                 })
-            };
-            mockGetProjectCliClient.mockResolvedValue(mockClient);
+            });
+            mockGetProjectCliClient.mockResolvedValue({
+                getDocument: vi.fn().mockResolvedValue(null),
+                transaction: mockTransaction
+            });
             setupWatchMocks();
             mockJson5.stringify.mockReturnValue(JSON.stringify({
                 _id: 'test-doc',
@@ -951,11 +1010,15 @@ describe('#documents:create', ()=>{
             mockJson5.parse.mockReturnValue(mockDoc);
             await testCommand(CreateDocumentCommand, [
                 '--watch'
-            ]);
+            ], {
+                mocks: {
+                    ...defaultMocks
+                }
+            });
             // Simulate file change
             expect(changeHandler).toBeDefined();
             await changeHandler();
-            expect(mockClient.transaction).toHaveBeenCalledWith([
+            expect(mockTransaction).toHaveBeenCalledWith([
                 {
                     create: mockDoc
                 }