@astrojs/cloudflare 0.0.0-404-fix-20231115224256

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/image-config.d.ts

@@ -0,0 +1,12 @@
+import type { AstroConfig, AstroIntegrationLogger } from 'astro';
+export declare function prepareImageConfig(service: string, config: AstroConfig['image'], command: 'dev' | 'build' | 'preview', logger: AstroIntegrationLogger): {
+    service: import("astro").ImageServiceConfig<Record<string, any>>;
+    domains: string[];
+    remotePatterns: {
+        protocol?: string | undefined;
+        hostname?: string | undefined;
+        port?: string | undefined;
+        pathname?: string | undefined;
+    }[];
+    endpoint?: string | undefined;
+};

package/dist/utils/image-config.js

@@ -0,0 +1,21 @@
+import { passthroughImageService, sharpImageService } from 'astro/config';
+export function prepareImageConfig(service, config, command, logger) {
+    switch (service) {
+        case 'passthrough':
+            return { ...config, service: passthroughImageService() };
+        case 'cloudflare':
+            return {
+                ...config,
+                service: command === 'dev'
+                    ? sharpImageService()
+                    : { entrypoint: '@astrojs/cloudflare/image-service' },
+            };
+        default:
+            if (config.service.entrypoint === 'astro/assets/services/sharp' ||
+                config.service.entrypoint === 'astro/assets/services/squoosh') {
+                logger.warn(`The current configuration does not support image optimization. To allow your project to build with the original, unoptimized images, the image service has been automatically switched to the 'noop' option. See https://docs.astro.build/en/reference/configuration-reference/#imageservice`);
+                return { ...config, service: passthroughImageService() };
+            }
+            return { ...config };
+    }
+}

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;
+}>;

package/dist/utils/parser.js

