@zintrust/core 3.5.1 → 3.5.2

package/src/runtime/WorkersModule.js

@@ -0,0 +1,387 @@
+import * as Common from '../common/index.js';
+import { Logger } from '../config/logger.js';
+import * as fs from '../node-singletons/fs.js';
+import { createRequire } from '../node-singletons/module.js';
+import * as path from '../node-singletons/path.js';
+import { pathToFileURL } from '../node-singletons/url.js';
+const KNOWN_EXTENSIONS = ['.js', '.mjs', '.cjs', '.json', '.node'];
+const isNodeRuntime = () => typeof process !== 'undefined' && Boolean(process.versions?.node);
+const readFlag = (name) => {
+    if (!isNodeRuntime())
+        return '';
+    return String(process.env?.[name] ?? '')
+        .trim()
+        .toLowerCase();
+};
+const isTruthy = (value) => value === '1' || value === 'true';
+const isFalsy = (value) => value === '0' || value === 'false';
+const shouldDisableWorkerModules = () => {
+    const dockerWorker = readFlag('DOCKER_WORKER');
+    if (isTruthy(dockerWorker))
+        return true;
+    const workerEnabled = readFlag('WORKER_ENABLED');
+    if (isFalsy(workerEnabled))
+        return true;
+    return false;
+};
+const createDisabledWorkersModule = () => {
+    return {
+        WorkerInit: {
+            initialize: async () => {
+                await Promise.resolve();
+            },
+            autoStartPersistedWorkers: async () => {
+                await Promise.resolve();
+            },
+        },
+        WorkerShutdown: {
+            shutdown: async () => {
+                await Promise.resolve();
+            },
+            isShuttingDown: () => false,
+            getShutdownState: () => ({ isShuttingDown: false, completedAt: null }),
+        },
+        registerWorkerRoutes: () => undefined,
+    };
+};
+const listJsFilesRecursive = (dir) => {
+    const out = [];
+    const stack = [dir];
+    while (stack.length > 0) {
+        const current = stack.pop();
+        if (current === undefined)
+            continue;
+        let entries;
+        try {
+            entries = fs.readdirSync(current, { withFileTypes: true });
+        }
+        catch {
+            continue;
+        }
+        for (const entry of entries) {
+            const full = path.join(current, entry.name);
+            if (entry.isDirectory()) {
+                stack.push(full);
+                continue;
+            }
+            if (entry.isFile() && full.endsWith('.js')) {
+                out.push(full);
+            }
+        }
+    }
+    return out;
+};
+const shouldConsiderSpecifier = (specifier) => {
+    if (!specifier.startsWith('./') && !specifier.startsWith('../'))
+        return false;
+    if (specifier.includes('?') || specifier.includes('#'))
+        return false;
+    const lower = specifier.toLowerCase();
+    return !KNOWN_EXTENSIONS.some((ext) => lower.endsWith(ext));
+};
+const resolveSpecifier = (filePath, specifier) => {
+    if (!shouldConsiderSpecifier(specifier))
+        return null;
+    const baseDir = path.dirname(filePath);
+    const resolved = path.resolve(baseDir, specifier);
+    try {
+        if (fs.statSync(resolved).isDirectory()) {
+            const indexJs = path.join(resolved, 'index.js');
+            if (fs.existsSync(indexJs))
+                return `${specifier.endsWith('/') ? specifier.slice(0, -1) : specifier}/index.js`;
+        }
+    }
+    catch {
+        // ignore stat errors
+    }
+    if (fs.existsSync(`${resolved}.js`))
+        return `${specifier}.js`;
+    return null;
+};
+const patchImportsInFile = (filePath) => {
+    let text;
+    try {
+        text = fs.readFileSync(filePath, 'utf8');
+    }
+    catch {
+        return 0;
+    }
+    let replacements = 0;
+    const rewrite = (match, quote, specifier) => {
+        const next = resolveSpecifier(filePath, specifier);
+        if (next === null)
+            return match;
+        replacements += 1;
+        return match.replace(`${quote}${specifier}${quote}`, `${quote}${next}${quote}`);
+    };
+    const updated = text
+        .replaceAll(/\bfrom\s+(['"])(\.[^'"]+)\1/g, rewrite)
+        .replaceAll(/\bimport\s+(['"])(\.[^'"]+)\1/g, rewrite)
+        .replaceAll(/\bimport\s*\(\s*(['"])(\.[^'"]+)\1\s*\)/g, rewrite);
+    if (updated !== text) {
+        try {
+            fs.writeFileSync(filePath, updated, 'utf8');
+        }
+        catch {
+            return 0;
+        }
+    }
+    return replacements;
+};
+const patchPackageDist = (packageName) => {
+    if (!isNodeRuntime())
+        return { replacements: 0, filesChanged: 0 };
+    let entryPath;
+    try {
+        const require = createRequire(import.meta.url);
+        entryPath = require.resolve(packageName);
+    }
+    catch {
+        return { replacements: 0, filesChanged: 0 };
+    }
+    const distDir = path.dirname(entryPath);
+    if (!fs.existsSync(distDir))
+        return { replacements: 0, filesChanged: 0 };
+    const files = listJsFilesRecursive(distDir);
+    let replacements = 0;
+    let filesChanged = 0;
+    for (const file of files) {
+        const changes = patchImportsInFile(file);
+        if (changes > 0) {
+            replacements += changes;
+            filesChanged += 1;
+        }
+    }
+    return { replacements, filesChanged };
+};
+const patchWorkersDist = () => patchPackageDist('@zintrust/workers');
+const patchQueueMonitorDist = () => patchPackageDist('@zintrust/queue-monitor');
+const resolveLocalModuleUrl = (packageDir) => {
+    if (!isNodeRuntime())
+        return null;
+    const root = process.cwd();
+    const mode = (process.env['NODE_ENV'] ?? 'development').toString().trim().toLowerCase();
+    const isProductionMode = mode === 'production' || mode === 'pro' || mode === 'prod';
+    const runFromSource = typeof Common.runFromSource === 'function' ? Common.runFromSource() : false;
+    const preferSource = runFromSource || !isProductionMode;
+    const candidates = preferSource
+        ? [
+            path.join(root, 'packages', packageDir, 'src', 'index.ts'),
+            path.join(root, 'dist', 'packages', packageDir, 'src', 'index.js'),
+        ]
+        : [
+            path.join(root, 'dist', 'packages', packageDir, 'src', 'index.js'),
+            path.join(root, 'packages', packageDir, 'src', 'index.ts'),
+        ];
+    for (const candidate of candidates) {
+        if (fs.existsSync(candidate)) {
+            return pathToFileURL(candidate).href;
+        }
+    }
+    return null;
+};
+const importLocalModule = async (packageDir, packageName) => {
+    const url = resolveLocalModuleUrl(packageDir);
+    if (url === null || url === '' || url === undefined)
+        return null;
+    try {
+        return (await import(url));
+    }
+    catch (error) {
+        Logger.warn(`Failed to import local ${packageName} fallback`, error);
+        return null;
+    }
+};
+const importLocalWorkersModule = async () => importLocalModule('workers', '@zintrust/workers');
+const importLocalQueueMonitorModule = async () => importLocalModule('queue-monitor', '@zintrust/queue-monitor');
+const importOptionalPackage = async (specifier) => {
+    return (await import(specifier));
+};
+let workersModulePromise;
+let patchAttempted = false;
+let patchAfterFailureAttempted = false;
+let queueMonitorModulePromise;
+let queueMonitorPatchAfterFailureAttempted = false;
+let workersResolverDiagnosticLogged = false;
+let workersDisabledByEnvLogged = false;
+const resolvePackageEntryForDebug = (packageName) => {
+    if (!isNodeRuntime())
+        return null;
+    try {
+        const require = createRequire(import.meta.url);
+        return require.resolve(packageName);
+    }
+    catch {
+        return null;
+    }
+};
+const logWorkersResolverDiagnostics = () => {
+    if (workersResolverDiagnosticLogged)
+        return;
+    workersResolverDiagnosticLogged = true;
+    Logger.warn('Workers module resolver diagnostics', {
+        cwd: process.cwd(),
+        workersEntry: resolvePackageEntryForDebug('@zintrust/workers'),
+        coreEntry: resolvePackageEntryForDebug('@zintrust/core'),
+    });
+};
+const applyInitialPatches = () => {
+    if (patchAttempted)
+        return;
+    patchAttempted = true;
+    const workersPatch = patchWorkersDist();
+    if (workersPatch.filesChanged > 0) {
+        Logger.warn('Rewrote @zintrust/workers ESM specifiers before import', workersPatch);
+    }
+    const monitorPatch = patchQueueMonitorDist();
+    if (monitorPatch.filesChanged > 0) {
+        Logger.warn('Rewrote @zintrust/queue-monitor ESM specifiers before import', monitorPatch);
+    }
+};
+const getErrorChain = (error) => {
+    const chain = [];
+    const seen = new Set();
+    let current = error;
+    while (current !== null && current !== undefined && !seen.has(current)) {
+        seen.add(current);
+        const entry = current;
+        chain.push({
+            message: typeof entry.message === 'string' && entry.message !== '' ? entry.message : String(current),
+            code: typeof entry.code === 'string' ? entry.code : undefined,
+        });
+        current = entry.cause;
+    }
+    return chain;
+};
+const shouldRetryAfterFailure = (error) => {
+    if (patchAfterFailureAttempted)
+        return false;
+    return getErrorChain(error).some(({ message, code }) => code === 'ERR_MODULE_NOT_FOUND' && message.includes('@zintrust/workers'));
+};
+const isMissingOptionalWorkersModuleError = (error) => {
+    return getErrorChain(error).some(({ message, code }) => {
+        if (!message.includes('@zintrust/workers'))
+            return false;
+        return (code === 'ERR_MODULE_NOT_FOUND' ||
+            message.includes('ERR_MODULE_NOT_FOUND') ||
+            message.includes('Cannot find package') ||
+            message.includes('No such module'));
+    });
+};
+const handleImportFailure = async (error) => {
+    let finalError = error;
+    if (shouldRetryAfterFailure(error)) {
+        patchAfterFailureAttempted = true;
+        const { replacements, filesChanged } = patchWorkersDist();
+        if (filesChanged > 0) {
+            Logger.warn('Rewrote @zintrust/workers ESM specifiers after import failure', {
+                filesChanged,
+                replacements,
+            });
+            workersModulePromise = importOptionalPackage('@zintrust/workers');
+            try {
+                return await workersModulePromise;
+            }
+            catch (retryError) {
+                finalError = retryError;
+            }
+        }
+    }
+    const localFallback = await importLocalWorkersModule();
+    if (localFallback) {
+        workersModulePromise = Promise.resolve(localFallback);
+        return localFallback;
+    }
+    if (isMissingOptionalWorkersModuleError(finalError)) {
+        Logger.info('Optional @zintrust/workers package is unavailable; worker routes are disabled.');
+        workersModulePromise = Promise.resolve(createDisabledWorkersModule());
+        return workersModulePromise;
+    }
+    throw finalError;
+};
+const tryLocalFallback = async () => {
+    const localFallback = await importLocalWorkersModule();
+    if (localFallback) {
+        workersModulePromise = Promise.resolve(localFallback);
+        return localFallback;
+    }
+    return null;
+};
+export const loadWorkersModule = async (options = {}) => {
+    if (shouldDisableWorkerModules() && options.allowWhenDisabled !== true) {
+        if (!workersDisabledByEnvLogged) {
+            workersDisabledByEnvLogged = true;
+            Logger.info('Skipping @zintrust/workers module import (workers disabled by env).');
+        }
+        workersModulePromise ??= Promise.resolve(createDisabledWorkersModule());
+        return workersModulePromise;
+    }
+    applyInitialPatches();
+    if (workersModulePromise === undefined) {
+        const localFallback = await tryLocalFallback();
+        if (localFallback) {
+            return localFallback;
+        }
+    }
+    logWorkersResolverDiagnostics();
+    workersModulePromise ??= importOptionalPackage('@zintrust/workers');
+    try {
+        return await workersModulePromise;
+    }
+    catch (error) {
+        return handleImportFailure(error);
+    }
+};
+const shouldRetryQueueMonitorAfterFailure = (error) => {
+    if (queueMonitorPatchAfterFailureAttempted)
+        return false;
+    const message = error instanceof Error ? error.message : String(error);
+    const code = error?.code;
+    return code === 'ERR_MODULE_NOT_FOUND' && message.includes('@zintrust/queue-monitor');
+};
+const handleQueueMonitorImportFailure = async (error) => {
+    if (shouldRetryQueueMonitorAfterFailure(error)) {
+        queueMonitorPatchAfterFailureAttempted = true;
+        const { replacements, filesChanged } = patchQueueMonitorDist();
+        if (filesChanged > 0) {
+            Logger.warn('Rewrote @zintrust/queue-monitor ESM specifiers after import failure', {
+                filesChanged,
+                replacements,
+            });
+            queueMonitorModulePromise =
+                importOptionalPackage('@zintrust/queue-monitor');
+            return queueMonitorModulePromise;
+        }
+    }
+    const localFallback = await importLocalQueueMonitorModule();
+    if (localFallback) {
+        queueMonitorModulePromise = Promise.resolve(localFallback);
+        return localFallback;
+    }
+    throw error;
+};
+const tryQueueMonitorLocalFallback = async () => {
+    const localFallback = await importLocalQueueMonitorModule();
+    if (localFallback) {
+        queueMonitorModulePromise = Promise.resolve(localFallback);
+        return localFallback;
+    }
+    return null;
+};
+export const loadQueueMonitorModule = async () => {
+    applyInitialPatches();
+    if (queueMonitorModulePromise === undefined) {
+        const localFallback = await tryQueueMonitorLocalFallback();
+        if (localFallback) {
+            return localFallback;
+        }
+    }
+    queueMonitorModulePromise ??=
+        importOptionalPackage('@zintrust/queue-monitor');
+    try {
+        return await queueMonitorModulePromise;
+    }
+    catch (error) {
+        return handleQueueMonitorImportFailure(error);
+    }
+};

package/src/runtime/adapters/CloudflareAdapter.d.ts

@@ -0,0 +1,43 @@
+import type { AdapterConfig, RuntimeAdapter } from '../RuntimeAdapter.js';
+/**
+ * Cloudflare Workers adapter for Cloudflare's edge compute platform
+ * Uses fetch API and handles D1 database, KV storage bindings
+ * Sealed namespace for immutability
+ */
+export declare const CloudflareAdapter: Readonly<{
+    /**
+     * Create a new Cloudflare adapter instance
+     */
+    create(config: AdapterConfig): RuntimeAdapter;
+    /**
+     * Get D1 database binding
+     * Usage: adapter.getD1Database()
+     */
+    getD1Database(): unknown;
+    /**
+     * Get KV namespace binding for secrets/configuration
+     * Usage: adapter.getKV('NAMESPACE_NAME')
+     */
+    getKV(namespace: string): unknown;
+}>;
+/**
+ * Cloudflare Worker Request type
+
+ * Extends standard Web API Request with Cloudflare-specific properties
+ */
+export interface CloudflareRequest extends Request {
+    url: string;
+    method: string;
+    headers: Headers;
+    body: ReadableStream<Uint8Array>;
+    cf?: {
+        colo?: string;
+        country?: string;
+        clientTcpRtt?: number;
+        latitude?: string;
+        longitude?: string;
+        postalCode?: string;
+        requestPriority?: string;
+    };
+}
+//# sourceMappingURL=CloudflareAdapter.d.ts.map

package/src/runtime/adapters/CloudflareAdapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CloudflareAdapter.d.ts","sourceRoot":"","sources":["../../../../src/runtime/adapters/CloudflareAdapter.ts"],"names":[],"mappings":"AASA,OAAO,KAAK,EACV,aAAa,EAGb,cAAc,EACf,MAAM,yBAAyB,CAAC;AAIjC;;;;GAIG;AACH,eAAO,MAAM,iBAAiB;IAC5B;;OAEG;mBACY,aAAa,GAAG,cAAc;IA8D7C;;;OAGG;qBACc,OAAO;IAKxB;;;OAGG;qBACc,MAAM,GAAG,OAAO;EAIjC,CAAC;AAyMH;;;;GAIG;AACH,MAAM,WAAW,iBAAkB,SAAQ,OAAO;IAChD,GAAG,EAAE,MAAM,CAAC;IACZ,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,OAAO,CAAC;IACjB,IAAI,EAAE,cAAc,CAAC,UAAU,CAAC,CAAC;IACjC,EAAE,CAAC,EAAE;QACH,IAAI,CAAC,EAAE,MAAM,CAAC;QACd,OAAO,CAAC,EAAE,MAAM,CAAC;QACjB,YAAY,CAAC,EAAE,MAAM,CAAC;QACtB,QAAQ,CAAC,EAAE,MAAM,CAAC;QAClB,SAAS,CAAC,EAAE,MAAM,CAAC;QACnB,UAAU,CAAC,EAAE,MAAM,CAAC;QACpB,eAAe,CAAC,EAAE,MAAM,CAAC;KAC1B,CAAC;CACH"}

package/src/runtime/adapters/CloudflareAdapter.js

@@ -0,0 +1,242 @@
+/**
+ * Runtime adapter for Cloudflare Workers
+ */
+import { appConfig } from '../../config/index.js';
+import { isUndefinedOrNull } from '../../helper/index.js';
+import { Cloudflare } from '../../config/cloudflare.js';
+import { Env, getProcessLike } from '../../config/env.js';
+import { Logger } from '../../config/logger.js';
+import { createMockHttpObjects, ErrorResponse, HttpResponse } from '../RuntimeAdapter.js';
+import { StartupErrorLogging } from '../StartupErrorLogging.js';
+/**
+ * Cloudflare Workers adapter for Cloudflare's edge compute platform
+ * Uses fetch API and handles D1 database, KV storage bindings
+ * Sealed namespace for immutability
+ */
+export const CloudflareAdapter = Object.freeze({
+    /**
+     * Create a new Cloudflare adapter instance
+     */
+    create(config) {
+        const workersEnv = Cloudflare.getWorkersEnv();
+        if (workersEnv !== null) {
+            const processEnv = getProcessLike()?.env;
+            const resolveEnvSource = () => {
+                if (processEnv === undefined)
+                    return workersEnv;
+                return { ...processEnv, ...workersEnv };
+            };
+            Env.setSource(resolveEnvSource);
+        }
+        const logger = config.logger ?? createDefaultLogger();
+        return {
+            platform: 'cloudflare',
+            async handle(event) {
+                return handleCloudflareRequest(this, config, logger, event);
+            },
+            parseRequest(event) {
+                return parseCloudflareRequest(event);
+            },
+            formatResponse(response) {
+                return formatCloudflareResponse(response);
+            },
+            getLogger() {
+                return (logger ?? {
+                    debug: (msg) => Logger.debug(`[Cloudflare] ${msg}`),
+                    info: (msg) => Logger.info(`[Cloudflare] ${msg}`),
+                    warn: (msg) => Logger.warn(`[Cloudflare] ${msg}`),
+                    error: (msg, err) => Logger.error(`[Cloudflare] ${msg}`, err?.message),
+                });
+            },
+            supportsPersistentConnections() {
+                // Cloudflare Workers isolates don't support persistent connections
+                return false;
+            },
+            getEnvironment() {
+                return getCloudflareEnvironment();
+            },
+        };
+    },
+    /**
+     * Get D1 database binding
+     * Usage: adapter.getD1Database()
+     */
+    getD1Database() {
+        // @ts-ignore - Cloudflare Workers environment
+        return globalThis.env?.DB ?? null;
+    },
+    /**
+     * Get KV namespace binding for secrets/configuration
+     * Usage: adapter.getKV('NAMESPACE_NAME')
+     */
+    getKV(namespace) {
+        // @ts-ignore - Cloudflare Workers environment
+        return globalThis.env?.[namespace] ?? null;
+    },
+});
+/**
+ * Read the Cloudflare request body in a content-type aware way.
+ *
+ * Multipart bodies are read as a binary Buffer (via arrayBuffer) so uploaded
+ * files are not corrupted by text decoding. All other bodies are read as text,
+ * preserving the previous behavior for JSON / urlencoded / text payloads.
+ */
+async function readCloudflareRequestBody(request, platformRequest) {
+    if (request.method === 'GET' || request.method === 'HEAD')
+        return null;
+    const rawContentType = platformRequest.headers['content-type'];
+    const contentType = Array.isArray(rawContentType)
+        ? (rawContentType[0] ?? '')
+        : (rawContentType ?? '');
+    if (contentType.toLowerCase().includes('multipart/form-data')) {
+        const arrayBuffer = await request.arrayBuffer();
+        return Buffer.from(arrayBuffer);
+    }
+    return request.text();
+}
+/**
+ * Handle Cloudflare request
+ */
+async function handleCloudflareRequest(adapter, config, logger, event) {
+    try {
+        const request = event;
+        // Parse incoming request
+        const platformRequest = adapter.parseRequest(request);
+        // Read request body. Multipart bodies may contain binary bytes, so read them
+        // as an ArrayBuffer and keep a binary Buffer — converting to text first would
+        // corrupt uploaded files. Other content types remain text for downstream parsing.
+        const body = await readCloudflareRequestBody(request, platformRequest);
+        platformRequest.body = body;
+        // Create mock Node.js request/response objects
+        const { req, res, responseData } = createMockHttpObjects(platformRequest);
+        // Set request timeout
+        const timeout = config.timeout ?? 30000;
+        const timeoutHandle = setTimeout(() => {
+            responseData.statusCode = 504;
+            responseData.body = JSON.stringify({
+                error: 'Gateway Timeout',
+                statusCode: 504,
+            });
+        }, timeout);
+        try {
+            // Process request through ZinTrust handler
+            await config.handler(req, res, body);
+        }
+        finally {
+            clearTimeout(timeoutHandle);
+        }
+        // Format response for Cloudflare
+        const response = HttpResponse.create();
+        response.setStatus(responseData.statusCode);
+        response.setHeaders(responseData.headers);
+        response.setBody(responseData.body);
+        logger?.debug('Cloudflare request processed', {
+            statusCode: response.statusCode,
+            path: platformRequest.path,
+        });
+        return response.toResponse();
+    }
+    catch (error) {
+        const err = error;
+        Logger.error('Cloudflare handler error', err);
+        StartupErrorLogging.logDetails(err, {
+            errors: 'Cloudflare startup configuration errors:',
+            warnings: 'Cloudflare startup configuration warnings:',
+            report: 'Cloudflare startup health report:',
+        });
+        if (typeof err?.stack === 'string' && err.stack.trim() !== '') {
+            Logger.error('Cloudflare handler stack', err.stack);
+        }
+        const errorResponse = ErrorResponse.create(500, 'Internal Server Error', appConfig.isDevelopment() ? { message: error.message } : undefined);
+        return errorResponse.toResponse();
+    }
+}
+function parseCloudflareRequest(event) {
+    const url = new URL(event.url);
+    const headers = {};
+    // Convert Headers object to Record
+    event.headers.forEach((value, key) => {
+        headers[key.toLowerCase()] = value;
+    });
+    // Build query object manually to ensure it works
+    const query = {};
+    for (const [key, value] of url.searchParams.entries()) {
+        if (isUndefinedOrNull(query[key])) {
+            query[key] = value;
+        }
+        else if (Array.isArray(query[key])) {
+            query[key].push(value);
+        }
+        else {
+            query[key] = [query[key], value];
+        }
+    }
+    return {
+        method: event.method.toUpperCase(),
+        path: url.pathname,
+        headers,
+        query,
+        remoteAddr: headers['cf-connecting-ip']?.toString() || '0.0.0.0',
+        signal: event.signal,
+    };
+}
+/**
+ * Format Cloudflare response
+ */
+function formatCloudflareResponse(response) {
+    // Convert to Cloudflare Response format
+    const headers = new Headers();
+    for (const [key, value] of Object.entries(response.headers)) {
+        if (Array.isArray(value)) {
+            value.forEach((v) => headers.append(key, v));
+        }
+        else {
+            headers.set(key, value);
+        }
+    }
+    // Null body status codes per Fetch spec
+    // These statuses must not have a body; Workers runtime warns if body is non-null
+    const NULL_BODY_STATUS_CODES = new Set([101, 204, 205, 304]);
+    let body = null;
+    if (!NULL_BODY_STATUS_CODES.has(response.statusCode) &&
+        response.body !== null &&
+        response.body !== undefined) {
+        if (typeof response.body === 'string') {
+            body = response.body;
+        }
+        else if (typeof ReadableStream !== 'undefined' &&
+            (response.body instanceof ReadableStream ||
+                response.body?.constructor?.name === 'ReadableStream')) {
+            body = response.body;
+        }
+        else {
+            body = response.body.toString();
+        }
+    }
+    return new Response(body, {
+        status: response.statusCode,
+        headers,
+    });
+}
+/**
+ * Get Cloudflare environment
+ */
+function getCloudflareEnvironment() {
+    // @ts-ignore - Cloudflare Workers environment
+    const env = globalThis.env ?? {};
+    return {
+        nodeEnv: env.ENVIRONMENT ?? 'production',
+        runtime: 'cloudflare',
+        dbConnection: env.DB_CONNECTION ?? 'd1', // D1 is Cloudflare's database
+        dbHost: undefined, // D1 uses bindings, not host
+        dbPort: undefined,
+    };
+}
+function createDefaultLogger() {
+    return {
+        debug: (msg, data) => Logger.debug(`[Cloudflare] ${msg}`, data !== undefined && data !== null ? JSON.stringify(data) : ''),
+        info: (msg, data) => Logger.info(`[Cloudflare] ${msg}`, data !== undefined && data !== null ? JSON.stringify(data) : ''),
+        warn: (msg, data) => Logger.warn(`[Cloudflare] ${msg}`, data !== undefined && data !== null ? JSON.stringify(data) : ''),
+        error: (msg, err) => Logger.error(`[Cloudflare] ${msg}`, err?.message),
+    };
+}