weflayr 0.22.0 → 0.22.1

package/dist/api/index.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Entry point for the Weflayr public API (revenue, key metrics, customer tags).
+ *
+ * The endpoint functions and types under ./generated are produced from the
+ * platform's OpenAPI spec (`make generate-sdk-api-clients`) and speak the
+ * wire's snake_case, same as the Python SDK. generated/facade.gen.ts (also
+ * produced by that command, via scripts/generate_facade.mjs) wraps every
+ * endpoint so JS callers use camelCase instead - see ./caseConversion and
+ * ./makeEndpoint. This module is the handwritten front door that configures
+ * their client:
+ *
+ *     const weflayr = require('weflayr');
+ *
+ *     const apiClient = weflayr.client({ apiKey: 'wf-...' });
+ *     const { data } = await weflayr.api.getAllRevenue({ client: apiClient, throwOnError: true });
+ */
+import { type Client } from './generated/client';
+export declare const DEFAULT_BASE_URL = "https://app.weflayr.com/api";
+export interface ApiClientOptions {
+    /** A project API key, created in the Weflayr dashboard. Defaults to the `WEFLAYR_API_KEY` environment variable. */
+    apiKey?: string;
+    /** Where the API lives — override for local or self-hosted deployments. */
+    baseUrl?: string;
+}
+/** A client for the public API, authenticated with a project API key. */
+export declare function client(options?: ApiClientOptions): Client;
+export * from './generated/facade.gen';

package/dist/api/index.js

@@ -0,0 +1,48 @@
+"use strict";
+/**
+ * Entry point for the Weflayr public API (revenue, key metrics, customer tags).
+ *
+ * The endpoint functions and types under ./generated are produced from the
+ * platform's OpenAPI spec (`make generate-sdk-api-clients`) and speak the
+ * wire's snake_case, same as the Python SDK. generated/facade.gen.ts (also
+ * produced by that command, via scripts/generate_facade.mjs) wraps every
+ * endpoint so JS callers use camelCase instead - see ./caseConversion and
+ * ./makeEndpoint. This module is the handwritten front door that configures
+ * their client:
+ *
+ *     const weflayr = require('weflayr');
+ *
+ *     const apiClient = weflayr.client({ apiKey: 'wf-...' });
+ *     const { data } = await weflayr.api.getAllRevenue({ client: apiClient, throwOnError: true });
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_BASE_URL = void 0;
+exports.client = client;
+const client_1 = require("./generated/client");
+exports.DEFAULT_BASE_URL = 'https://app.weflayr.com/api';
+/** A client for the public API, authenticated with a project API key. */
+function client(options = {}) {
+    const apiKey = options.apiKey || process.env.WEFLAYR_API_KEY;
+    if (!apiKey) {
+        throw new Error('weflayr.client: `apiKey` is required (pass it explicitly or set WEFLAYR_API_KEY)');
+    }
+    return (0, client_1.createClient)((0, client_1.createConfig)({
+        baseUrl: options.baseUrl ?? exports.DEFAULT_BASE_URL,
+        auth: () => apiKey,
+    }));
+}
+__exportStar(require("./generated/facade.gen"), exports);

package/dist/api/makeEndpoint.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Wraps a generated public-API endpoint function so its `body`/`path`/`query`
+ * are converted from camelCase to the wire's snake_case on the way out, and
+ * its `data`/`error` are converted back to camelCase on the way in.
+ *
+ * Instantiated once per endpoint in generated/facade.gen.ts, produced by
+ * scripts/generate_facade.mjs - see that script for how the per-endpoint
+ * type arguments are derived.
+ */
+import type { Client } from './generated/client';
+export interface ClientOption {
+    client: Client;
+    throwOnError?: boolean;
+    headers?: HeadersInit;
+}
+export interface CallResult<TData, TError> {
+    data?: TData;
+    error?: TError;
+    request?: Request;
+    response?: Response;
+}
+type WireResult = {
+    data?: unknown;
+    error?: unknown;
+};
+export declare function makeEndpoint<TParams extends object, TData, TError>(wireFn: (options: any) => Promise<WireResult>): (options: ClientOption & TParams) => Promise<CallResult<TData, TError>>;
+export {};

package/dist/api/makeEndpoint.js

