@astrojs/cloudflare 0.0.0-cf-assets-20231021193132

package/dist/index.js

@@ -0,0 +1,517 @@
+import { createRedirectsFromAstroRoutes } from '@astrojs/underscore-redirects';
+import { sharpImageService } from 'astro/config';
+import { AstroError } from 'astro/errors';
+import esbuild from 'esbuild';
+import { Miniflare } from 'miniflare';
+import * as fs from 'node:fs';
+import * as os from 'node:os';
+import { dirname, relative, sep } from 'node:path';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+import glob from 'tiny-glob';
+import { getAdapter } from './getAdapter.js';
+import { deduplicatePatterns } from './utils/deduplicatePatterns.js';
+import { getCFObject } from './utils/getCFObject.js';
+import { getD1Bindings, getDOBindings, getEnvVars, getKVBindings, getR2Bindings, } from './utils/parser.js';
+import { prependForwardSlash } from './utils/prependForwardSlash.js';
+import { rewriteWasmImportPath } from './utils/rewriteWasmImportPath.js';
+import { wasmModuleLoader } from './utils/wasm-module-loader.js';
+const RUNTIME_WARNING = `You are using a deprecated string format for the \`runtime\` API. Please update to the current format for better support. 
+
+Example:
+Old Format: 'local'
+Current Format: { mode: 'local', persistTo: '.wrangler/state/v3' }
+
+Please refer to our runtime documentation for more details on the format. https://docs.astro.build/en/guides/integrations-guide/cloudflare/#runtime`;
+export default function createIntegration(args) {
+    let _config;
+    let _buildConfig;
+    let _mf;
+    let _entryPoints = new Map();
+    const SERVER_BUILD_FOLDER = '/$server_build/';
+    const isModeDirectory = args?.mode === 'directory';
+    const functionPerRoute = args?.functionPerRoute ?? false;
+    let runtimeMode = { mode: 'off' };
+    if (args?.runtime === 'remote') {
+        runtimeMode = { mode: 'remote' };
+    }
+    else if (args?.runtime === 'local') {
+        runtimeMode = { mode: 'local', persistTo: '.wrangler/state/v3' };
+    }
+    else if (typeof args?.runtime === 'object' &&
+        args?.runtime.mode === 'local' &&
+        args.runtime.persistTo === undefined) {
+        runtimeMode = { mode: 'local', persistTo: '.wrangler/state/v3' };
+    }
+    else if (args?.runtime) {
+        runtimeMode = args?.runtime;
+    }
+    return {
+        name: '@astrojs/cloudflare',
+        hooks: {
+            'astro:config:setup': ({ command, config, updateConfig }) => {
+                updateConfig({
+                    build: {
+                        client: new URL(`.${config.base}`, config.outDir),
+                        server: new URL(`.${SERVER_BUILD_FOLDER}`, config.outDir),
+                        serverEntry: '_worker.mjs',
+                        redirects: false,
+                    },
+                    vite: {
+                        // load .wasm files as WebAssembly modules
+                        plugins: [
+                            wasmModuleLoader({
+                                disabled: !args?.wasmModuleImports,
+                                assetsDirectory: config.build.assets,
+                            }),
+                        ],
+                    },
+                    image: {
+                        service: command === 'dev'
+                            ? sharpImageService()
+                            : {
+                                entrypoint: '@astrojs/cloudflare/image-service',
+                            },
+                    },
+                });
+            },
+            'astro:config:done': ({ setAdapter, config, logger }) => {
+                setAdapter(getAdapter({ isModeDirectory, functionPerRoute }));
+                _config = config;
+                _buildConfig = config.build;
+                if (_config.output === 'static') {
+                    throw new AstroError('[@astrojs/cloudflare] `output: "server"` or `output: "hybrid"` is required to use this adapter. Otherwise, this adapter is not necessary to deploy a static site to Cloudflare.');
+                }
+                if (_config.base === SERVER_BUILD_FOLDER) {
+                    throw new AstroError('[@astrojs/cloudflare] `base: "${SERVER_BUILD_FOLDER}"` is not allowed. Please change your `base` config to something else.');
+                }
+                if (typeof args?.runtime === 'string') {
+                    logger.warn(RUNTIME_WARNING);
+                }
+            },
+            'astro:server:setup': ({ server }) => {
+                if (runtimeMode.mode === 'local') {
+                    const typedRuntimeMode = runtimeMode;
+                    server.middlewares.use(async function middleware(req, res, next) {
+                        try {
+                            const cf = await getCFObject(typedRuntimeMode.mode);
+                            const vars = await getEnvVars();
+                            const D1Bindings = await getD1Bindings();
+                            const R2Bindings = await getR2Bindings();
+                            const KVBindings = await getKVBindings();
+                            const DOBindings = await getDOBindings();
+                            let bindingsEnv = new Object({});
+                            // fix for the error "kj/filesystem-disk-unix.c++:1709: warning: PWD environment variable doesn't match current directory."
+                            // note: This mismatch might be primarily due to the test runner.
+                            const originalPWD = process.env.PWD;
+                            process.env.PWD = process.cwd();
+                            _mf = new Miniflare({
+                                modules: true,
+                                script: '',
+                                cache: true,
+                                cachePersist: `${typedRuntimeMode.persistTo}/cache`,
+                                cacheWarnUsage: true,
+                                d1Databases: D1Bindings,
+                                d1Persist: `${typedRuntimeMode.persistTo}/d1`,
+                                r2Buckets: R2Bindings,
+                                r2Persist: `${typedRuntimeMode.persistTo}/r2`,
+                                kvNamespaces: KVBindings,
+                                kvPersist: `${typedRuntimeMode.persistTo}/kv`,
+                                durableObjects: DOBindings,
+                                durableObjectsPersist: `${typedRuntimeMode.persistTo}/do`,
+                            });
+                            await _mf.ready;
+                            for (const D1Binding of D1Bindings) {
+                                const db = await _mf.getD1Database(D1Binding);
+                                Reflect.set(bindingsEnv, D1Binding, db);
+                            }
+                            for (const R2Binding of R2Bindings) {
+                                const bucket = await _mf.getR2Bucket(R2Binding);
+                                Reflect.set(bindingsEnv, R2Binding, bucket);
+                            }
+                            for (const KVBinding of KVBindings) {
+                                const namespace = await _mf.getKVNamespace(KVBinding);
+                                Reflect.set(bindingsEnv, KVBinding, namespace);
+                            }
+                            for (const key in DOBindings) {
+                                if (Object.prototype.hasOwnProperty.call(DOBindings, key)) {
+                                    const DO = await _mf.getDurableObjectNamespace(key);
+                                    Reflect.set(bindingsEnv, key, DO);
+                                }
+                            }
+                            const mfCache = await _mf.getCaches();
+                            process.env.PWD = originalPWD;
+                            const clientLocalsSymbol = Symbol.for('astro.locals');
+                            Reflect.set(req, clientLocalsSymbol, {
+                                runtime: {
+                                    env: {
+                                        // default binding for static assets will be dynamic once we support mocking of bindings
+                                        ASSETS: {},
+                                        // this is just a VAR for CF to change build behavior, on dev it should be 0
+                                        CF_PAGES: '0',
+                                        // will be fetched from git dynamically once we support mocking of bindings
+                                        CF_PAGES_BRANCH: 'TBA',
+                                        // will be fetched from git dynamically once we support mocking of bindings
+                                        CF_PAGES_COMMIT_SHA: 'TBA',
+                                        CF_PAGES_URL: `http://${req.headers.host}`,
+                                        ...bindingsEnv,
+                                        ...vars,
+                                    },
+                                    cf: cf,
+                                    waitUntil: (_promise) => {
+                                        return;
+                                    },
+                                    caches: mfCache,
+                                },
+                            });
+                            next();
+                        }
+                        catch {
+                            next();
+                        }
+                    });
+                }
+            },
+            'astro:server:done': async ({ logger }) => {
+                if (_mf) {
+                    logger.info('Cleaning up the Miniflare instance, and shutting down the workerd server.');
+                    await _mf.dispose();
+                }
+            },
+            'astro:build:setup': ({ vite, target }) => {
+                if (target === 'server') {
+                    vite.resolve ||= {};
+                    vite.resolve.alias ||= {};
+                    const aliases = [
+                        {
+                            find: 'react-dom/server',
+                            replacement: 'react-dom/server.browser',
+                        },
+                    ];
+                    if (Array.isArray(vite.resolve.alias)) {
+                        vite.resolve.alias = [...vite.resolve.alias, ...aliases];
+                    }
+                    else {
+                        for (const alias of aliases) {
+                            vite.resolve.alias[alias.find] = alias.replacement;
+                        }
+                    }
+                    vite.ssr ||= {};
+                    vite.ssr.target = 'webworker';
+                    // Cloudflare env is only available per request. This isn't feasible for code that access env vars
+                    // in a global way, so we shim their access as `process.env.*`. We will populate `process.env` later
+                    // in its fetch handler.
+                    vite.define = {
+                        'process.env': 'process.env',
+                        ...vite.define,
+                    };
+                }
+            },
+            'astro:build:ssr': ({ entryPoints }) => {
+                _entryPoints = entryPoints;
+            },
+            'astro:build:done': async ({ pages, routes, dir }) => {
+                const functionsUrl = new URL('functions/', _config.root);
+                const assetsUrl = new URL(_buildConfig.assets, _buildConfig.client);
+                if (isModeDirectory) {
+                    await fs.promises.mkdir(functionsUrl, { recursive: true });
+                }
+                // TODO: remove _buildConfig.split in Astro 4.0
+                if (isModeDirectory && (_buildConfig.split || functionPerRoute)) {
+                    const entryPointsURL = [..._entryPoints.values()];
+                    const entryPaths = entryPointsURL.map((entry) => fileURLToPath(entry));
+                    const outputUrl = new URL('$astro', _buildConfig.server);
+                    const outputDir = fileURLToPath(outputUrl);
+                    //
+                    // Sadly, when wasmModuleImports is enabled, this needs to build esbuild for each depth of routes/entrypoints
+                    // independently so that relative import paths to the assets are the correct depth of '../' traversals
+                    // This is inefficient, so wasmModuleImports is opt-in. This could potentially be improved in the future by
+                    // taking advantage of the esbuild "onEnd" hook to rewrite import code per entry point relative to where the final
+                    // destination of the entrypoint is
+                    const entryPathsGroupedByDepth = !args.wasmModuleImports
+                        ? [entryPaths]
+                        : entryPaths
+                            .reduce((sum, thisPath) => {
+                            const depthFromRoot = thisPath.split(sep).length;
+                            sum.set(depthFromRoot, (sum.get(depthFromRoot) || []).concat(thisPath));
+                            return sum;
+                        }, new Map())
+                            .values();
+                    for (const pathsGroup of entryPathsGroupedByDepth) {
+                        // for some reason this exports to "entry.pages" on windows instead of "pages" on unix environments.
+                        // This deduces the name of the "pages" build directory
+                        const pagesDirname = relative(fileURLToPath(_buildConfig.server), pathsGroup[0]).split(sep)[0];
+                        const absolutePagesDirname = fileURLToPath(new URL(pagesDirname, _buildConfig.server));
+                        const urlWithinFunctions = new URL(relative(absolutePagesDirname, pathsGroup[0]), functionsUrl);
+                        const relativePathToAssets = relative(dirname(fileURLToPath(urlWithinFunctions)), fileURLToPath(assetsUrl));
+                        await esbuild.build({
+                            target: 'es2022',
+                            platform: 'browser',
+                            conditions: ['workerd', 'worker', 'browser'],
+                            external: [
+                                'node:assert',
+                                'node:async_hooks',
+                                'node:buffer',
+                                'node:crypto',
+                                'node:diagnostics_channel',
+                                'node:events',
+                                'node:path',
+                                'node:process',
+                                'node:stream',
+                                'node:string_decoder',
+                                'node:util',
+                                'cloudflare:*',
+                            ],
+                            entryPoints: pathsGroup,
+                            outbase: absolutePagesDirname,
+                            outdir: outputDir,
+                            allowOverwrite: true,
+                            format: 'esm',
+                            bundle: true,
+                            minify: _config.vite?.build?.minify !== false,
+                            banner: {
+                                js: `globalThis.process = {
+									argv: [],
+									env: {},
+								};`,
+                            },
+                            logOverride: {
+                                'ignored-bare-import': 'silent',
+                            },
+                            plugins: !args?.wasmModuleImports
+                                ? []
+                                : [rewriteWasmImportPath({ relativePathToAssets })],
+                        });
+                    }
+                    const outputFiles = await glob(`**/*`, {
+                        cwd: outputDir,
+                        filesOnly: true,
+                    });
+                    // move the files into the functions folder
+                    // & make sure the file names match Cloudflare syntax for routing
+                    for (const outputFile of outputFiles) {
+                        const path = outputFile.split(sep);
+                        const finalSegments = path.map((segment) => segment
+                            .replace(/(\_)(\w+)(\_)/g, (_, __, prop) => {
+                            return `[${prop}]`;
+                        })
+                            .replace(/(\_\-\-\-)(\w+)(\_)/g, (_, __, prop) => {
+                            return `[[${prop}]]`;
+                        }));
+                        finalSegments[finalSegments.length - 1] = finalSegments[finalSegments.length - 1]
+                            .replace('entry.', '')
+                            .replace(/(.*)\.(\w+)\.(\w+)$/g, (_, fileName, __, newExt) => {
+                            return `${fileName}.${newExt}`;
+                        });
+                        const finalDirPath = finalSegments.slice(0, -1).join(sep);
+                        const finalPath = finalSegments.join(sep);
+                        const newDirUrl = new URL(finalDirPath, functionsUrl);
+                        await fs.promises.mkdir(newDirUrl, { recursive: true });
+                        const oldFileUrl = new URL(`$astro/${outputFile}`, outputUrl);
+                        const newFileUrl = new URL(finalPath, functionsUrl);
+                        await fs.promises.rename(oldFileUrl, newFileUrl);
+                    }
+                }
+                else {
+                    const entryPath = fileURLToPath(new URL(_buildConfig.serverEntry, _buildConfig.server));
+                    const entryUrl = new URL(_buildConfig.serverEntry, _config.outDir);
+                    const buildPath = fileURLToPath(entryUrl);
+                    // A URL for the final build path after renaming
+                    const finalBuildUrl = pathToFileURL(buildPath.replace(/\.mjs$/, '.js'));
+                    await esbuild.build({
+                        target: 'es2022',
+                        platform: 'browser',
+                        conditions: ['workerd', 'worker', 'browser'],
+                        external: [
+                            'node:assert',
+                            'node:async_hooks',
+                            'node:buffer',
+                            'node:crypto',
+                            'node:diagnostics_channel',
+                            'node:events',
+                            'node:path',
+                            'node:process',
+                            'node:stream',
+                            'node:string_decoder',
+                            'node:util',
+                            'cloudflare:*',
+                        ],
+                        entryPoints: [entryPath],
+                        outfile: buildPath,
+                        allowOverwrite: true,
+                        format: 'esm',
+                        bundle: true,
+                        minify: _config.vite?.build?.minify !== false,
+                        banner: {
+                            js: `globalThis.process = {
+								argv: [],
+								env: {},
+							};`,
+                        },
+                        logOverride: {
+                            'ignored-bare-import': 'silent',
+                        },
+                        plugins: !args?.wasmModuleImports
+                            ? []
+                            : [
+                                rewriteWasmImportPath({
+                                    relativePathToAssets: isModeDirectory
+                                        ? relative(fileURLToPath(functionsUrl), fileURLToPath(assetsUrl))
+                                        : relative(fileURLToPath(_buildConfig.client), fileURLToPath(assetsUrl)),
+                                }),
+                            ],
+                    });
+                    // Rename to worker.js
+                    await fs.promises.rename(buildPath, finalBuildUrl);
+                    if (isModeDirectory) {
+                        const directoryUrl = new URL('[[path]].js', functionsUrl);
+                        await fs.promises.rename(finalBuildUrl, directoryUrl);
+                    }
+                }
+                // throw the server folder in the bin
+                const serverUrl = new URL(_buildConfig.server);
+                await fs.promises.rm(serverUrl, { recursive: true, force: true });
+                // move cloudflare specific files to the root
+                const cloudflareSpecialFiles = ['_headers', '_redirects', '_routes.json'];
+                if (_config.base !== '/') {
+                    for (const file of cloudflareSpecialFiles) {
+                        try {
+                            await fs.promises.rename(new URL(file, _buildConfig.client), new URL(file, _config.outDir));
+                        }
+                        catch (e) {
+                            // ignore
+                        }
+                    }
+                }
+                // Add also the worker file so it's excluded from the _routes.json generation
+                if (!isModeDirectory) {
+                    cloudflareSpecialFiles.push('_worker.js');
+                }
+                const routesExists = await fs.promises
+                    .stat(new URL('./_routes.json', _config.outDir))
+                    .then((stat) => stat.isFile())
+                    .catch(() => false);
+                // this creates a _routes.json, in case there is none present to enable
+                // cloudflare to handle static files and support _redirects configuration
+                if (!routesExists) {
+                    /**
+                     * These route types are candiates for being part of the `_routes.json` `include` array.
+                     */
+                    const potentialFunctionRouteTypes = ['endpoint', 'page'];
+                    const functionEndpoints = routes
+                        // Certain route types, when their prerender option is set to false, run on the server as function invocations
+                        .filter((route) => potentialFunctionRouteTypes.includes(route.type) && !route.prerender)
+                        .map((route) => {
+                        const includePattern = '/' +
+                            route.segments
+                                .flat()
+                                .map((segment) => (segment.dynamic ? '*' : segment.content))
+                                .join('/');
+                        const regexp = new RegExp('^\\/' +
+                            route.segments
+                                .flat()
+                                .map((segment) => (segment.dynamic ? '(.*)' : segment.content))
+                                .join('\\/') +
+                            '$');
+                        return {
+                            includePattern,
+                            regexp,
+                        };
+                    });
+                    const staticPathList = (await glob(`${fileURLToPath(_buildConfig.client)}/**/*`, {
+                        cwd: fileURLToPath(_config.outDir),
+                        filesOnly: true,
+                        dot: true,
+                    }))
+                        .filter((file) => cloudflareSpecialFiles.indexOf(file) < 0)
+                        .map((file) => `/${file.replace(/\\/g, '/')}`);
+                    for (let page of pages) {
+                        let pagePath = prependForwardSlash(page.pathname);
+                        if (_config.base !== '/') {
+                            const base = _config.base.endsWith('/') ? _config.base.slice(0, -1) : _config.base;
+                            pagePath = `${base}${pagePath}`;
+                        }
+                        staticPathList.push(pagePath);
+                    }
+                    const redirectsExists = await fs.promises
+                        .stat(new URL('./_redirects', _config.outDir))
+                        .then((stat) => stat.isFile())
+                        .catch(() => false);
+                    // convert all redirect source paths into a list of routes
+                    // and add them to the static path
+                    if (redirectsExists) {
+                        const redirects = (await fs.promises.readFile(new URL('./_redirects', _config.outDir), 'utf-8'))
+                            .split(os.EOL)
+                            .map((line) => {
+                            const parts = line.split(' ');
+                            if (parts.length < 2) {
+                                return null;
+                            }
+                            else {
+                                // convert /products/:id to /products/*
+                                return (parts[0]
+                                    .replace(/\/:.*?(?=\/|$)/g, '/*')
+                                    // remove query params as they are not supported by cloudflare
+                                    .replace(/\?.*$/, ''));
+                            }
+                        })
+                            .filter((line, index, arr) => line !== null && arr.indexOf(line) === index);
+                        if (redirects.length > 0) {
+                            staticPathList.push(...redirects);
+                        }
+                    }
+                    const redirectRoutes = routes
+                        .filter((r) => r.type === 'redirect')
+                        .map((r) => {
+                        return [r, ''];
+                    });
+                    const trueRedirects = createRedirectsFromAstroRoutes({
+                        config: _config,
+                        routeToDynamicTargetMap: new Map(Array.from(redirectRoutes)),
+                        dir,
+                    });
+                    if (!trueRedirects.empty()) {
+                        await fs.promises.appendFile(new URL('./_redirects', _config.outDir), trueRedirects.print());
+                    }
+                    staticPathList.push(...routes.filter((r) => r.type === 'redirect').map((r) => r.route));
+                    const strategy = args?.routes?.strategy ?? 'auto';
+                    // Strategy `include`: include all function endpoints, and then exclude static paths that would be matched by an include pattern
+                    const includeStrategy = strategy === 'exclude'
+                        ? undefined
+                        : {
+                            include: deduplicatePatterns(functionEndpoints
+                                .map((endpoint) => endpoint.includePattern)
+                                .concat(args?.routes?.include ?? [])),
+                            exclude: deduplicatePatterns(staticPathList
+                                .filter((file) => functionEndpoints.some((endpoint) => endpoint.regexp.test(file)))
+                                .concat(args?.routes?.exclude ?? [])),
+                        };
+                    // Cloudflare requires at least one include pattern:
+                    // https://developers.cloudflare.com/pages/platform/functions/routing/#limits
+                    // So we add a pattern that we immediately exclude again
+                    if (includeStrategy?.include.length === 0) {
+                        includeStrategy.include = ['/'];
+                        includeStrategy.exclude = ['/'];
+                    }
+                    // Strategy `exclude`: include everything, and then exclude all static paths
+                    const excludeStrategy = strategy === 'include'
+                        ? undefined
+                        : {
+                            include: ['/*'],
+                            exclude: deduplicatePatterns(staticPathList.concat(args?.routes?.exclude ?? [])),
+                        };
+                    const includeStrategyLength = includeStrategy
+                        ? includeStrategy.include.length + includeStrategy.exclude.length
+                        : Infinity;
+                    const excludeStrategyLength = excludeStrategy
+                        ? excludeStrategy.include.length + excludeStrategy.exclude.length
+                        : Infinity;
+                    const winningStrategy = includeStrategyLength <= excludeStrategyLength ? includeStrategy : excludeStrategy;
+                    await fs.promises.writeFile(new URL('./_routes.json', _config.outDir), JSON.stringify({
+                        version: 1,
+                        ...winningStrategy,
+                    }, null, 2));
+                }
+            },
+        },
+    };
+}

