@flowripple/sdk 0.1.0

package/.changeset/README.md

@@ -0,0 +1,8 @@
+# Changesets
+
+Hello and welcome! This folder has been automatically generated by `@changesets/cli`, a build tool that works
+with multi-package repos, or single-package repos to help you version and publish your code. You can
+find the full documentation for it [in our repository](https://github.com/changesets/changesets)
+
+We have a quick list of common questions to get you started engaging with this project in
+[our documentation](https://github.com/changesets/changesets/blob/main/docs/common-questions.md)

package/.changeset/config.json

@@ -0,0 +1,11 @@
+{
+  "$schema": "https://unpkg.com/@changesets/config@3.0.5/schema.json",
+  "changelog": "@changesets/cli/changelog",
+  "commit": false,
+  "fixed": [],
+  "linked": [],
+  "access": "restricted",
+  "baseBranch": "main",
+  "updateInternalDependencies": "patch",
+  "ignore": []
+}

package/.env.test

@@ -0,0 +1,3 @@
+FLOWRIPPLE_API_CLIENT_ID=1
+FLOWRIPPLE_API_KEY=f7add1c7-d147-470c-85fb-6c99da9a9e95
+FLOWRIPPLE_BASE_URL=https://api.flowripple.com

package/.env.test.example

@@ -0,0 +1,3 @@
+FLOWRIPPLE_API_KEY=
+FLOWRIPPLE_BASE_URL=
+FLOWRIPPLE_API_CLIENT_ID=

package/.github/workflows/release.yml

@@ -0,0 +1,71 @@
+name: Release CI/CD
+
+on:
+  push:
+    branches:
+      - main
+
+# Avoid overlapping runs on the same branch
+concurrency: ${{ github.workflow }}-${{ github.ref }}
+
+permissions:
+  contents: write # to push changes (e.g., tags or changeset PR)
+  pull-requests: write # to create or update release PR
+  packages: write # to publish to npm
+  id-token: write # for provenance (optional, requires Node 16+)
+
+jobs:
+  release:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v3
+
+      - uses: pnpm/action-setup@v2 # Install pnpm first
+        with:
+          version: 9 # specify pnpm version (e.g., v8 or v9)
+
+      - name: Setup Node.js 20.x and pnpm
+        uses: actions/setup-node@v4
+        with:
+          node-version: 20.x
+          cache: "pnpm"
+          registry-url: "https://registry.npmjs.org" # use npm registry
+
+      - name: Install dependencies
+        run: pnpm install --frozen-lockfile
+
+      - name: Build package
+        run: pnpm build
+
+      - name: Validate environment
+        run: |
+          if [ -z "${{ secrets.NPM_TOKEN }}" ]; then
+            echo "NPM_TOKEN is not set"
+            exit 1
+          fi
+          if [ -z "${{ secrets.FLOWRIPPLE_API_KEY }}" ]; then
+            echo "FLOWRIPPLE_API_KEY is not set"
+            exit 1
+          fi
+
+      - name: Run tests
+        run: |
+          echo "FLOWRIPPLE_API_CLIENT_ID=${{ secrets.FLOWRIPPLE_API_CLIENT_ID }}" >> .env.test
+          echo "FLOWRIPPLE_API_KEY=${{ secrets.FLOWRIPPLE_API_KEY }}" >> .env.test
+          echo "FLOWRIPPLE_BASE_URL=${{ secrets.FLOWRIPPLE_BASE_URL }}" >> .env.test
+          pnpm test # Runs Jest tests
+        env:
+          FLOWRIPPLE_API_CLIENT_ID: ${{ secrets.FLOWRIPPLE_API_CLIENT_ID }}
+          FLOWRIPPLE_API_KEY: ${{ secrets.FLOWRIPPLE_API_KEY }}
+          FLOWRIPPLE_BASE_URL: ${{ secrets.FLOWRIPPLE_BASE_URL }}
+
+    
+      - name: Create Release PR or Publish
+        id: changesets
+        uses: changesets/action@v1
+        with:
+          publish: pnpm run ci:publish # run publish script (defined in package.json)
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          NPM_TOKEN: ${{ secrets.NPM_TOKEN }}

package/README.md

@@ -0,0 +1,99 @@
+# @flowripple/sdk
+
+The official Node.js SDK for Flowripple - a powerful event tracking and analytics platform.
+
+## Installation
+
+Install the package using npm:
+
+```bash
+npm install @flowripple/sdk
+```
+
+Or using yarn:
+
+```bash
+yarn add @flowripple/sdk
+```
+
+## Usage
+
+First, import and initialize the FlowrippleClient with your API credentials:
+
+```typescript
+import { FlowrippleClient } from '@flowripple/sdk';
+
+const client = new FlowrippleClient({
+  apiClientId: YOUR_CLIENT_ID,
+  apiKey: 'YOUR_API_KEY'
+});
+```
+
+Then use the client to capture events:
+
+```typescript
+// Capture a simple event
+await client.capture('user.signup', {
+  userId: '123',
+  email: 'user@example.com'
+});
+
+// Capture an event with custom properties
+await client.capture('order.completed', {
+  orderId: 'ord_123',
+  amount: 99.99,
+  currency: 'USD',
+  items: [
+    { id: 'prod_1', name: 'T-Shirt', quantity: 2 }
+  ]
+});
+```
+
+## API Reference
+
+### FlowrippleClient
+
+#### Constructor Options
+
+The `FlowrippleClient` constructor accepts a configuration object with the following properties:
+
+| Option | Type | Required | Default | Description |
+|--------|------|----------|---------|-------------|
+| `apiClientId` | number | Yes | - | Your Flowripple API Client ID |
+| `apiKey` | string | Yes | - | Your Flowripple API Key |
+| `baseUrl` | string | No | 'https://api.flowripple.com' | Custom API base URL |
+| `silent` | boolean | No | false | If true, failed API calls return false instead of throwing errors |
+| `version` | 'v1' | No | 'v1' | API version to use |
+
+#### Methods
+
+##### `capture(eventName: string, payload: object): Promise<false | void>`
+
+Captures an event by sending it to the Flowripple API.
+
+- `eventName`: The name of the event to capture
+- `payload`: An object containing the event data
+- Returns: A promise that resolves to `void` on success, or `false` if the request fails and silent mode is enabled
+- Throws: An error if the request fails and silent mode is not enabled
+
+## Error Handling
+
+By default, the SDK will throw errors when API requests fail. You can enable silent mode to return `false` instead:
+
+```typescript
+const client = new FlowrippleClient({
+  apiClientId: YOUR_CLIENT_ID,
+  apiKey: 'YOUR_API_KEY',
+  silent: true
+});
+
+// This will return false instead of throwing if the request fails
+const result = await client.capture('user.signup', { userId: '123' });
+if (result === false) {
+  console.log('Event capture failed');
+}
+```
+
+## License
+
+MIT

package/dist/index.d.mts

@@ -0,0 +1,50 @@
+/**
+ * Configuration options for initializing the FlowrippleClient
+ */
+interface FlowrippleClientOptions {
+    /** (Required) Flowripple API Client ID */
+    apiClientId: number;
+    /** (Required) API key for authentication with Flowripple */
+    apiKey: string;
+    /** (Optional) Base URL for the Flowripple API. Defaults to https://api.flowripple.com */
+    baseUrl?: string;
+    /** (Optional) If true, failed API calls will return false instead of throwing errors */
+    silent?: boolean;
+    /** (Optional) Version of the Flowripple API to use. Defaults to 'v1' */
+    version?: 'v1';
+}
+/**
+ * Client for interacting with the Flowripple API
+ *
+ * @example
+ * ```typescript
+ * const client = new FlowrippleClient({
+ *   apiKey: 'your-api-key'
+ * });
+ *
+ * await client.capture('user.signup', {
+ *   userId: '123',
+ *   email: 'user@example.com'
+ * });
+ * ```
+ */
+declare class FlowrippleClient {
+    private readonly options;
+    private readonly baseUrl;
+    /**
+     * Creates a new FlowrippleClient instance
+     * @param options - Configuration options for the client
+     */
+    constructor(options: FlowrippleClientOptions);
+    /**
+     * Captures an event by sending it to the Flowripple API
+     * @param eventName - The name of the event to capture
+     * @param payload - The payload data associated with the event
+     * @returns Promise that resolves to true if the event was successfully captured,
+     *          or false if silent mode is enabled and the request failed
+     * @throws {Error} If the request fails and silent mode is not enabled
+     */
+    capture(eventName: string, payload: object): Promise<false | void>;
+}
+
+export { FlowrippleClient };

package/dist/index.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Configuration options for initializing the FlowrippleClient
+ */
+interface FlowrippleClientOptions {
+    /** (Required) Flowripple API Client ID */
+    apiClientId: number;
+    /** (Required) API key for authentication with Flowripple */
+    apiKey: string;
+    /** (Optional) Base URL for the Flowripple API. Defaults to https://api.flowripple.com */
+    baseUrl?: string;
+    /** (Optional) If true, failed API calls will return false instead of throwing errors */
+    silent?: boolean;
+    /** (Optional) Version of the Flowripple API to use. Defaults to 'v1' */
+    version?: 'v1';
+}
+/**
+ * Client for interacting with the Flowripple API
+ *
+ * @example
+ * ```typescript
+ * const client = new FlowrippleClient({
+ *   apiKey: 'your-api-key'
+ * });
+ *
+ * await client.capture('user.signup', {
+ *   userId: '123',
+ *   email: 'user@example.com'
+ * });
+ * ```
+ */
+declare class FlowrippleClient {
+    private readonly options;
+    private readonly baseUrl;
+    /**
+     * Creates a new FlowrippleClient instance
+     * @param options - Configuration options for the client
+     */
+    constructor(options: FlowrippleClientOptions);
+    /**
+     * Captures an event by sending it to the Flowripple API
+     * @param eventName - The name of the event to capture
+     * @param payload - The payload data associated with the event
+     * @returns Promise that resolves to true if the event was successfully captured,
+     *          or false if silent mode is enabled and the request failed
+     * @throws {Error} If the request fails and silent mode is not enabled
+     */
+    capture(eventName: string, payload: object): Promise<false | void>;
+}
+
+export { FlowrippleClient };

package/dist/index.js

@@ -0,0 +1,110 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  FlowrippleClient: () => FlowrippleClient
+});
+module.exports = __toCommonJS(index_exports);
+var import_axios = __toESM(require("axios"));
+var import_crypto = __toESM(require("crypto"));
+var FlowrippleClient = class {
+  /**
+   * Creates a new FlowrippleClient instance
+   * @param options - Configuration options for the client
+   */
+  constructor(options) {
+    this.options = options;
+    this.baseUrl = options.baseUrl || "https://api.flowripple.com";
+  }
+  /**
+   * Captures an event by sending it to the Flowripple API
+   * @param eventName - The name of the event to capture
+   * @param payload - The payload data associated with the event
+   * @returns Promise that resolves to true if the event was successfully captured,
+   *          or false if silent mode is enabled and the request failed
+   * @throws {Error} If the request fails and silent mode is not enabled
+   */
+  capture(eventName, payload) {
+    return __async(this, null, function* () {
+      var _a, _b;
+      try {
+        const body = {
+          event: eventName,
+          payload
+        };
+        const timestamp = Date.now().toString();
+        const stringToSign = timestamp + JSON.stringify(body);
+        const hmac = import_crypto.default.createHmac("sha256", this.options.apiKey).update(stringToSign).digest("hex");
+        const url = `${this.baseUrl.replace(/^\/+/, "")}/sdk/${(_a = this.options.version) != null ? _a : "v1"}/capture`;
+        yield import_axios.default.post(url, body, {
+          headers: {
+            "Content-Type": "application/json",
+            "X-Flowripple-Api-Client-Id": this.options.apiClientId,
+            "X-Flowripple-Signature": hmac,
+            "X-Flowripple-Timestamp": timestamp
+          }
+        });
+        return;
+      } catch (error) {
+        if (this.options.silent) {
+          return false;
+        }
+        throw new Error(
+          `Failed to capture event: ${(_b = error == null ? void 0 : error.message) != null ? _b : error}`
+        );
+      }
+    });
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  FlowrippleClient
+});