@@ -0,0 +1,149 @@
+/**
+ * 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 TOML from '@iarna/toml';
+import dotenv from 'dotenv';
+import { findUpSync } from 'find-up';
+import * as fs from 'node:fs';
+import { dirname, resolve } from 'node:path';
+let _wrangler;
+function findWranglerToml(referencePath = process.cwd(), preferJson = false) {
+    if (preferJson) {
+        return (findUpSync(`wrangler.json`, { cwd: referencePath }) ??
+            findUpSync(`wrangler.toml`, { cwd: referencePath }));
+    }
+    return findUpSync(`wrangler.toml`, { cwd: referencePath });
+}
+class ParseError extends Error {
+    text;
+    notes;
+    location;
+    kind;
+    constructor({ text, notes, location, kind }) {
+        super(text);
+        this.name = this.constructor.name;
+        this.text = text;
+        this.notes = notes ?? [];
+        this.location = location;
+        this.kind = kind ?? 'error';
+    }
+}
+const TOML_ERROR_NAME = 'TomlError';
+const TOML_ERROR_SUFFIX = ' at row ';
+function parseTOML(input, file) {
+    try {
+        // Normalize CRLF to LF to avoid hitting https://github.com/iarna/iarna-toml/issues/33.
+        const normalizedInput = input.replace(/\r\n/g, '\n');
+        return TOML.parse(normalizedInput);
+    }
+    catch (err) {
+        const { name, message, line, col } = err;
+        if (name !== TOML_ERROR_NAME) {
+            throw err;
+        }
+        const text = message.substring(0, message.lastIndexOf(TOML_ERROR_SUFFIX));
+        const lineText = input.split('\n')[line];
+        const location = {
+            lineText,
+            line: line + 1,
+            column: col - 1,
+            file,
+            fileText: input,
+        };
+        throw new ParseError({ text, location });
+    }
+}
+function tryLoadDotEnv(path) {
+    try {
+        const parsed = dotenv.parse(fs.readFileSync(path));
+        return { path, parsed };
+    }
+    catch (e) {
+        // logger.debug(`Failed to load .env file "${path}":`, e);
+    }
+}
+/**
+ * Loads a dotenv file from <path>, preferring to read <path>.<environment> if
+ * <environment> is defined and that file exists.
+ */
+export function loadDotEnv(path) {
+    return tryLoadDotEnv(path);
+}
+function getVarsForDev(config, configPath) {
+    const configDir = resolve(dirname(configPath ?? '.'));
+    const devVarsPath = resolve(configDir, '.dev.vars');
+    const loaded = loadDotEnv(devVarsPath);
+    if (loaded !== undefined) {
+        return {
+            ...config.vars,
+            ...loaded.parsed,
+        };
+    }
+    else {
+        return config.vars;
+    }
+}
+function parseConfig() {
+    if (_wrangler)
+        return _wrangler;
+    let rawConfig;
+    const configPath = findWranglerToml(process.cwd(), false); // false = args.experimentalJsonConfig
+    if (!configPath) {
+        throw new Error('Could not find wrangler.toml');
+    }
+    // Load the configuration from disk if available
+    if (configPath?.endsWith('toml')) {
+        rawConfig = parseTOML(fs.readFileSync(configPath).toString(), configPath);
+    }
+    _wrangler = { rawConfig, configPath };
+    return { rawConfig, configPath };
+}
+export async function getEnvVars() {
+    const { rawConfig, configPath } = parseConfig();
+    const vars = getVarsForDev(rawConfig, configPath);
+    return vars;
+}
+export async function getD1Bindings() {
+    const { rawConfig } = parseConfig();
+    if (!rawConfig)
+        return [];
+    if (!rawConfig?.d1_databases)
+        return [];
+    const bindings = (rawConfig?.d1_databases).map((binding) => binding.binding);
+    return bindings;
+}
+export async function getR2Bindings() {
+    const { rawConfig } = parseConfig();
+    if (!rawConfig)
+        return [];
+    if (!rawConfig?.r2_buckets)
+        return [];
+    const bindings = (rawConfig?.r2_buckets).map((binding) => binding.binding);
+    return bindings;
+}
+export async function getKVBindings() {
+    const { rawConfig } = parseConfig();
+    if (!rawConfig)
+        return [];
+    if (!rawConfig?.kv_namespaces)
+        return [];
+    const bindings = (rawConfig?.kv_namespaces).map((binding) => binding.binding);
+    return bindings;
+}
+export function getDOBindings() {
+    const { rawConfig } = parseConfig();
+    if (!rawConfig)
+        return {};
+    if (!rawConfig?.durable_objects)
+        return {};
+    const output = new Object({});
+    for (const binding of rawConfig?.durable_objects.bindings) {
+        Reflect.set(output, binding.name, { className: binding.class_name });
+    }
+    return output;
+}

package/dist/utils/prependForwardSlash.d.ts

@@ -0,0 +1 @@
+export declare function prependForwardSlash(path: string): string;

package/dist/utils/prependForwardSlash.js

@@ -0,0 +1,3 @@
+export function prependForwardSlash(path) {
+    return path[0] === '/' ? path : '/' + path;
+}

package/dist/utils/rewriteWasmImportPath.d.ts

@@ -0,0 +1,8 @@
+import esbuild from 'esbuild';
+/**
+ *
+ * @param relativePathToAssets - relative path from the final location for the current esbuild output bundle, to the assets directory.
+ */
+export declare function rewriteWasmImportPath({ relativePathToAssets, }: {
+    relativePathToAssets: string;
+}): esbuild.Plugin;

package/dist/utils/rewriteWasmImportPath.js

@@ -0,0 +1,23 @@
+import esbuild from 'esbuild';
+import { basename } from 'node:path';
+/**
+ *
+ * @param relativePathToAssets - relative path from the final location for the current esbuild output bundle, to the assets directory.
+ */
+export function rewriteWasmImportPath({ relativePathToAssets, }) {
+    return {
+        name: 'wasm-loader',
+        setup(build) {
+            build.onResolve({ filter: /.*\.wasm.mjs$/ }, (args) => {
+                const updatedPath = [
+                    relativePathToAssets.replaceAll('\\', '/'),
+                    basename(args.path).replace(/\.mjs$/, ''),
+                ].join('/');
+                return {
+                    path: updatedPath,
+                    external: true, // mark it as external in the bundle
+                };
+            });
+        },
+    };
+}