package/dist/util.d.ts

@@ -0,0 +1,2 @@
+export declare const isNode: boolean;
+export declare function getProcessEnvProxy(): {};

package/dist/util.js

@@ -0,0 +1,13 @@
+export const isNode = typeof process === 'object' && Object.prototype.toString.call(process) === '[object process]';
+export function getProcessEnvProxy() {
+    return new Proxy({}, {
+        get: (target, prop) => {
+            console.warn(
+            // NOTE: \0 prevents Vite replacement
+            `Unable to access \`import.meta\0.env.${prop.toString()}\` on initialization ` +
+                `as the Cloudflare platform only provides the environment variables per request. ` +
+                `Please move the environment variable access inside a function ` +
+                `that's only called after a request has been received.`);
+        },
+    });
+}

package/dist/utils/deduplicatePatterns.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Remove duplicates and redundant patterns from an `include` or `exclude` list.
+ * Otherwise Cloudflare will throw an error on deployment. Plus, it saves more entries.
+ * E.g. `['/foo/*', '/foo/*', '/foo/bar'] => ['/foo/*']`
+ * @param patterns a list of `include` or `exclude` patterns
+ * @returns a deduplicated list of patterns
+ */
+export declare function deduplicatePatterns(patterns: string[]): string[];

package/dist/utils/deduplicatePatterns.js