@@ -0,0 +1,37 @@
+"use strict";
+/**
+ * Wraps a generated public-API endpoint function so its `body`/`path`/`query`
+ * are converted from camelCase to the wire's snake_case on the way out, and
+ * its `data`/`error` are converted back to camelCase on the way in.
+ *
+ * Instantiated once per endpoint in generated/facade.gen.ts, produced by
+ * scripts/generate_facade.mjs - see that script for how the per-endpoint
+ * type arguments are derived.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeEndpoint = makeEndpoint;
+const caseConversion_1 = require("./caseConversion");
+function makeEndpoint(
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+wireFn) {
+    return async (options) => {
+        const wireOptions = { ...options };
+        for (const key of ['body', 'path', 'query']) {
+            if (wireOptions[key] !== undefined) {
+                wireOptions[key] = (0, caseConversion_1.toSnakeCaseDeep)(wireOptions[key]);
+            }
+        }
+        let result;
+        try {
+            result = await wireFn(wireOptions);
+        }
+        catch (error) {
+            throw (0, caseConversion_1.toCamelCaseDeep)(error);
+        }
+        return {
+            ...result,
+            data: result.data !== undefined ? (0, caseConversion_1.toCamelCaseDeep)(result.data) : undefined,
+            error: result.error !== undefined ? (0, caseConversion_1.toCamelCaseDeep)(result.error) : undefined,
+        };
+    };
+}

package/index.d.ts

@@ -33,31 +33,29 @@ export const AiSdk: {
   readonly OPENAI: 'openai';
   readonly ANTHROPIC: 'anthropic';
   readonly BEDROCK: 'bedrock';
-  readonly AZURE: 'azure';
   readonly COHERE: 'cohere';
-  readonly TOGETHER: 'together';
-  readonly GOOGLE_VERTEX: 'google-vertex';
   readonly GOOGLE_GENAI: 'google-genai';
   readonly ELEVENLABS: 'elevenlabs';
+  readonly VERCEL_AI_GATEWAY: 'vercel_ai_gateway';
 };
 export type AiSdk = (typeof AiSdk)[keyof typeof AiSdk];
 
 /**
- * Allowed values for `propagateMetadata({ providerName })`: every SDK the
- * auto-instrumentation registry knows, plus providers reached via the OpenAI
- * SDK on the wire but reported as themselves (e.g. Vercel AI Gateway).
+ * Allowed values for `propagateMetadata({ providerName })`: the actual AI
+ * providers a call can be attributed to. Unlike AiSdk this names providers,
+ * not SDKs — google-genai is an SDK whose calls are labelled gemini or vertex,
+ * and mistral is reached via the OpenAI SDK on the wire but reported as itself.
  */
 export const AIProviderName: {
   readonly OPENAI: 'openai';
   readonly ANTHROPIC: 'anthropic';
   readonly BEDROCK: 'bedrock';
-  readonly AZURE: 'azure';
   readonly COHERE: 'cohere';
-  readonly TOGETHER: 'together';
-  readonly GOOGLE_VERTEX: 'google-vertex';
-  readonly GOOGLE_GENAI: 'google-genai';
   readonly ELEVENLABS: 'elevenlabs';
+  readonly MISTRAL: 'mistral';
   readonly VERCEL_AI_GATEWAY: 'vercel_ai_gateway';
+  readonly GEMINI: 'gemini';
+  readonly VERTEX: 'vertex';
 };
 export type AIProviderName = (typeof AIProviderName)[keyof typeof AIProviderName];
 
