@thorprovider/medusa-extended 1.3.0 → 1.5.0

package/src/dropshipper.test.ts

@@ -13,6 +13,7 @@ import { describe, expect, it } from 'vitest'
 import { http, HttpResponse } from 'msw'
 import { server } from '../stelorder/client.test-helpers'
 import { DropshipperClient } from './dropshipper'
+import { ProviderAPIError } from '@thorprovider/adapters'
 
 const BASE = 'https://medusa.example.com'
 const TOKEN = 'test-jwt-token'
@@ -372,6 +373,241 @@ describe('DropshipperClient.createOrder', () => {
     })
     expect(result.order.id).toBe('ord_new')
   })
+
+  it('POST /admin/thor/dropshipper/orders with province and city (geozone match)', async () => {
+    server.use(
+      http.post(`${BASE}/admin/thor/dropshipper/orders`, async ({ request }) => {
+        requireBearerToken(request)
+        const body = await request.json() as any
+        expect(body.shipping_address.province).toBe('La Habana')
+        expect(body.shipping_address.city).toBe('Centro Habana')
+        return HttpResponse.json({
+          order: {
+            id: 'ord_new',
+            display_id: 43,
+            status: 'pending',
+            subtotal: 4000,
+            tax_total: 0,
+            shipping_total: 1000,
+            discount_total: 0,
+            total: 5000,
+            profit: 2000,
+            created_at: '2026-01-01T00:00:00Z',
+            shipping_method: null,
+          },
+        })
+      }),
+    )
+
+    const result = await client().createOrder({
+      customer_id: 'cus_1',
+      currency_code: 'usd',
+      items: [{ variant_id: 'var_1', quantity: 1 }],
+      shipping_address: { full_name: 'John', address_1: '123 Main', city: 'Centro Habana', province: 'La Habana', postal_code: '10001', country_code: 'cu' },
+      payment_method_id: 'pm_1',
+    })
+    expect(result.order.id).toBe('ord_new')
+  })
+
+  it('POST /admin/thor/dropshipper/orders without province/city (geozone fallback)', async () => {
+    server.use(
+      http.post(`${BASE}/admin/thor/dropshipper/orders`, async ({ request }) => {
+        requireBearerToken(request)
+        const body = await request.json() as any
+        expect(body.shipping_address.province).toBeUndefined()
+        expect(body.shipping_address.city).toBe('Miami')
+        return HttpResponse.json({
+          order: {
+            id: 'ord_new',
+            display_id: 44,
+            status: 'pending',
+            subtotal: 3000,
+            tax_total: 0,
+            shipping_total: 500,
+            discount_total: 0,
+            total: 3500,
+            profit: 1500,
+            created_at: '2026-01-01T00:00:00Z',
+            shipping_method: null,
+          },
+        })
+      }),
+    )
+
+    const result = await client().createOrder({
+      customer_id: 'cus_2',
+      currency_code: 'usd',
+      items: [{ variant_id: 'var_2', quantity: 2 }],
+      shipping_address: { full_name: 'Jane', address_1: '456 Oak', city: 'Miami', postal_code: '33101', country_code: 'us' },
+      payment_method_id: 'pm_2',
+    })
+    expect(result.order.id).toBe('ord_new')
+  })
+
+  it('POST /admin/thor/dropshipper/orders with separate billing_address', async () => {
+    server.use(
+      http.post(`${BASE}/admin/thor/dropshipper/orders`, async ({ request }) => {
+        requireBearerToken(request)
+        const body = await request.json() as any
+        expect(body.billing_address).toBeDefined()
+        expect(body.billing_address.full_name).toBe('Jane Doe')
+        expect(body.billing_address.address_1).toBe('456 Main')
+        expect(body.billing_address.city).toBe('NY')
+        expect(body.billing_address.postal_code).toBe('10001')
+        expect(body.billing_address.country_code).toBe('us')
+        return HttpResponse.json({
+          order: {
+            id: 'ord_new',
+            display_id: 45,
+            status: 'pending',
+            subtotal: 5000,
+            tax_total: 0,
+            shipping_total: 1000,
+            discount_total: 0,
+            total: 6000,
+            profit: 2500,
+            created_at: '2026-01-01T00:00:00Z',
+            shipping_method: null,
+          },
+        })
+      }),
+    )
+
+    const result = await client().createOrder({
+      customer_id: 'cus_1',
+      currency_code: 'usd',
+      items: [{ variant_id: 'var_1', quantity: 1 }],
+      shipping_address: { full_name: 'John', address_1: '123 Main', city: 'NY', province: null, postal_code: '10001', country_code: 'us' },
+      billing_address: { full_name: 'Jane Doe', address_1: '456 Main', city: 'NY', province: null, postal_code: '10001', country_code: 'us' },
+      payment_method_id: 'pm_1',
+    })
+    expect(result.order.id).toBe('ord_new')
+  })
+
+  it('createOrder with dropshipper-collected payment method', async () => {
+    server.use(
+      http.post(`${BASE}/admin/thor/dropshipper/orders`, async ({ request }) => {
+        requireBearerToken(request)
+        const body = await request.json() as any
+        expect(body.payment_method_id).toBe('pm_dropshipper')
+        return HttpResponse.json({
+          order: {
+            id: 'ord_new',
+            display_id: 44,
+            status: 'pending',
+            subtotal: 4000,
+            tax_total: 0,
+            shipping_total: 1000,
+            discount_total: 0,
+            total: 5000,
+            profit: 2000,
+            created_at: '2026-01-01T00:00:00Z',
+            shipping_method: null,
+          },
+        })
+      }),
+    )
+
+    const result = await client().createOrder({
+      customer_id: 'cus_1',
+      currency_code: 'usd',
+      items: [{ variant_id: 'var_1', quantity: 1 }],
+      shipping_address: { full_name: 'John', address_1: '123 Main', city: 'NY', province: null, postal_code: '10001', country_code: 'us' },
+      payment_method_id: 'pm_dropshipper',
+    })
+    expect(result.order.id).toBe('ord_new')
+  })
+
+  it('createOrder with provider-collected payment method', async () => {
+    server.use(
+      http.post(`${BASE}/admin/thor/dropshipper/orders`, async ({ request }) => {
+        requireBearerToken(request)
+        const body = await request.json() as any
+        expect(body.payment_method_id).toBe('pm_provider')
+        return HttpResponse.json({
+          order: {
+            id: 'ord_new',
+            display_id: 45,
+            status: 'pending',
+            subtotal: 4000,
+            tax_total: 0,
+            shipping_total: 1000,
+            discount_total: 0,
+            total: 5000,
+            profit: 2000,
+            created_at: '2026-01-01T00:00:00Z',
+            shipping_method: null,
+          },
+        })
+      }),
+    )
+
+    const result = await client().createOrder({
+      customer_id: 'cus_1',
+      currency_code: 'usd',
+      items: [{ variant_id: 'var_1', quantity: 1 }],
+      shipping_address: { full_name: 'John', address_1: '123 Main', city: 'NY', province: null, postal_code: '10001', country_code: 'us' },
+      payment_method_id: 'pm_provider',
+    })
+    expect(result.order.id).toBe('ord_new')
+  })
+
+  it('throws ProviderAPIError on 422 for invalid variants', async () => {
+    server.use(
+      http.post(`${BASE}/admin/thor/dropshipper/orders`, async () => {
+        return HttpResponse.json(
+          { message: 'Invalid variants: var_invalid_1, var_invalid_2' },
+          { status: 422 },
+        )
+      }),
+    )
+
+    await expect(client().createOrder({
+      customer_id: 'cus_1',
+      currency_code: 'usd',
+      items: [{ variant_id: 'var_invalid_1', quantity: 1 }],
+      shipping_address: { full_name: 'John', address_1: '123 Main', city: 'NY', province: null, postal_code: '10001', country_code: 'us' },
+      payment_method_id: 'pm_1',
+    })).rejects.toThrow(ProviderAPIError)
+  })
+
+  it('throws ProviderAPIError on 404 for customer not found', async () => {
+    server.use(
+      http.post(`${BASE}/admin/thor/dropshipper/orders`, async () => {
+        return HttpResponse.json(
+          { message: 'Customer not found' },
+          { status: 404 },
+        )
+      }),
+    )
+
+    await expect(client().createOrder({
+      customer_id: 'cus_missing',
+      currency_code: 'usd',
+      items: [{ variant_id: 'var_1', quantity: 1 }],
+      shipping_address: { full_name: 'John', address_1: '123 Main', city: 'NY', province: null, postal_code: '10001', country_code: 'us' },
+      payment_method_id: 'pm_1',
+    })).rejects.toThrow(ProviderAPIError)
+  })
+
+  it('throws ProviderAPIError on 500 for server error', async () => {
+    server.use(
+      http.post(`${BASE}/admin/thor/dropshipper/orders`, async () => {
+        return HttpResponse.json(
+          { message: 'Internal server error' },
+          { status: 500 },
+        )
+      }),
+    )
+
+    await expect(client().createOrder({
+      customer_id: 'cus_1',
+      currency_code: 'usd',
+      items: [{ variant_id: 'var_1', quantity: 1 }],
+      shipping_address: { full_name: 'John', address_1: '123 Main', city: 'NY', province: null, postal_code: '10001', country_code: 'us' },
+      payment_method_id: 'pm_1',
+    })).rejects.toThrow(ProviderAPIError)
+  })
 })
 
 describe('DropshipperClient.getOrderShippingOptions', () => {
@@ -403,6 +639,42 @@ describe('DropshipperClient.getOrderShippingOptions', () => {
     expect(result.shipping_options).toHaveLength(1)
     expect(result.shipping_options[0].id).toBe('ship_1')
   })
+
+  it('forwards province and city as query params', async () => {
+    server.use(
+      http.get(`${BASE}/admin/thor/dropshipper/orders/shipping-options`, ({ request }) => {
+        requireBearerToken(request)
+        const url = new URL(request.url)
+        expect(url.searchParams.get('currency_code')).toBe('usd')
+        expect(url.searchParams.get('country_code')).toBe('cu')
+        expect(url.searchParams.get('province')).toBe('La Habana')
+        expect(url.searchParams.get('city')).toBe('Centro Habana')
+        return HttpResponse.json({
+          shipping_options: [
+            {
+              id: 'ship_1',
+              name: 'La Habana Express',
+              amount: 500,
+              currency_code: 'usd',
+              price_type: 'flat',
+              is_default: true,
+              type: null,
+            },
+          ],
+          count: 1,
+        })
+      }),
+    )
+
+    const result = await client().getOrderShippingOptions({
+      currency_code: 'usd',
+      country_code: 'cu',
+      province: 'La Habana',
+      city: 'Centro Habana',
+    })
+    expect(result.shipping_options).toHaveLength(1)
+    expect(result.shipping_options[0].id).toBe('ship_1')
+  })
 })
 
 describe('DropshipperClient.setPaymentCollector', () => {

package/src/dropshipper.ts

@@ -133,6 +133,10 @@ import type {
   GetFinancialAnalysisResponse,
   RegisterPaymentBody,
   RegisterPaymentResponse,
+  // Geo-reference
+  GetGeoCountriesResponse,
+  GetGeoProvincesResponse,
+  GetGeoCitiesResponse,
   // Dashboard Capabilities
   DropshipperDashboardCapabilities,
   // Inline return types
@@ -1451,6 +1455,43 @@ export class DropshipperClient {
       '/store/thor/dropshipper-categories',
     );
   }
+
+  // -------------------------------------------------------------------------
+  // Geo-reference
+  // -------------------------------------------------------------------------
+
+  /**
+   * List all geo-reference countries.
+   *
+   * `GET /admin/geo-reference`
+   */
+  async getGeoCountries(): Promise<GetGeoCountriesResponse> {
+    return this.request<GetGeoCountriesResponse>('GET', '/admin/geo-reference');
+  }
+
+  /**
+   * List provinces/states for a country.
+   *
+   * `GET /admin/geo-reference/countries/:iso_2/provinces`
+   */
+  async getGeoProvinces(iso2: string): Promise<GetGeoProvincesResponse> {
+    return this.request<GetGeoProvincesResponse>(
+      'GET',
+      `/admin/geo-reference/countries/${iso2}/provinces`,
+    );
+  }
+
+  /**
+   * List cities for a province/state.
+   *
+   * `GET /admin/geo-reference/provinces/:code/cities`
+   */
+  async getGeoCities(code: string): Promise<GetGeoCitiesResponse> {
+    return this.request<GetGeoCitiesResponse>(
+      'GET',
+      `/admin/geo-reference/provinces/${code}/cities`,
+    );
+  }
 }
 
 // Re-export types used by callers so they don't need to import from @thorprovider/types directly.