@startsimpli/billing 0.4.8 → 0.4.9

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@startsimpli/billing",
-  "version": "0.4.8",
+  "version": "0.4.9",
   "description": "Universal billing integration for StartSimpli Next.js apps",
   "main": "./src/index.ts",
   "types": "./src/index.ts",

package/src/server/index.ts

@@ -1,2 +1,2 @@
-export { camelToSnake, proxyBillingRequest, fetchDjangoServiceToken } from './proxy';
+export { camelToSnake, snakeToCamel, proxyBillingRequest, fetchDjangoServiceToken } from './proxy';
 export type { BillingProxyOptions, DjangoServiceTokenOptions } from './proxy';

package/src/server/proxy.test.ts

@@ -0,0 +1,93 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { snakeToCamel, camelToSnake, proxyBillingRequest } from './proxy';
+
+describe('snakeToCamel', () => {
+  it('converts snake_case keys to camelCase recursively', () => {
+    const input = {
+      unit_price: '9.00',
+      is_free: false,
+      nested_obj: { interval_display: 'per month', is_recurring: true },
+      list_of_things: [{ cta_text: 'Get Started' }],
+    };
+    expect(snakeToCamel(input)).toEqual({
+      unitPrice: '9.00',
+      isFree: false,
+      nestedObj: { intervalDisplay: 'per month', isRecurring: true },
+      listOfThings: [{ ctaText: 'Get Started' }],
+    });
+  });
+
+  it('leaves string values untouched even when they contain underscores', () => {
+    expect(snakeToCamel({ feature_key: 'patterns_per_month' })).toEqual({
+      featureKey: 'patterns_per_month',
+    });
+  });
+
+  it('is idempotent for camelCase keys', () => {
+    const input = { alreadyCamel: true, nested: { stillCamel: 1 } };
+    expect(snakeToCamel(input)).toEqual(input);
+  });
+
+  it('is the inverse of camelToSnake', () => {
+    const camel = { unitPrice: '9.00', isFree: true, nested: { ctaText: 'Go' } };
+    expect(snakeToCamel(camelToSnake(camel))).toEqual(camel);
+  });
+});
+
+describe('proxyBillingRequest with fromSnake option', () => {
+  const originalFetch = globalThis.fetch;
+
+  beforeEach(() => {
+    globalThis.fetch = vi.fn();
+  });
+
+  afterEach(() => {
+    globalThis.fetch = originalFetch;
+  });
+
+  it('transforms snake_case response to camelCase when fromSnake is true', async () => {
+    (globalThis.fetch as ReturnType<typeof vi.fn>).mockResolvedValueOnce(
+      new Response(
+        JSON.stringify({ unit_price: '9.00', is_free: false, offers: [{ cta_text: 'Go' }] }),
+        { status: 200, headers: { 'Content-Type': 'application/json' } }
+      )
+    );
+
+    const response = await proxyBillingRequest(
+      'http://django',
+      '/api/v1/billing/products/x/',
+      undefined,
+      { public: true, fromSnake: true }
+    );
+    const body = await response.json();
+    expect(body).toEqual({
+      unitPrice: '9.00',
+      isFree: false,
+      offers: [{ ctaText: 'Go' }],
+    });
+  });
+
+  it('leaves response untouched when no transform option is set', async () => {
+    (globalThis.fetch as ReturnType<typeof vi.fn>).mockResolvedValueOnce(
+      new Response(JSON.stringify({ alreadyCamel: true }), { status: 200 })
+    );
+
+    const response = await proxyBillingRequest('http://django', '/path/', 'token');
+    const body = await response.json();
+    expect(body).toEqual({ alreadyCamel: true });
+  });
+
+  it('preserves non-OK status and error shape', async () => {
+    (globalThis.fetch as ReturnType<typeof vi.fn>).mockResolvedValueOnce(
+      new Response('Not found', { status: 404 })
+    );
+
+    const response = await proxyBillingRequest(
+      'http://django',
+      '/x/',
+      undefined,
+      { public: true, fromSnake: true }
+    );
+    expect(response.status).toBe(404);
+  });
+});

package/src/server/proxy.ts

@@ -87,11 +87,31 @@ export function camelToSnake(obj: unknown): unknown {
   return obj;
 }
 
+/**
+ * Recursively converts snake_case object keys to camelCase.
+ * Used for Django endpoints that bypass the camel-case middleware
+ * (e.g. public product endpoints) so consumers always receive camelCase.
+ */
+export function snakeToCamel(obj: unknown): unknown {
+  if (Array.isArray(obj)) return obj.map(snakeToCamel);
+  if (obj !== null && typeof obj === 'object') {
+    return Object.fromEntries(
+      Object.entries(obj as Record<string, unknown>).map(([k, v]) => [
+        k.replace(/_([a-z0-9])/g, (_, c) => c.toUpperCase()),
+        snakeToCamel(v),
+      ])
+    );
+  }
+  return obj;
+}
+
 export interface BillingProxyOptions {
   method?: string;
   body?: unknown;
   /** If true, apply camelToSnake transform to the response body */
   normalize?: boolean;
+  /** If true, apply snakeToCamel transform to the response body */
+  fromSnake?: boolean;
   /** If true, skip Authorization header even when accessToken is provided */
   public?: boolean;
 }
@@ -110,7 +130,7 @@ export async function proxyBillingRequest(
   accessToken: string | undefined,
   options: BillingProxyOptions = {}
 ): Promise<NextResponse> {
-  const { method = 'GET', body, normalize = false } = options;
+  const { method = 'GET', body, normalize = false, fromSnake = false } = options;
   const url = `${apiBaseUrl}${path}`;
 
   const headers: Record<string, string> = { 'Content-Type': 'application/json' };
@@ -135,7 +155,8 @@ export async function proxyBillingRequest(
     }
 
     const data = await response.json();
-    return NextResponse.json(normalize ? camelToSnake(data) : data);
+    const transformed = normalize ? camelToSnake(data) : fromSnake ? snakeToCamel(data) : data;
+    return NextResponse.json(transformed);
   } catch (error) {
     return NextResponse.json(
       {