@c15t/backend 0.0.1-rc.10

package/dist/integrations/next.cjs

@@ -0,0 +1,131 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = function(exports1) {
+        if ('undefined' != typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    toNextJsHandler: ()=>toNextJsHandler
+});
+const BASE_ERROR_CODES = {
+    NOT_FOUND: 'Resource not found',
+    BAD_REQUEST: 'Bad request',
+    CONFLICT: 'Conflict with current state',
+    CONSENT_NOT_FOUND: 'Consent not found',
+    CONSENT_EXPIRED: 'Consent has expired',
+    FAILED_TO_CREATE_CONSENT: 'Failed to create consent',
+    FAILED_TO_UPDATE_CONSENT: 'Failed to update consent',
+    FAILED_TO_GET_CONSENT: 'Failed to get consent',
+    FAILED_TO_CREATE_PURPOSE: 'Failed to create consentPurpose',
+    PURPOSE_NOT_FOUND: 'Consent Purpose not found',
+    INVALID_CONFIGURATION: 'Invalid configuration',
+    MISSING_REQUIRED_PARAMETER: 'Missing required parameter',
+    UNAUTHORIZED: 'Unauthorized',
+    FORBIDDEN: 'Forbidden',
+    INTERNAL_SERVER_ERROR: 'Internal server error',
+    INITIALIZATION_FAILED: 'Initialization failed',
+    PLUGIN_INITIALIZATION_FAILED: 'Plugin initialization failed',
+    DATABASE_CONNECTION_ERROR: 'Database connection error',
+    DATABASE_QUERY_ERROR: 'Database query error',
+    REQUEST_HANDLER_ERROR: 'Request handler error',
+    API_RETRIEVAL_ERROR: 'API retrieval error',
+    INVALID_REQUEST: 'Invalid request',
+    UNKNOWN_ERROR: 'Unknown error'
+};
+function toNextJsHandler(instance) {
+    const handler = async (initialRequest)=>{
+        try {
+            const request = initialRequest;
+            if ('POST' === request.method) try {
+                const clonedRequest = request.clone();
+                await clonedRequest.json();
+            } catch (error) {
+                return new Response(JSON.stringify({
+                    error: true,
+                    code: BASE_ERROR_CODES.REQUEST_HANDLER_ERROR,
+                    message: 'Invalid JSON in request body',
+                    details: error instanceof Error ? error.message : 'Unknown error'
+                }), {
+                    status: 400,
+                    headers: {
+                        'Content-Type': 'application/json'
+                    }
+                });
+            }
+            if (instance.$context) {
+                const contextPromise = instance.$context;
+                try {
+                    const contextResult = await contextPromise;
+                    contextResult.match((context)=>{
+                        if (!context.baseURL || '' === context.baseURL.trim()) {
+                            const url = new URL(request.url);
+                            const basePath = context.options?.basePath || '/api/c15t';
+                            const baseURL = `${url.origin}${basePath}`;
+                            context.baseURL = baseURL;
+                            if (context.options) context.options.baseURL = baseURL;
+                        }
+                    }, ()=>{});
+                } catch  {}
+            }
+            const result = await instance.handler(request);
+            return await result.match((response)=>response, (error)=>{
+                const status = error.status || 500;
+                const message = error.message || BASE_ERROR_CODES.INTERNAL_SERVER_ERROR;
+                return new Response(JSON.stringify({
+                    error: true,
+                    code: error.code || BASE_ERROR_CODES.INTERNAL_SERVER_ERROR,
+                    message,
+                    data: error.data
+                }), {
+                    status,
+                    headers: {
+                        'Content-Type': 'application/json'
+                    }
+                });
+            });
+        } catch (error) {
+            console.error('Unexpected error in c15t handler:', error);
+            return new Response(JSON.stringify({
+                error: true,
+                code: BASE_ERROR_CODES.INTERNAL_SERVER_ERROR,
+                message: 'An unexpected error occurred',
+                data: {
+                    error: String(error)
+                }
+            }), {
+                status: 500,
+                headers: {
+                    'Content-Type': 'application/json'
+                }
+            });
+        }
+    };
+    return {
+        GET: handler,
+        POST: handler
+    };
+}
+var __webpack_export_target__ = exports;
+for(var __webpack_i__ in __webpack_exports__)__webpack_export_target__[__webpack_i__] = __webpack_exports__[__webpack_i__];
+if (__webpack_exports__.__esModule) Object.defineProperty(__webpack_export_target__, '__esModule', {
+    value: true
+});

