@c15t/backend 1.8.0 → 2.0.0-rc.0

package/dist/cache.js

@@ -0,0 +1,467 @@
+import { Redis } from "@upstash/redis";
+import { SpanKind as api_SpanKind, SpanStatusCode as api_SpanStatusCode, context, metrics, trace as api_trace } from "@opentelemetry/api";
+const GVL_TTL_MS = 259200000;
+function createCloudflareKVAdapter(kv) {
+    return {
+        async get (key) {
+            const value = await kv.get(key, {
+                type: 'json'
+            });
+            return value;
+        },
+        async set (key, value, ttlMs = GVL_TTL_MS) {
+            const ttlSeconds = Math.ceil(ttlMs / 1000);
+            await kv.put(key, JSON.stringify(value), {
+                expirationTtl: ttlSeconds
+            });
+        },
+        async delete (key) {
+            await kv.delete(key);
+        },
+        async has (key) {
+            const value = await kv.get(key);
+            return null !== value;
+        }
+    };
+}
+const memory_memoryCache = new Map();
+function createMemoryCacheAdapter() {
+    return {
+        async get (key) {
+            const entry = memory_memoryCache.get(key);
+            if (!entry) return null;
+            if (Date.now() > entry.expiresAt) {
+                memory_memoryCache.delete(key);
+                return null;
+            }
+            return entry.value;
+        },
+        async set (key, value, ttlMs = 300000) {
+            memory_memoryCache.set(key, {
+                value,
+                expiresAt: Date.now() + ttlMs
+            });
+        },
+        async delete (key) {
+            memory_memoryCache.delete(key);
+        },
+        async has (key) {
+            const entry = memory_memoryCache.get(key);
+            if (!entry) return false;
+            if (Date.now() > entry.expiresAt) {
+                memory_memoryCache.delete(key);
+                return false;
+            }
+            return true;
+        }
+    };
+}
+function clearMemoryCache() {
+    memory_memoryCache.clear();
+}
+function getMemoryCacheSize() {
+    return memory_memoryCache.size;
+}
+function createUpstashRedisAdapter(options) {
+    const client = new Redis({
+        url: options.url,
+        token: options.token
+    });
+    return createUpstashRedisAdapterFromClient(client);
+}
+function createUpstashRedisAdapterFromClient(client) {
+    return {
+        async get (key) {
+            const result = await client.get(key);
+            return result ?? null;
+        },
+        async set (key, value, ttlMs = GVL_TTL_MS) {
+            const ttlSeconds = Math.ceil(ttlMs / 1000);
+            await client.set(key, value, {
+                ex: ttlSeconds
+            });
+        },
+        async delete (key) {
+            await client.del(key);
+        },
+        async has (key) {
+            const exists = await client.exists(key);
+            return exists > 0;
+        }
+    };
+}
+function extractErrorMessage(error) {
+    if (error instanceof AggregateError && error.errors?.length > 0) {
+        const inner = error.errors.map((e)=>e instanceof Error ? e.message : String(e)).join('; ');
+        return `AggregateError: ${inner}`;
+    }
+    if (error instanceof Error) return error.message || error.name;
+    return String(error);
+}
+let cachedConfig = null;
+let cachedDefaultAttributes = {};
+function create_telemetry_options_isTelemetryEnabled(options) {
+    if (options) return options.advanced?.telemetry?.enabled === true;
+    return cachedConfig?.enabled === true;
+}
+const create_telemetry_options_getTracer = (options)=>{
+    if (!create_telemetry_options_isTelemetryEnabled(options)) return api_trace.getTracer('c15t-noop');
+    const tracer = options?.advanced?.telemetry?.tracer ?? cachedConfig?.tracer;
+    if (tracer) return tracer;
+    return api_trace.getTracer(options?.appName ?? 'c15t');
+};
+const getMeter = (options)=>{
+    if (!create_telemetry_options_isTelemetryEnabled(options)) return metrics.getMeter('c15t-noop');
+    const meter = options?.advanced?.telemetry?.meter ?? cachedConfig?.meter;
+    if (meter) return meter;
+    return metrics.getMeter(options?.appName ?? 'c15t');
+};
+function getDefaultAttributes() {
+    return cachedDefaultAttributes;
+}
+const handleSpanError = (span, error)=>{
+    span.setStatus({
+        code: api_SpanStatusCode.ERROR,
+        message: extractErrorMessage(error)
+    });
+    if (error instanceof Error) span.setAttribute('error.type', error.name);
+};
+const withSpanContext = async (span, operation)=>context["with"](api_trace.setSpan(context.active(), span), operation);
+async function executeWithSpan(span, operation) {
+    try {
+        const result = await withSpanContext(span, operation);
+        span.setStatus({
+            code: api_SpanStatusCode.OK
+        });
+        return result;
+    } catch (error) {
+        handleSpanError(span, error);
+        throw error;
+    } finally{
+        span.end();
+    }
+}
+function resolveDefaultAttributes(options) {
+    return options?.advanced?.telemetry?.defaultAttributes || getDefaultAttributes();
+}
+async function withExternalSpan(attributes, operation, options) {
+    if (!create_telemetry_options_isTelemetryEnabled(options)) return operation();
+    const tracer = create_telemetry_options_getTracer(options);
+    const url = new URL(attributes.url);
+    const spanName = `HTTP ${attributes.method} ${url.hostname}`;
+    const span = tracer.startSpan(spanName, {
+        kind: api_SpanKind.CLIENT,
+        attributes: {
+            'http.method': attributes.method,
+            'http.url': `${url.origin}${url.pathname}`,
+            'http.host': url.hostname,
+            ...resolveDefaultAttributes(options),
+            ...Object.fromEntries(Object.entries(attributes).filter(([key])=>![
+                    'url',
+                    'method'
+                ].includes(key)))
+        }
+    });
+    return executeWithSpan(span, operation);
+}
+async function withCacheSpan(operation, layer, fn, options) {
+    if (!create_telemetry_options_isTelemetryEnabled(options)) return fn();
+    const tracer = create_telemetry_options_getTracer(options);
+    const spanName = `cache.${layer}.${operation}`;
+    const span = tracer.startSpan(spanName, {
+        kind: api_SpanKind.CLIENT,
+        attributes: {
+            'cache.operation': operation,
+            'cache.layer': layer,
+            ...resolveDefaultAttributes(options)
+        }
+    });
+    return executeWithSpan(span, fn);
+}
+function sanitizeAttributes(attrs) {
+    return Object.fromEntries(Object.entries(attrs).filter(([_, v])=>null != v));
+}
+function createMetrics(meter) {
+    const consentCreated = meter.createCounter('c15t.consent.created', {
+        description: 'Number of consent submissions',
+        unit: '1'
+    });
+    const consentAccepted = meter.createCounter('c15t.consent.accepted', {
+        description: 'Number of consents accepted',
+        unit: '1'
+    });
+    const consentRejected = meter.createCounter('c15t.consent.rejected', {
+        description: 'Number of consents rejected',
+        unit: '1'
+    });
+    const subjectCreated = meter.createCounter('c15t.subject.created', {
+        description: 'Number of new subjects created',
+        unit: '1'
+    });
+    const subjectLinked = meter.createCounter('c15t.subject.linked', {
+        description: 'Number of subjects linked to external ID',
+        unit: '1'
+    });
+    const consentCheckCount = meter.createCounter('c15t.consent_check.count', {
+        description: 'Number of cross-device consent checks',
+        unit: '1'
+    });
+    const initCount = meter.createCounter('c15t.init.count', {
+        description: 'Number of init endpoint calls',
+        unit: '1'
+    });
+    const httpRequestDuration = meter.createHistogram('c15t.http.request.duration', {
+        description: 'HTTP request latency',
+        unit: 'ms'
+    });
+    const httpRequestCount = meter.createCounter('c15t.http.request.count', {
+        description: 'Number of HTTP requests',
+        unit: '1'
+    });
+    const httpErrorCount = meter.createCounter('c15t.http.error.count', {
+        description: 'Number of HTTP errors',
+        unit: '1'
+    });
+    const dbQueryDuration = meter.createHistogram('c15t.db.query.duration', {
+        description: 'Database query latency',
+        unit: 'ms'
+    });
+    const dbQueryCount = meter.createCounter('c15t.db.query.count', {
+        description: 'Number of database queries',
+        unit: '1'
+    });
+    const dbErrorCount = meter.createCounter('c15t.db.error.count', {
+        description: 'Number of database errors',
+        unit: '1'
+    });
+    const cacheHit = meter.createCounter('c15t.cache.hit', {
+        description: 'Number of cache hits',
+        unit: '1'
+    });
+    const cacheMiss = meter.createCounter('c15t.cache.miss', {
+        description: 'Number of cache misses',
+        unit: '1'
+    });
+    const cacheLatency = meter.createHistogram('c15t.cache.latency', {
+        description: 'Cache operation latency',
+        unit: 'ms'
+    });
+    const gvlFetchDuration = meter.createHistogram('c15t.gvl.fetch.duration', {
+        description: 'GVL fetch latency',
+        unit: 'ms'
+    });
+    const gvlFetchCount = meter.createCounter('c15t.gvl.fetch.count', {
+        description: 'Number of GVL fetches',
+        unit: '1'
+    });
+    const gvlFetchError = meter.createCounter('c15t.gvl.fetch.error', {
+        description: 'Number of GVL fetch errors',
+        unit: '1'
+    });
+    return {
+        consentCreated,
+        consentAccepted,
+        consentRejected,
+        subjectCreated,
+        subjectLinked,
+        consentCheckCount,
+        initCount,
+        httpRequestDuration,
+        httpRequestCount,
+        httpErrorCount,
+        dbQueryDuration,
+        dbQueryCount,
+        dbErrorCount,
+        cacheHit,
+        cacheMiss,
+        cacheLatency,
+        gvlFetchDuration,
+        gvlFetchCount,
+        gvlFetchError,
+        recordConsentCreated (attributes) {
+            consentCreated.add(1, sanitizeAttributes(attributes));
+        },
+        recordConsentAccepted (attributes) {
+            consentAccepted.add(1, sanitizeAttributes(attributes));
+        },
+        recordConsentRejected (attributes) {
+            consentRejected.add(1, sanitizeAttributes(attributes));
+        },
+        recordSubjectCreated (attributes) {
+            subjectCreated.add(1, sanitizeAttributes(attributes));
+        },
+        recordSubjectLinked (identityProvider) {
+            subjectLinked.add(1, {
+                identityProvider: identityProvider || 'unknown'
+            });
+        },
+        recordConsentCheck (type, found) {
+            consentCheckCount.add(1, {
+                type,
+                found: String(found)
+            });
+        },
+        recordInit (attributes) {
+            initCount.add(1, sanitizeAttributes(attributes));
+        },
+        recordHttpRequest (attributes, durationMs) {
+            const attrs = sanitizeAttributes(attributes);
+            httpRequestCount.add(1, attrs);
+            httpRequestDuration.record(durationMs, attrs);
+            if (attributes.status >= 400) httpErrorCount.add(1, attrs);
+        },
+        recordDbQuery (attributes, durationMs) {
+            const attrs = sanitizeAttributes(attributes);
+            dbQueryCount.add(1, attrs);
+            dbQueryDuration.record(durationMs, attrs);
+        },
+        recordDbError (attributes) {
+            dbErrorCount.add(1, sanitizeAttributes(attributes));
+        },
+        recordCacheHit (layer) {
+            cacheHit.add(1, {
+                layer
+            });
+        },
+        recordCacheMiss (layer) {
+            cacheMiss.add(1, {
+                layer
+            });
+        },
+        recordCacheLatency (attributes, durationMs) {
+            cacheLatency.record(durationMs, sanitizeAttributes(attributes));
+        },
+        recordGvlFetch (attributes, durationMs) {
+            const attrs = sanitizeAttributes(attributes);
+            gvlFetchCount.add(1, attrs);
+            gvlFetchDuration.record(durationMs, attrs);
+        },
+        recordGvlError (attributes) {
+            gvlFetchError.add(1, sanitizeAttributes(attributes));
+        }
+    };
+}
+let metricsInstance = null;
+function getMetrics(options) {
+    if (metricsInstance) return metricsInstance;
+    if (!create_telemetry_options_isTelemetryEnabled(options)) return null;
+    metricsInstance = createMetrics(getMeter(options));
+    return metricsInstance;
+}
+function createGVLCacheKey(appName, language, vendorIds) {
+    const sortedIds = vendorIds ? [
+        ...vendorIds
+    ].sort((a, b)=>a - b).join(',') : 'all';
+    return `${appName}:gvl:${language}:${sortedIds}`;
+}
+function createCacheKey(appName, namespace, ...parts) {
+    const allParts = [
+        appName,
+        namespace,
+        ...parts
+    ];
+    return allParts.join(':');
+}
+const GVL_ENDPOINT = 'https://gvl.consent.io';
+const inflightRequests = new Map();
+async function fetchGVLWithLanguage(language, vendorIds, endpoint = GVL_ENDPOINT) {
+    const sortedVendorIds = vendorIds ? [
+        ...vendorIds
+    ].sort((a, b)=>a - b) : [];
+    const dedupeKey = `${endpoint}|${language}|${sortedVendorIds.join(',')}`;
+    const existingRequest = inflightRequests.get(dedupeKey);
+    if (existingRequest) return existingRequest;
+    const url = new URL(endpoint);
+    if (sortedVendorIds.length > 0) url.searchParams.set('vendorIds', sortedVendorIds.join(','));
+    const promise = (async ()=>{
+        const fetchStart = Date.now();
+        try {
+            const gvl = await withExternalSpan({
+                url: url.toString(),
+                method: 'GET'
+            }, async ()=>{
+                const response = await fetch(url.toString(), {
+                    headers: {
+                        'Accept-Language': language
+                    }
+                });
+                if (204 === response.status) return null;
+                if (!response.ok) throw new Error(`Failed to fetch GVL: ${response.status} ${response.statusText}`);
+                const text = await response.text();
+                const trimmed = text.trim().replace(/^\uFEFF/, '');
+                let parsed;
+                try {
+                    parsed = JSON.parse(trimmed);
+                } catch  {
+                    let depth = 0;
+                    let end = -1;
+                    const start = trimmed.indexOf('{');
+                    if (start >= 0) for(let i = start; i < trimmed.length; i++){
+                        const c = trimmed[i];
+                        if ('{' === c) depth++;
+                        else if ('}' === c) {
+                            depth--;
+                            if (0 === depth) {
+                                end = i + 1;
+                                break;
+                            }
+                        }
+                    }
+                    if (end > 0) parsed = JSON.parse(trimmed.slice(0, end));
+                    else throw new SyntaxError('Invalid GVL response: not valid JSON');
+                }
+                if (!parsed.vendorListVersion || !parsed.purposes || !parsed.vendors) throw new Error('Invalid GVL response: missing required fields');
+                return parsed;
+            });
+            getMetrics()?.recordGvlFetch({
+                language,
+                source: 'fetch',
+                status: 200
+            }, Date.now() - fetchStart);
+            return gvl;
+        } catch (error) {
+            getMetrics()?.recordGvlError({
+                language,
+                errorType: error instanceof Error ? error.name : 'UnknownError'
+            });
+            throw error;
+        } finally{
+            inflightRequests.delete(dedupeKey);
+        }
+    })();
+    inflightRequests.set(dedupeKey, promise);
+    return promise;
+}
+function createGVLResolver(options) {
+    const { appName, bundled, cacheAdapter, vendorIds, endpoint } = options;
+    const memoryCache = createMemoryCacheAdapter();
+    return {
+        async get (language) {
+            const cacheKey = createGVLCacheKey(appName, language, vendorIds);
+            if (bundled?.[language]) return bundled[language];
+            const memoryHit = await withCacheSpan('get', 'memory', ()=>memoryCache.get(cacheKey));
+            if (memoryHit) {
+                getMetrics()?.recordCacheHit('memory');
+                return memoryHit;
+            }
+            getMetrics()?.recordCacheMiss('memory');
+            if (cacheAdapter) {
+                const externalHit = await withCacheSpan('get', 'external', ()=>cacheAdapter.get(cacheKey));
+                if (externalHit) {
+                    getMetrics()?.recordCacheHit('external');
+                    await withCacheSpan('set', 'memory', ()=>memoryCache.set(cacheKey, externalHit, 300000));
+                    return externalHit;
+                }
+                getMetrics()?.recordCacheMiss('external');
+            }
+            const gvl = await fetchGVLWithLanguage(language, vendorIds, endpoint);
+            if (gvl) {
+                await withCacheSpan('set', 'memory', ()=>memoryCache.set(cacheKey, gvl, 300000));
+                if (cacheAdapter) await withCacheSpan('set', 'external', ()=>cacheAdapter.set(cacheKey, gvl, GVL_TTL_MS));
+            }
+            return gvl;
+        }
+    };
+}
+var __webpack_exports__MEMORY_TTL_MS = 300000;
+export { GVL_TTL_MS, clearMemoryCache, createCacheKey, createCloudflareKVAdapter, createGVLCacheKey, createGVLResolver, createMemoryCacheAdapter, createUpstashRedisAdapter, createUpstashRedisAdapterFromClient, getMemoryCacheSize, __webpack_exports__MEMORY_TTL_MS as MEMORY_TTL_MS };