@@ -0,0 +1,23 @@
+/**
+ * Remove duplicates and redundant patterns from an `include` or `exclude` list.
+ * Otherwise Cloudflare will throw an error on deployment. Plus, it saves more entries.
+ * E.g. `['/foo/*', '/foo/*', '/foo/bar'] => ['/foo/*']`
+ * @param patterns a list of `include` or `exclude` patterns
+ * @returns a deduplicated list of patterns
+ */
+export function deduplicatePatterns(patterns) {
+    const openPatterns = [];
+    // A value in the set may only occur once; it is unique in the set's collection.
+    // ref: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Set
+    return [...new Set(patterns)]
+        .sort((a, b) => a.length - b.length)
+        .filter((pattern) => {
+        if (openPatterns.some((p) => p.test(pattern))) {
+            return false;
+        }
+        if (pattern.endsWith('*')) {
+            openPatterns.push(new RegExp(`^${pattern.replace(/(\*\/)*\*$/g, '.*')}`));
+        }
+        return true;
+    });
+}

package/dist/utils/getCFObject.d.ts

@@ -0,0 +1,2 @@
+import type { IncomingRequestCfProperties } from '@cloudflare/workers-types/experimental';
+export declare function getCFObject(runtimeMode: string): Promise<IncomingRequestCfProperties | void>;