package/dist/integrations/next.d.ts

@@ -0,0 +1,29 @@
+import type { C15TInstance } from '../core';
+/**
+ * Convert a c15t handler to a Next.js API route handler.
+ *
+ * This function adapts a c15t instance to work with Next.js App Router API routes,
+ * providing GET and POST handler functions. It handles the conversion between
+ * c15t's Result types and Next.js Response objects.
+ *
+ * @example
+ * ```typescript
+ * // app/api/c15t/route.ts
+ * import { toNextJsHandler } from '@c15t/integrations/next';
+ * import { c15t } from '@/lib/c15t';
+ *
+ * // Pass the entire c15t instance, not just the handler
+ * export const { GET, POST } = toNextJsHandler(c15t);
+ *
+ * // ❌ Don't do this:
+ * // export const { GET, POST } = toNextJsHandler(c15t.handler);
+ * ```
+ *
+ * @param instance - The complete c15t instance (not just the handler)
+ * @returns Next.js API route handler functions for GET and POST
+ */
+export declare function toNextJsHandler(instance: C15TInstance): {
+    GET: (initialRequest: Request) => Promise<Response>;
+    POST: (initialRequest: Request) => Promise<Response>;
+};
+//# sourceMappingURL=next.d.ts.map

package/dist/integrations/next.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"next.d.ts","sourceRoot":"","sources":["../../src/integrations/next.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,QAAQ,CAAC;AAI3C;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,eAAe,CAAC,QAAQ,EAAE,YAAY;0BACd,OAAO;2BAAP,OAAO;EA2G9C"}

package/dist/integrations/next.js

@@ -0,0 +1,99 @@
+const BASE_ERROR_CODES = {
+    NOT_FOUND: 'Resource not found',
+    BAD_REQUEST: 'Bad request',
+    CONFLICT: 'Conflict with current state',
+    CONSENT_NOT_FOUND: 'Consent not found',
+    CONSENT_EXPIRED: 'Consent has expired',
+    FAILED_TO_CREATE_CONSENT: 'Failed to create consent',
+    FAILED_TO_UPDATE_CONSENT: 'Failed to update consent',
+    FAILED_TO_GET_CONSENT: 'Failed to get consent',
+    FAILED_TO_CREATE_PURPOSE: 'Failed to create consentPurpose',
+    PURPOSE_NOT_FOUND: 'Consent Purpose not found',
+    INVALID_CONFIGURATION: 'Invalid configuration',
+    MISSING_REQUIRED_PARAMETER: 'Missing required parameter',
+    UNAUTHORIZED: 'Unauthorized',
+    FORBIDDEN: 'Forbidden',
+    INTERNAL_SERVER_ERROR: 'Internal server error',
+    INITIALIZATION_FAILED: 'Initialization failed',
+    PLUGIN_INITIALIZATION_FAILED: 'Plugin initialization failed',
+    DATABASE_CONNECTION_ERROR: 'Database connection error',
+    DATABASE_QUERY_ERROR: 'Database query error',
+    REQUEST_HANDLER_ERROR: 'Request handler error',
+    API_RETRIEVAL_ERROR: 'API retrieval error',
+    INVALID_REQUEST: 'Invalid request',
+    UNKNOWN_ERROR: 'Unknown error'
+};
+function toNextJsHandler(instance) {
+    const handler = async (initialRequest)=>{
+        try {
+            const request = initialRequest;
+            if ('POST' === request.method) try {
+                const clonedRequest = request.clone();
+                await clonedRequest.json();
+            } catch (error) {
+                return new Response(JSON.stringify({
+                    error: true,
+                    code: BASE_ERROR_CODES.REQUEST_HANDLER_ERROR,
+                    message: 'Invalid JSON in request body',
+                    details: error instanceof Error ? error.message : 'Unknown error'
+                }), {
+                    status: 400,
+                    headers: {
+                        'Content-Type': 'application/json'
+                    }
+                });
+            }
+            if (instance.$context) {
+                const contextPromise = instance.$context;
+                try {
+                    const contextResult = await contextPromise;
+                    contextResult.match((context)=>{
+                        if (!context.baseURL || '' === context.baseURL.trim()) {
+                            const url = new URL(request.url);
+                            const basePath = context.options?.basePath || '/api/c15t';
+                            const baseURL = `${url.origin}${basePath}`;
+                            context.baseURL = baseURL;
+                            if (context.options) context.options.baseURL = baseURL;
+                        }
+                    }, ()=>{});
+                } catch  {}
+            }
+            const result = await instance.handler(request);
+            return await result.match((response)=>response, (error)=>{
+                const status = error.status || 500;
+                const message = error.message || BASE_ERROR_CODES.INTERNAL_SERVER_ERROR;
+                return new Response(JSON.stringify({
+                    error: true,
+                    code: error.code || BASE_ERROR_CODES.INTERNAL_SERVER_ERROR,
+                    message,
+                    data: error.data
+                }), {
+                    status,
+                    headers: {
+                        'Content-Type': 'application/json'
+                    }
+                });
+            });
+        } catch (error) {
+            console.error('Unexpected error in c15t handler:', error);
+            return new Response(JSON.stringify({
+                error: true,
+                code: BASE_ERROR_CODES.INTERNAL_SERVER_ERROR,
+                message: 'An unexpected error occurred',
+                data: {
+                    error: String(error)
+                }
+            }), {
+                status: 500,
+                headers: {
+                    'Content-Type': 'application/json'
+                }
+            });
+        }
+    };
+    return {
+        GET: handler,
+        POST: handler
+    };
+}
+export { toNextJsHandler };

