@dk/jolly 0.1.0

package/src/commands/app.ts

@@ -0,0 +1,126 @@
+import { SaleorCloudClient } from '../api/client.js';
+import { requireToken } from '../api/auth.js';
+import { success, error, info } from '../tui/components.js';
+
+type AppType = 'dashboard-extension' | 'payment' | 'webhook';
+type PaymentProvider = 'dummy' | 'stripe';
+
+const APP_TEMPLATES = {
+  'dashboard-extension': {
+    repo: 'https://github.com/saleor/saleor-app-sdk',
+    description: 'Dashboard Extension App',
+  },
+  payment: {
+    repo: 'https://github.com/saleor/saleor-apps',
+    description: 'Payment App',
+  },
+  webhook: {
+    repo: 'https://github.com/saleor/saleor-webhook-template',
+    description: 'Webhook Handler',
+  },
+};
+
+const PAYMENT_APP_URLS = {
+  dummy: 'https://dummy-payment.saleor.io',
+  stripe: 'https://stripe-payment.saleor.io',
+};
+
+export async function createApp(
+  name: string,
+  type: AppType,
+  environmentId?: string,
+  provider?: PaymentProvider
+): Promise<void> {
+  info(`Creating ${type} app: ${name}`);
+
+  if (type === 'payment') {
+    const paymentProvider = provider || 'dummy';
+    info(`Payment provider: ${paymentProvider}`);
+    info(`Using hosted payment app: ${PAYMENT_APP_URLS[paymentProvider]}`);
+
+    if (environmentId) {
+      await registerHostedApp(environmentId, name, paymentProvider);
+    } else {
+      success(`\nPayment app "${name}" configured to use ${PAYMENT_APP_URLS[paymentProvider]}`);
+      info(`\nTo complete setup:`);
+      info(`1. Go to your dashboard at https://cloud.saleor.io`);
+      info(`2. Navigate to Apps > Third party apps`);
+      info(`3. Add the ${paymentProvider} payment app from ${PAYMENT_APP_URLS[paymentProvider]}`);
+    }
+    return;
+  }
+
+  const template = APP_TEMPLATES[type];
+  info(`Cloning template from: ${template.repo}`);
+
+  try {
+    const { spawn } = await import('child_process');
+    const child = spawn('git', ['clone', template.repo, name], {
+      stdio: 'inherit',
+    });
+
+    child.on('close', (code) => {
+      if (code === 0) {
+        success(`\n${type} app "${name}" created successfully!`);
+        info(`\nTo get started:`);
+        info(`cd ${name}`);
+        info(`npm install`);
+        info(`npm run dev`);
+
+        if (environmentId) {
+          info(`\nRegistering app with environment ${environmentId}...`);
+          registerLocalApp(environmentId, name, type);
+        }
+      } else {
+        error(`Failed to clone template (exit code: ${code})`);
+        process.exit(1);
+      }
+    });
+  } catch (err) {
+    error(`Failed to create app: ${err}`);
+    process.exit(1);
+  }
+}
+
+async function registerHostedApp(
+  environmentId: string,
+  name: string,
+  provider: PaymentProvider
+): Promise<void> {
+  const token = requireToken();
+  const client = new SaleorCloudClient(token);
+
+  info(`Registering hosted ${provider} payment app with environment...`);
+
+  try {
+    const result = await client.registerApp(environmentId, 'payment', name);
+    success(`Payment app registered successfully!`);
+    info(`App ID: ${result.app.id}`);
+    info(`Payment URL: ${PAYMENT_APP_URLS[provider]}`);
+  } catch (err) {
+    error(`Failed to register app: ${err}`);
+    process.exit(1);
+  }
+}
+
+async function registerLocalApp(
+  environmentId: string,
+  name: string,
+  type: AppType
+): Promise<void> {
+  const token = requireToken();
+  const client = new SaleorCloudClient(token);
+
+  try {
+    const result = await client.registerApp(environmentId, type, name);
+    success(`App registered with environment!`);
+    info(`App ID: ${result.app.id}`);
+  } catch (err) {
+    warning(`Could not register app automatically: ${err}`);
+    info(`You can register manually in the dashboard.`);
+  }
+}
+
+function warning(msg: string): void {
+  console.log(`\x1b[33m${msg}\x1b[0m`);
+}

package/src/commands/index.ts

@@ -0,0 +1 @@
+export {};

