import { BasicWorker, TextResponse } from "@adonix.org/cloud-spark";

class HelloWorld extends BasicWorker {
    get() {
        return this.response(TextResponse, "Hi from Cloud Spark!");
    }
}

export default HelloWorld.ignite();

import { BasicWorker, JsonResponse, Method, POST, TextResponse } from "@adonix.org/cloud-spark";

/**
 * To access the Cloudflare runtime properties:
 *   • this.request — the incoming Request
 *   • this.env — environment bindings (KV, R2, etc.)
 *   • this.ctx — the execution context for background tasks
 */
export class MyWorker extends BasicWorker {
    /**
     * Override to allow additional method support for the worker.
     * GET and HEAD requests are always allowed.
     *
     * Default: GET, HEAD, OPTIONS
     *
     * For OPTIONS requests, the default response is:
     *     204 No Content
     *     "Allow" response header contains all allowed methods.
     *
     * If a requested method is not listed, the response is:
     *     405 Method Not Allowed
     *
     * If an allowed method is not implemented, the response is:
     *     GET or HEAD: 404 Not Found
     *     All other methods: 501 Not Implemented
     *
     * This example adds POST method support to the defaults.
     */
    public override getAllowedMethods(): Method[] {
        return [...super.getAllowedMethods(), POST];
    }

    /**
     * Example handler for GET requests that returns a simple
     * text response.
     */
    protected override get(): Promise<Response> {
        return this.response(TextResponse, "Hello from Cloud Spark!");
    }

    /**
     * Example handler for POST requests that echoes the
     * incoming JSON.
     */
    protected override async post(): Promise<Response> {
        const json = await this.request.json();
        // Do something with the request JSON.

        return this.response(JsonResponse, json);
    }

    /**
     * Supported BasicWorker request methods:
     *    protected override get(): Promise<Response>
     *    protected override put(): Promise<Response>
     *    protected override post(): Promise<Response>
     *    protected override patch(): Promise<Response>
     *    protected override delete(): Promise<Response>
     *
     * Implementations are provided but can be overridden for:
     *    protected override head(): Promise<Response>
     *    protected override options(): Promise<Response>
     */
}

/**
 * Connects this worker to the Cloudflare runtime.
 */
export default MyWorker.ignite();

import { BasicWorker, GET, PathParams, RouteWorker, TextResponse } from "@adonix.org/cloud-spark";

/**
 * An example worker with path routing.
 */
class GreetingWorker extends RouteWorker {
    /**
     * Called before request processing to enable worker
     * initialization without overriding the constructor.
     */
    protected override init(): void {
        /**
         * Example of path-to-regexp and local method routing.
         */
        this.route(GET, "/hello/:name", this.hello);

        /**
         * Example of simple path to a nested worker.
         */
        this.route(GET, "/goodbye", GoodbyeWorker);
    }

    /**
     * Path parameters are provided via path-to-regexp parsing
     * of the request path.
     *
     * For example, http://localhost:8787/hello/Inigo will yield
     * the text response "Hello Inigo!"
     */
    protected hello(params: PathParams): Promise<Response> {
        return this.response(TextResponse, `Hello ${params["name"]}!`);
    }
}

/**
 * An example nested BasicWorker.
 *
 * The original request, env, and ctx are passed to the nested
 * worker via the constructor.
 *
 * RouteWorkers may also be nested to access path parameters.
 */
class GoodbyeWorker extends BasicWorker {
    /**
     * GET handler for the "/goodbye" path.
     */
    protected override get(): Promise<Response> {
        return this.response(TextResponse, "Goodbye!");
    }
}

/**
 * Connects GreetingWorker to the Cloudflare runtime.
 */
export default GreetingWorker.ignite();

import { BasicWorker, cors } from "@adonix.org/cloud-spark";

class MyWorker extends BasicWorker {
    /**
     * Register middleware in the init method.
     */
    protected override init(): void {
        /**
         * Create and register the built-in CORS middleware
         * with default options:
         *
         * {
         *   allowedOrigins: ["*"],
         *   allowedHeaders: ["Content-Type"],
         *   exposedHeaders: [],
         *   allowCredentials: false,
         *   maxAge: 300,
         * }
         *
         */
        this.use(cors());

        /**
         * To override specific default CORS options:
         *
         * this.use(cors({ allowedOrigins: ["https://www.adonix.org"], maxAge: 604800 }));
         *
         */
    }
}