package/dist/utils/wasm-module-loader.d.ts

@@ -0,0 +1,14 @@
+import { type Plugin } from 'vite';
+/**
+ * Loads '*.wasm?module' imports as WebAssembly modules, which is the only way to load WASM in cloudflare workers.
+ * Current proposal for WASM modules: https://github.com/WebAssembly/esm-integration/tree/main/proposals/esm-integration
+ * Cloudflare worker WASM from javascript support: https://developers.cloudflare.com/workers/runtime-apis/webassembly/javascript/
+ * @param disabled - if true throws a helpful error message if wasm is encountered and wasm imports are not enabled,
+ * 								otherwise it will error obscurely in the esbuild and vite builds
+ * @param assetsDirectory - the folder name for the assets directory in the build directory. Usually '_astro'
+ * @returns Vite plugin to load WASM tagged with '?module' as a WASM modules
+ */
+export declare function wasmModuleLoader({ disabled, assetsDirectory, }: {
+    disabled: boolean;
+    assetsDirectory: string;
+}): Plugin;

package/dist/utils/wasm-module-loader.js

@@ -0,0 +1,101 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import {} from 'vite';
+/**
+ * Loads '*.wasm?module' imports as WebAssembly modules, which is the only way to load WASM in cloudflare workers.
+ * Current proposal for WASM modules: https://github.com/WebAssembly/esm-integration/tree/main/proposals/esm-integration
+ * Cloudflare worker WASM from javascript support: https://developers.cloudflare.com/workers/runtime-apis/webassembly/javascript/
+ * @param disabled - if true throws a helpful error message if wasm is encountered and wasm imports are not enabled,
+ * 								otherwise it will error obscurely in the esbuild and vite builds
+ * @param assetsDirectory - the folder name for the assets directory in the build directory. Usually '_astro'
+ * @returns Vite plugin to load WASM tagged with '?module' as a WASM modules
+ */
+export function wasmModuleLoader({ disabled, assetsDirectory, }) {
+    const postfix = '.wasm?module';
+    let isDev = false;
+    return {
+        name: 'vite:wasm-module-loader',
+        enforce: 'pre',
+        configResolved(config) {
+            isDev = config.command === 'serve';
+        },
+        config(_, __) {
+            // let vite know that file format and the magic import string is intentional, and will be handled in this plugin
+            return {
+                assetsInclude: ['**/*.wasm?module'],
+                build: { rollupOptions: { external: /^__WASM_ASSET__.+\.wasm\.mjs$/i } },
+            };
+        },
+        load(id, _) {
+            if (!id.endsWith(postfix)) {
+                return;
+            }
+            if (disabled) {
+                throw new Error(`WASM module's cannot be loaded unless you add \`wasmModuleImports: true\` to your astro config.`);
+            }
+            const filePath = id.slice(0, -1 * '?module'.length);
+            const data = fs.readFileSync(filePath);
+            const base64 = data.toString('base64');
+            const base64Module = `
+const wasmModule = new WebAssembly.Module(Uint8Array.from(atob("${base64}"), c => c.charCodeAt(0)));
+export default wasmModule
+`;
+            if (isDev) {
+                // no need to wire up the assets in dev mode, just rewrite
+                return base64Module;
+            }
+            else {
+                // just some shared ID
+                let hash = hashString(base64);
+                // emit the wasm binary as an asset file, to be picked up later by the esbuild bundle for the worker.
+                // give it a shared deterministic name to make things easy for esbuild to switch on later
+                const assetName = path.basename(filePath).split('.')[0] + '.' + hash + '.wasm';
+                this.emitFile({
+                    type: 'asset',
+                    // put it explicitly in the _astro assets directory with `fileName` rather than `name` so that
+                    // vite doesn't give it a random id in its name. We need to be able to easily rewrite from
+                    // the .mjs loader and the actual wasm asset later in the ESbuild for the worker
+                    fileName: path.join(assetsDirectory, assetName),
+                    source: fs.readFileSync(filePath),
+                });
+                // however, by default, the SSG generator cannot import the .wasm as a module, so embed as a base64 string
+                const chunkId = this.emitFile({
+                    type: 'prebuilt-chunk',
+                    fileName: assetName + '.mjs',
+                    code: base64Module,
+                });
+                return `
+import wasmModule from "__WASM_ASSET__${chunkId}.wasm.mjs";
+export default wasmModule;
+	`;
+            }
+        },
+        // output original wasm file relative to the chunk
+        renderChunk(code, chunk, _) {
+            if (isDev)
+                return;
+            if (!/__WASM_ASSET__/g.test(code))
+                return;
+            const final = code.replaceAll(/__WASM_ASSET__([a-z\d]+).wasm.mjs/g, (s, assetId) => {
+                const fileName = this.getFileName(assetId);
+                const relativePath = path
+                    .relative(path.dirname(chunk.fileName), fileName)
+                    .replaceAll('\\', '/'); // fix windows paths for import
+                return `./${relativePath}`;
+            });
+            return { code: final };
+        },
+    };
+}
+/**
+ * Returns a deterministic 32 bit hash code from a string
+ */
+function hashString(str) {
+    let hash = 0;
+    for (let i = 0; i < str.length; i++) {
+        const char = str.charCodeAt(i);
+        hash = (hash << 5) - hash + char;
+        hash &= hash; // Convert to 32bit integer
+    }
+    return new Uint32Array([hash])[0].toString(36);
+}

