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

package/dist/commands/schema/__tests__/delete.test.js

@@ -1,44 +1,81 @@
 import { runCommand } from '@oclif/test';
-import { getCliConfig } from '@sanity/cli-core';
-import { testCommand } from '@sanity/cli-test';
+import { mockApi, testCommand } from '@sanity/cli-test';
 import { afterEach, beforeEach, describe, expect, test, vi } from 'vitest';
-import { deleteSchemaAction } from '../../../actions/schema/deleteSchemaAction.js';
+import { extractManifestSafe } from '../../../actions/manifest/extractManifest.js';
+import { createManifestReader } from '../../../actions/schema/utils/manifestReader.js';
+import { SCHEMA_API_VERSION } from '../../../services/schemas.js';
+import { NO_DATASET_ID, NO_PROJECT_ID } from '../../../util/errorMessages.js';
 import { DeleteSchemaCommand } from '../delete.js';
-// Mock the delete schema action
-vi.mock('../../../actions/schema/deleteSchemaAction.js', ()=>({
-        deleteSchemaAction: vi.fn()
-    }));
-// Mock the manifest extractor
-vi.mock('../../../actions/schema/utils/manifestExtractor.js', ()=>({
-        createManifestExtractor: vi.fn(()=>vi.fn())
-    }));
-// Mock the config functions
-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().mockResolvedValue({
-            api: {
-                dataset: 'production',
-                projectId: 'test-project'
-            }
-        })
-    }));
-vi.mock('../../../../../cli-core/src/services/apiClient.js', ()=>({
-        getProjectCliClient: vi.fn()
-    }));
-vi.mock('../../../../../cli-core/src/services/getCliToken.js', ()=>({
-        getCliToken: vi.fn().mockResolvedValue('test-token')
-    }));
-const mockedDeleteSchemaAction = vi.mocked(deleteSchemaAction);
-const mockedGetCliConfig = vi.mocked(getCliConfig);
+const mockManifest = {
+    createdAt: '2024-01-01T00:00:00.000Z',
+    studioVersion: '3.0.0',
+    version: 3,
+    workspaces: [
+        {
+            basePath: '/',
+            dataset: 'production',
+            icon: null,
+            name: 'default',
+            projectId: 'test-project',
+            schema: 'default.create-schema.json',
+            tools: 'default.create-tools.json'
+        },
+        {
+            basePath: '/staging',
+            dataset: 'staging',
+            icon: null,
+            name: 'staging',
+            projectId: 'test-project',
+            schema: 'staging.create-schema.json',
+            tools: 'staging.create-tools.json'
+        }
+    ]
+};
+const mockSchemas = [
+    '_.schemas.default',
+    '_.schemas.staging'
+];
+vi.mock('../../../actions/manifest/extractManifest.js');
+vi.mock('../../../actions/schema/utils/manifestReader.js');
+const mockExtractManifestSafe = vi.mocked(extractManifestSafe);
+const mockedCreateManifestReader = vi.mocked(createManifestReader);
+const testProjectId = 'test-project';
+const defaultMocks = {
+    cliConfig: {
+        api: {
+            dataset: 'production',
+            projectId: testProjectId
+        }
+    },
+    projectRoot: {
+        directory: '/test/path',
+        path: '/test/path/sanity.config.ts',
+        type: 'studio'
+    },
+    token: 'test-token'
+};
 describe('#schema:delete', ()=>{
     beforeEach(()=>{
-        mockedDeleteSchemaAction.mockResolvedValue('success');
+        vi.clearAllMocks();
+        for (const schema of mockSchemas){
+            mockApi({
+                apiVersion: SCHEMA_API_VERSION,
+                uri: `/projects/test-project/datasets/production/schemas/${schema}`
+            }).reply(200, [
+                {}
+            ]);
+            mockApi({
+                apiVersion: SCHEMA_API_VERSION,
+                uri: `/projects/test-project/datasets/staging/schemas/${schema}`
+            }).reply(200, [
+                {}
+            ]);
+        }
+        mockedCreateManifestReader.mockReturnValue({
+            getManifest: vi.fn().mockResolvedValue(mockManifest),
+            getWorkspaceSchema: vi.fn()
+        });
+        mockExtractManifestSafe.mockResolvedValue(undefined);
     });
     afterEach(()=>{
         vi.clearAllMocks();
@@ -55,100 +92,74 @@ describe('#schema:delete', ()=>{
         expect(stdout).toContain('--manifest-dir');
         expect(stdout).toContain('--verbose');
     });
-    test('deletes a single schema successfully', async ()=>{
-        mockedDeleteSchemaAction.mockResolvedValue('success');
-        await testCommand(DeleteSchemaCommand, [
+    test('successfully deletes a single schema', async ()=>{
+        mockApi({
+            apiVersion: SCHEMA_API_VERSION,
+            method: 'delete',
+            uri: '/projects/test-project/datasets/production/schemas/_.schemas.default'
+        }).reply(200, {
+            deleted: true
+        });
+        mockApi({
+            apiVersion: SCHEMA_API_VERSION,
+            method: 'delete',
+            uri: '/projects/test-project/datasets/staging/schemas/_.schemas.default'
+        }).reply(200, {
+            deleted: true
+        });
+        const { error, stdout } = await testCommand(DeleteSchemaCommand, [
             '--ids',
-            'sanity.workspace.schema.workspaceName'
-        ]);
-        expect(mockedDeleteSchemaAction).toHaveBeenCalledWith(expect.objectContaining({
-            ids: 'sanity.workspace.schema.workspaceName'
-        }), expect.any(Object));
+            '_.schemas.default'
+        ], {
+            mocks: defaultMocks
+        });
+        expect(stdout).toContain('Successfully deleted 1/1 schemas');
+        expect(error).toBeUndefined();
     });
-    test('deletes multiple schemas successfully', async ()=>{
-        mockedDeleteSchemaAction.mockResolvedValue('success');
-        await testCommand(DeleteSchemaCommand, [
+    test('successfully deletes multiple schemas', async ()=>{
+        for (const schema of mockSchemas){
+            mockApi({
+                apiVersion: SCHEMA_API_VERSION,
+                method: 'delete',
+                uri: `/projects/test-project/datasets/production/schemas/${schema}`
+            }).reply(200, {
+                deleted: true
+            });
+            mockApi({
+                apiVersion: SCHEMA_API_VERSION,
+                method: 'delete',
+                uri: `/projects/test-project/datasets/staging/schemas/${schema}`
+            }).reply(200, {
+                deleted: true
+            });
+        }
+        const { error, stdout } = await testCommand(DeleteSchemaCommand, [
             '--ids',
-            'sanity.workspace.schema.workspace1,sanity.workspace.schema.workspace2'
-        ]);
-        expect(mockedDeleteSchemaAction).toHaveBeenCalledWith(expect.objectContaining({
-            ids: 'sanity.workspace.schema.workspace1,sanity.workspace.schema.workspace2'
-        }), expect.any(Object));
+            '_.schemas.default,_.schemas.staging'
+        ], {
+            mocks: defaultMocks
+        });
+        expect(stdout).toContain('Successfully deleted 2/2 schemas');
+        expect(error).toBeUndefined();
     });
-    test('uses custom dataset when --dataset flag is provided', async ()=>{
-        mockedDeleteSchemaAction.mockResolvedValue('success');
-        await testCommand(DeleteSchemaCommand, [
+    test('filters schemas by dataset when dataset flag is provided', async ()=>{
+        mockApi({
+            apiVersion: SCHEMA_API_VERSION,
+            method: 'delete',
+            uri: '/projects/test-project/datasets/production/schemas/_.schemas.default'
+        }).reply(200, {
+            deleted: true
+        });
+        const { error, stdout } = await testCommand(DeleteSchemaCommand, [
             '--ids',
-            'sanity.workspace.schema.workspaceName',
+            '_.schemas.default',
             '--dataset',
-            'staging'
-        ]);
-        expect(mockedDeleteSchemaAction).toHaveBeenCalledWith(expect.objectContaining({
-            dataset: 'staging',
-            ids: 'sanity.workspace.schema.workspaceName'
-        }), expect.any(Object));
-    });
-    test('disables manifest extraction with --no-extract-manifest', async ()=>{
-        mockedDeleteSchemaAction.mockResolvedValue('success');
-        await testCommand(DeleteSchemaCommand, [
-            '--ids',
-            'sanity.workspace.schema.workspaceName',
-            '--no-extract-manifest'
-        ]);
-        expect(mockedDeleteSchemaAction).toHaveBeenCalledWith(expect.objectContaining({
-            'extract-manifest': false,
-            ids: 'sanity.workspace.schema.workspaceName'
-        }), expect.any(Object));
-    });
-    test('uses custom manifest directory when --manifest-dir is provided', async ()=>{
-        mockedDeleteSchemaAction.mockResolvedValue('success');
-        await testCommand(DeleteSchemaCommand, [
-            '--ids',
-            'sanity.workspace.schema.workspaceName',
-            '--manifest-dir',
-            './custom/path'
-        ]);
-        expect(mockedDeleteSchemaAction).toHaveBeenCalledWith(expect.objectContaining({
-            ids: 'sanity.workspace.schema.workspaceName',
-            'manifest-dir': './custom/path'
-        }), expect.any(Object));
-    });
-    test('enables verbose logging when --verbose is provided', async ()=>{
-        mockedDeleteSchemaAction.mockResolvedValue('success');
-        await testCommand(DeleteSchemaCommand, [
-            '--ids',
-            'sanity.workspace.schema.workspaceName',
-            '--verbose'
-        ]);
-        expect(mockedDeleteSchemaAction).toHaveBeenCalledWith(expect.objectContaining({
-            ids: 'sanity.workspace.schema.workspaceName',
-            verbose: true
-        }), expect.any(Object));
-    });
-    test('handles action failure', async ()=>{
-        mockedDeleteSchemaAction.mockResolvedValue('failure');
-        const { error } = await testCommand(DeleteSchemaCommand, [
-            '--ids',
-            'sanity.workspace.schema.workspaceName'
-        ]);
-        expect(error).toBeInstanceOf(Error);
-        expect(error?.message).toContain('Failed to delete schemas');
-        expect(error?.oclif?.exit).toBe(1);
-    });
-    test('handles action errors gracefully', async ()=>{
-        mockedDeleteSchemaAction.mockRejectedValue(new Error('Schema delete failed'));
-        const { error } = await testCommand(DeleteSchemaCommand, [
-            '--ids',
-            'sanity.workspace.schema.workspaceName'
-        ]);
-        expect(error).toBeInstanceOf(Error);
-        expect(error?.message).toContain('Failed to delete schemas: Schema delete failed');
-        expect(error?.oclif?.exit).toBe(1);
-    });
-    test('requires --ids flag', async ()=>{
-        const { error } = await testCommand(DeleteSchemaCommand, []);
-        expect(error).toBeInstanceOf(Error);
-        expect(error?.message).toContain('Missing required flag ids');
+            'production'
+        ], {
+            mocks: defaultMocks
+        });
+        expect(stdout).toContain('Successfully deleted 1/1 schemas');
+        expect(error).toBeUndefined();
     });
     test.each([
         {
@@ -159,22 +170,22 @@ describe('#schema:delete', ()=>{
             desc: 'project ID is empty string',
             projectId: ''
         }
-    ])('throws error when $desc', async ({ projectId })=>{
-        // Mock getCliConfig twice since it's called by both run() and getProjectId()
-        const mockConfig = {
-            api: {
-                dataset: 'production',
-                projectId
-            }
-        };
-        mockedGetCliConfig.mockResolvedValueOnce(mockConfig).mockResolvedValueOnce(mockConfig);
+    ])('throws an error if $desc', async ({ projectId })=>{
         const { error } = await testCommand(DeleteSchemaCommand, [
             '--ids',
-            'sanity.workspace.schema.workspaceName'
-        ]);
-        expect(error).toBeInstanceOf(Error);
-        expect(error?.message).toContain('No project ID found');
-        expect(error?.message).toContain('Sanity project directory');
+            '_.schemas.default'
+        ], {
+            mocks: {
+                ...defaultMocks,
+                cliConfig: {
+                    api: {
+                        dataset: 'production',
+                        projectId
+                    }
+                }
+            }
+        });
+        expect(error?.message).toContain(NO_PROJECT_ID);
         expect(error?.oclif?.exit).toBe(1);
     });
     test.each([
@@ -186,24 +197,258 @@ describe('#schema:delete', ()=>{
             dataset: '',
             desc: 'dataset is empty string'
         }
-    ])('throws error when $desc', async ({ dataset })=>{
-        // Mock getCliConfig twice since it's called by both run() and getProjectId()
-        const mockConfig = {
-            api: {
-                dataset,
-                projectId: 'test-project'
+    ])('throws an error if $desc', async ({ dataset })=>{
+        const { error } = await testCommand(DeleteSchemaCommand, [
+            '--ids',
+            '_.schemas.default'
+        ], {
+            mocks: {
+                ...defaultMocks,
+                cliConfig: {
+                    api: {
+                        dataset,
+                        projectId: 'test-project'
+                    }
+                }
             }
-        };
-        mockedGetCliConfig.mockResolvedValueOnce(mockConfig).mockResolvedValueOnce(mockConfig);
+        });
+        expect(error?.message).toContain(NO_DATASET_ID);
+        expect(error?.oclif?.exit).toBe(1);
+    });
+    test('throws an error if ids is an empty string', async ()=>{
+        const { error } = await testCommand(DeleteSchemaCommand, [
+            '--ids'
+        ], {
+            mocks: defaultMocks
+        });
+        expect(error?.message).toContain('Flag --ids expects a value');
+        expect(error?.oclif?.exit).toBe(2);
+    });
+    test.each([
+        {
+            desc: 'ids with invalid characters (!)',
+            expectedError: 'id can only contain characters in [a-zA-Z0-9._-]',
+            ids: 'test-id!!'
+        },
+        {
+            desc: 'ids with invalid characters (@)',
+            expectedError: 'id can only contain characters in [a-zA-Z0-9._-]',
+            ids: '_.schemas.default@tag'
+        },
+        {
+            desc: 'id starts with dash',
+            expectedError: 'id cannot start with - (dash)',
+            ids: '-_.schemas.default'
+        },
+        {
+            desc: 'id has consecutive periods',
+            expectedError: 'id cannot have consecutive . (period) characters',
+            ids: '_.schemas..default'
+        },
+        {
+            desc: 'id missing required prefix',
+            expectedError: 'id must either match _.schemas.<workspaceName>',
+            ids: 'schemas.default'
+        },
+        {
+            desc: 'id has invalid workspace name (space)',
+            expectedError: 'id can only contain characters in [a-zA-Z0-9._-]',
+            ids: '_.schemas.default workspace'
+        },
+        {
+            desc: 'duplicate ids in comma-separated list',
+            expectedError: 'ids contains duplicates',
+            ids: '_.schemas.default,_.schemas.default'
+        },
+        {
+            desc: 'comma-separated with one duplicate',
+            expectedError: 'ids contains duplicates',
+            ids: '_.schemas.production,_.schemas.staging,_.schemas.production'
+        },
+        {
+            desc: 'all entries are empty after trimming',
+            expectedError: 'ids contains no valid id strings',
+            ids: ' , , '
+        }
+    ])('throws error when $desc', async ({ expectedError, ids })=>{
         const { error } = await testCommand(DeleteSchemaCommand, [
             '--ids',
-            'sanity.workspace.schema.workspaceName'
-        ]);
-        expect(error).toBeInstanceOf(Error);
-        expect(error?.message).toContain('No dataset found');
-        expect(error?.message).toContain('sanity.config.ts');
+            ids
+        ], {
+            mocks: defaultMocks
+        });
+        expect(error?.message).toContain(expectedError);
+        expect(error?.oclif?.exit).toBe(2);
+    });
+    test('throws error when dataset flag is not provided a value', async ()=>{
+        const { error } = await testCommand(DeleteSchemaCommand, [
+            '--ids',
+            '_.schemas.default',
+            '--dataset'
+        ], {
+            mocks: defaultMocks
+        });
+        expect(error?.message).toContain('Flag --dataset expects a value');
+        expect(error?.oclif?.exit).toBe(2);
+    });
+    test('throws an error when schema is not found', async ()=>{
+        mockApi({
+            apiVersion: SCHEMA_API_VERSION,
+            uri: `/projects/test-project/datasets/production/schemas/_.schemas.nonexistent`
+        }).reply(200, []);
+        mockApi({
+            apiVersion: SCHEMA_API_VERSION,
+            uri: `/projects/test-project/datasets/staging/schemas/_.schemas.nonexistent`
+        }).reply(200, []);
+        const { error } = await testCommand(DeleteSchemaCommand, [
+            '--ids',
+            '_.schemas.nonexistent'
+        ], {
+            mocks: defaultMocks
+        });
+        expect(error?.message).toContain('Deleted 0/1 schemas');
+        expect(error?.message).toContain('not found');
+        expect(error?.oclif?.exit).toBe(1);
+    });
+    test('throws an error when some schemas are not found', async ()=>{
+        mockApi({
+            apiVersion: SCHEMA_API_VERSION,
+            method: 'delete',
+            uri: '/projects/test-project/datasets/production/schemas/_.schemas.default'
+        }).reply(200, {
+            deleted: true
+        });
+        mockApi({
+            apiVersion: SCHEMA_API_VERSION,
+            method: 'delete',
+            uri: '/projects/test-project/datasets/staging/schemas/_.schemas.default'
+        }).reply(200, {
+            deleted: true
+        });
+        mockApi({
+            apiVersion: SCHEMA_API_VERSION,
+            uri: `/projects/test-project/datasets/production/schemas/_.schemas.nonexistent`
+        }).reply(200, []);
+        mockApi({
+            apiVersion: SCHEMA_API_VERSION,
+            uri: `/projects/test-project/datasets/staging/schemas/_.schemas.nonexistent`
+        }).reply(200, []);
+        const { error } = await testCommand(DeleteSchemaCommand, [
+            '--ids',
+            '_.schemas.default,_.schemas.nonexistent'
+        ], {
+            mocks: defaultMocks
+        });
+        expect(error?.message).toContain('Deleted 1/2 schemas');
+        expect(error?.oclif?.exit).toBe(1);
+    });
+    test('throws an error if delete request fails', async ()=>{
+        mockApi({
+            apiVersion: SCHEMA_API_VERSION,
+            method: 'delete',
+            uri: '/projects/test-project/datasets/production/schemas/_.schemas.default'
+        }).reply(403, {
+            error: 'Delete failed'
+        });
+        mockApi({
+            apiVersion: SCHEMA_API_VERSION,
+            method: 'delete',
+            uri: '/projects/test-project/datasets/staging/schemas/_.schemas.default'
+        }).reply(403, {
+            error: 'Delete failed'
+        });
+        const { error } = await testCommand(DeleteSchemaCommand, [
+            '--ids',
+            '_.schemas.default'
+        ], {
+            mocks: defaultMocks
+        });
+        expect(error?.message).toContain('Failed to delete schema');
+        expect(error?.oclif?.exit).toBe(1);
+    });
+    test('outputs a verbose warning when verbose flag is enabled', async ()=>{
+        mockApi({
+            apiVersion: SCHEMA_API_VERSION,
+            method: 'delete',
+            uri: '/projects/test-project/datasets/production/schemas/_.schemas.default'
+        }).reply(403, {
+            error: 'Delete failed'
+        });
+        mockApi({
+            apiVersion: SCHEMA_API_VERSION,
+            method: 'delete',
+            uri: '/projects/test-project/datasets/staging/schemas/_.schemas.default'
+        }).reply(403, {
+            error: 'Delete failed'
+        });
+        const { error, stderr } = await testCommand(DeleteSchemaCommand, [
+            '--ids',
+            '_.schemas.default',
+            '--verbose'
+        ], {
+            mocks: defaultMocks
+        });
+        expect(stderr).toContain('Failed to delete schema "_.schemas.default"');
+        expect(stderr).toContain('DeleteIdError: Delete failed');
+        expect(error?.message).toContain('Deleted 0/1 schemas');
         expect(error?.oclif?.exit).toBe(1);
     });
+    test('outputs a warning on projectId mismatch', async ()=>{
+        mockApi({
+            apiVersion: SCHEMA_API_VERSION,
+            method: 'delete',
+            uri: '/projects/test-project/datasets/production/schemas/_.schemas.default'
+        }).reply(200, {
+            deleted: true
+        });
+        const mismatchManifest = {
+            ...mockManifest,
+            workspaces: [
+                {
+                    ...mockManifest.workspaces[0],
+                    projectId: 'test-project'
+                },
+                {
+                    ...mockManifest.workspaces[1],
+                    projectId: 'different-project'
+                }
+            ]
+        };
+        mockedCreateManifestReader.mockReturnValue({
+            getManifest: vi.fn().mockResolvedValue(mismatchManifest),
+            getWorkspaceSchema: vi.fn()
+        });
+        const { stderr, stdout } = await testCommand(DeleteSchemaCommand, [
+            '--ids',
+            '_.schemas.default'
+        ], {
+            mocks: defaultMocks
+        });
+        expect(stderr).toContain('No permissions to read schema for workspace "staging"');
+        expect(stdout).toContain('Successfully deleted 1/1 schemas');
+    });
+    test('skips manifest extraction with no-extract-manifest flag', async ()=>{
+        mockApi({
+            apiVersion: SCHEMA_API_VERSION,
+            method: 'delete',
+            uri: '/projects/test-project/datasets/production/schemas/_.schemas.default'
+        }).reply(200, {
+            deleted: true
+        });
+        mockApi({
+            apiVersion: SCHEMA_API_VERSION,
+            method: 'delete',
+            uri: '/projects/test-project/datasets/staging/schemas/_.schemas.default'
+        }).reply(200, {
+            deleted: true
+        });
+        await testCommand(DeleteSchemaCommand, [
+            '--ids',
+            '_.schemas.default',
+            '--no-manifest-extract'
+        ]);
+        expect(mockExtractManifestSafe).not.toHaveBeenCalled();
+    });
 });
 
 //# sourceMappingURL=delete.test.js.map