import { BasicWorker, cache, CacheControl, JsonResponse, Time } from "@adonix.org/cloud-spark";

class MyWorker extends BasicWorker {
    /**
     * Enable middleware in the worker init method.
     */
    protected override init(): void {
        /**
         * Create and register the built-in cache middleware.
         */
        this.use(cache());

        /**
         * Optionally pass settings to the cache function:
         *
         * 	name — the name of the cache storage to use. If omitted,
         *         the default cache is used.
         *  getKey — a function that maps the incoming request to a
         *           cache key.
         *           Built-in key functions include:
         *               • sortSearchParams (Default)
         *               • stripSearchParams
         *
         * this.use(cache({
         *     name: "my-cache",
         *     getKey: stripSearchParams,
         * }));
         *
         */
    }

    /**
     * Create a cacheable response.
     */
    protected override get(): Promise<Response> {
        /**
         * Example JSON message.
         */
        const json = {
            message: "Hi from Cloud Spark!",
            timestamp: new Date().toLocaleString(),
        };

        /**
         * Cache the response for 10 seconds.
         */
        const cc: CacheControl = {
            "s-maxage": 10 * Time.Second,
        };

        return this.response(JsonResponse, json, cc);
    }
}

/**
 * Connects MyWorker to the Cloudflare runtime.
 */
export default MyWorker.ignite();

import { GET, PathParams, RouteWorker, websocket } from "@adonix.org/cloud-spark";

class ChatWorker extends RouteWorker {
    /**
     * Register both the upgrade route and middleware.
     */
    protected override init(): void {
        /**
         * Route for WebSocket upgrades.
         */
        this.route(GET, "/chat/:room", this.upgrade);

        /**
         * Register WebSocket middleware to match the
         * upgrade route.
         */
        this.use(websocket("/chat/:room"));
    }

    /**
     * Handles WebSocket upgrade requests.
     *
     * Expects a DurableObject binding named CHAT
     * in wrangler.jsonc
     */
    protected upgrade(params: PathParams): Promise<Response> {
        const room = params["room"];
        const chat = this.env.CHAT;

        /**
         * Request has already been validated by the
         * WebSocket middleware.
         */
        return chat.get(chat.idFromName(room)).fetch(this.request);
    }
}

/**
 * Connects ChatWorker to the Cloudflare runtime.
 */
export default ChatWorker.ignite();

import { BadRequest, CopyResponse, Middleware, Worker } from "@adonix.org/cloud-spark";

/**
 * Custom middleware example.
 *
 * Demonstrates several key middleware capabilities:
 *   • Options via constructor parameters.
 *   • Inspection of the incoming request.
 *   • Short-circuiting by returning a response directly.
 *   • Modifying outgoing responses dispatched by the worker.
 */
class PoweredBy implements Middleware {
    /**
     * Optional constructor parameter to customize the "X-Powered-By" header.
     */
    constructor(private readonly name = "CloudSpark") {}

    public async handle(worker: Worker, next: () => Promise<Response>): Promise<Response> {
        /**
         * Extract the User-Agent header from the request.
         */
        const userAgent = worker.request.headers.get("User-Agent")?.trim();

        /**
         * If the User-Agent is missing, short-circuit by directly
         * returning 400 Bad Request.
         */
        if (!userAgent) {
            return new BadRequest(`Missing User-Agent`).response();
        }

        /**
         * Calls the next middleware or worker dispatch method.
         */
        const response = await next();

        /**
         * Wrap the response in a mutable copy.
         */
        const copy = new CopyResponse(response);

        /**
         * Append custom headers to the response.
         */
        copy.setHeader("X-User-Agent", userAgent);
        copy.setHeader("X-Powered-By", this.name);
        copy.setHeader("X-Processed-At", new Date().toUTCString());

        /**
         * Return the modified response.
         */
        return copy.response();
    }
}

/**
 * Factory function for registering the middleware, with an optional
 * name parameter. Workers interact with the `Middleware` interface,
 * and not the concrete implementation.
 *
 * Example:
 *   this.use(poweredby());
 *   this.use(poweredby("My Project Name"));
 */
export function poweredby(name?: string): Middleware {
    return new PoweredBy(name);
}