package/dist/index.mjs

@@ -0,0 +1,76 @@
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+
+// src/index.ts
+import axios from "axios";
+import crypto from "crypto";
+var FlowrippleClient = class {
+  /**
+   * Creates a new FlowrippleClient instance
+   * @param options - Configuration options for the client
+   */
+  constructor(options) {
+    this.options = options;
+    this.baseUrl = options.baseUrl || "https://api.flowripple.com";
+  }
+  /**
+   * Captures an event by sending it to the Flowripple API
+   * @param eventName - The name of the event to capture
+   * @param payload - The payload data associated with the event
+   * @returns Promise that resolves to true if the event was successfully captured,
+   *          or false if silent mode is enabled and the request failed
+   * @throws {Error} If the request fails and silent mode is not enabled
+   */
+  capture(eventName, payload) {
+    return __async(this, null, function* () {
+      var _a, _b;
+      try {
+        const body = {
+          event: eventName,
+          payload
+        };
+        const timestamp = Date.now().toString();
+        const stringToSign = timestamp + JSON.stringify(body);
+        const hmac = crypto.createHmac("sha256", this.options.apiKey).update(stringToSign).digest("hex");
+        const url = `${this.baseUrl.replace(/^\/+/, "")}/sdk/${(_a = this.options.version) != null ? _a : "v1"}/capture`;
+        yield axios.post(url, body, {
+          headers: {
+            "Content-Type": "application/json",
+            "X-Flowripple-Api-Client-Id": this.options.apiClientId,
+            "X-Flowripple-Signature": hmac,
+            "X-Flowripple-Timestamp": timestamp
+          }
+        });
+        return;
+      } catch (error) {
+        if (this.options.silent) {
+          return false;
+        }
+        throw new Error(
+          `Failed to capture event: ${(_b = error == null ? void 0 : error.message) != null ? _b : error}`
+        );
+      }
+    });
+  }
+};
+export {
+  FlowrippleClient
+};

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "@flowripple/sdk",
+  "version": "0.1.0",
+  "description": "FlowRipple SDK",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/FlowRipple/sdk.git"
+  },
+  "bugs": {
+    "url": "https://github.com/flowripple/sdk/issues"
+  },
+  "homepage": "https://github.com/flowripple/sdk#readme",
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "devDependencies": {
+    "@changesets/cli": "^2.27.12",
+    "@types/jest": "^29.5.2",
+    "@types/node": "^22.11.1",
+    "jest": "^29.7.0",
+    "pnpm": "^10.2.1",
+    "dotenv": "^16.4.5",
+    "ts-jest": "^29.1.0",
+    "tsup": "^8.3.5",
+    "typescript": "^5.6.3"
+  },
+  "dependencies": {
+    "axios": "^1.7.3"
+  },
+  "scripts": {
+    "build": "tsup src/index.ts --format cjs,esm --dts",
+    "test": "jest",
+    "ci:publish": "pnpm test && pnpm build && changeset publish --access public"
+  }
+}

