@capawesome/cli 1.14.0 → 2.0.1

package/dist/commands/apps/channels/delete.js

@@ -1,100 +1,77 @@
-"use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const citty_1 = require("citty");
-const consola_1 = __importDefault(require("consola"));
-const app_channels_1 = __importDefault(require("../../../services/app-channels"));
-const apps_1 = __importDefault(require("../../../services/apps"));
-const organizations_1 = __importDefault(require("../../../services/organizations"));
-const ci_1 = require("../../../utils/ci");
-const error_1 = require("../../../utils/error");
-const prompt_1 = require("../../../utils/prompt");
-exports.default = (0, citty_1.defineCommand)({
-    meta: {
-        description: 'Delete an app channel.',
-    },
-    args: {
-        appId: {
-            type: 'string',
-            description: 'ID of the app.',
-        },
-        channelId: {
-            type: 'string',
-            description: 'ID of the channel. Either the ID or name of the channel must be provided.',
-        },
-        name: {
-            type: 'string',
-            description: 'Name of the channel. Either the ID or name of the channel must be provided.',
-        },
-    },
-    run: (ctx) => __awaiter(void 0, void 0, void 0, function* () {
-        let appId = ctx.args.appId;
-        let channelId = ctx.args.channelId;
-        let channelName = ctx.args.name;
+import appChannelsService from '../../../services/app-channels.js';
+import appsService from '../../../services/apps.js';
+import authorizationService from '../../../services/authorization-service.js';
+import organizationsService from '../../../services/organizations.js';
+import { prompt } from '../../../utils/prompt.js';
+import { defineCommand, defineOptions } from '@robingenz/zli';
+import consola from 'consola';
+import { isCI } from 'std-env';
+import { z } from 'zod';
+export default defineCommand({
+    description: 'Delete an app channel.',
+    options: defineOptions(z.object({
+        appId: z.string().optional().describe('ID of the app.'),
+        channelId: z
+            .string()
+            .optional()
+            .describe('ID of the channel. Either the ID or name of the channel must be provided.'),
+        name: z
+            .string()
+            .optional()
+            .describe('Name of the channel. Either the ID or name of the channel must be provided.'),
+    })),
+    action: async (options, args) => {
+        let { appId, channelId, name } = options;
+        if (!authorizationService.hasAuthorizationToken()) {
+            consola.error('You must be logged in to run this command.');
+            process.exit(1);
+        }
         if (!appId) {
-            const organizations = yield organizations_1.default.findAll();
+            const organizations = await organizationsService.findAll();
             if (organizations.length === 0) {
-                consola_1.default.error('You must create an organization before deleting a channel.');
+                consola.error('You must create an organization before deleting a channel.');
                 process.exit(1);
             }
             // @ts-ignore wait till https://github.com/unjs/consola/pull/280 is merged
-            const organizationId = yield (0, prompt_1.prompt)('Select the organization of the app from which you want to delete a channel.', {
+            const organizationId = await prompt('Select the organization of the app from which you want to delete a channel.', {
                 type: 'select',
                 options: organizations.map((organization) => ({ label: organization.name, value: organization.id })),
             });
             if (!organizationId) {
-                consola_1.default.error('You must select the organization of an app from which you want to delete a channel.');
+                consola.error('You must select the organization of an app from which you want to delete a channel.');
                 process.exit(1);
             }
-            const apps = yield apps_1.default.findAll({
+            const apps = await appsService.findAll({
                 organizationId,
             });
             if (!apps.length) {
-                consola_1.default.error('You must create an app before deleting a channel.');
+                consola.error('You must create an app before deleting a channel.');
                 process.exit(1);
             }
             // @ts-ignore wait till https://github.com/unjs/consola/pull/280 is merged
-            appId = yield (0, prompt_1.prompt)('Which app do you want to delete the channel from?', {
+            appId = await prompt('Which app do you want to delete the channel from?', {
                 type: 'select',
                 options: apps.map((app) => ({ label: app.name, value: app.id })),
             });
         }
-        if (!channelId && !channelName) {
-            channelName = yield (0, prompt_1.prompt)('Enter the channel name:', {
+        if (!channelId && !name) {
+            name = await prompt('Enter the channel name:', {
                 type: 'text',
             });
         }
-        if (!(0, ci_1.isRunningInCi)()) {
-            const confirmed = yield (0, prompt_1.prompt)('Are you sure you want to delete this channel?', {
+        if (!isCI) {
+            const confirmed = await prompt('Are you sure you want to delete this channel?', {
                 type: 'confirm',
             });
             if (!confirmed) {
                 return;
             }
         }
-        try {
-            yield app_channels_1.default.delete({
-                appId,
-                id: channelId,
-                name: channelName,
-            });
-            consola_1.default.success('Channel deleted successfully.');
-        }
-        catch (error) {
-            const message = (0, error_1.getMessageFromUnknownError)(error);
-            consola_1.default.error(message);
-            process.exit(1);
-        }
-    }),
+        await appChannelsService.delete({
+            appId,
+            id: channelId,
+            name,
+        });
+        consola.success('Channel deleted successfully.');
+    },
 });

package/dist/commands/apps/channels/delete.test.js

@@ -0,0 +1,141 @@
+import { DEFAULT_API_BASE_URL } from '../../../config/consts.js';
+import authorizationService from '../../../services/authorization-service.js';
+import { prompt } from '../../../utils/prompt.js';
+import userConfig from '../../../utils/user-config.js';
+import consola from 'consola';
+import nock from 'nock';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import deleteChannelCommand from './delete.js';
+// Mock dependencies
+vi.mock('@/utils/user-config.js');
+vi.mock('@/utils/prompt.js');
+vi.mock('@/services/authorization-service.js');
+vi.mock('consola');
+vi.mock('std-env', () => ({
+    isCI: false,
+}));
+describe('apps-channels-delete', () => {
+    const mockUserConfig = vi.mocked(userConfig);
+    const mockPrompt = vi.mocked(prompt);
+    const mockConsola = vi.mocked(consola);
+    const mockAuthorizationService = vi.mocked(authorizationService);
+    beforeEach(() => {
+        vi.clearAllMocks();
+        mockUserConfig.read.mockReturnValue({ token: 'test-token' });
+        mockAuthorizationService.getCurrentAuthorizationToken.mockReturnValue('test-token');
+        mockAuthorizationService.hasAuthorizationToken.mockReturnValue(true);
+        vi.spyOn(process, 'exit').mockImplementation((code) => {
+            throw new Error(`Process exited with code ${code}`);
+        });
+    });
+    afterEach(() => {
+        nock.cleanAll();
+        vi.restoreAllMocks();
+    });
+    it('should delete channel with provided appId and channelId after confirmation', async () => {
+        const appId = 'app-123';
+        const channelId = 'channel-456';
+        const testToken = 'test-token';
+        const options = { appId, channelId };
+        mockPrompt.mockResolvedValueOnce(true); // confirmation
+        const scope = nock(DEFAULT_API_BASE_URL)
+            .delete(`/v1/apps/${appId}/channels/${channelId}`)
+            .matchHeader('Authorization', `Bearer ${testToken}`)
+            .reply(200);
+        await deleteChannelCommand.action(options, undefined);
+        expect(scope.isDone()).toBe(true);
+        expect(mockPrompt).toHaveBeenCalledWith('Are you sure you want to delete this channel?', {
+            type: 'confirm',
+        });
+        expect(mockConsola.success).toHaveBeenCalledWith('Channel deleted successfully.');
+    });
+    it('should delete channel with provided appId and name after confirmation', async () => {
+        const appId = 'app-123';
+        const channelName = 'production';
+        const testToken = 'test-token';
+        const options = { appId, name: channelName };
+        mockPrompt.mockResolvedValueOnce(true); // confirmation
+        const scope = nock(DEFAULT_API_BASE_URL)
+            .delete(`/v1/apps/${appId}/channels`)
+            .query({ name: channelName })
+            .matchHeader('Authorization', `Bearer ${testToken}`)
+            .reply(200);
+        await deleteChannelCommand.action(options, undefined);
+        expect(scope.isDone()).toBe(true);
+        expect(mockConsola.success).toHaveBeenCalledWith('Channel deleted successfully.');
+    });
+    it('should not delete channel when confirmation is declined', async () => {
+        const appId = 'app-123';
+        const channelId = 'channel-456';
+        const options = { appId, channelId };
+        mockPrompt.mockResolvedValueOnce(false); // declined confirmation
+        await deleteChannelCommand.action(options, undefined);
+        expect(mockPrompt).toHaveBeenCalledWith('Are you sure you want to delete this channel?', {
+            type: 'confirm',
+        });
+        expect(mockConsola.success).not.toHaveBeenCalled();
+    });
+    it('should prompt for app selection when appId not provided', async () => {
+        const orgId = 'org-1';
+        const appId = 'app-1';
+        const channelName = 'staging';
+        const testToken = 'test-token';
+        const organization = { id: orgId, name: 'Org 1' };
+        const app = { id: appId, name: 'App 1' };
+        const options = { name: channelName };
+        const orgsScope = nock(DEFAULT_API_BASE_URL)
+            .get('/v1/organizations')
+            .matchHeader('Authorization', `Bearer ${testToken}`)
+            .reply(200, [organization]);
+        const appsScope = nock(DEFAULT_API_BASE_URL)
+            .get('/v1/apps')
+            .query({ organizationId: orgId })
+            .matchHeader('Authorization', `Bearer ${testToken}`)
+            .reply(200, [app]);
+        const deleteScope = nock(DEFAULT_API_BASE_URL)
+            .delete(`/v1/apps/${appId}/channels`)
+            .query({ name: channelName })
+            .matchHeader('Authorization', `Bearer ${testToken}`)
+            .reply(200);
+        mockPrompt
+            .mockResolvedValueOnce(orgId) // organization selection
+            .mockResolvedValueOnce(appId) // app selection
+            .mockResolvedValueOnce(true); // confirmation
+        await deleteChannelCommand.action(options, undefined);
+        expect(orgsScope.isDone()).toBe(true);
+        expect(appsScope.isDone()).toBe(true);
+        expect(deleteScope.isDone()).toBe(true);
+        expect(mockConsola.success).toHaveBeenCalledWith('Channel deleted successfully.');
+    });
+    it('should prompt for channel name when neither channelId nor name provided', async () => {
+        const appId = 'app-123';
+        const channelName = 'development';
+        const testToken = 'test-token';
+        const options = { appId };
+        const scope = nock(DEFAULT_API_BASE_URL)
+            .delete(`/v1/apps/${appId}/channels`)
+            .query({ name: channelName })
+            .matchHeader('Authorization', `Bearer ${testToken}`)
+            .reply(200);
+        mockPrompt
+            .mockResolvedValueOnce(channelName) // channel name input
+            .mockResolvedValueOnce(true); // confirmation
+        await deleteChannelCommand.action(options, undefined);
+        expect(scope.isDone()).toBe(true);
+        expect(mockPrompt).toHaveBeenCalledWith('Enter the channel name:', { type: 'text' });
+        expect(mockConsola.success).toHaveBeenCalledWith('Channel deleted successfully.');
+    });
+    it('should handle API error during deletion', async () => {
+        const appId = 'app-123';
+        const channelId = 'channel-456';
+        const testToken = 'test-token';
+        const options = { appId, channelId };
+        mockPrompt.mockResolvedValueOnce(true);
+        const scope = nock(DEFAULT_API_BASE_URL)
+            .delete(`/v1/apps/${appId}/channels/${channelId}`)
+            .matchHeader('Authorization', `Bearer ${testToken}`)
+            .reply(404, { message: 'Channel not found' });
+        await expect(deleteChannelCommand.action(options, undefined)).rejects.toThrow();
+        expect(scope.isDone()).toBe(true);
+    });
+});

package/dist/commands/apps/channels/get.js

@@ -1,106 +1,64 @@
-"use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const citty_1 = require("citty");
-const consola_1 = __importDefault(require("consola"));
-const app_channels_1 = __importDefault(require("../../../services/app-channels"));
-const authorization_service_1 = __importDefault(require("../../../services/authorization-service"));
-const error_1 = require("../../../utils/error");
-exports.default = (0, citty_1.defineCommand)({
-    meta: {
-        description: 'Get an existing app channel.',
-    },
-    args: {
-        appId: {
-            type: 'string',
-            description: 'ID of the app.',
-        },
-        channelId: {
-            type: 'string',
-            description: 'ID of the channel.',
-        },
-        json: {
-            type: 'boolean',
-            description: 'Output in JSON format.',
-        },
-        name: {
-            type: 'string',
-            description: 'Name of the channel.',
-        },
-    },
-    run: (ctx) => __awaiter(void 0, void 0, void 0, function* () {
-        if (!authorization_service_1.default.hasAuthorizationToken()) {
-            consola_1.default.error('You must be logged in to run this command.');
+import appChannelsService from '../../../services/app-channels.js';
+import authorizationService from '../../../services/authorization-service.js';
+import { defineCommand, defineOptions } from '@robingenz/zli';
+import consola from 'consola';
+import { z } from 'zod';
+export default defineCommand({
+    description: 'Get an existing app channel.',
+    options: defineOptions(z.object({
+        appId: z.string().optional().describe('ID of the app.'),
+        channelId: z.string().optional().describe('ID of the channel.'),
+        json: z.boolean().optional().describe('Output in JSON format.'),
+        name: z.string().optional().describe('Name of the channel.'),
+    })),
+    action: async (options, args) => {
+        let { appId, channelId, json, name } = options;
+        if (!authorizationService.hasAuthorizationToken()) {
+            consola.error('You must be logged in to run this command.');
             process.exit(1);
         }
-        let appId = ctx.args.appId;
-        let channelId = ctx.args.channelId;
-        let json = ctx.args.json;
-        // Convert json to boolean
-        if (typeof json === 'string') {
-            json = json.toLowerCase() === 'true';
-        }
-        let name = ctx.args.name;
         if (!appId) {
-            consola_1.default.error('You must provide an app ID.');
+            consola.error('You must provide an app ID.');
             process.exit(1);
         }
         if (!channelId && !name) {
-            consola_1.default.error('You must provide a channel ID or name.');
+            consola.error('You must provide a channel ID or name.');
             process.exit(1);
         }
-        try {
-            let channel;
-            if (channelId) {
-                channel = yield app_channels_1.default.findOneById({
-                    appId,
-                    id: channelId,
-                });
-            }
-            else if (name) {
-                const foundChannels = yield app_channels_1.default.findAll({
-                    appId,
-                    name,
-                });
-                channel = foundChannels[0];
-            }
-            if (!channel) {
-                consola_1.default.error('Channel not found.');
-                process.exit(1);
-            }
-            if (json) {
-                console.log(JSON.stringify({
-                    id: channel.id,
-                    name: channel.name,
-                    totalAppBundleLimit: channel.totalAppBundleLimit,
-                    appId: channel.appId,
-                }, null, 2));
-            }
-            else {
-                console.table({
-                    id: channel.id,
-                    name: channel.name,
-                    totalAppBundleLimit: channel.totalAppBundleLimit,
-                    appId: channel.appId,
-                });
-                consola_1.default.success('Channel retrieved successfully.');
-            }
+        let channel;
+        if (channelId) {
+            channel = await appChannelsService.findOneById({
+                appId,
+                id: channelId,
+            });
+        }
+        else if (name) {
+            const foundChannels = await appChannelsService.findAll({
+                appId,
+                name,
+            });
+            channel = foundChannels[0];
         }
-        catch (error) {
-            const message = (0, error_1.getMessageFromUnknownError)(error);
-            consola_1.default.error(message);
+        if (!channel) {
+            consola.error('Channel not found.');
             process.exit(1);
         }
-    }),
+        if (json) {
+            console.log(JSON.stringify({
+                id: channel.id,
+                name: channel.name,
+                totalAppBundleLimit: channel.totalAppBundleLimit,
+                appId: channel.appId,
+            }, null, 2));
+        }
+        else {
+            console.table({
+                id: channel.id,
+                name: channel.name,
+                totalAppBundleLimit: channel.totalAppBundleLimit,
+                appId: channel.appId,
+            });
+            consola.success('Channel retrieved successfully.');
+        }
+    },
 });

package/dist/commands/apps/channels/get.test.js

@@ -0,0 +1,135 @@
+import { DEFAULT_API_BASE_URL } from '../../../config/consts.js';
+import authorizationService from '../../../services/authorization-service.js';
+import userConfig from '../../../utils/user-config.js';
+import consola from 'consola';
+import nock from 'nock';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import getChannelCommand from './get.js';
+// Mock dependencies
+vi.mock('@/utils/user-config.js');
+vi.mock('@/services/authorization-service.js');
+vi.mock('consola');
+describe('apps-channels-get', () => {
+    const mockUserConfig = vi.mocked(userConfig);
+    const mockConsola = vi.mocked(consola);
+    const mockAuthorizationService = vi.mocked(authorizationService);
+    beforeEach(() => {
+        vi.clearAllMocks();
+        mockUserConfig.read.mockReturnValue({ token: 'test-token' });
+        mockAuthorizationService.hasAuthorizationToken.mockReturnValue(true);
+        mockAuthorizationService.getCurrentAuthorizationToken.mockReturnValue('test-token');
+        vi.spyOn(process, 'exit').mockImplementation((code) => {
+            throw new Error(`Process exited with code ${code}`);
+        });
+        vi.spyOn(console, 'log').mockImplementation(() => { });
+        vi.spyOn(console, 'table').mockImplementation(() => { });
+    });
+    afterEach(() => {
+        nock.cleanAll();
+        vi.restoreAllMocks();
+    });
+    it('should require authentication', async () => {
+        const appId = 'app-123';
+        const channelId = 'channel-456';
+        const options = { appId, channelId };
+        // Mock no authentication token
+        mockAuthorizationService.getCurrentAuthorizationToken.mockReturnValue(null);
+        const scope = nock(DEFAULT_API_BASE_URL)
+            .get(`/v1/apps/${appId}/channels/${channelId}`)
+            .matchHeader('Authorization', 'Bearer null')
+            .reply(401, { message: 'Unauthorized' });
+        await expect(getChannelCommand.action(options, undefined)).rejects.toThrow();
+        expect(scope.isDone()).toBe(true);
+    });
+    it('should require appId', async () => {
+        const channelId = 'channel-456';
+        const options = { channelId, appId: undefined };
+        await expect(getChannelCommand.action(options, undefined)).rejects.toThrow('Process exited with code 1');
+        expect(mockConsola.error).toHaveBeenCalledWith('You must provide an app ID.');
+    });
+    it('should require channelId or name', async () => {
+        const appId = 'app-123';
+        const options = { appId, channelId: undefined, name: undefined };
+        await expect(getChannelCommand.action(options, undefined)).rejects.toThrow('Process exited with code 1');
+        expect(mockConsola.error).toHaveBeenCalledWith('You must provide a channel ID or name.');
+    });
+    it('should get channel by channelId and display table format', async () => {
+        const appId = 'app-123';
+        const channelId = 'channel-456';
+        const testToken = 'test-token';
+        const channel = {
+            id: channelId,
+            name: 'production',
+            totalAppBundleLimit: 10,
+            appId,
+        };
+        const options = { appId, channelId };
+        const scope = nock(DEFAULT_API_BASE_URL)
+            .get(`/v1/apps/${appId}/channels/${channelId}`)
+            .matchHeader('Authorization', `Bearer ${testToken}`)
+            .reply(200, channel);
+        await getChannelCommand.action(options, undefined);
+        expect(scope.isDone()).toBe(true);
+        expect(console.table).toHaveBeenCalledWith(channel);
+        expect(mockConsola.success).toHaveBeenCalledWith('Channel retrieved successfully.');
+    });
+    it('should get channel by name and display JSON format', async () => {
+        const appId = 'app-123';
+        const channelName = 'staging';
+        const testToken = 'test-token';
+        const channel = {
+            id: 'channel-789',
+            name: channelName,
+            totalAppBundleLimit: 5,
+            appId,
+        };
+        const options = { appId, name: channelName, json: true };
+        const scope = nock(DEFAULT_API_BASE_URL)
+            .get(`/v1/apps/${appId}/channels`)
+            .query({ name: channelName })
+            .matchHeader('Authorization', `Bearer ${testToken}`)
+            .reply(200, [channel]);
+        await getChannelCommand.action(options, undefined);
+        expect(scope.isDone()).toBe(true);
+        expect(console.log).toHaveBeenCalledWith(JSON.stringify(channel, null, 2));
+        expect(mockConsola.success).not.toHaveBeenCalled();
+    });
+    it('should handle channel not found by channelId', async () => {
+        const appId = 'app-123';
+        const channelId = 'channel-456';
+        const testToken = 'test-token';
+        const options = { appId, channelId };
+        const scope = nock(DEFAULT_API_BASE_URL)
+            .get(`/v1/apps/${appId}/channels/${channelId}`)
+            .matchHeader('Authorization', `Bearer ${testToken}`)
+            .reply(404, { message: 'Channel not found' });
+        await expect(getChannelCommand.action(options, undefined)).rejects.toThrow();
+        expect(scope.isDone()).toBe(true);
+    });
+    it('should handle channel not found by name', async () => {
+        const appId = 'app-123';
+        const channelName = 'nonexistent';
+        const testToken = 'test-token';
+        const options = { appId, name: channelName };
+        const scope = nock(DEFAULT_API_BASE_URL)
+            .get(`/v1/apps/${appId}/channels`)
+            .query({ name: channelName })
+            .matchHeader('Authorization', `Bearer ${testToken}`)
+            .reply(200, []);
+        await expect(getChannelCommand.action(options, undefined)).rejects.toThrow('Process exited with code 1');
+        expect(scope.isDone()).toBe(true);
+        expect(mockConsola.error).toHaveBeenCalledWith('Channel not found.');
+    });
+    it('should handle API error', async () => {
+        const appId = 'app-123';
+        const channelId = 'channel-456';
+        const testToken = 'test-token';
+        const options = { appId, channelId };
+        const scope = nock(DEFAULT_API_BASE_URL)
+            .get(`/v1/apps/${appId}/channels/${channelId}`)
+            .matchHeader('Authorization', `Bearer ${testToken}`)
+            .reply(500, { message: 'Internal server error' });
+        await expect(getChannelCommand.action(options, undefined)).rejects.toThrow();
+        expect(scope.isDone()).toBe(true);
+    });
+});