@c15t/node-sdk 1.8.0 → 2.0.0-rc.0

package/README.md

@@ -18,33 +18,237 @@
 [![Last Commit](https://img.shields.io/github/last-commit/c15t/c15t?style=flat-square)](https://github.com/c15t/c15t/commits/main)
 [![Open Issues](https://img.shields.io/github/issues/c15t/c15t?style=flat-square)](https://github.com/c15t/c15t/issues)
 
-A fully typed, flexible Node.js SDK for seamless interaction with the c15t consent management platform API.
+A fully typed, lightweight Node.js SDK for seamless interaction with the c15t consent management platform API.
 
 ## Key Features
 
-- Type-safe API client with full TypeScript support
-- Flexible client configuration with authentication and custom headers
-- Supports dynamic base URL and API prefix configuration
-- Built on top of @orpc/client for robust API interactions
-- Easy integration with Node.js applications
-- Comprehensive error handling and URL validation
+- **Type-safe API client** with full TypeScript support
+- **Zero-config setup** with environment variable auto-detection
+- **Result-like error handling** with `unwrap()`, `unwrapOr()`, and `expect()` helpers
+- **Custom error class** (`C15TError`) for typed error handling
+- **Automatic retries** with exponential backoff
+- **Namespaced API methods** for intuitive organization
+- **Lightweight** with minimal dependencies
 
 ## Prerequisites
 
 - Node.js 18.17.0 or later
 - A Hosted [c15t instance](https://consent.io) (free sign-up) or [self-hosted deployment](https://c15t.com/docs/self-host/v2)
 
-## Manual Installation
+## Installation
 
 ```bash
+# npm
+npm install @c15t/node-sdk
+
+# pnpm
 pnpm add @c15t/node-sdk
+
+# yarn
+yarn add @c15t/node-sdk
+
+# bun
+bun add @c15t/node-sdk
+```
+
+## Quick Start
+
+### Basic Setup
+
+```typescript
+import { c15tClient } from '@c15t/node-sdk';
+
+// Auto-configure from environment variables
+// Reads C15T_API_URL and C15T_API_TOKEN automatically
+const client = c15tClient();
+
+// Or provide explicit configuration
+const client = c15tClient({
+  baseUrl: 'https://api.example.com',
+  token: 'your-api-token',
+});
 ```
 
-## Usage
+### Environment Variables
+
+The SDK automatically reads these environment variables:
+
+- `C15T_API_URL` - Base URL for the API server
+- `C15T_API_TOKEN` - Authentication token
+
+### Check Consent Status
+
+```typescript
+const result = await client.checkConsent({
+  externalId: 'user_123',
+  type: 'analytics',
+});
+
+if (result.ok) {
+  console.log('Has consent:', result.data?.results.analytics?.hasConsent);
+} else {
+  console.error('Error:', result.error?.message);
+}
+```
+
+### Using Result Helpers
+
+The SDK provides ergonomic helper methods inspired by Rust's Result type:
+
+```typescript
+// Unwrap data or throw if error
+const subject = (await client.getSubject('sub_123')).unwrap();
+
+// Unwrap with custom error message
+const subject = (await client.getSubject('sub_123')).expect('Subject not found');
+
+// Unwrap with default value
+const subject = (await client.getSubject('sub_123')).unwrapOr(defaultSubject);
+
+// Transform data with map
+const name = (await client.getSubject('sub_123')).map(s => s.externalId);
+```
+
+### Error Handling
+
+```typescript
+import { c15tClient, C15TError, isC15TError } from '@c15t/node-sdk';
+
+const client = c15tClient();
+
+try {
+  const subject = (await client.getSubject('sub_123')).unwrap();
+} catch (error) {
+  if (isC15TError(error)) {
+    console.log('Status:', error.status);     // 404
+    console.log('Code:', error.code);         // 'NOT_FOUND'
+    console.log('Details:', error.details);
+    
+    if (error.isNotFound()) {
+      // Handle not found
+    } else if (error.isServerError()) {
+      // Handle server error
+    }
+  }
+}
+```
 
-1. Import the c15tClient function from the SDK
-2. Configure the client with your API base URL
-3. Interact with the c15t API using type-safe methods
+### Create Subject with Consent
+
+```typescript
+const result = await client.createSubject({
+  type: 'cookie_banner',
+  subjectId: 'sub_123',
+  externalSubjectId: 'user_123',
+  domain: 'example.com',
+  preferences: {
+    analytics: true,
+    marketing: false,
+  },
+  givenAt: Date.now(),
+});
+
+if (result.ok) {
+  console.log('Subject created:', result.data?.subjectId);
+}
+```
+
+### Server Component Usage (Next.js)
+
+```typescript
+// lib/c15t-client.ts
+import { c15tClient } from '@c15t/node-sdk';
+
+export const consentClient = c15tClient({
+  baseUrl: process.env.C15T_API_URL || 'http://localhost:3000/api/self-host',
+});
+
+// app/consent-check/page.tsx
+import { consentClient } from '@/lib/c15t-client';
+
+export default async function ConsentCheckPage({ searchParams }) {
+  const { externalId } = await searchParams;
+  
+  const result = await consentClient.checkConsent({
+    externalId,
+    type: 'analytics',
+  });
+
+  if (!result.ok) {
+    return <div>Error: {result.error?.message}</div>;
+  }
+
+  return <pre>{JSON.stringify(result.data, null, 2)}</pre>;
+}
+```
+
+## API Reference
+
+### Client Methods
+
+| Method | Description |
+|--------|-------------|
+| `client.status()` | Check API status |
+| `client.init()` | Initialize consent manager |
+| `client.checkConsent(query)` | Check consent status |
+| `client.createSubject(input)` | Create a new subject |
+| `client.getSubject(id)` | Get subject by ID |
+| `client.patchSubject(id, input)` | Update subject |
+| `client.listSubjects(query)` | List subjects |
+
+### Namespaced Methods
+
+```typescript
+// Meta operations
+client.meta.status();
+client.meta.init();
+
+// Consent operations
+client.consent.check(query);
+
+// Subject operations
+client.subjects.create(input);
+client.subjects.get(id);
+client.subjects.patch(id, input);
+client.subjects.list(query);
+```
+
+### ResponseContext
+
+All methods return a `ResponseContext<T>` with:
+
+```typescript
+interface ResponseContext<T> {
+  data: T | null;           // Response data
+  error: {...} | null;      // Error details
+  ok: boolean;              // Success status
+  response: Response | null; // Raw Response object
+  
+  // Helper methods
+  unwrap(): T;              // Get data or throw
+  unwrapOr(default: T): T;  // Get data or return default
+  expect(msg: string): T;   // Get data or throw with custom message
+  map<U>(fn: (T) => U): ResponseContext<U>; // Transform data
+}
+```
+
+### Configuration Options
+
+```typescript
+interface C15TClientOptions {
+  baseUrl?: string;           // API base URL (or use C15T_API_URL env var)
+  token?: string;             // Auth token (or use C15T_API_TOKEN env var)
+  headers?: Record<string, string>; // Custom headers
+  prefix?: string;            // API path prefix
+  retryConfig?: {
+    maxRetries?: number;      // Default: 3
+    initialDelayMs?: number;  // Default: 100
+    backoffFactor?: number;   // Default: 2
+    retryableStatusCodes?: number[]; // Default: [500, 502, 503, 504]
+    retryOnNetworkError?: boolean;   // Default: true
+  };
+}
+```
 
 ## Support
 
@@ -82,4 +286,4 @@ Our preference is that you make use of GitHub's private vulnerability reporting
 
 ---
 
-**Built with ❤️ by the [consent.io](https://www.consent.io?utm_source=github&utm_medium=repopage_%40c15t%2Fnode-sdk) team**
+**Built with love by the [consent.io](https://www.consent.io?utm_source=github&utm_medium=repopage_%40c15t%2Fnode-sdk) team**

package/dist/client.d.ts

@@ -0,0 +1,433 @@
+import type { CheckConsentOutput, CheckConsentQuery, GetSubjectOutput, GetSubjectQuery, InitOutput, ListSubjectsOutput, ListSubjectsQuery, PatchSubjectFullInput, PatchSubjectOutput, PostSubjectInput, PostSubjectOutput, StatusOutput } from '@c15t/schema/types';
+import type { C15TClientOptions, FetchOptions, ResponseContext } from './types';
+/**
+ * C15T Client for interacting with the consent management API
+ *
+ * @example
+ * ```typescript
+ * const client = new C15TClient({
+ *   baseUrl: 'https://api.example.com',
+ *   token: 'your-auth-token',
+ * });
+ *
+ * // Check API status
+ * const statusResponse = await client.status();
+ *
+ * // Initialize consent manager
+ * const initResponse = await client.init();
+ *
+ * // Create a subject with consent
+ * const subject = await client.createSubject({
+ *   type: 'new',
+ *   subjectId: 'sub_123',
+ *   consents: { analytics: true },
+ * });
+ * ```
+ */
+export declare class C15TClient {
+    /**
+     * Internal fetcher context
+     */
+    private context;
+    /**
+     * Creates a new C15T client instance
+     *
+     * @param options - Client configuration options
+     * @throws {TypeError} If baseUrl is invalid or not provided (and no env var)
+     */
+    constructor(options?: C15TClientOptions);
+    /**
+     * Get API status
+     *
+     * @param options - Optional fetch options
+     * @returns Status response with version and client info
+     */
+    status(options?: FetchOptions<StatusOutput>): Promise<ResponseContext<StatusOutput>>;
+    /**
+     * Initialize consent manager
+     *
+     * @param options - Optional fetch options
+     * @returns Init response with jurisdiction, location, translations, branding
+     */
+    init(options?: FetchOptions<InitOutput>): Promise<ResponseContext<InitOutput>>;
+    /**
+     * Create a new subject with consent preferences
+     *
+     * @param input - Subject creation input
+     * @param options - Optional fetch options
+     * @returns Created subject response
+     */
+    createSubject(input: PostSubjectInput, options?: FetchOptions<PostSubjectOutput, PostSubjectInput>): Promise<ResponseContext<PostSubjectOutput>>;
+    /**
+     * Get a subject by ID
+     *
+     * @param id - Subject ID
+     * @param query - Optional query parameters
+     * @param options - Optional fetch options
+     * @returns Subject data response
+     */
+    getSubject(id: string, query?: GetSubjectQuery, options?: FetchOptions<GetSubjectOutput, never, GetSubjectQuery>): Promise<ResponseContext<GetSubjectOutput>>;
+    /**
+     * Update a subject (link external ID or update preferences)
+     *
+     * @param id - Subject ID
+     * @param input - Patch input with externalId or other fields
+     * @param options - Optional fetch options
+     * @returns Updated subject response
+     */
+    patchSubject(id: string, input: Omit<PatchSubjectFullInput, 'id'>, options?: FetchOptions<PatchSubjectOutput, Omit<PatchSubjectFullInput, 'id'>>): Promise<ResponseContext<PatchSubjectOutput>>;
+    /**
+     * List subjects with optional filtering
+     *
+     * @param query - Query parameters for filtering
+     * @param options - Optional fetch options
+     * @returns List of subjects
+     */
+    listSubjects(query?: ListSubjectsQuery, options?: FetchOptions<ListSubjectsOutput, never, ListSubjectsQuery>): Promise<ResponseContext<ListSubjectsOutput>>;
+    /**
+     * Check consent status for an external ID
+     *
+     * @param query - Query parameters (externalId required)
+     * @param options - Optional fetch options
+     * @returns Consent check response
+     */
+    checkConsent(query: CheckConsentQuery, options?: FetchOptions<CheckConsentOutput, never, CheckConsentQuery>): Promise<ResponseContext<CheckConsentOutput>>;
+    /**
+     * Make a custom API request to any endpoint
+     *
+     * @param path - API endpoint path
+     * @param options - Fetch options
+     * @returns Response context
+     */
+    $fetch<ResponseType, BodyType = unknown, QueryType = unknown>(path: string, options?: FetchOptions<ResponseType, BodyType, QueryType>): Promise<ResponseContext<ResponseType>>;
+    /**
+     * Namespaced access to consent endpoints
+     */
+    consent: {
+        /**
+         * Check consent status for an external ID
+         */
+        check: (query: CheckConsentQuery, options?: FetchOptions<CheckConsentOutput, never, CheckConsentQuery>) => Promise<ResponseContext<{
+            results: {
+                [x: string]: {
+                    hasConsent: boolean;
+                    isLatestPolicy: boolean;
+                };
+            };
+        }>>;
+    };
+    /**
+     * Namespaced access to subject endpoints
+     */
+    subjects: {
+        /**
+         * Create a new subject
+         */
+        create: (input: PostSubjectInput, options?: FetchOptions<PostSubjectOutput, PostSubjectInput>) => Promise<ResponseContext<{
+            subjectId: string;
+            consentId: string;
+            domainId: string;
+            domain: string;
+            type: "cookie_banner" | "privacy_policy" | "dpa" | "terms_and_conditions" | "marketing_communications" | "age_verification" | "other";
+            status: string;
+            recordId: string;
+            metadata?: {
+                [x: string]: unknown;
+            } | undefined;
+            uiSource?: string | undefined;
+            givenAt: Date;
+        }>>;
+        /**
+         * Get a subject by ID
+         */
+        get: (id: string, query?: GetSubjectQuery, options?: FetchOptions<GetSubjectOutput, never, GetSubjectQuery>) => Promise<ResponseContext<{
+            subject: {
+                id: string;
+                externalId?: string | undefined;
+                isIdentified: boolean;
+                createdAt?: Date | undefined;
+            };
+            consents: {
+                id: string;
+                type: string;
+                policyId?: string | undefined;
+                isLatestPolicy: boolean;
+                preferences?: {
+                    [x: string]: boolean;
+                } | undefined;
+                givenAt: Date;
+            }[];
+            isValid: boolean;
+        }>>;
+        /**
+         * Update a subject
+         */
+        patch: (id: string, input: Omit<PatchSubjectFullInput, "id">, options?: FetchOptions<PatchSubjectOutput, Omit<PatchSubjectFullInput, "id">>) => Promise<ResponseContext<{
+            success: boolean;
+            subject: {
+                id: string;
+                externalId: string;
+                isIdentified: boolean;
+            };
+        }>>;
+        /**
+         * List subjects
+         */
+        list: (query?: ListSubjectsQuery, options?: FetchOptions<ListSubjectsOutput, never, ListSubjectsQuery>) => Promise<ResponseContext<{
+            subjects: {
+                id: string;
+                externalId: string;
+                isIdentified: boolean;
+                createdAt: Date;
+                consents: {
+                    id: string;
+                    type: string;
+                    policyId?: string | undefined;
+                    isLatestPolicy: boolean;
+                    preferences?: {
+                        [x: string]: boolean;
+                    } | undefined;
+                    givenAt: Date;
+                }[];
+            }[];
+        }>>;
+    };
+    /**
+     * Namespaced access to meta endpoints
+     */
+    meta: {
+        /**
+         * Get API status
+         */
+        status: (options?: FetchOptions<StatusOutput>) => Promise<ResponseContext<{
+            version: string;
+            timestamp: Date;
+            client: {
+                ip: string | null;
+                acceptLanguage: string | null;
+                userAgent: string | null;
+                region: {
+                    countryCode: string | null;
+                    regionCode: string | null;
+                };
+            };
+        }>>;
+        /**
+         * Initialize consent manager
+         */
+        init: (options?: FetchOptions<InitOutput>) => Promise<ResponseContext<{
+            jurisdiction: "UK_GDPR" | "GDPR" | "CH" | "BR" | "PIPEDA" | "QC_LAW25" | "AU" | "APPI" | "PIPA" | "CCPA" | "NONE";
+            location: {
+                countryCode: string | null;
+                regionCode: string | null;
+            };
+            translations: {
+                language: string;
+                translations: {
+                    common: {
+                        acceptAll: string;
+                        rejectAll: string;
+                        customize: string;
+                        save: string;
+                    };
+                    cookieBanner: {
+                        title: string;
+                        description: string;
+                    };
+                    consentManagerDialog: {
+                        title: string;
+                        description: string;
+                    };
+                    consentTypes: {
+                        experience: {
+                            title: string;
+                            description: string;
+                        };
+                        functionality: {
+                            title: string;
+                            description: string;
+                        };
+                        marketing: {
+                            title: string;
+                            description: string;
+                        };
+                        measurement: {
+                            title: string;
+                            description: string;
+                        };
+                        necessary: {
+                            title: string;
+                            description: string;
+                        };
+                    };
+                    frame: {
+                        title: string;
+                        actionButton: string;
+                    };
+                    legalLinks: {
+                        privacyPolicy: string;
+                        termsOfService: string;
+                        cookiePolicy: string;
+                    };
+                } | {
+                    common: {
+                        acceptAll?: string | undefined;
+                        rejectAll?: string | undefined;
+                        customize?: string | undefined;
+                        save?: string | undefined;
+                    };
+                    cookieBanner: {
+                        title?: string | undefined;
+                        description?: string | undefined;
+                    };
+                    consentManagerDialog: {
+                        title?: string | undefined;
+                        description?: string | undefined;
+                    };
+                    consentTypes: {
+                        experience?: {
+                            title?: string | undefined;
+                            description?: string | undefined;
+                        } | undefined;
+                        functionality?: {
+                            title?: string | undefined;
+                            description?: string | undefined;
+                        } | undefined;
+                        marketing?: {
+                            title?: string | undefined;
+                            description?: string | undefined;
+                        } | undefined;
+                        measurement?: {
+                            title?: string | undefined;
+                            description?: string | undefined;
+                        } | undefined;
+                        necessary?: {
+                            title?: string | undefined;
+                            description?: string | undefined;
+                        } | undefined;
+                    };
+                    frame?: {
+                        title?: string | undefined;
+                        actionButton?: string | undefined;
+                    } | undefined;
+                    legalLinks?: {
+                        privacyPolicy?: string | undefined;
+                        termsOfService?: string | undefined;
+                        cookiePolicy?: string | undefined;
+                    } | undefined;
+                };
+            };
+            branding: "c15t" | "consent" | "none";
+            gvl?: {
+                gvlSpecificationVersion: number;
+                vendorListVersion: number;
+                tcfPolicyVersion: number;
+                lastUpdated: string;
+                purposes: {
+                    [x: string]: {
+                        id: number;
+                        name: string;
+                        description: string;
+                        illustrations: string[];
+                        descriptionLegal?: string | undefined;
+                    };
+                };
+                specialPurposes: {
+                    [x: string]: {
+                        id: number;
+                        name: string;
+                        description: string;
+                        illustrations: string[];
+                        descriptionLegal?: string | undefined;
+                    };
+                };
+                features: {
+                    [x: string]: {
+                        id: number;
+                        name: string;
+                        description: string;
+                        illustrations: string[];
+                        descriptionLegal?: string | undefined;
+                    };
+                };
+                specialFeatures: {
+                    [x: string]: {
+                        id: number;
+                        name: string;
+                        description: string;
+                        illustrations: string[];
+                        descriptionLegal?: string | undefined;
+                    };
+                };
+                vendors: {
+                    [x: string]: {
+                        id: number;
+                        name: string;
+                        purposes: number[];
+                        legIntPurposes: number[];
+                        flexiblePurposes: number[];
+                        specialPurposes: number[];
+                        features: number[];
+                        specialFeatures: number[];
+                        cookieMaxAgeSeconds: number | null;
+                        usesCookies: boolean;
+                        cookieRefresh: boolean;
+                        usesNonCookieAccess: boolean;
+                        urls: {
+                            langId: string;
+                            privacy?: string | undefined;
+                            legIntClaim?: string | undefined;
+                        }[];
+                        deviceStorageDisclosureUrl?: string | undefined;
+                        dataCategories?: number[] | undefined;
+                        dataRetention?: {
+                            purposes?: {
+                                [x: string]: number;
+                            } | undefined;
+                            specialPurposes?: {
+                                [x: string]: number;
+                            } | undefined;
+                            stdRetention?: number | undefined;
+                        } | undefined;
+                        deletedDate?: string | undefined;
+                        overflow?: {
+                            httpGetLimit: number;
+                        } | undefined;
+                    };
+                };
+                stacks: {
+                    [x: string]: {
+                        id: number;
+                        name: string;
+                        description: string;
+                        purposes: number[];
+                        specialFeatures: number[];
+                    };
+                };
+                dataCategories?: {
+                    [x: string]: {
+                        id: number;
+                        name: string;
+                        description: string;
+                    };
+                } | undefined;
+            } | null | undefined;
+            customVendors?: {
+                id: string | number;
+                name: string;
+                privacyPolicyUrl: string;
+                description?: string | undefined;
+                purposes: number[];
+                legIntPurposes?: number[] | undefined;
+                features?: number[] | undefined;
+                specialFeatures?: number[] | undefined;
+                dataCategories?: number[] | undefined;
+                cookieMaxAgeSeconds?: number | undefined;
+                usesCookies?: boolean | undefined;
+                usesNonCookieAccess?: boolean | undefined;
+                dataRetentionDays?: number | undefined;
+            }[] | undefined;
+        }>>;
+    };
+}
+//# sourceMappingURL=client.d.ts.map

package/dist/client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../src/client.ts"],"names":[],"mappings":"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"}