package/dist/integrations/react.cjs

@@ -0,0 +1,182 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = function(exports1) {
+        if ('undefined' != typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    createConsentClient: ()=>createConsentClient
+});
+function createConsentClient(config = {}) {
+    const { baseUrl = '/api/c15t', refreshInterval = 0, defaultPreferences = {
+        analytics: true,
+        marketing: true,
+        preferences: true
+    } } = config;
+    function createStore(createState) {
+        let state;
+        const listeners = new Set();
+        const setState = (partial)=>{
+            const nextState = 'function' == typeof partial ? {
+                ...state,
+                ...partial(state)
+            } : {
+                ...state,
+                ...partial
+            };
+            state = nextState;
+            for (const listener of listeners)listener(state);
+        };
+        const getState = ()=>state;
+        const subscribe = (listener)=>{
+            listeners.add(listener);
+            return ()=>listeners.delete(listener);
+        };
+        state = createState(setState, getState);
+        return {
+            getState,
+            setState,
+            subscribe
+        };
+    }
+    const consentStore = createStore((set, get)=>({
+            isLoading: true,
+            hasConsented: null,
+            preferences: null,
+            error: null,
+            lastUpdated: null,
+            setConsent: async (preferences)=>{
+                try {
+                    set({
+                        isLoading: true,
+                        error: null
+                    });
+                    const response = await fetch(`${baseUrl}/set`, {
+                        method: 'POST',
+                        headers: {
+                            'Content-Type': 'application/json'
+                        },
+                        body: JSON.stringify({
+                            preferences
+                        }),
+                        credentials: 'same-origin'
+                    });
+                    if (!response.ok) throw new Error(`Failed to set consent: ${response.statusText}`);
+                    const result = await response.json();
+                    set({
+                        isLoading: false,
+                        hasConsented: true,
+                        preferences: result.preferences || preferences,
+                        lastUpdated: Date.now()
+                    });
+                    return result;
+                } catch (error) {
+                    set({
+                        isLoading: false,
+                        error: error instanceof Error ? error : new Error(String(error))
+                    });
+                    throw error;
+                }
+            },
+            acceptAll: async ()=>{
+                const cleanPreferences = Object.entries(defaultPreferences).filter(([_, value])=>void 0 !== value).reduce((acc, [key, value])=>{
+                    acc[key] = value;
+                    return acc;
+                }, {});
+                return await get().setConsent(cleanPreferences);
+            },
+            declineAll: async ()=>{
+                const minimalConsent = Object.keys(defaultPreferences).reduce((acc, key)=>{
+                    acc[key] = false;
+                    return acc;
+                }, {});
+                return await get().setConsent(minimalConsent);
+            },
+            refreshStatus: async ()=>{
+                try {
+                    set({
+                        isLoading: true,
+                        error: null
+                    });
+                    const response = await fetch(`${baseUrl}/status`, {
+                        credentials: 'same-origin'
+                    });
+                    if (!response.ok) throw new Error(`Failed to get consent status: ${response.statusText}`);
+                    const { consented, preferences } = await response.json();
+                    set({
+                        isLoading: false,
+                        hasConsented: consented,
+                        preferences: preferences,
+                        lastUpdated: Date.now()
+                    });
+                } catch (error) {
+                    set({
+                        isLoading: false,
+                        error: error instanceof Error ? error : new Error(String(error))
+                    });
+                }
+            },
+            clearError: ()=>{
+                set({
+                    error: null
+                });
+            }
+        }));
+    const useConsent = ()=>{
+        const storeState = consentStore.getState();
+        if ('undefined' == typeof window) return storeState;
+        setTimeout(()=>{
+            if (null === storeState.hasConsented && !storeState.isLoading) storeState.refreshStatus();
+            if (refreshInterval > 0) {
+                const intervalId = setInterval(()=>{
+                    storeState.refreshStatus();
+                }, refreshInterval);
+                window.addEventListener('unload', ()=>clearInterval(intervalId));
+            }
+        }, 0);
+        return storeState;
+    };
+    const useConditionalContent = (requiredConsent)=>{
+        const store = useConsent();
+        const canShow = ()=>{
+            if (store.isLoading || !store.hasConsented || !store.preferences) return false;
+            if (Array.isArray(requiredConsent)) return requiredConsent.every((key)=>store.preferences?.[key]);
+            return !!store.preferences[requiredConsent];
+        };
+        return {
+            isLoading: store.isLoading,
+            hasConsented: store.hasConsented,
+            canShow: canShow(),
+            preferences: store.preferences
+        };
+    };
+    return {
+        store: consentStore,
+        useConsent,
+        useConditionalContent
+    };
+}
+var __webpack_export_target__ = exports;
+for(var __webpack_i__ in __webpack_exports__)__webpack_export_target__[__webpack_i__] = __webpack_exports__[__webpack_i__];
+if (__webpack_exports__.__esModule) Object.defineProperty(__webpack_export_target__, '__esModule', {
+    value: true
+});

