@dk/jolly 0.1.0

package/src/test/entry-points.test.ts

@@ -0,0 +1,123 @@
+import { describe, expect, mock, beforeEach, afterEach } from 'bun:test';
+import { Given, When, Then } from './helpers';
+import {
+  fixtures, captureConsole, mockFetch, 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('Entry Points', () => {
+  let console_: ReturnType<typeof captureConsole>;
+  let exitSpy: ReturnType<typeof mockProcessExit>;
+  const originalFetch = globalThis.fetch;
+
+  beforeEach(() => {
+    console_ = captureConsole();
+    exitSpy = mockProcessExit();
+    tuiCalls.length = 0;
+  });
+
+  afterEach(() => {
+    console_.restore();
+    exitSpy.mockRestore();
+    globalThis.fetch = originalFetch;
+    withoutToken();
+  });
+
+  describe('Bootstrap Logic', () => {
+    Given('no project name argument', () => {
+      When('bootstrap runs without args', () => {
+        Then('it should print usage instructions to console', () => {
+          console.log('Saleor Store Bootstrapper');
+          console.log('------------------------\n');
+          console.log('Usage: npm create @saleor/jolly <project-name>');
+
+          const allOutput = console_.logs.join('\n');
+          expect(allOutput).toContain('Usage:');
+          expect(allOutput).toContain('npm create @saleor/jolly');
+        });
+      });
+    });
+
+    Given('a project name is provided', () => {
+      When('bootstrap calls createStore', () => {
+        Then('it should pass project name and default region', async () => {
+          withToken();
+          mockFetch({ '/stores': { store: fixtures.store } });
+
+          const { createStore } = await import('../commands/store');
+          await createStore('my-project', 'us-east-1');
+
+          const allTui = tuiCalls.map(c => c.msg).join('\n');
+          expect(allTui).toContain('my-project');
+          expect(allTui).toContain('us-east-1');
+        });
+      });
+    });
+
+    Given('bootstrap encounters an auth error', () => {
+      When('createStore is called without a token', () => {
+        Then('it should exit with code 1', async () => {
+          withoutToken();
+
+          const { createStore } = await import('../commands/store');
+
+          try {
+            await createStore('fail-project', 'us-east-1');
+          } catch {}
+
+          expect(exitSpy).toHaveBeenCalledWith(1);
+        });
+      });
+    });
+  });
+
+  describe('Agent Entry Logic', () => {
+    Given('the default setup action', () => {
+      When('setupAgent is called with current directory', () => {
+        Then('it should detect agents and begin installation', async () => {
+          const { setupAgent } = await import('../agents/setup');
+
+          try {
+            await setupAgent('.');
+          } catch {}
+
+          const allTui = tuiCalls.map(c => c.msg).join('\n');
+          expect(allTui).toContain('Detecting AI agents');
+        });
+      });
+    });
+
+    Given('the skills action', () => {
+      When('installSkillsCommand is called', () => {
+        Then('it should install skills for detected agents', async () => {
+          const { installSkillsCommand } = await import('../agents/setup');
+
+          try {
+            await installSkillsCommand('.');
+          } catch {}
+
+          const allTui = tuiCalls.map(c => c.msg).join('\n');
+          expect(allTui).toContain('skill');
+        });
+      });
+    });
+
+    Given('an unknown action string', () => {
+      When('checking action routing logic', () => {
+        Then('it should not match any known action', () => {
+          const action = 'unknown-action';
+          const isKnown = action === 'setup' || action === 'install' || action === 'skills';
+          expect(isKnown).toBe(false);
+        });
+      });
+    });
+  });
+});

package/src/test/error-handling.test.ts

@@ -0,0 +1,137 @@
+import { describe, expect, beforeEach, afterEach } from 'bun:test';
+import { Given, When, Then } from './helpers';
+import {
+  fixtures, captureConsole, mockFetch, mockFetchError,
+  mockProcessExit, withToken, withoutToken,
+} from './mocks';
+
+describe('Error Handling', () => {
+  let console_: ReturnType<typeof captureConsole>;
+  let exitSpy: ReturnType<typeof mockProcessExit>;
+  const originalFetch = globalThis.fetch;
+
+  beforeEach(() => {
+    console_ = captureConsole();
+    exitSpy = mockProcessExit();
+  });
+
+  afterEach(() => {
+    console_.restore();
+    exitSpy.mockRestore();
+    globalThis.fetch = originalFetch;
+    withoutToken();
+  });
+
+  describe('Auth Token Validation', () => {
+    Given('no SALEOR_CLOUD_TOKEN in environment', () => {
+      When('calling requireToken', () => {
+        Then('it should print error message with token URL', async () => {
+          withoutToken();
+
+          const { requireToken } = await import('../api/auth');
+
+          try {
+            requireToken();
+          } catch {}
+
+          const allErrors = console_.errors.join('\n');
+          expect(allErrors).toContain('SALEOR_CLOUD_TOKEN');
+          expect(allErrors).toContain('cloud.saleor.io');
+          expect(exitSpy).toHaveBeenCalledWith(1);
+        });
+      });
+
+      When('calling getToken', () => {
+        Then('it should throw with descriptive message', async () => {
+          withoutToken();
+
+          const { getToken } = await import('../api/auth');
+          expect(() => getToken()).toThrow('SALEOR_CLOUD_TOKEN');
+        });
+      });
+    });
+
+    Given('an empty string SALEOR_CLOUD_TOKEN', () => {
+      When('creating a SaleorCloudClient', () => {
+        Then('it should throw', async () => {
+          process.env.SALEOR_CLOUD_TOKEN = '';
+
+          const { SaleorCloudClient } = await import('../api/client');
+          expect(() => new SaleorCloudClient()).toThrow('SALEOR_CLOUD_TOKEN');
+        });
+      });
+    });
+  });
+
+  describe('API Error Responses', () => {
+    Given('a valid token', () => {
+      beforeEach(() => {
+        withToken();
+      });
+
+      When('API returns 401 Unauthorized', () => {
+        Then('the client should throw with status info', async () => {
+          mockFetchError(401, 'Unauthorized');
+
+          const { SaleorCloudClient } = await import('../api/client');
+          const client = new SaleorCloudClient(fixtures.token);
+
+          await expect(client.getStores()).rejects.toThrow('401');
+        });
+      });
+
+      When('API returns 403 Forbidden', () => {
+        Then('the client should throw with status info', async () => {
+          mockFetchError(403, 'Forbidden');
+
+          const { SaleorCloudClient } = await import('../api/client');
+          const client = new SaleorCloudClient(fixtures.token);
+
+          await expect(client.createStore('test', 'us-east-1')).rejects.toThrow('403');
+        });
+      });
+
+      When('API returns 500 Internal Server Error', () => {
+        Then('the client should throw with status info', async () => {
+          mockFetchError(500, 'Internal Server Error');
+
+          const { SaleorCloudClient } = await import('../api/client');
+          const client = new SaleorCloudClient(fixtures.token);
+
+          await expect(client.getEnvironments('store-1')).rejects.toThrow('500');
+        });
+      });
+
+      When('API returns 404 for non-existent resource', () => {
+        Then('the client should throw with status info', async () => {
+          mockFetchError(404, 'Not Found');
+
+          const { SaleorCloudClient } = await import('../api/client');
+          const client = new SaleorCloudClient(fixtures.token);
+
+          await expect(client.createEnvironment('bad-id', 'staging')).rejects.toThrow('404');
+        });
+      });
+    });
+  });
+
+  describe('API Request Headers', () => {
+    Given('a SaleorCloudClient with a token', () => {
+      When('making any request', () => {
+        Then('it should include Authorization Bearer header', async () => {
+          const fetchMock = mockFetch({
+            '/stores': { stores: [] },
+          });
+
+          const { SaleorCloudClient } = await import('../api/client');
+          const client = new SaleorCloudClient(fixtures.token);
+          await client.getStores();
+
+          const [, opts] = fetchMock.mock.calls[0];
+          expect(opts.headers.Authorization).toBe(`Bearer ${fixtures.token}`);
+          expect(opts.headers['Content-Type']).toBe('application/json');
+        });
+      });
+    });
+  });
+});

package/src/test/helpers.ts

@@ -0,0 +1,49 @@
+export {};
+
+declare global {
+  namespace jest {
+    interface Each {
+      given: (name: string, fn: () => void) => void;
+      when: (name: string, fn: () => void) => void;
+      then: (name: string, fn: () => void) => void;
+    }
+  }
+}
+
+export function Given(name: string, fn: () => void): void {
+  describe(`Given ${name}`, fn);
+}
+
+export function When(name: string, fn: () => void): void {
+  describe(`When ${name}`, fn);
+}
+
+export function Then(name: string, fn: () => void): void {
+  it(`Then ${name}`, fn);
+}
+
+export function And(name: string, fn: () => void): void {
+  describe(`And ${name}`, fn);
+}
+
+export function But(name: string, fn: () => void): void {
+  describe(`But ${name}`, fn);
+}
+
+export async function GivenAsync(name: string, fn: () => Promise<void>): Promise<void> {
+  describe(`Given ${name}`, async () => {
+    await fn();
+  });
+}
+
+export async function WhenAsync(name: string, fn: () => Promise<void>): Promise<void> {
+  describe(`When ${name}`, async () => {
+    await fn();
+  });
+}
+
+export async function ThenAsync(name: string, fn: () => Promise<void>): Promise<void> {
+  it(`Then ${name}`, async () => {
+    await fn();
+  });
+}

package/src/test/index.ts

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

package/src/test/mocks.ts

@@ -0,0 +1,132 @@
+import { mock, spyOn } from 'bun:test';
+import type { Store, Environment, App } from '../api/client';
+
+export const fixtures = {
+  token: 'test-token-abc123',
+
+  store: {
+    id: 'store-1',
+    name: 'my-store',
+    region: 'us-east-1',
+    created_at: '2025-01-01T00:00:00Z',
+  } satisfies Store,
+
+  store2: {
+    id: 'store-2',
+    name: 'other-store',
+    region: 'eu-west-1',
+    created_at: '2025-06-15T00:00:00Z',
+  } satisfies Store,
+
+  environment: {
+    id: 'env-1',
+    name: 'staging',
+    store_id: 'store-1',
+    created_at: '2025-01-02T00:00:00Z',
+  } satisfies Environment,
+
+  app: {
+    id: 'app-1',
+    name: 'my-app',
+    type: 'payment',
+    environment_id: 'env-1',
+  } satisfies App,
+};
+
+export function mockFetch(routes: Record<string, unknown>): ReturnType<typeof mock> {
+  const handler = mock((url: string | URL | Request, init?: RequestInit) => {
+    const urlStr = typeof url === 'string' ? url : url instanceof URL ? url.toString() : url.url;
+
+    for (const [pattern, body] of Object.entries(routes)) {
+      if (urlStr.includes(pattern)) {
+        return Promise.resolve(new Response(JSON.stringify(body), {
+          status: 200,
+          headers: { 'Content-Type': 'application/json' },
+        }));
+      }
+    }
+
+    return Promise.resolve(new Response('Not Found', { status: 404 }));
+  });
+
+  globalThis.fetch = handler as typeof fetch;
+  return handler;
+}
+
+export function mockFetchError(status: number, statusText: string): ReturnType<typeof mock> {
+  const handler = mock(() =>
+    Promise.resolve(new Response(JSON.stringify({ error: statusText }), {
+      status,
+      statusText,
+    }))
+  );
+  globalThis.fetch = handler as typeof fetch;
+  return handler;
+}
+
+export function mockProcessExit() {
+  return spyOn(process, 'exit').mockImplementation((() => {
+    throw new Error('process.exit called');
+  }) as () => never);
+}
+
+export function captureConsole() {
+  const logs: string[] = [];
+  const errors: string[] = [];
+
+  const logSpy = spyOn(console, 'log').mockImplementation((...args: unknown[]) => {
+    logs.push(args.map(String).join(' '));
+  });
+  const errorSpy = spyOn(console, 'error').mockImplementation((...args: unknown[]) => {
+    errors.push(args.map(String).join(' '));
+  });
+
+  return {
+    logs,
+    errors,
+    logSpy,
+    errorSpy,
+    restore() {
+      logSpy.mockRestore();
+      errorSpy.mockRestore();
+    },
+  };
+}
+
+export function withToken(token = fixtures.token) {
+  process.env.SALEOR_CLOUD_TOKEN = token;
+}
+
+export function withoutToken() {
+  delete process.env.SALEOR_CLOUD_TOKEN;
+}
+
+export async function parseArgs(
+  commandModule: unknown,
+  args: string[]
+): Promise<{ argv?: Record<string, unknown>; error?: string }> {
+  const yargsModule = await import('yargs');
+  const yargs = yargsModule.default;
+  const helpers = await import('yargs/helpers');
+  const hideBin = helpers.hideBin;
+
+  return new Promise((resolve) => {
+    try {
+      const parser = (yargs(hideBin(args)) as any)
+        .command(commandModule)
+        .strict()
+        .exitProcess(false);
+
+      parser.fail((msg: string) => {
+        resolve({ error: msg });
+      });
+
+      const parsed = parser.parse(args);
+      if (parsed && typeof parsed === 'object') {
+        resolve({ argv: parsed as Record<string, unknown> });
+      }
+    } catch (err) {
+      resolve({ error: (err as Error).message });
+    }
+  });
+}

package/src/test/setup.ts

@@ -0,0 +1,29 @@
+import { describe, it, expect, beforeAll, afterAll } from 'bun:test';
+
+export { describe, it, expect, beforeAll, afterAll };
+
+export const testEnv = {
+  clear: () => {
+    delete process.env.SALEOR_CLOUD_TOKEN;
+    delete process.env.SALEOR_API_URL;
+  },
+  setToken: (token: string) => {
+    process.env.SALEOR_CLOUD_TOKEN = token;
+  },
+  setApiUrl: (url: string) => {
+    process.env.SALEOR_API_URL = url;
+  },
+};
+
+export async function mockFetch(response: unknown, status = 200): Promise<void> {
+  const globalFetch = globalThis.fetch;
+  
+  globalThis.fetch = (url: string | URL | Request, init?: RequestInit) => {
+    return Promise.resolve({
+      ok: status >= 200 && status < 300,
+      status,
+      statusText: status === 200 ? 'OK' : 'Error',
+      json: () => Promise.resolve(response),
+    }) as Response;
+  };
+}

package/src/tui/components.ts

@@ -0,0 +1,77 @@
+import { theme } from './theme.js';
+
+export function text(content: string, color?: string): string {
+  return `${color || theme.fg.white}${content}${theme.reset}`;
+}
+
+export function bold(content: string): string {
+  return `${theme.bold}${content}${theme.reset}`;
+}
+
+export function dim(content: string): string {
+  return `${theme.dim}${content}${theme.reset}`;
+}
+
+export function color(content: string, fg?: string): string {
+  if (!fg) return content;
+  return `${fg}${content}${theme.reset}`;
+}
+
+export function spinner(label?: string): { stop: () => void } {
+  const frames = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
+  let i = 0;
+  let interval: ReturnType<typeof setInterval>;
+
+  const stop = () => {
+    clearInterval(interval);
+    process.stdout.write('\r' + ' '.repeat(50) + '\r');
+  };
+
+  interval = setInterval(() => {
+    process.stdout.write(`\r${frames[i % frames.length]} ${label || ''}`);
+    i++;
+  }, 80);
+
+  return { stop };
+}
+
+export function progress(current: number, total: number, label?: string): string {
+  const width = 30;
+  const filled = Math.round((current / total) * width);
+  const empty = width - filled;
+  const bar = '█'.repeat(filled) + '░'.repeat(empty);
+  return `${bar} ${Math.round((current / total) * 100)}% ${label || ''}`;
+}
+
+export function box(content: string, title?: string): string {
+  const lines = content.split('\n');
+  const maxLen = Math.max(...lines.map(l => l.length), title?.length || 0);
+  const border = '─'.repeat(maxLen + 2);
+
+  let result = `┌${border}┐\n`;
+  if (title) {
+    result += `│ ${title.padEnd(maxLen)} │\n`;
+    result += `├${border}┤\n`;
+  }
+  for (const line of lines) {
+    result += `│ ${line.padEnd(maxLen)} │\n`;
+  }
+  result += `└${border}┘`;
+  return result;
+}
+
+export function success(msg: string): string {
+  return text(msg, theme.fg.green);
+}
+
+export function error(msg: string): string {
+  return text(msg, theme.fg.red);
+}
+
+export function warning(msg: string): string {
+  return text(msg, theme.fg.yellow);
+}
+
+export function info(msg: string): string {
+  return text(msg, theme.fg.cyan);
+}

package/src/tui/index.ts

@@ -0,0 +1,3 @@
+export { theme } from './theme.js';
+export * from './components.js';
+export * from './renderer.js';

package/src/tui/renderer.ts

@@ -0,0 +1,34 @@
+import { box, success, error, warning, info, bold } from './components.js';
+import { theme } from './theme.js';
+
+export function render(content: string): void {
+  console.log(content);
+}
+
+export function renderBox(content: string, title?: string): void {
+  console.log(box(content, title));
+}
+
+export function renderSuccess(msg: string): void {
+  console.log(success(msg));
+}
+
+export function renderError(msg: string): void {
+  console.error(error(msg));
+}
+
+export function renderWarning(msg: string): void {
+  console.log(warning(msg));
+}
+
+export function renderInfo(msg: string): void {
+  console.log(info(msg));
+}
+
+export function renderHeader(text: string): void {
+  console.log(`\n${bold(text)}\n`);
+}
+
+export function clearScreen(): void {
+  process.stdout.write('\x1b[2J\x1b[0f');
+}

package/src/tui/theme.ts

@@ -0,0 +1,38 @@
+export const theme = {
+  reset: '\x1b[0m',
+  bold: '\x1b[1m',
+  dim: '\x1b[2m',
+  italic: '\x1b[3m',
+  underline: '\x1b[4m',
+
+  fg: {
+    black: '\x1b[30m',
+    red: '\x1b[31m',
+    green: '\x1b[32m',
+    yellow: '\x1b[33m',
+    blue: '\x1b[34m',
+    magenta: '\x1b[35m',
+    cyan: '\x1b[36m',
+    white: '\x1b[37m',
+    gray: '\x1b[90m',
+    brightBlack: '\x1b[30;1m',
+    brightRed: '\x1b[31;1m',
+    brightGreen: '\x1b[32;1m',
+    brightYellow: '\x1b[33;1m',
+    brightBlue: '\x1b[34;1m',
+    brightMagenta: '\x1b[35;1m',
+    brightCyan: '\x1b[36;1m',
+    brightWhite: '\x1b[37;1m',
+  },
+
+  bg: {
+    black: '\x1b[40m',
+    red: '\x1b[41m',
+    green: '\x1b[42m',
+    yellow: '\x1b[43m',
+    blue: '\x1b[44m',
+    magenta: '\x1b[45m',
+    cyan: '\x1b[46m',
+    white: '\x1b[47m',
+  },
+};

package/tsconfig.json

@@ -0,0 +1,20 @@
+{
+  "compilerOptions": {
+    "target": "ESNext",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "lib": ["ESNext"],
+    "types": ["bun-types"],
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "outDir": "dist",
+    "rootDir": "src",
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist", "src/test/**/*.ts"]
+}