package/package.json

@@ -0,0 +1,65 @@
+{
+  "//comment": "test changeset-bot",
+  "name": "@astrojs/cloudflare",
+  "description": "Deploy your site to Cloudflare Workers/Pages",
+  "version": "0.0.0-404-fix-20231115224256",
+  "type": "module",
+  "types": "./dist/index.d.ts",
+  "author": "withastro",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/withastro/adapters.git",
+    "directory": "packages/cloudflare"
+  },
+  "keywords": [
+    "withastro",
+    "astro-adapter"
+  ],
+  "bugs": "https://github.com/withastro/adapters/issues",
+  "homepage": "https://docs.astro.build/en/guides/integrations-guide/cloudflare/",
+  "exports": {
+    ".": "./dist/index.js",
+    "./entrypoints/server.advanced.js": "./dist/entrypoints/server.advanced.js",
+    "./entrypoints/server.directory.js": "./dist/entrypoints/server.directory.js",
+    "./image-service": "./dist/entrypoints/image-service.js",
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "@astrojs/underscore-redirects": "^0.3.3",
+    "@cloudflare/workers-types": "^4.20231025.0",
+    "miniflare": "3.20231025.1",
+    "@iarna/toml": "^2.2.5",
+    "dotenv": "^16.3.1",
+    "esbuild": "^0.19.5",
+    "find-up": "^6.3.0",
+    "tiny-glob": "^0.2.9",
+    "vite": "^4.5.0"
+  },
+  "peerDependencies": {
+    "astro": "^3.4.3"
+  },
+  "devDependencies": {
+    "execa": "^8.0.1",
+    "fast-glob": "^3.3.1",
+    "@types/iarna__toml": "^2.0.2",
+    "strip-ansi": "^7.1.0",
+    "astro": "^3.4.3",
+    "chai": "^4.3.10",
+    "cheerio": "1.0.0-rc.12",
+    "mocha": "^10.2.0",
+    "wrangler": "^3.15.0",
+    "@astrojs/test-utils": "0.0.1"
+  },
+  "publishConfig": {
+    "provenance": true
+  },
+  "scripts": {
+    "build": "tsc",
+    "test": "mocha --exit --timeout 30000 test/",
+    "test:match": "mocha --exit --timeout 30000 -g"
+  }
+}