package/test/actual.test.ts

@@ -0,0 +1,94 @@
+import { FlowrippleClient } from '../src/index';
+
+const baseUrl = process.env.FLOWRIPPLE_BASE_URL || 'http://localhost:3000';
+const validApiClientId = parseInt(process.env.FLOWRIPPLE_API_CLIENT_ID || '1');
+const validApiKey = process.env.FLOWRIPPLE_API_KEY || 'test-api-key';
+
+describe('FlowrippleClient', () => {
+  describe('constructor', () => {
+    it('should set default baseUrl if not provided', () => {
+      const client = new FlowrippleClient({
+        apiClientId: validApiClientId,
+        apiKey: validApiKey,
+      });
+      expect(client['baseUrl']).toBe('https://api.flowripple.com');
+    });
+
+    it('should use provided baseUrl', () => {
+      const client = new FlowrippleClient({
+        apiClientId: validApiClientId,
+        apiKey: validApiKey,
+        baseUrl: 'http://custom.url',
+      });
+      expect(client['baseUrl']).toBe('http://custom.url');
+    });
+  });
+
+  describe('capture method', () => {
+    describe('success cases', () => {
+      it('should successfully capture an event', async () => {
+        const client = new FlowrippleClient({
+          apiClientId: validApiClientId,
+          apiKey: validApiKey,
+          baseUrl,
+        });
+
+        const eventName = 'test.event';
+        const payload = { userId: '123', action: 'test' };
+
+        const result = await client.capture(eventName, payload);
+        expect(result).toBeUndefined();
+      });
+
+      it('should handle successful capture in silent mode', async () => {
+        const client = new FlowrippleClient({
+          apiClientId: validApiClientId,
+          apiKey: validApiKey,
+          baseUrl,
+          silent: true,
+        });
+
+        const result = await client.capture('test.event', { userId: '123' });
+        expect(result).toBeUndefined();
+      });
+    });
+
+    describe('error cases', () => {
+      it('should throw error with descriptive message in normal mode', async () => {
+        const client = new FlowrippleClient({
+          apiClientId: -1, // Invalid ID to force error
+          apiKey: validApiKey,
+          baseUrl,
+        });
+
+        await expect(client.capture('test.event', {})).rejects.toThrow(
+          'Failed to capture event',
+        );
+      });
+
+      it('should return false in silent mode on error', async () => {
+        const client = new FlowrippleClient({
+          apiClientId: -1, // Invalid ID to force error
+          apiKey: validApiKey,
+          baseUrl,
+          silent: true,
+        });
+
+        const result = await client.capture('test.event', {});
+        expect(result).toBe(false);
+      });
+
+      it('should handle invalid API responses', async () => {
+        const client = new FlowrippleClient({
+          apiClientId: validApiClientId,
+          apiKey: 'invalid-key', // Invalid key to force error
+          baseUrl,
+        });
+
+        await expect(client.capture('test.event', {})).rejects.toThrow(
+          'Failed to capture event',
+        );
+      });
+    });
+  });
+});