@@ -104,8 +102,10 @@ export function autoInstrument(
 export interface PropagateMetadataOptions {
   /** Product-side feature triggering the LLM call (e.g. `"onboarding-summary"`). */
   featureName: string;
-  /** Identifier of the end-user / tenant the call is made for. */
-  customerId: string;
+  /** Name of the end-user / tenant customer the call is made for. */
+  customerName?: string;
+  /** @deprecated Use `customerName` instead. */
+  customerId?: string;
   /**
    * Override for the provider seen on the wire. Set this only if it differs
    * from the SDK auto-detected by OpenTelemetry — e.g. calls routed through
@@ -116,7 +116,7 @@ export interface PropagateMetadataOptions {
   /**
    * Arbitrary scalar key/value pairs to attach. Values must be `string`,
    * `number`, or `boolean` so they survive the ClickHouse `Map(String,
-   * String)` column they land in. Avoid `featureName` / `customerId` keys
+   * String)` column they land in. Avoid `featureName` / `customerName` keys
    * here — they have dedicated fields.
    */
   extraTags?: Record<string, string | number | boolean>;
@@ -131,7 +131,7 @@ export interface PropagateMetadataOptions {
  *
  * @example
  * await weflayr.propagateMetadata(
- *   { featureName: 'onboarding', customerId: '#3756', extraTags: { variant: 'control' } },
+ *   { featureName: 'onboarding', customerName: 'Acme Corp', extraTags: { variant: 'control' } },
  *   async () => { await openai.chat.completions.create({ ... }); },
  * );
  */
@@ -146,7 +146,7 @@ export function propagateMetadata<T>(
  *
  * @example
  * class ChatService {
- *   @weflayr.propagateMetadata({ featureName: 'chat', customerId: 'user_42' })
+ *   @weflayr.propagateMetadata({ featureName: 'chat', customerName: 'Acme Corp' })
  *   async reply(userId: string) { ... }
  * }
  */
@@ -156,3 +156,12 @@ export function propagateMetadata(
 
 /** Flush any pending spans. Await before a short-lived runtime exits. */
 export function flush(): Promise<void>;
+
+/**
+ * Endpoint functions for the Weflayr public API (revenue, key metrics, customer
+ * tags), generated from the platform's OpenAPI spec.
+ */
+export * as api from './dist/api';
+
+/** A client for the public API, authenticated with a project API key. */
+export { client, type ApiClientOptions } from './dist/api';

package/openapi-ts.config.mjs

@@ -0,0 +1,9 @@
+import { defineConfig } from '@hey-api/openapi-ts';
+
+// Regenerated by `make generate-sdk-api-clients`; src/api/generated/ is wiped
+// on every run, the handwritten facade lives in src/api/index.ts.
+export default defineConfig({
+  input: '../observability_dashboard/app_api/openapi.json',
+  output: 'src/api/generated',
+  plugins: ['@hey-api/client-fetch'],
+});

package/package.json

@@ -1,10 +1,14 @@
 {
   "name": "weflayr",
-  "version": "0.22.0",
+  "version": "0.22.1",
   "description": "Weflayr Node.js SDK — instrument any LLM client via JS Proxy",
   "main": "src/index.js",
   "types": "index.d.ts",
   "scripts": {
+    "build": "tsc",
+    "generate-api": "openapi-ts && node scripts/generate_facade.mjs",
+    "pretest": "npm run build",
+    "prepublishOnly": "npm run build",
     "test": "node --test",
     "lint": "eslint src tests",
     "lint:fix": "eslint src tests --fix",
@@ -31,7 +35,10 @@
     "async-retry": "^1.3.3"
   },
   "devDependencies": {
+    "@hey-api/openapi-ts": "^0.99.0",
+    "@types/node": "^26.1.1",
     "eslint": "^9.18.0",
-    "prettier": "^3.4.2"
+    "prettier": "^3.4.2",
+    "typescript": "^6.0.3"
   }
 }

package/scripts/generate_facade.mjs

@@ -0,0 +1,86 @@
+#!/usr/bin/env node
+'use strict';
+
+// Generates src/api/generated/facade.gen.ts: one camelCase-facing wrapper
+// per public-API endpoint exported from src/api/generated/sdk.gen.ts.
+//
+// Run via `npm run generate-api`, right after `openapi-ts` regenerates
+// src/api/generated/ (which wipes the directory first, so this always
+// starts from a clean slate). Do not edit facade.gen.ts by hand - it is
+// overwritten on every run.
+//
+// @hey-api/openapi-ts names an operation's request/response types after its
+// PascalCase operation name (e.g. operation `getAllRevenue` gets types
+// `GetAllRevenueData`, `GetAllRevenueResponse`, `GetAllRevenueError`), so the
+// only thing this script needs from the generated source is the list of
+// operation names - the type names, and the per-endpoint camelCase/snake_case
+// conversion, follow mechanically from there.
+
+import { readFileSync, writeFileSync } from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const GENERATED_DIR = path.join(
+  path.dirname(fileURLToPath(import.meta.url)),
+  '..',
+  'src',
+  'api',
+  'generated'
+);
+const SDK_PATH = path.join(GENERATED_DIR, 'sdk.gen.ts');
+const TYPES_PATH = path.join(GENERATED_DIR, 'types.gen.ts');
+const OUTPUT_PATH = path.join(GENERATED_DIR, 'facade.gen.ts');
+
+const HEADER = `// Generated by services/sdk_node_js/scripts/generate_facade.mjs from
+// sdk.gen.ts. Do not edit by hand.
+
+import { makeEndpoint } from '../makeEndpoint.js';
+import type { CamelCaseDeep } from '../caseConversion.js';
+import * as generated from './sdk.gen.js';
+import type * as generatedTypes from './types.gen.js';
+`;
+
+function pascalCase(operationName) {
+  return operationName[0].toUpperCase() + operationName.slice(1);
+}
+
+function collectOperationNames(sdkSource) {
+  return [...sdkSource.matchAll(/^export const (\w+) = </gm)].map((match) => match[1]);
+}
+
+function collectExportedTypeNames(typesSource) {
+  return new Set([...typesSource.matchAll(/^export type (\w+)/gm)].map((match) => match[1]));
+}
+
+function main() {
+  const sdkSource = readFileSync(SDK_PATH, 'utf8');
+  const typesSource = readFileSync(TYPES_PATH, 'utf8');
+  const operationNames = collectOperationNames(sdkSource);
+  const exportedTypeNames = collectExportedTypeNames(typesSource);
+
+  const lines = [HEADER];
+  for (const operationName of operationNames) {
+    const pascal = pascalCase(operationName);
+    for (const suffix of ['Data', 'Response', 'Error']) {
+      const typeName = `${pascal}${suffix}`;
+      if (!exportedTypeNames.has(typeName)) {
+        throw new Error(
+          `generate_facade.mjs: expected type '${typeName}' for operation '${operationName}' ` +
+            "not found in types.gen.ts - has @hey-api/openapi-ts's naming convention changed?"
+        );
+      }
+    }
+    lines.push(
+      `export const ${operationName} = makeEndpoint<\n` +
+        `  CamelCaseDeep<Omit<generatedTypes.${pascal}Data, 'url'>>,\n` +
+        `  CamelCaseDeep<generatedTypes.${pascal}Response>,\n` +
+        `  CamelCaseDeep<generatedTypes.${pascal}Error>\n` +
+        `>(generated.${operationName});`
+    );
+  }
+
+  writeFileSync(OUTPUT_PATH, lines.join('\n\n') + '\n');
+  console.log(`Generated ${OUTPUT_PATH} (${operationNames.length} endpoints)`);
+}
+
+main();

package/src/api/caseConversion.ts

@@ -0,0 +1,58 @@
+/**
+ * Converts between the wire's snake_case JSON keys (also the Python SDK's
+ * native casing) and the camelCase keys this SDK exposes to JS callers.
+ *
+ * `tags` (see CustomerTags / CustomerTagsOutput) is a free-form map of
+ * user-chosen tag names, not a fixed schema - its own field name is renamed
+ * like any other, but the keys inside it are left untouched in both
+ * directions, otherwise a tag literally named e.g. "utm_source" would be
+ * silently mangled into "utmSource" on the way out.
+ */
+
+const OPAQUE_KEYS = new Set(['tags']);
+
+export type CamelCase<S extends string> = S extends `${infer Head}_${infer Tail}`
+  ? `${Head}${Capitalize<CamelCase<Tail>>}`
+  : S;
+
+export type CamelCaseDeep<T> = T extends readonly (infer Item)[]
+  ? CamelCaseDeep<Item>[]
+  : T extends object
+    ? { [Key in keyof T as CamelCase<Key & string>]: CamelCaseDeep<T[Key]> }
+    : T;
+
+function isPlainObject(value: unknown): value is Record<string, unknown> {
+  return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+
+function snakeToCamel(key: string): string {
+  return key.replace(/_[a-z0-9]/g, (match) => match[1].toUpperCase());
+}
+
+function camelToSnake(key: string): string {
+  return key.replace(/[A-Z]/g, (letter) => `_${letter.toLowerCase()}`);
+}
+
+function convertKeysDeep(value: unknown, convertKey: (key: string) => string): unknown {
+  if (Array.isArray(value)) {
+    return value.map((item) => convertKeysDeep(item, convertKey));
+  }
+  if (!isPlainObject(value)) {
+    return value;
+  }
+  const converted: Record<string, unknown> = {};
+  for (const [key, entryValue] of Object.entries(value)) {
+    converted[convertKey(key)] = OPAQUE_KEYS.has(key)
+      ? entryValue
+      : convertKeysDeep(entryValue, convertKey);
+  }
+  return converted;
+}
+
+export function toCamelCaseDeep<T>(value: T): CamelCaseDeep<T> {
+  return convertKeysDeep(value, snakeToCamel) as CamelCaseDeep<T>;
+}
+
+export function toSnakeCaseDeep(value: unknown): unknown {
+  return convertKeysDeep(value, camelToSnake);
+}