package/src/commands/store.ts

@@ -0,0 +1,64 @@
+import { SaleorCloudClient } from '../api/client.js';
+import { requireToken } from '../api/auth.js';
+import { spinner, success, error, info } from '../tui/components.js';
+
+export async function createStore(name: string, region: string): Promise<void> {
+  const token = requireToken();
+  const client = new SaleorCloudClient(token);
+
+  info(`Creating store: ${name} in ${region}...`);
+
+  try {
+    const result = await client.createStore(name, region);
+    success(`Store created successfully!`);
+    info(`Store ID: ${result.store.id}`);
+    info(`Dashboard: https://cloud.saleor.io/stores/${result.store.id}`);
+  } catch (err) {
+    error(`Failed to create store: ${err}`);
+    process.exit(1);
+  }
+}
+
+export async function listStores(): Promise<void> {
+  const token = requireToken();
+  const client = new SaleorCloudClient(token);
+
+  info('Fetching stores...');
+
+  try {
+    const result = await client.getStores();
+
+    if (result.stores.length === 0) {
+      info('No stores found. Create one with: jolly store create --name <name>');
+      return;
+    }
+
+    success(`Found ${result.stores.length} store(s):\n`);
+    for (const store of result.stores) {
+      console.log(`  ${store.name} (${store.id})`);
+      console.log(`    Region: ${store.region}`);
+      console.log(`    Created: ${new Date(store.created_at).toLocaleDateString()}`);
+      console.log();
+    }
+  } catch (err) {
+    error(`Failed to list stores: ${err}`);
+    process.exit(1);
+  }
+}
+
+export async function createEnvironment(storeId: string, name: string): Promise<void> {
+  const token = requireToken();
+  const client = new SaleorCloudClient(token);
+
+  info(`Creating environment: ${name} for store ${storeId}...`);
+
+  try {
+    const result = await client.createEnvironment(storeId, name);
+    success(`Environment created successfully!`);
+    info(`Environment ID: ${result.environment.id}`);
+    info(`API URL will be available at: https://${result.environment.id}.saleor.cloud`);
+  } catch (err) {
+    error(`Failed to create environment: ${err}`);
+    process.exit(1);
+  }
+}

package/src/test/command-handlers.test.ts

