weflayr 0.22.1 → 0.23.0

package/tests/api/index.test.js

@@ -48,7 +48,7 @@ async function withClientReturning(responseBody, statusCode, run, clientOptions
 
 test('client sends the bearer key to the configured host', async () => {
   await withClientReturning({ rows: [] }, 200, async (client, seenRequests) => {
-    const { data } = await api.getAllRevenue({ client, throwOnError: true });
+    const { data } = await api.getRevenue({ client, throwOnError: true });
     assert.deepEqual(data, { rows: [] });
     assert.deepEqual(seenRequests, [
       { method: 'GET', url: '/api/revenue/', authorization: 'Bearer wf-test-key', body: null },
@@ -82,7 +82,7 @@ test('client picks up apiKey from WEFLAYR_API_KEY env var', async () => {
       { rows: [] },
       200,
       async (client, seenRequests) => {
-        await api.getAllRevenue({ client, throwOnError: true });
+        await api.getRevenue({ client, throwOnError: true });
         assert.equal(seenRequests[0].authorization, 'Bearer env-key');
       },
       { apiKey: undefined }
@@ -97,8 +97,8 @@ test('client picks up apiKey from WEFLAYR_API_KEY env var', async () => {
 test('setRevenue posts the rows in snake_case and parses the booked count', async () => {
   await withClientReturning({ ok: true, rows_inserted: 2 }, 200, async (client, seenRequests) => {
     const rows = [
-      { customerName: 'c_1', amount: '1200.50', month: '2026-06' },
-      { customerName: 'c_2', amount: '800', month: '2026-06' },
+      { customerName: 'c_1', amount: 1200.5, month: '2026-06' },
+      { customerName: 'c_2', amount: 800, month: '2026-06' },
     ];
     const { data } = await api.setRevenue({ client, throwOnError: true, body: { rows } });
     assert.deepEqual(data, { ok: true, rowsInserted: 2 });
@@ -107,70 +107,91 @@ test('setRevenue posts the rows in snake_case and parses the booked count', asyn
     assert.equal(request.url, '/api/revenue/');
     assert.deepEqual(request.body, {
       rows: [
-        { customer_name: 'c_1', amount: '1200.50', month: '2026-06' },
-        { customer_name: 'c_2', amount: '800', month: '2026-06' },
+        { customer_name: 'c_1', amount: 1200.5, month: '2026-06' },
+        { customer_name: 'c_2', amount: 800, month: '2026-06' },
       ],
     });
   });
 });
 
-test('getAllRevenue parses the returned rows into camelCase', async () => {
+test('setRevenue posts the revenueId in snake_case and the upsert flag', async () => {
+  await withClientReturning({ ok: true, rows_inserted: 1 }, 200, async (client, seenRequests) => {
+    const rows = [
+      {
+        revenueId: 'b3f2b160-6e12-4f1a-9c3d-0a2e7c9b5d41',
+        customerName: 'c_1',
+        amount: 1300,
+        month: '2026-06',
+      },
+    ];
+    const { data } = await api.setRevenue({
+      client,
+      throwOnError: true,
+      body: { upsert: true, rows },
+    });
+    assert.deepEqual(data, { ok: true, rowsInserted: 1 });
+    assert.deepEqual(seenRequests[0].body, {
+      upsert: true,
+      rows: [
+        {
+          revenue_id: 'b3f2b160-6e12-4f1a-9c3d-0a2e7c9b5d41',
+          customer_name: 'c_1',
+          amount: 1300,
+          month: '2026-06',
+        },
+      ],
+    });
+  });
+});
+
+test('getRevenue parses the returned rows into camelCase', async () => {
   const wireRow = {
     customer_name: 'c_1',
     metric_name: 'revenue',
     month: '2026-06',
-    amount: '1200.50000000',
+    amount: 1200.5,
     source: 'api',
   };
   await withClientReturning({ rows: [wireRow] }, 200, async (client) => {
-    const { data } = await api.getAllRevenue({ client, throwOnError: true });
+    const { data } = await api.getRevenue({ client, throwOnError: true });
     assert.deepEqual(data.rows, [
       {
         customerName: 'c_1',
         metricName: 'revenue',
         month: '2026-06',
-        amount: '1200.50000000',
+        amount: 1200.5,
         source: 'api',
       },
     ]);
   });
 });
 
-test('getCustomerRevenue requests the customer path', async () => {
+test('getRevenue sends the customerNames filter as repeated params', async () => {
   await withClientReturning({ rows: [] }, 200, async (client, seenRequests) => {
-    const { data } = await api.getCustomerRevenue({
+    const { data } = await api.getRevenue({
       client,
       throwOnError: true,
-      path: { customerName: 'c_1' },
+      query: { customerNames: ['c_1', 'c_2'] },
     });
     assert.deepEqual(data, { rows: [] });
-    assert.equal(seenRequests[0].url, '/api/revenue/c_1/');
+    const query = new URL(seenRequests[0].url, 'http://x').searchParams;
+    assert.deepEqual(query.getAll('customer_names'), ['c_1', 'c_2']);
   });
 });
 
-test('getCustomerRevenue surfaces a 404 and its error', async () => {
-  const rejection = { error: 'No revenue for this customer.' };
-  await withClientReturning(rejection, 404, async (client) => {
-    const { error, response } = await api.getCustomerRevenue({
-      client,
-      path: { customerName: 'nobody' },
-    });
-    assert.equal(response.status, 404);
-    assert.deepEqual(error, rejection);
-  });
-});
-
-test('deleteCustomerRevenue parses the deleted count', async () => {
-  await withClientReturning({ ok: true, rows_deleted: 1 }, 200, async (client, seenRequests) => {
-    const { data } = await api.deleteCustomerRevenue({
+test('deleteRevenue sends the customerNames filter and parses the deleted count', async () => {
+  await withClientReturning({ ok: true, rows_deleted: 2 }, 200, async (client, seenRequests) => {
+    const { data } = await api.deleteRevenue({
       client,
       throwOnError: true,
-      path: { customerName: 'c_1' },
+      query: { customerNames: ['c_1', 'c_2'] },
     });
-    assert.deepEqual(data, { ok: true, rowsDeleted: 1 });
+    assert.deepEqual(data, { ok: true, rowsDeleted: 2 });
     const request = seenRequests[0];
     assert.equal(request.method, 'DELETE');
-    assert.equal(request.url, '/api/revenue/c_1/');
+    const url = new URL(request.url, 'http://x');
+    assert.equal(url.pathname, '/api/revenue/');
+    assert.deepEqual(url.searchParams.getAll('customer_names'), ['c_1', 'c_2']);
   });
 });
 
@@ -178,51 +199,50 @@ test('deleteCustomerRevenue parses the deleted count', async () => {
 
 test('setKeyMetrics posts the rows in snake_case and parses the booked count', async () => {
   await withClientReturning({ ok: true, rows_inserted: 1 }, 200, async (client, seenRequests) => {
-    const rows = [
-      { userName: 'u_1', metricName: 'Meetings booked', amount: '3', month: '2026-06' },
-    ];
+    const rows = [{ userName: 'u_1', metricName: 'Meetings booked', amount: 3, month: '2026-06' }];
     const { data } = await api.setKeyMetrics({ client, throwOnError: true, body: { rows } });
     assert.deepEqual(data, { ok: true, rowsInserted: 1 });
     const request = seenRequests[0];
     assert.equal(request.method, 'POST');
     assert.equal(request.url, '/api/key-metrics/');
     assert.deepEqual(request.body, {
-      rows: [{ user_name: 'u_1', metric_name: 'Meetings booked', amount: '3', month: '2026-06' }],
+      rows: [{ user_name: 'u_1', metric_name: 'Meetings booked', amount: 3, month: '2026-06' }],
     });
   });
 });
 
-test('getAllKeyMetrics parses the returned rows into camelCase', async () => {
+test('getKeyMetrics parses the returned rows into camelCase', async () => {
   const wireRow = {
     user_name: 'u_1',
     metric_name: 'Meetings booked',
     month: '2026-06',
-    amount: '3.00000000',
+    amount: 3.0,
     source: 'api',
   };
   await withClientReturning({ rows: [wireRow] }, 200, async (client) => {
-    const { data } = await api.getAllKeyMetrics({ client, throwOnError: true });
+    const { data } = await api.getKeyMetrics({ client, throwOnError: true });
     assert.deepEqual(data.rows, [
       {
         userName: 'u_1',
         metricName: 'Meetings booked',
         month: '2026-06',
-        amount: '3.00000000',
+        amount: 3.0,
         source: 'api',
       },
     ]);
   });
 });
 
-test('getUserKeyMetrics requests the user path', async () => {
+test('getKeyMetrics sends the userNames filter as repeated params', async () => {
   await withClientReturning({ rows: [] }, 200, async (client, seenRequests) => {
-    const { data } = await api.getUserKeyMetrics({
+    const { data } = await api.getKeyMetrics({
       client,
       throwOnError: true,
-      path: { userName: 'u_1' },
+      query: { userNames: ['u_1', 'u_2'] },
     });
     assert.deepEqual(data, { rows: [] });
-    assert.equal(seenRequests[0].url, '/api/key-metrics/u_1/');
+    const query = new URL(seenRequests[0].url, 'http://x').searchParams;
+    assert.deepEqual(query.getAll('user_names'), ['u_1', 'u_2']);
   });
 });
 
@@ -238,17 +258,95 @@ test('setKeyMetrics surfaces a 422 and its details', async () => {
   });
 });
 
-test('deleteUserKeyMetrics parses the deleted count', async () => {
-  await withClientReturning({ ok: true, rows_deleted: 1 }, 200, async (client, seenRequests) => {
-    const { data } = await api.deleteUserKeyMetrics({
+test('deleteKeyMetrics sends the userNames filter and parses the deleted count', async () => {
+  await withClientReturning({ ok: true, rows_deleted: 2 }, 200, async (client, seenRequests) => {
+    const { data } = await api.deleteKeyMetrics({
       client,
       throwOnError: true,
-      path: { userName: 'u_1' },
+      query: { userNames: ['u_1', 'u_2'] },
     });
-    assert.deepEqual(data, { ok: true, rowsDeleted: 1 });
+    assert.deepEqual(data, { ok: true, rowsDeleted: 2 });
     const request = seenRequests[0];
     assert.equal(request.method, 'DELETE');
-    assert.equal(request.url, '/api/key-metrics/u_1/');
+    const url = new URL(request.url, 'http://x');
+    assert.equal(url.pathname, '/api/key-metrics/');
+    assert.deepEqual(url.searchParams.getAll('user_names'), ['u_1', 'u_2']);
+  });
+});
+
+// ── Margin ────────────────────────────────────────────────────────────────────
+
+test('getMargin parses the returned rows into camelCase', async () => {
+  const wireRow = {
+    customer_name: 'c_1',
+    revenue: 1000.0,
+    cost: 200.0,
+    margin: 800.0,
+    margin_pct: 80.0,
+    profitability_status: 'healthy',
+  };
+  await withClientReturning(
+    { rows: [wireRow], next_cursor: null, has_more: false },
+    200,
+    async (client) => {
+      const { data } = await api.getMargin({ client, throwOnError: true });
+      assert.deepEqual(data.rows, [
+        {
+          customerName: 'c_1',
+          revenue: 1000.0,
+          cost: 200.0,
+          margin: 800.0,
+          marginPct: 80.0,
+          profitabilityStatus: 'healthy',
+        },
+      ]);
+    }
+  );
+});
+
+test('getMargin sends the cursor and limit query params', async () => {
+  await withClientReturning(
+    { rows: [], next_cursor: 'Y19h', has_more: true },
+    200,
+    async (client, seenRequests) => {
+      const { data } = await api.getMargin({
+        client,
+        throwOnError: true,
+        query: { cursor: 'abc123', limit: 2 },
+      });
+      assert.equal(data.nextCursor, 'Y19h');
+      assert.equal(data.hasMore, true);
+      const query = new URL(seenRequests[0].url, 'http://x').searchParams;
+      assert.equal(query.get('cursor'), 'abc123');
+      assert.equal(query.get('limit'), '2');
+    }
+  );
+});
+
+test('getMargin sends the customerNames filter as repeated params', async () => {
+  await withClientReturning({ rows: [] }, 200, async (client, seenRequests) => {
+    const { data } = await api.getMargin({
+      client,
+      throwOnError: true,
+      query: { customerNames: ['c_1', 'c_2'] },
+    });
+    assert.deepEqual(data, { rows: [] });
+    const query = new URL(seenRequests[0].url, 'http://x').searchParams;
+    assert.deepEqual(query.getAll('customer_names'), ['c_1', 'c_2']);
+  });
+});
+
+test('getMargin sends the dateFrom/dateTo/applyCredits filters in snake_case', async () => {
+  await withClientReturning({ rows: [] }, 200, async (client, seenRequests) => {
+    await api.getMargin({
+      client,
+      throwOnError: true,
+      query: { dateFrom: '2026-06-01', dateTo: '2026-06-30', applyCredits: true },
+    });
+    const query = new URL(seenRequests[0].url, 'http://x').searchParams;
+    assert.equal(query.get('date_from'), '2026-06-01');
+    assert.equal(query.get('date_to'), '2026-06-30');
+    assert.equal(query.get('apply_credits'), 'true');
   });
 });
 
@@ -290,41 +388,50 @@ test('setCustomersTags leaves tag keys untouched, even when they contain undersc
   );
 });
 
-test('getAllCustomersTags parses the returned customers into camelCase', async () => {
+test('getCustomersTags parses the returned customers into camelCase', async () => {
   const wireCustomer = { customer_name: 'c_1', tags: { plan: 'pro' } };
   await withClientReturning(
     { customers: [wireCustomer], next_cursor: null, has_more: false },
     200,
     async (client) => {
-      const { data } = await api.getAllCustomersTags({ client, throwOnError: true });
+      const { data } = await api.getCustomersTags({ client, throwOnError: true });
       assert.deepEqual(data.customers, [{ customerName: 'c_1', tags: { plan: 'pro' } }]);
     }
   );
 });
 
-test('getCustomerTags parses the customer tags, leaving tag keys untouched', async () => {
-  const wireTags = { customer_name: 'c_1', tags: { plan: 'pro', utm_source: 'ads' } };
-  await withClientReturning(wireTags, 200, async (client, seenRequests) => {
-    const { data } = await api.getCustomerTags({
-      client,
-      throwOnError: true,
-      path: { customerName: 'c_1' },
-    });
-    assert.deepEqual(data, { customerName: 'c_1', tags: { plan: 'pro', utm_source: 'ads' } });
-    assert.equal(seenRequests[0].url, '/api/customer-tags/c_1/');
-  });
+test('getCustomersTags sends the customerNames filter, leaving tag keys untouched', async () => {
+  const wireCustomer = { customer_name: 'c_1', tags: { plan: 'pro', utm_source: 'ads' } };
+  await withClientReturning(
+    { customers: [wireCustomer], next_cursor: null, has_more: false },
+    200,
+    async (client, seenRequests) => {
+      const { data } = await api.getCustomersTags({
+        client,
+        throwOnError: true,
+        query: { customerNames: ['c_1', 'c_2'] },
+      });
+      assert.deepEqual(data.customers, [
+        { customerName: 'c_1', tags: { plan: 'pro', utm_source: 'ads' } },
+      ]);
+      const query = new URL(seenRequests[0].url, 'http://x').searchParams;
+      assert.deepEqual(query.getAll('customer_names'), ['c_1', 'c_2']);
+    }
+  );
 });
 
-test('deleteCustomerTags parses the deleted count', async () => {
-  await withClientReturning({ ok: true, tags_deleted: 1 }, 200, async (client, seenRequests) => {
-    const { data } = await api.deleteCustomerTags({
+test('deleteCustomersTags sends the customerNames filter and parses the deleted count', async () => {
+  await withClientReturning({ ok: true, tags_deleted: 3 }, 200, async (client, seenRequests) => {
+    const { data } = await api.deleteCustomersTags({
       client,
       throwOnError: true,
-      path: { customerName: 'c_1' },
+      query: { customerNames: ['c_1', 'c_2'] },
     });
-    assert.deepEqual(data, { ok: true, tagsDeleted: 1 });
+    assert.deepEqual(data, { ok: true, tagsDeleted: 3 });
     const request = seenRequests[0];
     assert.equal(request.method, 'DELETE');
-    assert.equal(request.url, '/api/customer-tags/c_1/');
+    const url = new URL(request.url, 'http://x');
+    assert.equal(url.pathname, '/api/customer-tags/');
+    assert.deepEqual(url.searchParams.getAll('customer_names'), ['c_1', 'c_2']);
   });
 });