@zintrust/core 0.1.40 → 0.1.41

package/src/runtime/RuntimeServices.js

@@ -0,0 +1,164 @@
+/**
+ * Runtime Services
+ * Adapter layer for env/crypto/timers/fs/fetch across Node and Workers
+ * Sealed namespace for immutability
+ */
+import { Cloudflare } from '../config/cloudflare.js';
+import { Env } from '../config/env.js';
+import { ErrorFactory } from '../exceptions/ZintrustError.js';
+import { randomUUID as nodeRandomUUID, randomBytes } from '../node-singletons/crypto.js';
+import * as nodeFs from '../node-singletons/fs.js';
+export const detectCloudflareWorkers = () => {
+    return Cloudflare.getWorkersEnv() !== null;
+};
+export const detectRuntimePlatform = () => {
+    if (detectCloudflareWorkers())
+        return 'cloudflare';
+    return 'nodejs';
+};
+export const RUNTIME_PLATFORM = detectRuntimePlatform();
+const normalizeEnvValue = (value) => {
+    if (value === null || value === undefined)
+        return '';
+    if (typeof value === 'string')
+        return value;
+    if (typeof value === 'number' || typeof value === 'boolean' || typeof value === 'bigint') {
+        return String(value);
+    }
+    return '';
+};
+const readEnvFromRecord = (record, key) => {
+    return normalizeEnvValue(record[key]);
+};
+const createWorkersEnvReader = () => {
+    return {
+        get(key, defaultValue = '') {
+            const env = Cloudflare.getWorkersEnv() ?? {};
+            const value = readEnvFromRecord(env, key);
+            return value === '' ? defaultValue : value;
+        },
+        getInt(key, defaultValue = 0) {
+            const raw = this.get(key, String(defaultValue));
+            const parsed = Number.parseInt(raw, 10);
+            return Number.isFinite(parsed) ? parsed : defaultValue;
+        },
+        getFloat(key, defaultValue = 0) {
+            const raw = this.get(key, String(defaultValue));
+            const parsed = Number.parseFloat(raw);
+            return Number.isFinite(parsed) ? parsed : defaultValue;
+        },
+        getBool(key, defaultValue = false) {
+            const raw = this.get(key, defaultValue ? 'true' : 'false').toLowerCase();
+            if (raw === '')
+                return defaultValue;
+            return raw === 'true' || raw === '1';
+        },
+    };
+};
+const createNodeEnvReader = () => {
+    return {
+        get: (key, defaultValue) => Env.get(key, defaultValue),
+        getInt: (key, defaultValue) => Env.getInt(key, defaultValue ?? 0),
+        getFloat: (key, defaultValue) => Env.getFloat(key, defaultValue ?? 0),
+        getBool: (key, defaultValue) => Env.getBool(key, defaultValue),
+    };
+};
+const getWebCrypto = () => {
+    if (globalThis.crypto === undefined) {
+        throw ErrorFactory.createConfigError('WebCrypto is not available in this runtime');
+    }
+    return globalThis.crypto;
+};
+const fillRandomValues = (webCrypto, array) => {
+    if (typeof webCrypto.getRandomValues === 'function') {
+        return webCrypto.getRandomValues(array);
+    }
+    if (array instanceof BigInt64Array || array instanceof BigUint64Array) {
+        throw ErrorFactory.createConfigError('BigInt typed arrays require WebCrypto support');
+    }
+    const bytes = randomBytes(array.byteLength);
+    const view = new Uint8Array(array.buffer, array.byteOffset, array.byteLength);
+    view.set(bytes);
+    return array;
+};
+const createNodeCrypto = () => {
+    const webCrypto = getWebCrypto();
+    if (webCrypto.subtle === undefined) {
+        throw ErrorFactory.createConfigError('WebCrypto subtle is not available in Node runtime');
+    }
+    return {
+        subtle: webCrypto.subtle,
+        getRandomValues: (array) => {
+            return fillRandomValues(webCrypto, array);
+        },
+        randomUUID: () => {
+            if (typeof webCrypto.randomUUID === 'function')
+                return webCrypto.randomUUID();
+            return nodeRandomUUID();
+        },
+        randomBytes: (size) => randomBytes(size),
+    };
+};
+const createWorkersCrypto = () => {
+    const webCrypto = getWebCrypto();
+    if (webCrypto.subtle === undefined) {
+        throw ErrorFactory.createConfigError('WebCrypto subtle is not available in Workers runtime');
+    }
+    return {
+        subtle: webCrypto.subtle,
+        getRandomValues: (array) => webCrypto.getRandomValues(array),
+        randomUUID: () => {
+            if (typeof webCrypto.randomUUID === 'function')
+                return webCrypto.randomUUID();
+            return nodeRandomUUID();
+        },
+    };
+};
+const createNodeFs = () => {
+    return {
+        supported: true,
+        readFileSync: (path, encoding) => nodeFs.readFileSync(path, encoding),
+        readdirSync: (path) => nodeFs.readdirSync(path),
+        existsSync: (path) => nodeFs.existsSync(path),
+    };
+};
+const createWorkersFs = () => {
+    const unsupported = () => {
+        throw ErrorFactory.createConfigError('Filesystem access is not supported in Workers runtime');
+    };
+    return {
+        supported: false,
+        readFileSync: () => unsupported(),
+        readdirSync: () => unsupported(),
+        existsSync: () => false,
+    };
+};
+const createTimers = () => ({
+    setTimeout: globalThis.setTimeout.bind(globalThis),
+    clearTimeout: globalThis.clearTimeout.bind(globalThis),
+    setInterval: globalThis.setInterval.bind(globalThis),
+    clearInterval: globalThis.clearInterval.bind(globalThis),
+});
+export const RuntimeServices = Object.freeze({
+    create(platform) {
+        if (platform === 'cloudflare') {
+            return {
+                platform,
+                env: createWorkersEnvReader(),
+                crypto: createWorkersCrypto(),
+                timers: createTimers(),
+                fs: createWorkersFs(),
+                fetch: globalThis.fetch.bind(globalThis),
+            };
+        }
+        return {
+            platform,
+            env: createNodeEnvReader(),
+            crypto: createNodeCrypto(),
+            timers: createTimers(),
+            fs: createNodeFs(),
+            fetch: globalThis.fetch.bind(globalThis),
+        };
+    },
+});
+export default RuntimeServices;