package/test/mock.test.ts

@@ -0,0 +1,129 @@
+import { FlowrippleClient } from '../src/index';
+import axios from 'axios';
+
+const baseUrl = process.env.FLOWRIPPLE_BASE_URL || 'http://localhost:3000';
+const validApiClientId = parseInt(process.env.FLOWRIPPLE_API_CLIENT_ID || '1');
+const validApiKey = process.env.FLOWRIPPLE_API_KEY || 'test-api-key';
+
+jest.mock('axios');
+const mockedAxios = axios as jest.Mocked<typeof axios>;
+
+describe('FlowrippleClient', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  describe('constructor', () => {
+    it('should set default baseUrl if not provided', () => {
+      const client = new FlowrippleClient({
+        apiClientId: validApiClientId,
+        apiKey: validApiKey,
+      });
+      expect(client['baseUrl']).toBe('https://api.flowripple.com');
+    });
+
+    it('should use provided baseUrl', () => {
+      const client = new FlowrippleClient({
+        apiClientId: validApiClientId,
+        apiKey: validApiKey,
+        baseUrl: 'http://custom.url',
+      });
+      expect(client['baseUrl']).toBe('http://custom.url');
+    });
+  });
+
+  describe('capture method', () => {
+    describe('success cases', () => {
+      beforeEach(() => {
+        mockedAxios.post.mockResolvedValue({ data: {} });
+      });
+
+      it('should send correct request payload and headers', async () => {
+        const client = new FlowrippleClient({
+          apiClientId: validApiClientId,
+          apiKey: validApiKey,
+          baseUrl,
+        });
+
+        const eventName = 'test.event';
+        const payload = { userId: '123', action: 'test' };
+
+        await client.capture(eventName, payload);
+
+        expect(mockedAxios.post).toHaveBeenCalledTimes(1);
+        const [url, body, config] = mockedAxios.post.mock.calls[0] ?? [];
+
+        expect(url).toBe(`${baseUrl}/sdk/v1/capture`);
+        expect(body).toEqual({ event: eventName, payload });
+        expect(config?.headers).toMatchObject({
+          'Content-Type': 'application/json',
+          'X-Flowripple-Api-Client-Id': validApiClientId,
+          'X-Flowripple-Signature': expect.any(String),
+          'X-Flowripple-Timestamp': expect.any(String),
+        });
+      });
+
+      it('should handle successful capture in silent mode', async () => {
+        const client = new FlowrippleClient({
+          apiClientId: validApiClientId,
+          apiKey: validApiKey,
+          baseUrl,
+          silent: true,
+        });
+
+        const result = await client.capture('test.event', { userId: '123' });
+        expect(result).toBeUndefined();
+      });
+    });
+
+    describe('error cases', () => {
+      beforeEach(() => {
+        mockedAxios.post.mockRejectedValue(new Error('Network error'));
+      });
+
+      it('should throw error with descriptive message in normal mode', async () => {
+        const client = new FlowrippleClient({
+          apiClientId: validApiClientId,
+          apiKey: validApiKey,
+          baseUrl,
+        });
+
+        await expect(client.capture('test.event', {})).rejects.toThrow(
+          'Failed to capture event: Network error',
+        );
+      });
+
+      it('should return false in silent mode on error', async () => {
+        const client = new FlowrippleClient({
+          apiClientId: validApiClientId,
+          apiKey: validApiKey,
+          baseUrl,
+          silent: true,
+        });
+
+        const result = await client.capture('test.event', {});
+        expect(result).toBe(false);
+      });
+
+      it('should handle malformed API responses', async () => {
+        mockedAxios.post.mockRejectedValue({
+          isAxiosError: true,
+          response: {
+            status: 400,
+            data: { message: 'Invalid payload' },
+          },
+        });
+
+        const client = new FlowrippleClient({
+          apiClientId: validApiClientId,
+          apiKey: validApiKey,
+          baseUrl,
+        });
+
+        await expect(client.capture('test.event', {})).rejects.toThrow(
+          'Failed to capture event',
+        );
+      });
+    });
+  });
+});

package/test/setup.ts

@@ -0,0 +1,5 @@
+import { config } from 'dotenv';
+import { resolve } from 'path';
+
+// Load test environment variables
+config({ path: resolve(__dirname, '../.env.test') });