weflayr 0.22.0 → 0.22.2

package/tests/api/index.test.js

@@ -0,0 +1,361 @@
+'use strict';
+
+// Tests for the public-API client: auth and base-URL wiring of the
+// client facade, plus the request/response wiring of every generated
+// endpoint (server behavior is covered by the dashboard's app_api tests).
+
+const { test } = require('node:test');
+const assert = require('node:assert/strict');
+const http = require('node:http');
+
+const weflayr = require('../../src/index');
+const { api } = weflayr;
+
+// A client whose server records requests and returns a canned response.
+async function withClientReturning(responseBody, statusCode, run, clientOptions = {}) {
+  const seenRequests = [];
+  const server = http.createServer((request, response) => {
+    let requestBody = '';
+    request.on('data', (chunk) => {
+      requestBody += chunk;
+    });
+    request.on('end', () => {
+      seenRequests.push({
+        method: request.method,
+        url: request.url,
+        authorization: request.headers.authorization,
+        body: requestBody === '' ? null : JSON.parse(requestBody),
+      });
+      response.statusCode = statusCode;
+      response.setHeader('content-type', 'application/json');
+      response.end(JSON.stringify(responseBody));
+    });
+  });
+  await new Promise((resolve) => server.listen(0, resolve));
+  const client = api.client({
+    apiKey: 'wf-test-key',
+    ...clientOptions,
+    baseUrl: `http://127.0.0.1:${server.address().port}/api`,
+  });
+  try {
+    await run(client, seenRequests);
+  } finally {
+    server.close();
+  }
+}
+
+// ── client facade ─────────────────────────────────────────────────────────
+
+test('client sends the bearer key to the configured host', async () => {
+  await withClientReturning({ rows: [] }, 200, async (client, seenRequests) => {
+    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 },
+    ]);
+  });
+});
+
+test('weflayr.client is the same function as api.client', () => {
+  assert.equal(weflayr.client, api.client);
+});
+
+test('client defaults to the production API host', () => {
+  const client = api.client({ apiKey: 'wf-test-key' });
+  assert.equal(client.getConfig().baseUrl, 'https://app.weflayr.com/api');
+});
+
+test('client throws without apiKey', () => {
+  const saved = process.env.WEFLAYR_API_KEY;
+  delete process.env.WEFLAYR_API_KEY;
+  try {
+    assert.throws(() => api.client(), /apiKey/);
+  } finally {
+    if (saved !== undefined) process.env.WEFLAYR_API_KEY = saved;
+  }
+});
+
+test('client picks up apiKey from WEFLAYR_API_KEY env var', async () => {
+  process.env.WEFLAYR_API_KEY = 'env-key';
+  try {
+    await withClientReturning(
+      { rows: [] },
+      200,
+      async (client, seenRequests) => {
+        await api.getRevenue({ client, throwOnError: true });
+        assert.equal(seenRequests[0].authorization, 'Bearer env-key');
+      },
+      { apiKey: undefined }
+    );
+  } finally {
+    delete process.env.WEFLAYR_API_KEY;
+  }
+});
+
+// ── Revenue ───────────────────────────────────────────────────────────────────
+
+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.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 });
+    const request = seenRequests[0];
+    assert.equal(request.method, 'POST');
+    assert.equal(request.url, '/api/revenue/');
+    assert.deepEqual(request.body, {
+      rows: [
+        { customer_name: 'c_1', amount: 1200.5, month: '2026-06' },
+        { customer_name: 'c_2', amount: 800, month: '2026-06' },
+      ],
+    });
+  });
+});
+
+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.5,
+    source: 'api',
+  };
+  await withClientReturning({ rows: [wireRow] }, 200, async (client) => {
+    const { data } = await api.getRevenue({ client, throwOnError: true });
+    assert.deepEqual(data.rows, [
+      {
+        customerName: 'c_1',
+        metricName: 'revenue',
+        month: '2026-06',
+        amount: 1200.5,
+        source: 'api',
+      },
+    ]);
+  });
+});
+
+test('getRevenue sends the customerNames filter as repeated params', async () => {
+  await withClientReturning({ rows: [] }, 200, async (client, seenRequests) => {
+    const { data } = await api.getRevenue({
+      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('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,
+      query: { customerNames: ['c_1', 'c_2'] },
+    });
+    assert.deepEqual(data, { ok: true, rowsDeleted: 2 });
+    const request = seenRequests[0];
+    assert.equal(request.method, 'DELETE');
+    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']);
+  });
+});
+
+// ── Key metrics ───────────────────────────────────────────────────────────────
+
+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 { 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' }],
+    });
+  });
+});
+
+test('getKeyMetrics parses the returned rows into camelCase', async () => {
+  const wireRow = {
+    user_name: 'u_1',
+    metric_name: 'Meetings booked',
+    month: '2026-06',
+    amount: 3.0,
+    source: 'api',
+  };
+  await withClientReturning({ rows: [wireRow] }, 200, async (client) => {
+    const { data } = await api.getKeyMetrics({ client, throwOnError: true });
+    assert.deepEqual(data.rows, [
+      {
+        userName: 'u_1',
+        metricName: 'Meetings booked',
+        month: '2026-06',
+        amount: 3.0,
+        source: 'api',
+      },
+    ]);
+  });
+});
+
+test('getKeyMetrics sends the userNames filter as repeated params', async () => {
+  await withClientReturning({ rows: [] }, 200, async (client, seenRequests) => {
+    const { data } = await api.getKeyMetrics({
+      client,
+      throwOnError: true,
+      query: { userNames: ['u_1', 'u_2'] },
+    });
+    assert.deepEqual(data, { rows: [] });
+    const query = new URL(seenRequests[0].url, 'http://x').searchParams;
+    assert.deepEqual(query.getAll('user_names'), ['u_1', 'u_2']);
+  });
+});
+
+test('setKeyMetrics surfaces a 422 and its details', async () => {
+  const rejection = {
+    error: 'Invalid payload.',
+    detail: [{ field: 'rows.0.metric_name', error: 'Unknown metric.' }],
+  };
+  await withClientReturning(rejection, 422, async (client) => {
+    const { error, response } = await api.setKeyMetrics({ client, body: { rows: [] } });
+    assert.equal(response.status, 422);
+    assert.deepEqual(error, rejection);
+  });
+});
+
+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,
+      query: { userNames: ['u_1', 'u_2'] },
+    });
+    assert.deepEqual(data, { ok: true, rowsDeleted: 2 });
+    const request = seenRequests[0];
+    assert.equal(request.method, 'DELETE');
+    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']);
+  });
+});
+
+// ── Customer tags ─────────────────────────────────────────────────────────────
+
+test('setCustomersTags posts the customers in snake_case and parses the updated count', async () => {
+  await withClientReturning(
+    { ok: true, customers_updated: 1 },
+    200,
+    async (client, seenRequests) => {
+      const customers = [{ customerName: 'c_1', tags: { plan: 'pro' } }];
+      const { data } = await api.setCustomersTags({
+        client,
+        throwOnError: true,
+        body: { customers },
+      });
+      assert.deepEqual(data, { ok: true, customersUpdated: 1 });
+      const request = seenRequests[0];
+      assert.equal(request.method, 'POST');
+      assert.equal(request.url, '/api/customer-tags/');
+      assert.deepEqual(request.body, {
+        customers: [{ customer_name: 'c_1', tags: { plan: 'pro' } }],
+      });
+    }
+  );
+});
+
+test('setCustomersTags leaves tag keys untouched, even when they contain underscores', async () => {
+  await withClientReturning(
+    { ok: true, customers_updated: 1 },
+    200,
+    async (client, seenRequests) => {
+      const customers = [{ customerName: 'c_1', tags: { utm_source: 'ads', plan_tier: 'pro' } }];
+      await api.setCustomersTags({ client, throwOnError: true, body: { customers } });
+      assert.deepEqual(seenRequests[0].body, {
+        customers: [{ customer_name: 'c_1', tags: { utm_source: 'ads', plan_tier: 'pro' } }],
+      });
+    }
+  );
+});
+
+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.getCustomersTags({ client, throwOnError: true });
+      assert.deepEqual(data.customers, [{ customerName: 'c_1', tags: { plan: 'pro' } }]);
+    }
+  );
+});
+
+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('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,
+      query: { customerNames: ['c_1', 'c_2'] },
+    });
+    assert.deepEqual(data, { ok: true, tagsDeleted: 3 });
+    const request = seenRequests[0];
+    assert.equal(request.method, 'DELETE');
+    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']);
+  });
+});