@@ -0,0 +1,227 @@
+import { describe, expect, mock, beforeEach, afterEach } from 'bun:test';
+import { Given, When, Then } from './helpers';
+import {
+  fixtures, captureConsole, mockFetch, mockFetchError,
+  mockProcessExit, withToken, withoutToken,
+} from './mocks';
+
+const tuiCalls: { fn: string; msg: string }[] = [];
+mock.module('../tui/components', () => ({
+  info: (msg: string) => { tuiCalls.push({ fn: 'info', msg }); return msg; },
+  success: (msg: string) => { tuiCalls.push({ fn: 'success', msg }); return msg; },
+  error: (msg: string) => { tuiCalls.push({ fn: 'error', msg }); return msg; },
+  warning: (msg: string) => { tuiCalls.push({ fn: 'warning', msg }); return msg; },
+  spinner: () => ({ stop: () => {} }),
+}));
+
+describe('Command Handlers', () => {
+  let console_: ReturnType<typeof captureConsole>;
+  let exitSpy: ReturnType<typeof mockProcessExit>;
+  const originalFetch = globalThis.fetch;
+
+  beforeEach(() => {
+    console_ = captureConsole();
+    exitSpy = mockProcessExit();
+    tuiCalls.length = 0;
+    withToken();
+  });
+
+  afterEach(() => {
+    console_.restore();
+    exitSpy.mockRestore();
+    globalThis.fetch = originalFetch;
+    withoutToken();
+  });
+
+  describe('Store Handlers', () => {
+    Given('a valid token and successful API', () => {
+      When('calling createStore', () => {
+        Then('it should call POST /stores with name and region', async () => {
+          const fetchMock = mockFetch({
+            '/stores': { store: fixtures.store },
+          });
+
+          const { createStore } = await import('../commands/store');
+          await createStore('my-store', 'us-east-1');
+
+          expect(fetchMock).toHaveBeenCalledTimes(1);
+          const [url, opts] = fetchMock.mock.calls[0];
+          expect(url).toContain('/stores');
+          expect(opts.method).toBe('POST');
+          expect(JSON.parse(opts.body)).toEqual({ name: 'my-store', region: 'us-east-1' });
+        });
+      });
+
+      When('calling listStores with results', () => {
+        Then('it should display store names and IDs', async () => {
+          mockFetch({
+            '/stores': { stores: [fixtures.store, fixtures.store2] },
+          });
+
+          const { listStores } = await import('../commands/store');
+          await listStores();
+
+          const allOutput = console_.logs.join('\n');
+          expect(allOutput).toContain('my-store');
+          expect(allOutput).toContain('store-1');
+          expect(allOutput).toContain('other-store');
+          expect(allOutput).toContain('store-2');
+        });
+      });
+
+      When('calling listStores with empty results', () => {
+        Then('it should display a helpful message', async () => {
+          mockFetch({
+            '/stores': { stores: [] },
+          });
+
+          const { listStores } = await import('../commands/store');
+          await listStores();
+
+          const infoMessages = tuiCalls.filter(c => c.fn === 'info').map(c => c.msg).join('\n');
+          expect(infoMessages).toContain('No stores found');
+        });
+      });
+
+      When('calling createEnvironment', () => {
+        Then('it should call POST /stores/:id/environments', async () => {
+          const fetchMock = mockFetch({
+            '/stores/store-1/environments': { environment: fixtures.environment },
+          });
+
+          const { createEnvironment } = await import('../commands/store');
+          await createEnvironment('store-1', 'staging');
+
+          expect(fetchMock).toHaveBeenCalledTimes(1);
+          const [url, opts] = fetchMock.mock.calls[0];
+          expect(url).toContain('/stores/store-1/environments');
+          expect(opts.method).toBe('POST');
+          expect(JSON.parse(opts.body)).toEqual({ name: 'staging' });
+        });
+      });
+    });
+
+    Given('a valid token but failing API', () => {
+      When('calling createStore and API returns 500', () => {
+        Then('it should print error and exit 1', async () => {
+          mockFetchError(500, 'Internal Server Error');
+
+          const { createStore } = await import('../commands/store');
+
+          try {
+            await createStore('fail-store', 'us-east-1');
+          } catch {}
+
+          expect(exitSpy).toHaveBeenCalledWith(1);
+        });
+      });
+
+      When('calling listStores and API returns 401', () => {
+        Then('it should print error and exit 1', async () => {
+          mockFetchError(401, 'Unauthorized');
+
+          const { listStores } = await import('../commands/store');
+
+          try {
+            await listStores();
+          } catch {}
+
+          expect(exitSpy).toHaveBeenCalledWith(1);
+        });
+      });
+
+      When('calling createEnvironment and API returns 404', () => {
+        Then('it should print error and exit 1', async () => {
+          mockFetchError(404, 'Not Found');
+
+          const { createEnvironment } = await import('../commands/store');
+
+          try {
+            await createEnvironment('bad-store', 'staging');
+          } catch {}
+
+          expect(exitSpy).toHaveBeenCalledWith(1);
+        });
+      });
+    });
+
+    Given('no token is set', () => {
+      When('calling createStore', () => {
+        Then('it should exit with code 1 from requireToken', async () => {
+          withoutToken();
+
+          const { createStore } = await import('../commands/store');
+
+          try {
+            await createStore('no-token-store', 'us-east-1');
+          } catch {}
+
+          expect(exitSpy).toHaveBeenCalledWith(1);
+        });
+      });
+
+      When('calling listStores', () => {
+        Then('it should exit with code 1 from requireToken', async () => {
+          withoutToken();
+
+          const { listStores } = await import('../commands/store');
+
+          try {
+            await listStores();
+          } catch {}
+
+          expect(exitSpy).toHaveBeenCalledWith(1);
+        });
+      });
+    });
+  });
+
+  describe('App Handlers', () => {
+    Given('a payment app with no environment', () => {
+      When('calling createApp', () => {
+        Then('it should print hosted payment app instructions', async () => {
+          const { createApp } = await import('../commands/app');
+          await createApp('pay-app', 'payment', undefined, 'stripe');
+
+          const allTuiOutput = tuiCalls.map(c => c.msg).join('\n');
+          expect(allTuiOutput).toContain('payment');
+          expect(allTuiOutput).toContain('stripe');
+        });
+      });
+    });
+
+    Given('a payment app with environment and valid token', () => {
+      When('calling createApp', () => {
+        Then('it should register the hosted app via API', async () => {
+          const fetchMock = mockFetch({
+            '/environments/env-1/apps': { app: fixtures.app },
+          });
+
+          const { createApp } = await import('../commands/app');
+          await createApp('pay-app', 'payment', 'env-1', 'dummy');
+
+          expect(fetchMock).toHaveBeenCalledTimes(1);
+          const [url, opts] = fetchMock.mock.calls[0];
+          expect(url).toContain('/environments/env-1/apps');
+          expect(opts.method).toBe('POST');
+        });
+      });
+    });
+
+    Given('a payment app with environment but failing API', () => {
+      When('calling createApp', () => {
+        Then('it should print error and exit 1', async () => {
+          mockFetchError(500, 'Internal Server Error');
+
+          const { createApp } = await import('../commands/app');
+
+          try {
+            await createApp('pay-app', 'payment', 'env-1', 'dummy');
+          } catch {}
+
+          expect(exitSpy).toHaveBeenCalledWith(1);
+        });
+      });
+    });
+  });
+});

