@c15t/backend 0.0.1-rc.15 → 0.0.1-rc.17

package/.turbo/turbo-build.log

@@ -1,23 +1,24 @@
 
 
-> @c15t/backend@0.0.1-rc.15 build /Users/christopherburns/glados/k/c15t/packages/backend
+> @c15t/backend@0.0.1-rc.17 build /Users/christopherburns/glados/k/c15t/packages/backend
 > rslib build
 
   Rslib v0.5.3
 
-ready   built in 0.34 s (esm)
-ready   built in 0.34 s (cjs)
+ready   built in 0.36 s (esm)
+ready   built in 0.36 s (cjs)
 start   Generating DTS... (esm)
 start   Generating DTS... (cjs)
-ready   DTS generated in 3.23 s (esm)
-ready   DTS generated in 3.19 s (cjs)
+ready   DTS generated in 3.61 s (esm)
+ready   DTS generated in 3.57 s (cjs)
 
   File (esm)                                                 Size        
   dist/pkgs/types/index.js                                   0.00 kB 
   dist/pkgs/data-model/fields/index.js                       5.6 kB  
   dist/pkgs/logger/index.js                                  7.2 kB  
-  dist/integrations/index.js                                 9.3 kB  
-  dist/integrations/next.js                                  9.3 kB  
+  dist/integrations/node.js                                  9.1 kB  
+  dist/integrations/next.js                                  9.6 kB  
+  dist/integrations/cloudflare.js                            11.2 kB 
   dist/pkgs/results/index.js                                 22.2 kB 
   dist/pkgs/db-adapters/adapters/memory-adapter/index.js     49.4 kB 
   dist/pkgs/db-adapters/adapters/prisma-adapter/index.js     52.6 kB 
@@ -28,9 +29,9 @@
   dist/schema/index.js                                       74.9 kB 
   dist/pkgs/data-model/index.js                              75.6 kB 
   dist/pkgs/db-adapters/index.js                             94.3 kB 
-  dist/index.js                                              154.5 kB
+  dist/index.js                                              154.6 kB
 
-  Total: 800.7 kB
+  Total: 812.0 kB
 
   -----
 
@@ -38,8 +39,9 @@
   dist/pkgs/types/index.cjs                                   0.72 kB 
   dist/pkgs/data-model/fields/index.cjs                       7.0 kB  
   dist/pkgs/logger/index.cjs                                  8.1 kB  
-  dist/integrations/index.cjs                                 10.4 kB 
-  dist/integrations/next.cjs                                  10.4 kB 
+  dist/integrations/node.cjs                                  10.2 kB 
+  dist/integrations/next.cjs                                  10.7 kB 
+  dist/integrations/cloudflare.cjs                            12.3 kB 
   dist/pkgs/results/index.cjs                                 23.1 kB 
   dist/pkgs/db-adapters/adapters/memory-adapter/index.cjs     50.1 kB 
   dist/pkgs/db-adapters/adapters/prisma-adapter/index.cjs     53.3 kB 
@@ -50,7 +52,7 @@
   dist/schema/index.cjs                                       82.6 kB 
   dist/pkgs/data-model/index.cjs                              83.5 kB 
   dist/pkgs/db-adapters/index.cjs                             95.0 kB 
-  dist/index.cjs                                              168.2 kB
+  dist/index.cjs                                              168.3 kB
 
-  Total: 848.0 kB
+  Total: 860.4 kB
 

package/.turbo/turbo-fmt.log

@@ -1,7 +1,7 @@
 
 
-> @c15t/backend@0.0.1-rc.14 fmt /Users/christopherburns/glados/k/c15t/packages/backend
+> @c15t/backend@0.0.1-rc.15 fmt /Users/christopherburns/glados/k/c15t/packages/backend
 > pnpm biome format --write . && biome check --formatter-enabled=false --linter-enabled=false --organize-imports-enabled=true --write
 
-Formatted 166 files in 60ms. No fixes applied.
-Checked 358 files in 84ms. Fixed 27 files.
+Formatted 167 files in 42ms. Fixed 2 files.
+Checked 362 files in 49ms. Fixed 28 files.

package/dist/index.cjs

@@ -3300,13 +3300,16 @@ var __webpack_exports__ = {};
             message
         };
     }