package/dist/utils/getCFObject.js

@@ -0,0 +1,67 @@
+export async function getCFObject(runtimeMode) {
+    const CF_ENDPOINT = 'https://workers.cloudflare.com/cf.json';
+    const CF_FALLBACK = {
+        asOrganization: '',
+        asn: 395747,
+        colo: 'DFW',
+        city: 'Austin',
+        region: 'Texas',
+        regionCode: 'TX',
+        metroCode: '635',
+        postalCode: '78701',
+        country: 'US',
+        continent: 'NA',
+        timezone: 'America/Chicago',
+        latitude: '30.27130',
+        longitude: '-97.74260',
+        clientTcpRtt: 0,
+        httpProtocol: 'HTTP/1.1',
+        requestPriority: 'weight=192;exclusive=0',
+        tlsCipher: 'AEAD-AES128-GCM-SHA256',
+        tlsVersion: 'TLSv1.3',
+        tlsClientAuth: {
+            certPresented: '0',
+            certVerified: 'NONE',
+            certRevoked: '0',
+            certIssuerDN: '',
+            certSubjectDN: '',
+            certIssuerDNRFC2253: '',
+            certSubjectDNRFC2253: '',
+            certIssuerDNLegacy: '',
+            certSubjectDNLegacy: '',
+            certSerial: '',
+            certIssuerSerial: '',
+            certSKI: '',
+            certIssuerSKI: '',
+            certFingerprintSHA1: '',
+            certFingerprintSHA256: '',
+            certNotBefore: '',
+            certNotAfter: '',
+        },
+        edgeRequestKeepAliveStatus: 0,
+        hostMetadata: undefined,
+        clientTrustScore: 99,
+        botManagement: {
+            corporateProxy: false,
+            verifiedBot: false,
+            ja3Hash: '25b4882c2bcb50cd6b469ff28c596742',
+            staticResource: false,
+            detectionIds: [],
+            score: 99,
+        },
+    };
+    if (runtimeMode === 'local') {
+        return CF_FALLBACK;
+    }
+    else if (runtimeMode === 'remote') {
+        try {
+            const res = await fetch(CF_ENDPOINT);
+            const cfText = await res.text();
+            const storedCf = JSON.parse(cfText);
+            return storedCf;
+        }
+        catch (e) {
+            return CF_FALLBACK;
+        }
+    }
+}

package/dist/utils/parser.d.ts

@@ -0,0 +1,27 @@
+/**
+ * This file is a derivative work of wrangler by Cloudflare
+ * An upstream request for exposing this API was made here:
+ * https://github.com/cloudflare/workers-sdk/issues/3897
+ *
+ * Until further notice, we will be using this file as a workaround
+ * TODO: Tackle this file, once their is an decision on the upstream request
+ */
+import dotenv from 'dotenv';
+export interface DotEnv {
+    path: string;
+    parsed: dotenv.DotenvParseOutput;
+}
+/**
+ * Loads a dotenv file from <path>, preferring to read <path>.<environment> if
+ * <environment> is defined and that file exists.
+ */
+export declare function loadDotEnv(path: string): DotEnv | undefined;
+export declare function getEnvVars(): Promise<any>;
+export declare function getD1Bindings(): Promise<string[]>;
+export declare function getR2Bindings(): Promise<string[]>;
+export declare function getKVBindings(): Promise<string[]>;
+export declare function getDOBindings(): Record<string, {
+    scriptName?: string | undefined;
+    unsafeUniqueKey?: string | undefined;
+    className: string;
+}>;