package/tests/index.test.js

@@ -405,7 +405,7 @@ test('propagateMetadata writes structured fields and extra tags', async () => {
   await weflayr.propagateMetadata(
     {
       featureName: 'onboarding',
-      customerId: '#3756',
+      customerName: '#3756',
       extraTags: { variant: 'control' },
     },
     async () => {
@@ -419,7 +419,7 @@ test('propagateMetadata writes structured fields and extra tags', async () => {
   assert.equal(exporter.exported.length, 1);
   const attrs = exporter.exported[0].attributes;
   assert.equal(attrs['weflayr.feature_name'], 'onboarding');
-  assert.equal(attrs['weflayr.customer_id'], '#3756');
+  assert.equal(attrs['weflayr.customer_name'], '#3756');
   assert.equal(attrs['weflayr.tag.variant'], 'control');
   assert.ok(attrs['weflayr.uuid']);
   assert.equal(attrs['weflayr.provider_name'], undefined);
@@ -429,7 +429,7 @@ test('propagateMetadata writes structured fields and extra tags', async () => {
 test('propagateMetadata uuid is stable within scope and changes across calls', async () => {
   const { exporter, proc, provider, tracer } = _makeMetadataHarness();
 
-  await weflayr.propagateMetadata({ featureName: 'f', customerId: 'c' }, async () => {
+  await weflayr.propagateMetadata({ featureName: 'f', customerName: 'c' }, async () => {
     const spanA = tracer.startSpan('a');
     spanA.setAttribute('gen_ai.system', 'openai');
     spanA.end();
@@ -438,7 +438,7 @@ test('propagateMetadata uuid is stable within scope and changes across calls', a
     spanB.end();
   });
 
-  await weflayr.propagateMetadata({ featureName: 'f', customerId: 'c' }, async () => {
+  await weflayr.propagateMetadata({ featureName: 'f', customerName: 'c' }, async () => {
     const spanC = tracer.startSpan('c_span');
     spanC.setAttribute('gen_ai.system', 'openai');
     spanC.end();
@@ -459,14 +459,14 @@ test('propagateMetadata nested scopes inner overrides and extra tags merge', asy
   await weflayr.propagateMetadata(
     {
       featureName: 'outer',
-      customerId: 'outer_c',
+      customerName: 'outer_c',
       extraTags: { variant: 'A', shared: 'outer' },
     },
     async () => {
       await weflayr.propagateMetadata(
         {
           featureName: 'inner',
-          customerId: 'inner_c',
+          customerName: 'inner_c',
           extraTags: { shared: 'inner', experiment: 'B' },
         },
         async () => {
@@ -481,7 +481,7 @@ test('propagateMetadata nested scopes inner overrides and extra tags merge', asy
   await proc.forceFlush();
   const attrs = exporter.exported[0].attributes;
   assert.equal(attrs['weflayr.feature_name'], 'inner');
-  assert.equal(attrs['weflayr.customer_id'], 'inner_c');
+  assert.equal(attrs['weflayr.customer_name'], 'inner_c');
   // Outer extra tag not shadowed survives
   assert.equal(attrs['weflayr.tag.variant'], 'A');
   // Inner extra tag wins on conflict
@@ -493,7 +493,7 @@ test('propagateMetadata nested scopes inner overrides and extra tags merge', asy
 test('propagateMetadata decorator mints fresh uuid per invocation', async () => {
   const { exporter, proc, provider, tracer } = _makeMetadataHarness();
 
-  const wrap = weflayr.propagateMetadata({ featureName: 'f', customerId: 'c' });
+  const wrap = weflayr.propagateMetadata({ featureName: 'f', customerName: 'c' });
   const leaf = wrap(async function leaf() {
     const span = tracer.startSpan('child');
     span.setAttribute('gen_ai.system', 'openai');
@@ -515,7 +515,7 @@ test('propagateMetadata decorator form wraps a function', async () => {
 
   const wrap = weflayr.propagateMetadata({
     featureName: 'chat',
-    customerId: 'c_42',
+    customerName: 'c_42',
     extraTags: { experiment: 'B' },
   });
   const leaf = wrap(async function leaf() {
@@ -528,7 +528,7 @@ test('propagateMetadata decorator form wraps a function', async () => {
   await proc.forceFlush();
   const attrs = exporter.exported[0].attributes;
   assert.equal(attrs['weflayr.feature_name'], 'chat');
-  assert.equal(attrs['weflayr.customer_id'], 'c_42');
+  assert.equal(attrs['weflayr.customer_name'], 'c_42');
   assert.equal(attrs['weflayr.tag.experiment'], 'B');
   await provider.shutdown();
 });
@@ -539,7 +539,7 @@ test('propagateMetadata callable form runs function', async () => {
   const result = await weflayr.propagateMetadata(
     {
       featureName: 'callable',
-      customerId: 'c_42',
+      customerName: 'c_42',
       extraTags: { variant: 'A' },
     },
     async () => {
@@ -564,7 +564,7 @@ test('propagateMetadata providerName writes attribute', async () => {
   await weflayr.propagateMetadata(
     {
       featureName: 'f',
-      customerId: 'c',
+      customerName: 'c',
       providerName: weflayr.AIProviderName.VERCEL_AI_GATEWAY,
     },
     async () => {
@@ -579,10 +579,34 @@ test('propagateMetadata providerName writes attribute', async () => {
   await provider.shutdown();
 });
 
-test('propagateMetadata requires featureName and customerId', () => {
-  assert.throws(() => weflayr.propagateMetadata({}), /featureName.*customerId.*required/);
+test('propagateMetadata requires featureName and customerName', () => {
+  assert.throws(() => weflayr.propagateMetadata({}), /featureName.*customerName.*required/);
   assert.throws(() => weflayr.propagateMetadata({ featureName: 'f' }), /required/);
-  assert.throws(() => weflayr.propagateMetadata({ customerId: 'c' }), /required/);
+  assert.throws(() => weflayr.propagateMetadata({ customerName: 'c' }), /required/);
+});
+
+test('propagateMetadata deprecated customerId still works', async () => {
+  const { exporter, proc, provider, tracer } = _makeMetadataHarness();
+
+  const warnings = [];
+  const onWarning = (warning) => warnings.push(warning);
+  process.on('warning', onWarning);
+
+  await weflayr.propagateMetadata({ featureName: 'f', customerId: 'Acme Corp' }, async () => {
+    const span = tracer.startSpan('child');
+    span.setAttribute('gen_ai.system', 'openai');
+    span.end();
+  });
+
+  // process.emitWarning delivers on a later tick; drain it before asserting.
+  await new Promise((resolve) => process.nextTick(resolve));
+  process.removeListener('warning', onWarning);
+  assert.ok(warnings.some((warning) => /customerId.*deprecated/.test(warning.message)));
+
+  await proc.forceFlush();
+  const attrs = exporter.exported[0].attributes;
+  assert.equal(attrs['weflayr.customer_name'], 'Acme Corp');
+  await provider.shutdown();
 });
 
 // ── autoInstrument ────────────────────────────────────────────────────────────
@@ -688,6 +712,15 @@ test('autoInstrument throws when no apiKey is reachable (env nor argument)', asy
   }
 });
 
+test('autoInstrument with an empty aiSdks list still runs setup', async () => {
+  // The vercel instrumentor's ai <= 6 error message tells users to keep their
+  // autoInstrument call with 'vercel_ai_gateway' removed (possibly leaving an
+  // empty list) — that must still install the processor.
+  _state.processor = null;
+  await weflayr.autoInstrument({ aiSdks: [], apiKey: 'empty-list-key' });
+  assert.ok(_state.processor, 'processor should be installed by the embedded setup() call');
+});
+
 test('autoInstrument runs setup when apiKey passed', async () => {
   _state.processor = null;
   class FakeOpenAIInstrumentation {

package/tests/instrumentation/vercel/full_instrumentation.test.js

@@ -0,0 +1,16 @@
+'use strict';
+
+const test = require('node:test');
+const assert = require('node:assert/strict');
+
+const {
+  VercelAiSdkInstrumentor,
+} = require('../../../src/instrumentation/vercel/full_instrumentation');
+
+// The `ai` / `@ai-sdk/otel` packages are app dependencies (not installed in
+// this repo), so instrument() must fail with an actionable install message.
+// The success path (registerTelemetry wiring) is covered by the vercel e2e
+// ingestion scenario.
+test('instrument() without the ai packages installed throws an install hint', () => {
+  assert.throws(() => new VercelAiSdkInstrumentor().instrument(), /npm install ai @ai-sdk\/otel/);
+});