@dk/jolly 0.1.5 → 0.1.7

package/src/api/client.ts

@@ -10,63 +10,136 @@ export class SaleorCloudClient {
   }
 
   async request<T>(endpoint: string, options?: RequestInit): Promise<T> {
-    const response = await fetch(`${this.baseUrl}${endpoint}`, {
+    const mergedOptions: RequestInit = {
+      method: options?.method || 'GET',
       ...options,
       headers: {
-        'Authorization': `Bearer ${this.token}`,
+        'Authorization': `Token ${this.token}`,
         'Content-Type': 'application/json',
         ...options?.headers,
       },
-    });
+    };
+
+    const response = await fetch(`${this.baseUrl}${endpoint}`, mergedOptions);
 
     if (!response.ok) {
-      throw new Error(`API error: ${response.status} ${response.statusText}`);
+      const body = await response.text();
+      throw new Error(`API error: ${response.status} ${response.statusText} - ${body}`);
     }
 
-    return response.json();
+    return response.json() as T;
   }
 
-  async getStores() {
-    return this.request<{ stores: Store[] }>('/stores');
+  // Organizations
+  async getOrganizations() {
+    return this.request<{ organizations: Organization[] }>('/organizations');
   }
 
-  async createStore(name: string, region: string = 'us-east-1') {
-    return this.request<{ store: Store }>('/stores', {
+  // Projects
+  async getProjects(organizationSlug: string) {
+    return this.request<{ projects: Project[] }>(`/organizations/${organizationSlug}/projects`);
+  }
+
+  async createProject(organizationSlug: string, name: string, region: string) {
+    return this.request<{ project: Project }>(`/organizations/${organizationSlug}/projects`, {
       method: 'POST',
       body: JSON.stringify({ name, region }),
     });
   }
 
-  async getEnvironments(storeId: string) {
-    return this.request<{ environments: Environment[] }>(`/stores/${storeId}/environments`);
+  // Environments
+  async getEnvironments(organizationSlug: string, projectSlug: string) {
+    return this.request<{ environments: Environment[] }>(
+      `/organizations/${organizationSlug}/projects/${projectSlug}/environments`
+    );
   }
 
-  async createEnvironment(storeId: string, name: string) {
-    return this.request<{ environment: Environment }>(`/stores/${storeId}/environments`, {
-      method: 'POST',
-      body: JSON.stringify({ name }),
-    });
+  async createEnvironment(organizationSlug: string, projectSlug: string, name: string, region: string) {
+    return this.request<{ environment: Environment; task: Task }>(
+      `/organizations/${organizationSlug}/projects/${projectSlug}/environments`,
+      {
+        method: 'POST',
+        body: JSON.stringify({ name, region }),
+      }
+    );
   }
 
+  async getEnvironment(organizationSlug: string, projectSlug: string, environmentSlug: string) {
+    return this.request<Environment>(
+      `/organizations/${organizationSlug}/projects/${projectSlug}/environments/${environmentSlug}`
+    );
+  }
+
+  // Apps
   async registerApp(environmentId: string, appType: string, name: string) {
     return this.request<{ app: App }>(`/environments/${environmentId}/apps`, {
       method: 'POST',
       body: JSON.stringify({ type: appType, name }),
     });
   }
+
+  // Backward compatibility methods
+  async getStores() {
+    return this.getOrganizations();
+  }
+
+  async createStore(name: string, region: string = 'us-east-1') {
+    // Create organization as "store" - requires org slug
+    // For now, create in first available org
+    const { organizations } = await this.getOrganizations();
+    if (organizations.length === 0) {
+      throw new Error('No organizations found. Create one at https://cloud.saleor.io');
+    }
+    return this.createProject(organizations[0].slug, name, region);
+  }
+
+  async createEnvironmentFromStore(storeId: string, name: string) {
+    // storeId is used as organization slug for backward compatibility
+    const { environments } = await this.getEnvironments(storeId, 'default');
+    // Create sandbox environment
+    return this.createEnvironment(storeId, environments.length > 0 ? environments[0].project?.slug || 'default' : 'default', name, 'default');
+  }
 }
 
-export interface Store {
-  id: string;
+export interface Organization {
+  slug: string;
+  name: string;
+  created: string;
+  company_name?: string;
+  owner_email: string;
+}
+
+export interface Project {
+  slug: string;
   name: string;
   region: string;
-  created_at: string;
+  created: string;
+  billing_period?: { start: string };
+  sandboxes: { count: number };
 }
 
 export interface Environment {
+  key: string;
+  name: string;
+  domain: string;
+  service: {
+    version: string;
+    type: string;
+    region: string;
+  };
+  created: string;
+  project: { name: string; slug: string };
+}
+
+export interface Task {
+  id: string;
+  status: string;
+}
+
+export interface Store {
   id: string;
   name: string;
-  store_id: string;
+  region: string;
   created_at: string;
 }
 

package/src/commands/app.ts

@@ -31,27 +31,27 @@ export async function createApp(
   environmentId?: string,
   provider?: PaymentProvider
 ): Promise<void> {
-  info(`Creating ${type} app: ${name}`);
+  console.log(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]}`);
+    console.log(info(`Payment provider: ${paymentProvider}`));
+    console.log(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]}`);
+      console.log(success(`\nPayment app "${name}" configured to use ${PAYMENT_APP_URLS[paymentProvider]}`));
+      console.log(info(`\nTo complete setup:`));
+      console.log(info(`1. Go to your dashboard at https://cloud.saleor.io`));
+      console.log(info(`2. Navigate to Apps > Third party apps`));
+      console.log(info(`3. Add the ${paymentProvider} payment app from ${PAYMENT_APP_URLS[paymentProvider]}`));
     }
     return;
   }
 
   const template = APP_TEMPLATES[type];
-  info(`Cloning template from: ${template.repo}`);
+  console.log(info(`Cloning template from: ${template.repo}`));
 
   try {
     const { spawn } = await import('child_process');
@@ -61,23 +61,23 @@ export async function createApp(
 
     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`);
+        console.log(success(`\n${type} app "${name}" created successfully!`));
+        console.log(info(`\nTo get started:`));
+        console.log(info(`cd ${name}`));
+        console.log(info(`npm install`));
+        console.log(info(`npm run dev`));
 
         if (environmentId) {
-          info(`\nRegistering app with environment ${environmentId}...`);
+          console.log(info(`\nRegistering app with environment ${environmentId}...`));
           registerLocalApp(environmentId, name, type);
         }
       } else {
-        error(`Failed to clone template (exit code: ${code})`);
+        console.log(error(`Failed to clone template (exit code: ${code})`));
         process.exit(1);
       }
     });
   } catch (err) {
-    error(`Failed to create app: ${err}`);
+    console.log(error(`Failed to create app: ${err}`));
     process.exit(1);
   }
 }
@@ -90,15 +90,15 @@ async function registerHostedApp(
   const token = requireToken();
   const client = new SaleorCloudClient(token);
 
-  info(`Registering hosted ${provider} payment app with environment...`);
+  console.log(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]}`);
+    console.log(success(`Payment app registered successfully!`));
+    console.log(info(`App ID: ${result.app.id}`));
+    console.log(info(`Payment URL: ${PAYMENT_APP_URLS[provider]}`));
   } catch (err) {
-    error(`Failed to register app: ${err}`);
+    console.log(error(`Failed to register app: ${err}`));
     process.exit(1);
   }
 }
@@ -113,11 +113,11 @@ async function registerLocalApp(
 
   try {
     const result = await client.registerApp(environmentId, type, name);
-    success(`App registered with environment!`);
-    info(`App ID: ${result.app.id}`);
+    console.log(success(`App registered with environment!`));
+    console.log(info(`App ID: ${result.app.id}`));
   } catch (err) {
-    warning(`Could not register app automatically: ${err}`);
-    info(`You can register manually in the dashboard.`);
+    console.log(warning(`Could not register app automatically: ${err}`));
+    console.log(info(`You can register manually in the dashboard.`));
   }
 }
 

package/src/commands/store.ts

@@ -1,20 +1,20 @@
 import { SaleorCloudClient } from '../api/client.js';
 import { requireToken } from '../api/auth.js';
-import { spinner, success, error, info } from '../tui/components.js';
+import { 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}...`);
+  console.log(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}`);
+    console.log(success(`Store created successfully!`));
+    console.log(info(`Project slug: ${result.project.slug}`));
+    console.log(info(`Dashboard: https://cloud.saleor.io/organizations/default/projects/${result.project.slug}`));
   } catch (err) {
-    error(`Failed to create store: ${err}`);
+    console.log(error(`Failed to create store: ${err}`));
     process.exit(1);
   }
 }