package/src/runtime/StartupConfigFileRegistry.d.ts

@@ -9,12 +9,12 @@ export declare const StartupConfigFile: {
     readonly Storage: "config/storage.ts";
     readonly Workers: "config/workers.ts";
 };
-export type StartupConfigFileTyps = typeof StartupConfigFile.Broadcast | typeof StartupConfigFile.Cache | typeof StartupConfigFile.Database | typeof StartupConfigFile.Mail | typeof StartupConfigFile.Middleware | typeof StartupConfigFile.Notification | typeof StartupConfigFile.Queue | typeof StartupConfigFile.Storage | typeof StartupConfigFile.Workers;
+export type StartupConfigFileTypes = typeof StartupConfigFile.Broadcast | typeof StartupConfigFile.Cache | typeof StartupConfigFile.Database | typeof StartupConfigFile.Mail | typeof StartupConfigFile.Middleware | typeof StartupConfigFile.Notification | typeof StartupConfigFile.Queue | typeof StartupConfigFile.Storage | typeof StartupConfigFile.Workers;
 export declare const StartupConfigFileRegistry: Readonly<{
-    preload(files: readonly StartupConfigFileTyps[]): Promise<void>;
+    preload(files: readonly StartupConfigFileTypes[]): Promise<void>;
     isPreloaded(): boolean;
-    get<T>(file: StartupConfigFileTyps): T | undefined;
-    has(file: StartupConfigFileTyps): boolean;
+    get<T>(file: StartupConfigFileTypes): T | undefined;
+    has(file: StartupConfigFileTypes): boolean;
     /** Intended for tests only. */
     clear(): void;
 }>;