package/src/test/e2e-flows.test.ts

@@ -0,0 +1,212 @@
+import { describe, expect, mock, beforeEach, afterEach } from 'bun:test';
+import { Given, When, Then, And } from './helpers';
+import {
+  fixtures, captureConsole, mockFetch, mockFetchError,
+  mockProcessExit, withToken, withoutToken,
+} from './mocks';
+
+const tuiCalls: { fn: string; msg: string }[] = [];
+mock.module('../tui/components', () => ({
+  info: (msg: string) => { tuiCalls.push({ fn: 'info', msg }); return msg; },
+  success: (msg: string) => { tuiCalls.push({ fn: 'success', msg }); return msg; },
+  error: (msg: string) => { tuiCalls.push({ fn: 'error', msg }); return msg; },
+  warning: (msg: string) => { tuiCalls.push({ fn: 'warning', msg }); return msg; },
+  spinner: () => ({ stop: () => {} }),
+}));
+
+describe('End-to-End Flows', () => {
+  let console_: ReturnType<typeof captureConsole>;
+  let exitSpy: ReturnType<typeof mockProcessExit>;
+  const originalFetch = globalThis.fetch;
+
+  beforeEach(() => {
+    console_ = captureConsole();
+    exitSpy = mockProcessExit();
+    tuiCalls.length = 0;
+    withToken();
+  });
+
+  afterEach(() => {
+    console_.restore();
+    exitSpy.mockRestore();
+    globalThis.fetch = originalFetch;
+    withoutToken();
+  });
+
+  describe('Store Creation Flow', () => {
+    Given('a valid token and working API', () => {
+      When('creating a store end-to-end', () => {
+        Then('it should call API and display store ID and dashboard URL', async () => {
+          const fetchMock = mockFetch({
+            '/stores': { store: fixtures.store },
+          });
+
+          const { createStore } = await import('../commands/store');
+          await createStore('my-store', 'us-east-1');
+
+          expect(fetchMock).toHaveBeenCalledTimes(1);
+
+          const allTui = tuiCalls.map(c => c.msg).join('\n');
+          expect(allTui).toContain('store-1');
+          expect(allTui).toContain('cloud.saleor.io/stores/store-1');
+        });
+      });
+    });
+  });
+
+  describe('Store List Flow', () => {
+    Given('a valid token and multiple stores', () => {
+      When('listing stores end-to-end', () => {
+        Then('it should display all stores with regions and dates', async () => {
+          mockFetch({
+            '/stores': { stores: [fixtures.store, fixtures.store2] },
+          });
+
+          const { listStores } = await import('../commands/store');
+          await listStores();
+
+          const allTui = tuiCalls.map(c => c.msg).join('\n');
+          const allConsole = console_.logs.join('\n');
+          expect(allTui).toContain('2 store(s)');
+          expect(allConsole).toContain('my-store');
+          expect(allConsole).toContain('us-east-1');
+          expect(allConsole).toContain('other-store');
+          expect(allConsole).toContain('eu-west-1');
+        });
+      });
+    });
+  });
+
+  describe('Environment Creation Flow', () => {
+    Given('a valid token and existing store', () => {
+      When('creating an environment end-to-end', () => {
+        Then('it should call API and display environment ID and URL', async () => {
+          const fetchMock = mockFetch({
+            '/stores/store-1/environments': { environment: fixtures.environment },
+          });
+
+          const { createEnvironment } = await import('../commands/store');
+          await createEnvironment('store-1', 'staging');
+
+          expect(fetchMock).toHaveBeenCalledTimes(1);
+
+          const allTui = tuiCalls.map(c => c.msg).join('\n');
+          expect(allTui).toContain('env-1');
+          expect(allTui).toContain('saleor.cloud');
+        });
+      });
+    });
+  });
+
+  describe('Payment App Registration Flow', () => {
+    Given('a valid token and environment', () => {
+      When('creating a payment app with environment', () => {
+        Then('it should register via API and display app ID', async () => {
+          const fetchMock = mockFetch({
+            '/environments/env-1/apps': { app: fixtures.app },
+          });
+
+          const { createApp } = await import('../commands/app');
+          await createApp('my-payment', 'payment', 'env-1', 'stripe');
+
+          expect(fetchMock).toHaveBeenCalledTimes(1);
+
+          const allTui = tuiCalls.map(c => c.msg).join('\n');
+          expect(allTui).toContain('app-1');
+          expect(allTui).toContain('stripe');
+        });
+      });
+    });
+
+    Given('a valid token but no environment', () => {
+      When('creating a payment app without environment', () => {
+        Then('it should display manual setup instructions', async () => {
+          const { createApp } = await import('../commands/app');
+          await createApp('my-payment', 'payment', undefined, 'stripe');
+
+          const allTui = tuiCalls.map(c => c.msg).join('\n');
+          expect(allTui).toContain('stripe');
+          expect(allTui).toContain('cloud.saleor.io');
+          expect(allTui).toContain('Third party apps');
+        });
+      });
+    });
+  });
+
+  describe('Full Error Recovery Flow', () => {
+    Given('no token set', () => {
+      When('attempting any store operation', () => {
+        Then('it should fail fast with auth error before API call', async () => {
+          withoutToken();
+          const fetchMock = mockFetch({ '/stores': { stores: [] } });
+
+          const { listStores } = await import('../commands/store');
+
+          try {
+            await listStores();
+          } catch {}
+
+          expect(exitSpy).toHaveBeenCalledWith(1);
+          expect(fetchMock).not.toHaveBeenCalled();
+        });
+      });
+    });
+
+    Given('a valid token but network failure', () => {
+      And('the API returns 500', () => {
+        When('creating a store', () => {
+          Then('it should display the error and exit 1', async () => {
+            mockFetchError(500, 'Internal Server Error');
+
+            const { createStore } = await import('../commands/store');
+
+            try {
+              await createStore('fail-store', 'us-east-1');
+            } catch {}
+
+            expect(exitSpy).toHaveBeenCalledWith(1);
+          });
+        });
+      });
+    });
+  });
+
+  describe('API Client Request Construction', () => {
+    Given('a SaleorCloudClient', () => {
+      When('creating a store', () => {
+        Then('it should send correct URL, method, headers, and body', async () => {
+          const fetchMock = mockFetch({
+            '/stores': { store: fixtures.store },
+          });
+
+          const { SaleorCloudClient } = await import('../api/client');
+          const client = new SaleorCloudClient(fixtures.token);
+          await client.createStore('test-store', 'eu-west-1');
+
+          expect(fetchMock).toHaveBeenCalledTimes(1);
+          const [url, opts] = fetchMock.mock.calls[0];
+          expect(url).toBe('https://cloud.saleor.io/api/stores');
+          expect(opts.method).toBe('POST');
+          expect(opts.headers.Authorization).toBe(`Bearer ${fixtures.token}`);
+          expect(JSON.parse(opts.body)).toEqual({ name: 'test-store', region: 'eu-west-1' });
+        });
+      });
+
+      When('registering an app', () => {
+        Then('it should send correct URL with environment ID', async () => {
+          const fetchMock = mockFetch({
+            '/environments/env-1/apps': { app: fixtures.app },
+          });
+
+          const { SaleorCloudClient } = await import('../api/client');
+          const client = new SaleorCloudClient(fixtures.token);
+          await client.registerApp('env-1', 'payment', 'my-app');
+
+          const [url, opts] = fetchMock.mock.calls[0];
+          expect(url).toBe('https://cloud.saleor.io/api/environments/env-1/apps');
+          expect(JSON.parse(opts.body)).toEqual({ type: 'payment', name: 'my-app' });
+        });
+      });
+    });
+  });
+});