@foldset/cloudflare 0.0.1 → 0.0.2

package/dist/index.d.ts

@@ -1,36 +1,7 @@
-import { Hono, type MiddlewareHandler } from 'hono';
-import { PaywallConfig, PaywallProvider, x402ResourceServer } from '@x402/hono';
-import type { RoutesConfig } from '@x402/core/http';
+import { Hono } from 'hono';
 type Env = {
     FOLDSET_API_KEY: string;
 };
-/**
- * Hono payment middleware for x402 protocol (direct server instance).
- *
- * Use this when you want to pass a pre-configured x402ResourceServer instance.
- * This provides more flexibility for testing, custom configuration, and reusing
- * server instances across multiple middlewares.
- *
- * @param routes - Route configurations for protected endpoints
- * @param server - Pre-configured x402ResourceServer instance
- * @param paywallConfig - Optional configuration for the built-in paywall UI
- * @param paywall - Optional custom paywall provider (overrides default)
- * @param syncFacilitatorOnStart - Whether to sync with the facilitator on startup (defaults to true)
- * @returns Hono middleware handler
- *
- * @example
- * ```typescript
- * import { paymentMiddleware } from "@x402/hono";
- * import { x402ResourceServer } from "@x402/core/server";
- * import { registerExactEvmScheme } from "@x402/evm/exact/server";
- *
- * const server = new x402ResourceServer(myFacilitatorClient);
- * registerExactEvmScheme(server, {});
- *
- * app.use(paymentMiddleware(routes, server, paywallConfig));
- * ```
- */
-export declare function paymentMiddleware(routes: RoutesConfig, server: x402ResourceServer, paywallConfig?: PaywallConfig, paywall?: PaywallProvider, syncFacilitatorOnStart?: boolean): MiddlewareHandler;
 declare const app: Hono<{
     Bindings: Env;
 }, import("hono/types").BlankSchema, "/">;

package/dist/index.js

@@ -3,9 +3,8 @@ import { Hono } from 'hono';
 import { x402ResourceServer, x402HTTPResourceServer } from '@x402/hono';
 import { registerExactEvmScheme } from '@x402/evm/exact/server';
 import { HTTPFacilitatorClient } from '@x402/core/server';
-import pMemoize from 'p-memoize';
 import { HonoAdapter } from './adapter';
