@c15t/backend 0.0.1-rc.10

package/dist/init.d.ts

@@ -0,0 +1,52 @@
+import { type C15TResult } from './error/results';
+/**
+ * c15t Initialization Module
+ *
+ * This module handles the initialization of the c15t consent management system.
+ * It sets up the consent context, configures storage adapters, initializes plugins,
+ * and establishes security settings like secrets and trusted origins.
+ *
+ * The initialization process includes:
+ * - Setting up storage adapters for consent data
+ * - Configuring security credentials and trusted origins
+ * - Initializing core and custom plugins
+ * - Creating the consent context object that serves as the foundation for the system
+ *
+ * This is an internal module typically not used directly by consumers of the c15t library.
+ */
+import type { C15TContext, C15TOptions, C15TPlugin } from './types';
+/**
+ * Initializes the c15t consent management system using Result pattern
+ *
+ * This function creates and configures the consent context based on the provided options.
+ * It sets up storage adapters, initializes plugins, configures security settings,
+ * and establishes the foundation for the consent management system.
+ *
+ * This version uses the neverthrow Result pattern for error handling.
+ *
+ * @template P - The plugin types used in the configuration
+ * @param options - Configuration options for the c15t instance
+ * @returns A Promise resolving to a Result containing the initialized consent context
+ *
+ * @example
+ * ```typescript
+ * const contextResult = await init({
+ *   secret: process.env.CONSENT_SECRET,
+ *   storage: memoryAdapter(),
+ *   plugins: [geoPlugin()]
+ * });
+ *
+ * // Handle success and error cases explicitly
+ * contextResult.match(
+ *   (context) => {
+ *     // Use the successfully initialized context
+ *   },
+ *   (error) => {
+ *     // Handle the initialization error
+ *     console.error('Failed to initialize:', error.message);
+ *   }
+ * );
+ * ```
+ */
+export declare const init: <P extends C15TPlugin[]>(options: C15TOptions<P>) => Promise<C15TResult<C15TContext>>;
+//# sourceMappingURL=init.d.ts.map

package/dist/init.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"init.d.ts","sourceRoot":"","sources":["../src/init.ts"],"names":[],"mappings":"AAYA,OAAO,EAAE,KAAK,UAAU,EAAY,MAAM,iBAAiB,CAAC;AAC5D;;;;;;;;;;;;;;GAcG;AACH,OAAO,KAAK,EACX,WAAW,EACX,WAAW,EACX,UAAU,EAEV,MAAM,SAAS,CAAC;AA2BjB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,eAAO,MAAM,IAAI,GAAU,CAAC,SAAS,UAAU,EAAE,EAChD,SAAS,WAAW,CAAC,CAAC,CAAC,KACrB,OAAO,CAAC,UAAU,CAAC,WAAW,CAAC,CA4EjC,CAAC"}

package/dist/init.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=init.test.d.ts.map

package/dist/init.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"init.test.d.ts","sourceRoot":"","sources":["../src/init.test.ts"],"names":[],"mappings":""}

package/dist/integrations/index.cjs

@@ -0,0 +1,281 @@
+"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,
+    createConsentClient: ()=>createConsentClient
+});
+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
+    };
+}
+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/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * c15t Framework Integrations
+ * This module exports integrations with various frameworks and libraries
+ */
+export * from './next';
+export * from './react';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/integrations/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAGH,cAAc,QAAQ,CAAC;AAGvB,cAAc,SAAS,CAAC"}

package/dist/integrations/index.js

@@ -0,0 +1,248 @@
+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
+    };
+}
+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
+    };
+}
+export { createConsentClient, toNextJsHandler };