package/src/runtime/StartupConfigFileRegistry.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"StartupConfigFileRegistry.d.ts","sourceRoot":"","sources":["../../../src/runtime/StartupConfigFileRegistry.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,iBAAiB;;;;;;;;;;CAUpB,CAAC;AAEX,MAAM,MAAM,qBAAqB,GAC7B,OAAO,iBAAiB,CAAC,SAAS,GAClC,OAAO,iBAAiB,CAAC,KAAK,GAC9B,OAAO,iBAAiB,CAAC,QAAQ,GACjC,OAAO,iBAAiB,CAAC,IAAI,GAC7B,OAAO,iBAAiB,CAAC,UAAU,GACnC,OAAO,iBAAiB,CAAC,YAAY,GACrC,OAAO,iBAAiB,CAAC,KAAK,GAC9B,OAAO,iBAAiB,CAAC,OAAO,GAChC,OAAO,iBAAiB,CAAC,OAAO,CAAC;AAKrC,eAAO,MAAM,yBAAyB;mBACf,SAAS,qBAAqB,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC;mBAetD,OAAO;QAIlB,CAAC,QAAQ,qBAAqB,GAAG,CAAC,GAAG,SAAS;cAIxC,qBAAqB,GAAG,OAAO;IAIzC,+BAA+B;aACtB,IAAI;EAIb,CAAC;AAEH,eAAe,yBAAyB,CAAC"}
+{"version":3,"file":"StartupConfigFileRegistry.d.ts","sourceRoot":"","sources":["../../../src/runtime/StartupConfigFileRegistry.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,iBAAiB;;;;;;;;;;CAUpB,CAAC;AAEX,MAAM,MAAM,sBAAsB,GAC9B,OAAO,iBAAiB,CAAC,SAAS,GAClC,OAAO,iBAAiB,CAAC,KAAK,GAC9B,OAAO,iBAAiB,CAAC,QAAQ,GACjC,OAAO,iBAAiB,CAAC,IAAI,GAC7B,OAAO,iBAAiB,CAAC,UAAU,GACnC,OAAO,iBAAiB,CAAC,YAAY,GACrC,OAAO,iBAAiB,CAAC,KAAK,GAC9B,OAAO,iBAAiB,CAAC,OAAO,GAChC,OAAO,iBAAiB,CAAC,OAAO,CAAC;AAarC,eAAO,MAAM,yBAAyB;mBACf,SAAS,sBAAsB,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC;mBAqBvD,OAAO;QAIlB,CAAC,QAAQ,sBAAsB,GAAG,CAAC,GAAG,SAAS;cAIzC,sBAAsB,GAAG,OAAO;IAI1C,+BAA+B;aACtB,IAAI;EAIb,CAAC;AAEH,eAAe,yBAAyB,CAAC"}

package/src/runtime/StartupConfigFileRegistry.js

@@ -1,4 +1,5 @@
 import useFileLoader from './useFileLoader.js';
+// NOTE runtime config loader
 export const StartupConfigFile = {
     Broadcast: 'config/broadcast.ts',
     Cache: 'config/cache.ts',
@@ -12,9 +13,20 @@ export const StartupConfigFile = {
 };
 const cache = new Map();
 let preloaded = false;
+const getWorkersStartupOverrides = () => {
+    if (typeof globalThis === 'undefined')
+        return undefined;
+    const globalAny = globalThis;
+    return globalAny.__zintrustStartupConfigOverrides;
+};
 export const StartupConfigFileRegistry = Object.freeze({
     async preload(files) {
         const tasks = files.map(async (file) => {
+            const overrides = getWorkersStartupOverrides();
+            if (overrides?.has(file) === true) {
+                cache.set(file, overrides.get(file));
+                return;
+            }
             const loader = useFileLoader(file);
             if (!loader.exists()) {
                 cache.delete(file);

package/src/runtime/WorkerAdapterImports.d.ts

@@ -0,0 +1,5 @@
+export declare const WorkerAdapterImports: Readonly<{
+    loaded: boolean;
+    ready: void;
+}>;
+//# sourceMappingURL=WorkerAdapterImports.d.ts.map

package/src/runtime/WorkerAdapterImports.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"WorkerAdapterImports.d.ts","sourceRoot":"","sources":["../../../src/runtime/WorkerAdapterImports.ts"],"names":[],"mappings":"AAeA,eAAO,MAAM,oBAAoB;;;EAG/B,CAAC"}

package/src/runtime/WorkerAdapterImports.js

@@ -0,0 +1,17 @@
+// Worker-only adapter auto-imports for bundler-based runtimes (e.g. Cloudflare Workers).
+// Keep this list limited to database adapters needed by runtime config.
+// These imports resolve against the host project (developer working directory)
+// via the @/ alias configured by the ZinTrust app templates.
+const tryImportOptional = async () => {
+    try {
+        await import('../zintrust.plugins.wg.js');
+    }
+    catch {
+        // Log and swallow errors since these are optional imports that may not exist in all projects.
+    }
+};
+const ready = await tryImportOptional();
+export const WorkerAdapterImports = Object.freeze({
+    loaded: true,
+    ready,
+});

package/src/runtime/WorkersModule.d.ts

@@ -0,0 +1,6 @@
+type WorkersModule = typeof import('../../packages/workers/src/index.js');
+type QueueMonitorModule = typeof import('../../packages/queue-monitor/src/index.js');
+export declare const loadWorkersModule: () => Promise<WorkersModule>;
+export declare const loadQueueMonitorModule: () => Promise<QueueMonitorModule>;
+export {};
+//# sourceMappingURL=WorkersModule.d.ts.map

package/src/runtime/WorkersModule.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"WorkersModule.d.ts","sourceRoot":"","sources":["../../../src/runtime/WorkersModule.ts"],"names":[],"mappings":"AAOA,KAAK,aAAa,GAAG,cAAc,mBAAmB,CAAC,CAAC;AACxD,KAAK,kBAAkB,GAAG,cAAc,yBAAyB,CAAC,CAAC;AA8PnE,eAAO,MAAM,iBAAiB,QAAa,OAAO,CAAC,aAAa,CAiB/D,CAAC;AA2CF,eAAO,MAAM,sBAAsB,QAAa,OAAO,CAAC,kBAAkB,CAiBzE,CAAC"}

package/src/runtime/WorkersModule.js

@@ -0,0 +1,278 @@
+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 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');
+let workersModulePromise;
+let patchAttempted = false;
+let patchAfterFailureAttempted = false;
+let queueMonitorModulePromise;
+let queueMonitorPatchAfterFailureAttempted = false;
+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 shouldRetryAfterFailure = (error) => {
+    if (patchAfterFailureAttempted)
+        return false;
+    const message = error instanceof Error ? error.message : String(error);
+    const code = error?.code;
+    return code === 'ERR_MODULE_NOT_FOUND' && message.includes('@zintrust/workers');
+};
+const handleImportFailure = async (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 = import('@zintrust/workers');
+            return workersModulePromise;
+        }
+    }
+    const localFallback = await importLocalWorkersModule();
+    if (localFallback) {
+        workersModulePromise = Promise.resolve(localFallback);
+        return localFallback;
+    }
+    throw error;
+};
+const tryLocalFallback = async () => {
+    const localFallback = await importLocalWorkersModule();
+    if (localFallback) {
+        workersModulePromise = Promise.resolve(localFallback);
+        return localFallback;
+    }
+    return null;
+};
+export const loadWorkersModule = async () => {
+    applyInitialPatches();
+    if (workersModulePromise === undefined) {
+        const localFallback = await tryLocalFallback();
+        if (localFallback) {
+            return localFallback;
+        }
+    }
+    workersModulePromise ??= import('@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 = import('@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 ??= import('@zintrust/queue-monitor');
+    try {
+        return await queueMonitorModulePromise;
+    }
+    catch (error) {
+        return handleQueueMonitorImportFailure(error);
+    }
+};

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

@@ -1 +1 @@
-{"version":3,"file":"CloudflareAdapter.d.ts","sourceRoot":"","sources":["../../../../src/runtime/adapters/CloudflareAdapter.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EACV,aAAa,EAGb,cAAc,EACf,MAAM,yBAAyB,CAAC;AAGjC;;;;GAIG;AACH,eAAO,MAAM,iBAAiB;IAC5B;;OAEG;mBACY,aAAa,GAAG,cAAc;IAoD7C;;;OAGG;qBACc,OAAO;IAKxB;;;OAGG;qBACc,MAAM,GAAG,OAAO;EAIjC,CAAC;AA4IH;;;;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"}
+{"version":3,"file":"CloudflareAdapter.d.ts","sourceRoot":"","sources":["../../../../src/runtime/adapters/CloudflareAdapter.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EACV,aAAa,EAGb,cAAc,EACf,MAAM,yBAAyB,CAAC;AAGjC;;;;GAIG;AACH,eAAO,MAAM,iBAAiB;IAC5B;;OAEG;mBACY,aAAa,GAAG,cAAc;IAwD7C;;;OAGG;qBACc,OAAO;IAKxB;;;OAGG;qBACc,MAAM,GAAG,OAAO;EAIjC,CAAC;AAwJH;;;;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

@@ -2,6 +2,8 @@
  * Runtime adapter for Cloudflare Workers
  */
 import { appConfig } from '../../config/index.js';
+import { Cloudflare } from '../../config/cloudflare.js';
+import { Env } from '../../config/env.js';
 import { Logger } from '../../config/logger.js';
 import { createMockHttpObjects, ErrorResponse, HttpResponse } from '../RuntimeAdapter.js';
 /**
@@ -14,6 +16,10 @@ export const CloudflareAdapter = Object.freeze({
      * Create a new Cloudflare adapter instance
      */
     create(config) {
+        const workersEnv = Cloudflare.getWorkersEnv();
+        if (workersEnv !== null) {
+            Env.setSource(() => workersEnv);
+        }
         const logger = config.logger ?? createDefaultLogger();
         return {
             platform: 'cloudflare',
@@ -70,6 +76,7 @@ async function handleCloudflareRequest(adapter, config, logger, event) {
         const platformRequest = adapter.parseRequest(request);
         // Read request body
         const body = request.method !== 'GET' && request.method !== 'HEAD' ? await request.text() : null;
+        platformRequest.body = body;
         // Create mock Node.js request/response objects
         const { req, res, responseData } = createMockHttpObjects(platformRequest);
         // Set request timeout
@@ -100,7 +107,11 @@ async function handleCloudflareRequest(adapter, config, logger, event) {
         return response.toResponse();
     }
     catch (error) {
-        Logger.error('Cloudflare handler error', error);
+        const err = error;
+        Logger.error('Cloudflare handler error', err);
+        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();
     }
@@ -121,6 +132,7 @@ function parseCloudflareRequest(event) {
         headers,
         query: Object.fromEntries(url.searchParams.entries()),
         remoteAddr: headers['cf-connecting-ip']?.toString() || '0.0.0.0',
+        signal: event.signal,
     };
 }
 /**
@@ -137,11 +149,16 @@ function formatCloudflareResponse(response) {
             headers.set(key, value);
         }
     }
-    let body = '';
+    let body = null;
     if (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();
         }

package/src/runtime/adapters/DenoAdapter.js

@@ -141,6 +141,7 @@ function parseDenoRequest(event) {
         headers,
         query: Object.fromEntries(url.searchParams.entries()),
         remoteAddr: headers['x-forwarded-for']?.toString().split(',')[0] ?? '0.0.0.0',
+        signal: event.signal,
     };
 }
 /**

package/src/runtime/adapters/FargateAdapter.js

@@ -48,7 +48,7 @@ export function createFargateAdapter(config) {
             return {
                 nodeEnv: Env.NODE_ENV,
                 runtime: 'fargate',
-                dbConnection: Env.DB_CONNECTION,
+                dbConnection: Env.DB_CONNECTION || 'sqlite',
                 dbHost: Env.DB_HOST,
                 dbPort: Env.DB_PORT,
             };

package/src/runtime/adapters/LambdaAdapter.js

@@ -45,7 +45,7 @@ export const LambdaAdapter = Object.freeze({
                 return {
                     nodeEnv: Env.NODE_ENV,
                     runtime: 'lambda',
-                    dbConnection: Env.DB_CONNECTION,
+                    dbConnection: Env.get('DB_CONNECTION', 'sqlite'),
                     dbHost: Env.DB_HOST,
                     dbPort: Env.DB_PORT,
                 };

package/src/runtime/adapters/NodeServerAdapter.js

@@ -102,7 +102,7 @@ function getNodeEnvironment() {
     return {
         nodeEnv: Env.NODE_ENV,
         runtime: 'nodejs',
-        dbConnection: Env.DB_CONNECTION,
+        dbConnection: Env.get('DB_CONNECTION', 'sqlite'),
         dbHost: Env.DB_HOST,
         dbPort: Env.DB_PORT,
     };

package/src/runtime/detectRuntime.d.ts

@@ -0,0 +1,10 @@
+export type RuntimeMode = 'cloudflare-workers' | 'containers' | 'node-server';
+export declare const isNodeRuntime: () => boolean;
+export declare const getRuntimeMode: () => RuntimeMode;
+export declare const detectRuntime: () => {
+    isCloudflare: boolean;
+    isNode: boolean;
+    isDeno: boolean;
+    isBun: boolean;
+};
+//# sourceMappingURL=detectRuntime.d.ts.map

package/src/runtime/detectRuntime.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"detectRuntime.d.ts","sourceRoot":"","sources":["../../../src/runtime/detectRuntime.ts"],"names":[],"mappings":"AAEA,MAAM,MAAM,WAAW,GAAG,oBAAoB,GAAG,YAAY,GAAG,aAAa,CAAC;AAE9E,eAAO,MAAM,aAAa,QAAO,OAUhC,CAAC;AAUF,eAAO,MAAM,cAAc,QAAO,WA6BjC,CAAC;AAEF,eAAO,MAAM,aAAa,QAAO;IAC/B,YAAY,EAAE,OAAO,CAAC;IACtB,MAAM,EAAE,OAAO,CAAC;IAChB,MAAM,EAAE,OAAO,CAAC;IAChB,KAAK,EAAE,OAAO,CAAC;CAwBhB,CAAC"}