@@ -23,42 +23,42 @@ export async function listStores(): Promise<void> {
   const token = requireToken();
   const client = new SaleorCloudClient(token);
 
-  info('Fetching stores...');
+  console.log(info('Fetching organizations...'));
 
   try {
-    const result = await client.getStores();
+    const { organizations } = await client.getOrganizations();
 
-    if (result.stores.length === 0) {
-      info('No stores found. Create one with: jolly store create --name <name>');
+    if (organizations.length === 0) {
+      console.log(info('No organizations found. Create one at https://cloud.saleor.io'));
       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(success(`Found ${organizations.length} organization(s):\n`));
+    for (const org of organizations) {
+      console.log(`  ${org.name} (${org.slug})`);
+      console.log(`    Email: ${org.owner_email}`);
+      console.log(`    Created: ${new Date(org.created).toLocaleDateString()}`);
       console.log();
     }
   } catch (err) {
-    error(`Failed to list stores: ${err}`);
+    console.log(error(`Failed to list stores: ${err}`));
     process.exit(1);
   }
 }
 
-export async function createEnvironment(storeId: string, name: string): Promise<void> {
+export async function createEnvironment(organizationSlug: string, name: string): Promise<void> {
   const token = requireToken();
   const client = new SaleorCloudClient(token);
 
-  info(`Creating environment: ${name} for store ${storeId}...`);
+  console.log(info(`Creating environment: ${name} for organization ${organizationSlug}...`));
 
   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`);
+    const { environment } = await client.createEnvironment(organizationSlug, 'default', name, 'us-east-1');
+    console.log(success(`Environment created successfully!`));
+    console.log(info(`Environment key: ${environment.key}`));
+    console.log(info(`Domain: ${environment.domain}`));
   } catch (err) {
-    error(`Failed to create environment: ${err}`);
+    console.log(error(`Failed to create environment: ${err}`));
     process.exit(1);
   }
 }

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

@@ -36,67 +36,72 @@ describe('Command Handlers', () => {
   describe('Store Handlers', () => {
     Given('a valid token and successful API', () => {
       When('calling createStore', () => {
-        Then('it should call POST /stores with name and region', async () => {
+        Then('it should call POST /organizations/:slug/projects with name and region', async () => {
           const fetchMock = mockFetch({
-            '/stores': { store: fixtures.store },
+            '/organizations': { organizations: [fixtures.organization] },
+            '/organizations/my-org/projects': { project: fixtures.project },
           });
 
           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' });
+          expect(fetchMock).toHaveBeenCalled();
+          const createCall = fetchMock.mock.calls.find(([url]: [string]) => 
+            (url as string).includes('/organizations/my-org/projects')
+          );
+          expect(createCall).toBeDefined();
+          expect(createCall?.[1].method).toBe('POST');
+          expect(JSON.parse(createCall?.[1].body)).toEqual({ name: 'my-store', region: 'us-east-1' });
         });
       });
 
       When('calling listStores with results', () => {
-        Then('it should display store names and IDs', async () => {
+        Then('it should display organization names and slugs', async () => {
           mockFetch({
-            '/stores': { stores: [fixtures.store, fixtures.store2] },
+            '/organizations': { organizations: [fixtures.organization, fixtures.organization2] },
           });
 
           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');
+          expect(allOutput).toContain('My Organization');
+          expect(allOutput).toContain('my-org');
+          expect(allOutput).toContain('Other Organization');
+          expect(allOutput).toContain('other-org');
         });
       });
 
       When('calling listStores with empty results', () => {
         Then('it should display a helpful message', async () => {
           mockFetch({
-            '/stores': { stores: [] },
+            '/organizations': { organizations: [] },
           });
 
           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');
+          expect(infoMessages).toContain('No organizations found');
         });
       });
 
       When('calling createEnvironment', () => {
-        Then('it should call POST /stores/:id/environments', async () => {
+        Then('it should call POST /organizations/:slug/projects/:slug/environments', async () => {
           const fetchMock = mockFetch({
-            '/stores/store-1/environments': { environment: fixtures.environment },
+            '/organizations/my-org/projects/default/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' });
+          await createEnvironment('my-org', 'staging');
+
+          expect(fetchMock).toHaveBeenCalled();
+          const createCall = fetchMock.mock.calls.find(([url]: [string]) => 
+            (url as string).includes('/organizations/my-org/projects/default/environments')
+          );
+          expect(createCall).toBeDefined();
+          expect(createCall?.[1].method).toBe('POST');
+          expect(JSON.parse(createCall?.[1].body)).toEqual({ name: 'staging', region: 'us-east-1' });
         });
       });
     });
@@ -137,7 +142,7 @@ describe('Command Handlers', () => {
           const { createEnvironment } = await import('../commands/store');
 
           try {
-            await createEnvironment('bad-store', 'staging');
+            await createEnvironment('bad-org', 'staging');
           } catch {}
 
           expect(exitSpy).toHaveBeenCalledWith(1);
@@ -194,15 +199,15 @@ describe('Command Handlers', () => {
       When('calling createApp', () => {
         Then('it should register the hosted app via API', async () => {
           const fetchMock = mockFetch({
-            '/environments/env-1/apps': { app: fixtures.app },
+            '/environments/staging/apps': { app: fixtures.app },
           });
 
           const { createApp } = await import('../commands/app');
-          await createApp('pay-app', 'payment', 'env-1', 'dummy');
+          await createApp('pay-app', 'payment', 'staging', 'dummy');
 
           expect(fetchMock).toHaveBeenCalledTimes(1);
           const [url, opts] = fetchMock.mock.calls[0];
-          expect(url).toContain('/environments/env-1/apps');
+          expect(url).toContain('/environments/staging/apps');
           expect(opts.method).toBe('POST');
         });
       });
@@ -216,7 +221,7 @@ describe('Command Handlers', () => {
           const { createApp } = await import('../commands/app');
 
           try {
-            await createApp('pay-app', 'payment', 'env-1', 'dummy');
+            await createApp('pay-app', 'payment', 'staging', 'dummy');
           } catch {}
 
           expect(exitSpy).toHaveBeenCalledWith(1);

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

@@ -36,30 +36,31 @@ describe('End-to-End Flows', () => {
   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 () => {
+        Then('it should call API and display project slug and dashboard URL', async () => {
           const fetchMock = mockFetch({
-            '/stores': { store: fixtures.store },
+            '/organizations': { organizations: [fixtures.organization] },
+            '/organizations/my-org/projects': { project: fixtures.project },
           });
 
           const { createStore } = await import('../commands/store');
           await createStore('my-store', 'us-east-1');
 
-          expect(fetchMock).toHaveBeenCalledTimes(1);
+          expect(fetchMock).toHaveBeenCalled();
 
           const allTui = tuiCalls.map(c => c.msg).join('\n');
-          expect(allTui).toContain('store-1');
-          expect(allTui).toContain('cloud.saleor.io/stores/store-1');
+          expect(allTui).toContain('my-store');
+          expect(allTui).toContain('cloud.saleor.io');
         });
       });
     });
   });
 
   describe('Store List Flow', () => {
-    Given('a valid token and multiple stores', () => {
+    Given('a valid token and multiple organizations', () => {
       When('listing stores end-to-end', () => {
-        Then('it should display all stores with regions and dates', async () => {
+        Then('it should display all organizations with emails and dates', async () => {
           mockFetch({
-            '/stores': { stores: [fixtures.store, fixtures.store2] },
+            '/organizations': { organizations: [fixtures.organization, fixtures.organization2] },
           });
 
           const { listStores } = await import('../commands/store');
@@ -67,31 +68,31 @@ describe('End-to-End Flows', () => {
 
           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');
+          expect(allTui).toContain('2 organization(s)');
+          expect(allConsole).toContain('My Organization');
+          expect(allConsole).toContain('owner@example.com');
+          expect(allConsole).toContain('Other Organization');
+          expect(allConsole).toContain('other@example.com');
         });
       });
     });
   });
 
   describe('Environment Creation Flow', () => {
-    Given('a valid token and existing store', () => {
+    Given('a valid token and existing organization', () => {
       When('creating an environment end-to-end', () => {
-        Then('it should call API and display environment ID and URL', async () => {
+        Then('it should call API and display environment key and domain', async () => {
           const fetchMock = mockFetch({
-            '/stores/store-1/environments': { environment: fixtures.environment },
+            '/organizations/my-org/projects/default/environments': { environment: fixtures.environment },
           });
 
           const { createEnvironment } = await import('../commands/store');
-          await createEnvironment('store-1', 'staging');
+          await createEnvironment('my-org', 'staging');
 
-          expect(fetchMock).toHaveBeenCalledTimes(1);
+          expect(fetchMock).toHaveBeenCalled();
 
           const allTui = tuiCalls.map(c => c.msg).join('\n');
-          expect(allTui).toContain('env-1');
+          expect(allTui).toContain('staging');
           expect(allTui).toContain('saleor.cloud');
         });
       });
@@ -103,11 +104,11 @@ describe('End-to-End Flows', () => {
       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 },
+            '/environments/staging/apps': { app: fixtures.app },
           });
 
           const { createApp } = await import('../commands/app');
-          await createApp('my-payment', 'payment', 'env-1', 'stripe');
+          await createApp('my-payment', 'payment', 'staging', 'stripe');
 
           expect(fetchMock).toHaveBeenCalledTimes(1);
 
@@ -138,7 +139,7 @@ describe('End-to-End Flows', () => {
       When('attempting any store operation', () => {
         Then('it should fail fast with auth error before API call', async () => {
           withoutToken();
-          const fetchMock = mockFetch({ '/stores': { stores: [] } });
+          const fetchMock = mockFetch({ '/organizations': { organizations: [] } });
 
           const { listStores } = await import('../commands/store');
 
@@ -173,37 +174,55 @@ describe('End-to-End Flows', () => {
 
   describe('API Client Request Construction', () => {
     Given('a SaleorCloudClient', () => {
-      When('creating a store', () => {
+      When('listing organizations', () => {
+        Then('it should send correct URL, method, and headers', async () => {
+          const fetchMock = mockFetch({
+            '/organizations': { organizations: [fixtures.organization] },
+          });
+
+          const { SaleorCloudClient } = await import('../api/client');
+          const client = new SaleorCloudClient(fixtures.token);
+          await client.getOrganizations();
+
+          expect(fetchMock).toHaveBeenCalledTimes(1);
+          const [url, opts] = fetchMock.mock.calls[0];
+          expect(url).toBe('https://cloud.saleor.io/api/organizations');
+          expect(opts.method).toBe('GET');
+          expect(opts.headers.Authorization).toBe(`Token ${fixtures.token}`);
+        });
+      });
+
+      When('creating a project', () => {
         Then('it should send correct URL, method, headers, and body', async () => {
           const fetchMock = mockFetch({
-            '/stores': { store: fixtures.store },
+            '/organizations/default/projects': { project: fixtures.project },
           });
 
           const { SaleorCloudClient } = await import('../api/client');
           const client = new SaleorCloudClient(fixtures.token);
-          await client.createStore('test-store', 'eu-west-1');
+          await client.createProject('default', '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(url).toBe('https://cloud.saleor.io/api/organizations/default/projects');
           expect(opts.method).toBe('POST');
-          expect(opts.headers.Authorization).toBe(`Bearer ${fixtures.token}`);
+          expect(opts.headers.Authorization).toBe(`Token ${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 () => {
+        Then('it should send correct URL with environment key', async () => {
           const fetchMock = mockFetch({
-            '/environments/env-1/apps': { app: fixtures.app },
+            '/environments/staging/apps': { app: fixtures.app },
           });
 
           const { SaleorCloudClient } = await import('../api/client');
           const client = new SaleorCloudClient(fixtures.token);
-          await client.registerApp('env-1', 'payment', 'my-app');
+          await client.registerApp('staging', 'payment', 'my-app');
 
           const [url, opts] = fetchMock.mock.calls[0];
-          expect(url).toBe('https://cloud.saleor.io/api/environments/env-1/apps');
+          expect(url).toBe('https://cloud.saleor.io/api/environments/staging/apps');
           expect(JSON.parse(opts.body)).toEqual({ type: 'payment', name: 'my-app' });
         });
       });