-async function _fetchFoldsetAPI(endpoint, env) {
+async function fetchFoldsetAPI(endpoint, env) {
     const res = await fetch(`https://api.foldset.com/v1/${endpoint}`, {
         method: 'GET',
         headers: {
@@ -18,15 +17,6 @@ async function _fetchFoldsetAPI(endpoint, env) {
     }
     return (await res.json());
 }
-const cacheTTL = 60000; // 60 seconds
-// This is an in memory cache. Cloudflare also has a cache but it is not
-// in memory, so it would survive cold starts (this won't). I think in-memory
-// makes more sense here for now.
-// TODO rfradkin: Also make sure this caching works, didn't test it
-const fetchFoldsetAPI = pMemoize(_fetchFoldsetAPI, {
-    maxAge: cacheTTL,
-    cacheKey: ([endpoint]) => endpoint,
-});
 async function getRestrictions(env) {
     const restrictionList = await fetchFoldsetAPI('restrictions', env);
     const restrictions = {};
@@ -35,6 +25,7 @@ async function getRestrictions(env) {
     }
     return restrictions;
 }
+// TODO rfradkin: Should change to get addresses...
 async function getEVMAddress(env) {
     const data = await fetchFoldsetAPI('get-address', env);
     return data.address;
@@ -63,7 +54,9 @@ let server = null;
 // Right now, load times are like 800ms, which is pretty slow since
 // static site is 200ms. Look into later, this call probably takes most of the time.
 // This is like this cause can'd do async calls at module level in cloudflare
-function getServer() {
+async function getHttpServer(routes, env) {
+    // At some point allow users to dynamically choose facilitator
+    // Setup endpoint for that
     if (!server) {
         // TODO rfradkin: Hard coded for now but consider making it configurable
         const facilitatorClient = new HTTPFacilitatorClient({
@@ -72,153 +65,86 @@ function getServer() {
         server = new x402ResourceServer(facilitatorClient);
         registerExactEvmScheme(server);
     }
-    return server;
-}
-/**
- * Hono payment middleware for x402 protocol (direct server instance).
- *
- * Use this when you want to pass a pre-configured x402ResourceServer instance.
- * This provides more flexibility for testing, custom configuration, and reusing
- * server instances across multiple middlewares.
- *
- * @param routes - Route configurations for protected endpoints
- * @param server - Pre-configured x402ResourceServer instance
- * @param paywallConfig - Optional configuration for the built-in paywall UI
- * @param paywall - Optional custom paywall provider (overrides default)
- * @param syncFacilitatorOnStart - Whether to sync with the facilitator on startup (defaults to true)
- * @returns Hono middleware handler
- *
- * @example
- * ```typescript
- * import { paymentMiddleware } from "@x402/hono";
- * import { x402ResourceServer } from "@x402/core/server";
- * import { registerExactEvmScheme } from "@x402/evm/exact/server";
- *
- * const server = new x402ResourceServer(myFacilitatorClient);
- * registerExactEvmScheme(server, {});
- *
- * app.use(paymentMiddleware(routes, server, paywallConfig));
- * ```
- */
-export function paymentMiddleware(routes, server, paywallConfig, paywall, syncFacilitatorOnStart = true) {
-    // Create the x402 HTTP server instance with the resource server
     const httpServer = new x402HTTPResourceServer(server, routes);
-    // Register custom paywall provider if provided
-    if (paywall) {
-        httpServer.registerPaywallProvider(paywall);
-    }
-    // Store initialization promise (not the result)
-    // httpServer.initialize() fetches facilitator support and validates routes
-    let initPromise = syncFacilitatorOnStart ? httpServer.initialize() : null;
-    // TODO rfradkin: Add bazaar extension
-    // // Dynamically register bazaar extension if routes declare it
-    // let bazaarPromise: Promise<void> | null = null;
-    // if (checkIfBazaarNeeded(routes)) {
-    //   bazaarPromise = import("@x402/extensions/bazaar")
-    //     .then(({ bazaarResourceServerExtension }) => {
-    //       server.registerExtension(bazaarResourceServerExtension);
-    //     })
-    //     .catch(err => {
-    //       console.error("Failed to load bazaar extension:", err);
-    //     });
-    // }
-    return async (c, next) => {
-        // Create adapter and context
-        const adapter = new HonoAdapter(c);
-        const context = {
-            adapter,
-            path: c.req.path,
-            method: c.req.method,
-            paymentHeader: adapter.getHeader("payment-signature") || adapter.getHeader("x-payment"),
-        };
-        // Check if route requires payment before initializing facilitator
-        if (!httpServer.requiresPayment(context)) {
-            return next();
-        }
-        // Only initialize when processing a protected route
-        if (initPromise) {
-            await initPromise;
-            initPromise = null; // Clear after first await
-        }
-        // // Await bazaar extension loading if needed
-        // if (bazaarPromise) {
-        //   await bazaarPromise;
-        //   bazaarPromise = null;
-        // }
-        // Process payment requirement check
-        const result = await httpServer.processHTTPRequest(context, paywallConfig);
-        // Handle the different result types
-        switch (result.type) {
-            case "no-payment-required":
-                // No payment needed, proceed directly to the route handler
-                return next();
-            case "payment-error":
-                // Payment required but not provided or invalid
-                const { response } = result;
-                Object.entries(response.headers).forEach(([key, value]) => {
-                    c.header(key, value);
-                });
-                if (response.isHtml) {
-                    return c.html(response.body, response.status);
-                }
-                else {
-                    return c.json(response.body || {}, response.status);
-                }
-            case "payment-verified":
-                // Payment is valid, need to wrap response for settlement
-                const { paymentPayload, paymentRequirements } = result;
-                // Proceed to the next middleware or route handler
-                await next();
-                // Get the current response
-                let res = c.res;
-                // If the response from the protected route is >= 400, do not settle payment
-                if (res.status >= 400) {
-                    return;
-                }
-                // Clear the response so we can modify headers
-                c.res = undefined;
-                try {
-                    const settleResult = await httpServer.processSettlement(paymentPayload, paymentRequirements);
-                    if (!settleResult.success) {
-                        // Settlement failed - do not return the protected resource
-                        res = c.json({
-                            error: "Settlement failed",
-                            details: settleResult.errorReason,
-                        }, 402);
-                    }
-                    else {
-                        // Settlement succeeded - add headers to response
-                        Object.entries(settleResult.headers).forEach(([key, value]) => {
-                            res.headers.set(key, value);
-                        });
-                    }
-                }
-                catch (error) {
-                    console.error(error);
-                    // If settlement fails, return an error response
-                    res = c.json({
-                        error: "Settlement failed",
-                        details: error instanceof Error ? error.message : "Unknown error",
-                    }, 402);
-                }
-                // Restore the response (potentially modified with settlement headers)
-                c.res = res;
-                return;
-        }
-    };
+    await httpServer.initialize();
+    return httpServer;
 }
 const app = new Hono();
 // TODO rfradkin: This is still potentially quite slow since it is getting
 // each of these on each request regardless of whether the request is in
 // the restrictions or not. Should find a better solution down the road
 app.use('*', async (c, next) => {
-    const [restrictions, payTo, server] = await Promise.all([
+    const [restrictions, payTo] = await Promise.all([
         getRestrictions(c.env),
         getEVMAddress(c.env),
-        getServer(),
     ]);
-    const config = buildRoutesConfig(restrictions, payTo);
-    return paymentMiddleware(config, server)(c, next);
+    const routes = buildRoutesConfig(restrictions, payTo);
+    const httpServer = await getHttpServer(routes, c.env);
+    const adapter = new HonoAdapter(c);
+    const context = {
+        adapter,
+        path: c.req.path,
+        method: c.req.method,
+        paymentHeader: adapter.getHeader("payment-signature") || adapter.getHeader("x-payment"),
+    };
+    if (!httpServer.requiresPayment(context)) {
+        return next();
+    }
+    const result = await httpServer.processHTTPRequest(context);
+    switch (result.type) {
+        case "no-payment-required":
+            return next();
+        case "payment-error":
+            // Payment required but not provided or invalid
+            const { response } = result;
+            Object.entries(response.headers).forEach(([key, value]) => {
+                c.header(key, value);
+            });
+            if (response.isHtml) {
+                return c.html(response.body, response.status);
+            }
+            else {
+                return c.json(response.body || {}, response.status);
+            }
+        case "payment-verified":
+            // Payment is valid, need to wrap response for settlement
+            const { paymentPayload, paymentRequirements } = result;
+            await next();
+            let res = c.res;
+            // If the response from the protected route is >= 400, do not settle payment
+            if (res.status >= 400) {
+                return;
+            }
+            // Clear the response so we can modify headers
+            c.res = undefined;
+            try {
+                const settleResult = await httpServer.processSettlement(paymentPayload, paymentRequirements);
+                if (!settleResult.success) {
+                    // Settlement failed - do not return the protected resource
+                    res = c.json({
+                        error: "Settlement failed",
+                        details: settleResult.errorReason,
+                    }, 402);
+                }
+                else {
+                    // Settlement succeeded - add headers to response
+                    Object.entries(settleResult.headers).forEach(([key, value]) => {
+                        res.headers.set(key, value);
+                    });
+                }
+            }
+            catch (error) {
+                console.error(error);
+                // If settlement fails, return an error response
+                res = c.json({
+                    error: "Settlement failed",
+                    details: error instanceof Error ? error.message : "Unknown error",
+                }, 402);
+            }
+            // Restore the response (potentially modified with settlement headers)
+            c.res = res;
+            return;
+    }
 });
 app.all('*', async (c) => {
     const req = c.req.raw;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@foldset/cloudflare",
-  "version": "0.0.1",
+  "version": "0.0.2",
   "description": "SDK for creating Foldset-enabled Cloudflare Workers",
   "type": "module",
   "main": "./dist/index.js",