+    var package_namespaceObject = {
+        i8: "0.0.1-rc.17"
+    };
     const status_status = defineRoute({
         path: '/status',
         method: 'get',
         handler: async (event)=>{
             const response = {
                 status: 'ok',
-                version: '2.0.0',
+                version: package_namespaceObject.i8,
                 timestamp: new Date().toISOString(),
                 storage: {
                     type: event.context.adapter?.id ?? 'Unavailable',

package/dist/index.js

@@ -3270,13 +3270,16 @@ function checkJurisdiction(countryCode) {
         message
     };
 }
+var package_namespaceObject = {
+    i8: "0.0.1-rc.17"
+};
 const status_status = defineRoute({
     path: '/status',
     method: 'get',
     handler: async (event)=>{
         const response = {
             status: 'ok',
-            version: '2.0.0',
+            version: package_namespaceObject.i8,
             timestamp: new Date().toISOString(),
             storage: {
                 type: event.context.adapter?.id ?? 'Unavailable',

package/dist/integrations/cloudflare.cjs

@@ -0,0 +1,291 @@
+"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__, {
+    toCloudflareHandler: ()=>toCloudflareHandler
+});
+require("neverthrow");
+const external_h3_namespaceObject = require("h3");
+const error_codes_ERROR_CODES = Object.freeze({
+    NOT_FOUND: 'Resource not found',
+    BAD_REQUEST: 'Bad request',
+    CONFLICT: 'Conflict with current state',
+    MISSING_REQUIRED_PARAMETER: 'Missing required parameter',
+    UNAUTHORIZED: 'Unauthorized',
+    FORBIDDEN: 'Forbidden',
+    INTERNAL_SERVER_ERROR: 'Internal server error',
+    INITIALIZATION_FAILED: 'Initialization failed',
+    DATABASE_CONNECTION_ERROR: 'Database connection error',
+    DATABASE_QUERY_ERROR: 'Database query error',
+    INVALID_CONFIGURATION: 'Invalid configuration',
+    REQUEST_HANDLER_ERROR: 'Request handler error',
+    INVALID_REQUEST: 'Invalid request',
+    UNKNOWN_ERROR: 'Unknown error',
+    NETWORK_ERROR: 'Network error',
+    PLUGIN_INITIALIZATION_FAILED: 'Plugin initialization failed',
+    API_RETRIEVAL_ERROR: 'API retrieval error',
+    VALIDATION_ERROR: 'Validation error',
+    UNEXPECTED: 'Unexpected error'
+});
+const ERROR_CATEGORIES = Object.freeze({
+    VALIDATION: 'validation',
+    AUTHORIZATION: 'authorization',
+    STORAGE: 'storage',
+    NETWORK: 'network',
+    PLUGIN: 'plugin',
+    CONFIGURATION: 'configuration',
+    UNEXPECTED: 'unexpected'
+});
+const api_namespaceObject = require("@opentelemetry/api");
+api_namespaceObject.trace.getTracer('@doubletie/results');
+class error_class_DoubleTieError extends external_h3_namespaceObject.H3Error {
+    code;
+    category;
+    meta;
+    constructor(message, options = {
+        code: error_codes_ERROR_CODES.UNKNOWN_ERROR,
+        status: 500,
+        category: ERROR_CATEGORIES.UNEXPECTED,
+        cause: void 0,
+        meta: {}
+    }){
+        super(message, {
+            cause: options.cause
+        });
+        this.name = this.constructor.name;
+        this.code = options.code ?? error_codes_ERROR_CODES.UNKNOWN_ERROR;
+        this.statusCode = options.status ?? 500;
+        this.category = options.category ?? ERROR_CATEGORIES.UNEXPECTED;
+        this.meta = options.meta ?? {};
+        this.data = {
+            code: this.code,
+            category: this.category,
+            meta: this.meta
+        };
+        tracing_withSpan('create_doubletie_error', async (span)=>{
+            span.setAttributes({
+                'error.name': this.name,
+                'error.message': message,
+                'error.code': this.code,
+                'error.status': this.statusCode,
+                'error.category': this.category,
+                'error.has_cause': !!this.cause,
+                'error.cause_type': this.cause instanceof Error ? this.cause.constructor.name : typeof this.cause,
+                'error.has_meta': !!this.meta
+            });
+            if (this.cause instanceof Error) span.recordException(this.cause);
+        });
+        if (Error.captureStackTrace) Error.captureStackTrace(this, this.constructor);
+    }
+    static isDoubleTieError(error) {
+        return error instanceof error_class_DoubleTieError;
+    }
+    toJSON() {
+        const validationErrorMessage = this.meta?.validationErrors ? String(this.meta.validationErrors) : void 0;
+        const stackTrace = this.stack ? this.stack.split('\n').map((line)=>line.trim()).filter((line)=>line && !line.includes('Error: ')) : [];
+        return {
+            statusCode: this.statusCode,
+            message: validationErrorMessage || this.message,
+            statusMessage: this.statusMessage,
+            data: {
+                code: this.code,
+                category: this.category,
+                meta: this.meta,
+                ...'production' === process.env.NODE_ENV ? {} : {
+                    stack: stackTrace
+                },
+                ...validationErrorMessage && this.message ? {
+                    originalMessage: this.message
+                } : {},
+                ...this.cause ? {
+                    cause: this.cause instanceof Error ? {
+                        name: this.cause.name,
+                        message: this.cause.message,
+                        stack: this.cause.stack ? this.cause.stack.split('\n').map((line)=>line.trim()) : void 0
+                    } : this.cause
+                } : {}
+            }
+        };
+    }
+    static fromResponse(response, data) {
+        let message = `HTTP error ${response.status}`;
+        let errorCode = `HTTP ${response.status}`;
+        let errorMeta = {};
+        if (data && 'object' == typeof data && null !== data) {
+            const errorObj = data;
+            if ('string' == typeof errorObj.message) message = errorObj.message;
+            if ('string' == typeof errorObj.code) errorCode = errorObj.code;
+            if ('object' == typeof errorObj.data && null !== errorObj.data) errorMeta = errorObj.data;
+        }
+        return new error_class_DoubleTieError(message, {
+            code: errorCode,
+            status: response.status,
+            meta: errorMeta
+        });
+    }
+    withMeta(additionalMeta) {
+        return new error_class_DoubleTieError(this.message, {
+            code: this.code,
+            status: this.statusCode,
+            category: this.category,
+            cause: this.cause instanceof Error ? this.cause : void 0,
+            meta: {
+                ...this.meta,
+                ...additionalMeta
+            }
+        });
+    }
+    static createSubclass(name) {
+        const ErrorSubclass = class extends error_class_DoubleTieError {
+            constructor(message, options){
+                super(message, options);
+                this.name = name;
+            }
+        };
+        Object.defineProperty(ErrorSubclass, 'name', {
+            value: name
+        });
+        return ErrorSubclass;
+    }
+    static formatValidationError(error) {
+        if (!error.meta) return error.message;
+        let formattedMessage = `${error.message} (${error.code})`;
+        if (error.meta.validationErrors) formattedMessage += `\nValidation Errors: ${JSON.stringify(error.meta.validationErrors, null, 2)}`;
+        const otherMeta = Object.fromEntries(Object.entries(error.meta).filter(([key])=>'validationErrors' !== key));
+        if (Object.keys(otherMeta).length > 0) formattedMessage += `\nAdditional Context: ${JSON.stringify(otherMeta, null, 2)}`;
+        return formattedMessage;
+    }
+}
+function toCloudflareHandler(instance) {
+    return async (request)=>{
+        try {
+            const basePath = instance.options?.basePath || '/api/c15t';
+            const originalUrl = new URL(request.url);
+            let pathWithoutBase = originalUrl.pathname;
+            if ('OPTIONS' === request.method) return handleCorsPreflightRequest(request, instance);
+            if (pathWithoutBase.startsWith(basePath)) {
+                pathWithoutBase = pathWithoutBase.substring(basePath.length);
+                if (!pathWithoutBase.startsWith('/')) pathWithoutBase = `/${pathWithoutBase}`;
+            }
+            const rewrittenUrl = new URL(originalUrl.toString());
+            rewrittenUrl.pathname = pathWithoutBase;
+            const headers = new Headers();
+            for (const [key, value] of request.headers.entries())headers.set(key, value);
+            const rewrittenRequest = new Request(rewrittenUrl.toString(), {
+                method: request.method,
+                headers,
+                body: [
+                    'GET',
+                    'HEAD'
+                ].includes(request.method) ? void 0 : request.body
+            });
+            await updateBaseUrl(request, basePath);
+            const result = await instance.handler(rewrittenRequest);
+            return await result.match((response)=>addCorsHeaders(response, request, instance), (error)=>{
+                const status = error.statusCode || 500;
+                const message = error.message || error_codes_ERROR_CODES.INTERNAL_SERVER_ERROR;
+                const errorResponse = new Response(JSON.stringify({
+                    error: true,
+                    code: error.code || error_codes_ERROR_CODES.INTERNAL_SERVER_ERROR,
+                    message,
+                    meta: error.meta
+                }), {
+                    status,
+                    headers: {
+                        'Content-Type': 'application/json'
+                    }
+                });
+                return addCorsHeaders(errorResponse, request, instance);
+            });
+        } catch (error) {
+            const errorResponse = new Response(JSON.stringify({
+                error: true,
+                code: error_codes_ERROR_CODES.INTERNAL_SERVER_ERROR,
+                message: 'An unexpected error occurred',
+                meta: {
+                    error: String(error)
+                }
+            }), {
+                status: 500,
+                headers: {
+                    'Content-Type': 'application/json'
+                }
+            });
+            return addCorsHeaders(errorResponse, request, instance);
+        }
+    };
+    function handleCorsPreflightRequest(request, instance) {
+        const origin = request.headers.get('Origin');
+        const isTrusted = isTrustedOrigin(origin, instance);
+        const headers = new Headers({
+            'Access-Control-Allow-Origin': isTrusted && origin ? origin : '*',
+            'Access-Control-Allow-Methods': 'GET, POST, PUT, DELETE, OPTIONS',
+            'Access-Control-Allow-Headers': 'Content-Type, Authorization, x-request-id',
+            'Access-Control-Max-Age': '86400'
+        });
+        if (isTrusted) headers.set('Access-Control-Allow-Credentials', 'true');
+        return new Response(null, {
+            status: 204,
+            headers
+        });
+    }
+    function addCorsHeaders(response, request, instance) {
+        const origin = request.headers.get('Origin');
+        const isTrusted = isTrustedOrigin(origin, instance);
+        const newResponse = new Response(response.body, {
+            status: response.status,
+            statusText: response.statusText,
+            headers: response.headers
+        });
+        newResponse.headers.set('Access-Control-Allow-Origin', isTrusted && origin ? origin : '*');
+        if (isTrusted) newResponse.headers.set('Access-Control-Allow-Credentials', 'true');
+        return newResponse;
+    }
+    function isTrustedOrigin(origin, instance) {
+        if (!origin) return false;
+        const { trustedOrigins = [] } = instance.options || {};
+        if (trustedOrigins.includes('*')) return true;
+        return trustedOrigins.includes(origin);
+    }
+    async function updateBaseUrl(request, basePath) {
+        if (!instance.$context) return;
+        try {
+            const contextResult = await instance.$context;
+            contextResult.match((context)=>{
+                const url = new URL(request.url);
+                const baseURL = `${url.protocol}//${url.host}${basePath}`;
+                if (!context.baseURL || context.baseURL !== baseURL) {
+                    context.baseURL = baseURL;
+                    if (context.options) context.options.baseURL = baseURL;
+                }
+            }, ()=>{});
+        } catch  {}
+    }
+}
+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/cloudflare.d.ts

@@ -0,0 +1,32 @@
+import type { C15TInstance } from '../core';
+/**
+ * Convert a c15t handler to a Cloudflare Worker handler.
+ *
+ * This adapter is specifically designed for Cloudflare Workers environments,
+ * avoiding Node.js-specific dependencies and APIs.
+ *
+ * @example
+ * ```typescript
+ * import { toCloudflareHandler } from '@c15t/backend/integrations';
+ * import { c15tInstance } from '@c15t/backend';
+ *
+ * // Create c15t instance
+ * const c15t = c15tInstance({
+ *   basePath: '/',
+ *   cors: true,
+ *   // other options...
+ * });
+ *
+ * // Export the worker handler
+ * export default {
+ *   async fetch(request, env, ctx) {
+ *     return await toCloudflareHandler(c15t)(request);
+ *   }
+ * };
+ * ```
+ *
+ * @param instance - The c15t instance to adapt
+ * @returns A handler function suitable for Cloudflare Workers
+ */
+export declare function toCloudflareHandler(instance: C15TInstance): (request: Request) => Promise<Response>;
+//# sourceMappingURL=cloudflare.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"cloudflare.d.ts","sourceRoot":"","sources":["../../src/integrations/cloudflare.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,QAAQ,CAAC;AAI3C;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,wBAAgB,mBAAmB,CAAC,QAAQ,EAAE,YAAY,IAC3C,SAAS,OAAO,KAAG,OAAO,CAAC,QAAQ,CAAC,CAiNlD"}