package/dist/integrations/react.d.ts

@@ -0,0 +1,257 @@
+/**
+ * React integration for c15t consent management system
+ *
+ * This module provides React hooks and state management for the c15t consent system.
+ * It implements a lightweight store and hooks for integrating consent management
+ * into React applications without requiring specific React dependencies.
+ *
+ * The implementation is designed to work in various React environments and can
+ * also function in non-React environments by providing a fallback pattern.
+ *
+ * @example
+ * ```tsx
+ * // Initialize in your app
+ * import { createConsentClient } from '@c15t/integrations/react';
+ *
+ * const consentClient = createConsentClient({
+ *   baseUrl: '/api/c15t',
+ *   refreshInterval: 60000, // Check every minute
+ * });
+ *
+ * // Use in components
+ * function ConsentBanner() {
+ *   const { isLoading, hasConsented, acceptAll, declineAll } = consentClient.useConsent();
+ *
+ *   if (isLoading) return <div>Loading...</div>;
+ *   if (hasConsented) return null;
+ *
+ *   return (
+ *     <div className="consent-banner">
+ *       <h2>We use cookies</h2>
+ *       <button onClick={acceptAll}>Accept All</button>
+ *       <button onClick={declineAll}>Decline All</button>
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+/**
+ * Type definition for a React-like hook function
+ *
+ * This type facilitates compatibility with React's hooks pattern
+ * without requiring a direct dependency on React.
+ *
+ * @template T The return type of the hook
+ */
+type ReactHook<T> = () => T;
+/**
+ * State for the consent management store
+ *
+ * Contains the current consent status, preferences, and loading state.
+ */
+interface ConsentState {
+    /**
+     * Whether consent data is currently being loaded
+     */
+    isLoading: boolean;
+    /**
+     * Whether the subject has provided consent
+     * - `true`: Subject has provided at least one consent
+     * - `false`: Subject has explicitly declined all consent
+     * - `null`: Consent status hasn't been determined yet
+     */
+    hasConsented: boolean | null;
+    /**
+     * Map of consent purposes to their consent status
+     * Key is the consentPurpose ID, value is a boolean indicating consent
+     */
+    preferences: Record<string, boolean> | null;
+    /**
+     * Error that occurred during consent operations
+     */
+    error: Error | null;
+    /**
+     * Timestamp of when consent was last updated
+     */
+    lastUpdated: number | null;
+}
+/**
+ * Actions that can be performed on the consent store
+ *
+ * These actions allow modifying the consent state and interacting
+ * with the consent management backend.
+ */
+interface ConsentActions {
+    /**
+     * Set specific consent preferences
+     *
+     * @param preferences - Map of consentPurpose IDs to consent values
+     * @returns Promise that resolves when consent is updated
+     */
+    setConsent: (preferences: Record<string, boolean>) => Promise<void>;
+    /**
+     * Accept all consent purposes
+     * Uses the default preferences defined in configuration
+     *
+     * @returns Promise that resolves when consent is updated
+     */
+    acceptAll: () => Promise<void>;
+    /**
+     * Decline all consent purposes
+     * Sets all purposes to `false`
+     *
+     * @returns Promise that resolves when consent is updated
+     */
+    declineAll: () => Promise<void>;
+    /**
+     * Refresh the consent status from the server
+     *
+     * @returns Promise that resolves when consent status is refreshed
+     */
+    refreshStatus: () => Promise<void>;
+    /**
+     * Clear any error state in the store
+     */
+    clearError: () => void;
+}
+/**
+ * Combined type for the consent store containing both state and actions
+ */
+type ConsentStore = ConsentState & ConsentActions;
+/**
+ * Configuration options for the c15t React client
+ */
+interface c15tClientConfig {
+    /**
+     * Base URL for API endpoints
+     * @default '/api/c15t'
+     */
+    baseUrl?: string;
+    /**
+     * Auto-refresh interval in milliseconds
+     * Set to 0 to disable auto-refresh
+     * @default 0 (disabled)
+     */
+    refreshInterval?: number;
+    /**
+     * Default preferences to use for acceptAll action
+     * These values determine what gets set when a subject accepts all consent
+     *
+     * @example
+     * ```ts
+     * {
+     *   analytics: true,
+     *   marketing: true,
+     *   preferences: true
+     * }
+     * ```
+     */
+    defaultPreferences?: {
+        analytics?: boolean;
+        marketing?: boolean;
+        preferences?: boolean;
+        [key: string]: boolean | undefined;
+    };
+}
+/**
+ * Interface for basic store operations
+ *
+ * Provides a minimal store API similar to common state management libraries
+ *
+ * @template T The type of state stored in the store
+ */
+interface StoreAPI<T> {
+    /**
+     * Get the current state
+     * @returns The current state
+     */
+    getState: () => T;
+    /**
+     * Update the state
+     * @param partial - Partial state or function that returns partial state
+     */
+    setState: (partial: Partial<T> | ((state: T) => Partial<T>)) => void;
+    /**
+     * Subscribe to state changes
+     * @param listener - Function to call when state changes
+     * @returns Unsubscribe function
+     */
+    subscribe: (listener: (state: T) => void) => () => void;
+}
+/**
+ * Result of the useConditionalContent hook
+ */
+interface ConditionalContentResult {
+    /**
+     * Whether consent data is currently loading
+     */
+    isLoading: boolean;
+    /**
+     * Whether the subject has given any consent
+     */
+    hasConsented: boolean | null;
+    /**
+     * Whether content can be shown based on required consent
+     */
+    canShow: boolean;
+    /**
+     * Current consent preferences
+     */
+    preferences: Record<string, boolean> | null;
+}
+/**
+ * Result of the createConsentClient function
+ */
+interface ConsentClient {
+    /**
+     * Store for managing consent state
+     */
+    store: StoreAPI<ConsentStore>;
+    /**
+     * Hook for accessing consent state and actions
+     */
+    useConsent: ReactHook<ConsentStore>;
+    /**
+     * Hook for conditionally showing content based on consent
+     */
+    useConditionalContent: (requiredConsent: string | string[]) => ConditionalContentResult;
+}
+/**
+ * Creates a c15t client for React applications
+ *
+ * This function creates a store and hooks for managing consent in React applications.
+ * It provides a lightweight implementation that works in various React environments
+ * and degrades gracefully in non-React environments.
+ *
+ * @example
+ * ```tsx
+ * // Create a client
+ * const client = createConsentClient({
+ *   baseUrl: '/api/c15t',
+ *   refreshInterval: 60000,
+ *   defaultPreferences: {
+ *     analytics: true,
+ *     marketing: false
+ *   }
+ * });
+ *
+ * // Use in a component
+ * function ConsentStatus() {
+ *   const { preferences, refreshStatus } = client.useConsent();
+ *
+ *   return (
+ *     <div>
+ *       <h2>Your consent preferences:</h2>
+ *       <pre>{JSON.stringify(preferences, null, 2)}</pre>
+ *       <button onClick={refreshStatus}>Refresh</button>
+ *     </div>
+ *   );
+ * }
+ * ```
+ *
+ * @param config - Client configuration options
+ * @returns A client object with store and hooks
+ */
+export declare function createConsentClient(config?: c15tClientConfig): ConsentClient;
+export {};
+//# sourceMappingURL=react.d.ts.map