@jon49/sw 0.13.3 → 0.14.0

package/lib/htmf.middleware.ts

@@ -0,0 +1,37 @@
+import { SwResponse } from "./sw-framework.js"
+
+function isHtmf(req: Request) {
+    return req.headers.has("HF-Request")
+}
+
+function htmfHeader(events: any = {}, messages: string[] = []) : Record<string, string> {
+    let userMessages =
+        messages?.length > 0
+            ? { "user-messages": messages }
+            : null
+    return {
+        "hf-events": JSON.stringify({
+            ...userMessages,
+            ...(events || {})
+        }) ?? "{}"
+    }
+}
+
+export function useHtmf(req: Request, res: SwResponse, ctx: any): void {
+    if (!isHtmf(req)) return
+
+    let messages = ctx.messages || []
+    if (res.error) {
+        messages.push(res.error)
+        res.error = undefined
+    }
+
+    let headers = htmfHeader(ctx.events, ctx.messages)
+
+    Object.assign(res, {
+        headers: {
+            ...res.headers,
+            ...headers,
+        }
+    })
+}

package/lib/response.middleware.ts

@@ -0,0 +1,60 @@
+import { isHtml } from "./utils.js"
+
+const encoder = new TextEncoder()
+function streamResponse(response: { body: Generator, headers?: any }): Response {
+    let { body, headers } = response
+    const stream = new ReadableStream({
+        async start(controller: ReadableStreamDefaultController<any>) {
+            try {
+                for await (let x of body) {
+                    if (typeof x === "string")
+                        controller.enqueue(encoder.encode(x))
+                }
+                controller.close()
+            } catch (error) {
+                console.error(error)
+            }
+        }
+    })
+
+    return new Response(stream, {
+        headers: {
+            "content-type": "text/html; charset=utf-8",
+            ...headers,
+        }
+    })
+}
+
+export function useResponse(_: Request, res: any, __: any) : void {
+    if (isHtml(res.body)) {
+        Object.assign(res, { response: streamResponse(res) })
+        return
+    }
+
+    if (res.error) {
+        Object.assign(res, {
+            response: new Response(res.error, {
+                status: 500,
+                headers: {
+                    "content-type": "text/plain; charset=utf-8",
+                }
+            })
+        })
+    }
+
+    if (res.response) {
+        return res.response
+    }
+
+    if (res.body) {
+        Object.assign(res, {
+            response: new Response(res.body, {
+                status: res.status || 200,
+                headers: {
+                    "content-type": res.type || "text/plain; charset=utf-8",
+                    ...res.headers,
+                }
+            })
+        })
+    }
+}

package/lib/{routes.ts → routes.middleware.ts}

@@ -1,3 +1,6 @@
+import { SwResponse } from "./sw-framework.js"
+import { isHtml } from "./utils.js"
+
 let { links, globalDb } =
     // @ts-ignore
     self.app as { links: { file: string, url: string }[], html: Function, db: any, globalDb: any }
@@ -29,48 +32,18 @@ interface ResponseOptions {
 
 export let options: ResponseOptions = {}
 
-// Test if value is Async Generator
-let isHtml = (value: any) =>
-    value?.next instanceof Function
-    && value.throw instanceof Function
-
 // @ts-ignore
-export async function getResponse(event: FetchEvent): Promise<Response> {
+export async function useRoutes(req: Request, res: SwResponse, ctx: any): Promise<void> {
     try {
-        const req: Request = event.request
         const url = normalizeUrl(req.url)
-        return (
-            !url.pathname.startsWith("/web/")
-                ? fetch(req)
-                : executeHandler({ url, req, event }))
+        if (!url.pathname.startsWith("/web/")) {
+            res.response = await fetch(req)
+        } else {
+            Object.assign(res, await executeHandler({ url, req, ctx }))
+        }
     } catch (error) {
         console.error("Get Response Error", error)
-        return new Response("Oops something happened which shouldn't have!")
-    }
-}
-
-function getErrors(errors: any): string[] {
-    return typeof errors === "string"
-        ? [errors]
-        : call(options.handleErrors, errors) ?? []
-}
-
-function isHtmf(req: Request) {
-    return req.headers.has("HF-Request")
-}
-
-function htmfHeader(req: Request, events: any = {}, messages: string[] = [])
-    : Record<string, string> {
-    if (!isHtmf(req)) return {}
-    let userMessages =
-        messages?.length > 0
-            ? { "user-messages": messages }
-            : null
-    return {
-        "hf-events": JSON.stringify({
-            ...userMessages,
-            ...(events || {})
-        }) ?? "{}"
+        res.error = "Oops something happened which shouldn't have!"
     }
 }
 
@@ -139,15 +112,14 @@ export async function findRoute(url: URL, method: unknown) {
 interface ExectuteHandlerOptions {
     url: URL
     req: Request
-    // @ts-ignore
-    event: FetchEvent
+    ctx: any
 }
-async function executeHandler({ url, req, event }: ExectuteHandlerOptions): Promise<Response> {
+async function executeHandler({ url, req, ctx }: ExectuteHandlerOptions): Promise<SwResponse> {
     let method = req.method.toLowerCase()
     let isPost = method === "post"
     if (!isPost) {
         if (!url.pathname.endsWith("/")) {
-            return cacheResponse(url.pathname, event)
+            return { response: await cacheResponse(url.pathname, req) }
         }
 
         if (url.searchParams.get("login") === "success") {
@@ -175,71 +147,57 @@ async function executeHandler({ url, req, event }: ExectuteHandlerOptions): Prom
 
             if (!result) {
                 return isPost
-                    ? redirect(req)
-                    : new Response("Not Found!", { status: 404 })
+                    ? { response: redirect(req) }
+                    : { error: "Not found!" }
             }
 
             if (isPost && result.message == null) {
                 messages.push("Saved!")
             }
 
-            if (isHtml(result)) {
-                return streamResponse({
-                    body: result,
-                    headers: htmfHeader(req, null, messages)
-                })
-            }
-
             if (result.message?.length > 0) {
                 messages.push(result.message)
             } else if (result.messages?.length > 0) {
                 messages.push(...result.messages)
             }
+            ctx.messages = messages
+            ctx.events = result.events
 
-            result.headers = {
-                ...htmfHeader(req, result.events, messages),
-                ...result.headers
+            if (isHtml(result)) {
+                return {
+                    body: result,
+                }
             }
 
             if (isHtml(result.body)) {
-                return streamResponse(result)
+                return { 
+                    ...result,
+                    type: "text/html",
+                }
             } else {
                 if ("json" in result) {
                     result.body = JSON.stringify(result.json)
                     result.headers = {
                         ...result.headers,
-                        "content-type": "application/json"
                     }
                 }
-                return new Response(result.body, {
-                    status: result.status ?? 200,
-                    headers: result.headers
-                })
+                return {
+                    ...result,
+                    type: "application/json"
+                }
             }
 
         } catch (error) {
             console.error(`"${method}" error:`, error, "\nURL:", url);
-            if (!isHtmf(req)) {
-                if (isPost) {
-                    return redirect(req)
-                } else {
-                    return new Response("Not Found!", { status: 404 })
-                }
+            if (isPost) {
+                return { error: "An error occurred while processing your request." }
             } else {
-                let errors: string[] = getErrors(error)
-                let headers = htmfHeader(req, {}, errors)
-                return new Response(null, {
-                    status: isPost ? 400 : 500,
-                    headers
-                })
+                return { error: "Not found!" }
             }
         }
     }
 
-    return new Response(null, {
-        status: 404,
-        headers: htmfHeader(req, {}, ["Not Found!"])
-    })
+    return { error: "Not Found!" }
 }
 
 async function getData(req: Request) {
@@ -264,46 +222,6 @@ async function getData(req: Request) {
     return o
 }
 
-async function cacheResponse(url: string, event?: { request: string | Request } | undefined): Promise<Response> {
-    url = links?.find(x => x.url === url)?.file || url
-    const match = await caches.match(url)
-    if (match) return match
-    const res = await fetch(event?.request || url)
-    if (!res || res.status !== 200 || res.type !== "basic") return res
-    const responseToCache = res.clone()
-    // @ts-ignore
-    let version: string = self.app?.version
-        ?? (console.warn("The version number is not available, expected glboal value `self.app.version`."), "")
-    const cache = await caches.open(version)
-    cache.put(url, responseToCache)
-    return res
-}
-
-const encoder = new TextEncoder()
-function streamResponse(response: { body: Generator, headers?: any }): Response {
-    let { body, headers } = response
-    const stream = new ReadableStream({
-        async start(controller: ReadableStreamDefaultController<any>) {
-            try {
-                for await (let x of body) {
-                    if (typeof x === "string")
-                        controller.enqueue(encoder.encode(x))
-                }
-                controller.close()
-            } catch (error) {
-                console.error(error)
-            }
-        }
-    })
-
-    return new Response(stream, {
-        headers: {
-            "content-type": "text/html; charset=utf-8",
-            ...headers,
-        }
-    })
-}
-
 /**
 *  /my/url -> /my/url/
 *  /my/script.js -> /my/script.js
@@ -319,6 +237,21 @@ function isFile(s: string) {
     return s.lastIndexOf("/") < s.lastIndexOf(".")
 }
 
+async function cacheResponse(url: string, req?: Request | undefined): Promise<Response> {
+    url = links?.find(x => x.url === url)?.file || url
+    const match = await caches.match(url)
+    if (match) return match
+    const res = await fetch(req || url)
+    if (!res || res.status !== 200 || res.type !== "basic") return res
+    const responseToCache = res.clone()
+    // @ts-ignore
+    let version: string = self.app?.version
+        ?? (console.warn("The version number is not available, expected glboal value `self.app.version`."), "")
+    const cache = await caches.open(version)
+    cache.put(url, responseToCache)
+    return res
+}
+
 export interface RouteGetArgs {
     req: Request
     query: any

package/lib/sw-framework.ts

@@ -0,0 +1,53 @@
+class SWFramework {
+    private middlewares: Middleware[];    
+
+    constructor() {
+        this.middlewares = [];
+    }
+
+    use(middleware: Middleware) {
+        if (typeof middleware !== 'function') {
+            throw new Error('Middleware must be a function');
+        }
+        this.middlewares.push(middleware);
+    }
+
+    async start(fetchEvent: FetchEvent) : Promise<Response> {
+        let ctx = {} // Context object to pass to middlewares
+        let res: SwResponse = {}
+        let req = fetchEvent.request
+        for (let middleware of this.middlewares) {
+            let result = middleware(req, res, ctx)
+            if (result instanceof Promise) {
+                result = await result;
+            }
+            if (result === false) {
+                // Stop processing middlewares if one returns false
+                break;
+            }
+        }
+        return res.response ?? new Response(res.error || "Not Found", {
+            status: res.status || 404,
+            headers: {
+                "content-type": res.type || "text/plain; charset=utf-8",
+                ...res.headers,
+            }
+        })
+    }
+}
+
+export let swFramework = new SWFramework();
+
+export type SwResponse = {
+    status?: number
+    headers?: { [key: string]: string }
+    response?: Response
+    error?: string
+} & (
+    | { body?: never; type?: never }
+    | { body: any; type: "text/plain" | "application/json" | "text/html" | "application/xml" }
+);
+
+interface Middleware {
+    (req: Request, res: SwResponse, ctx: any): void | Promise<void | false> | false
+}

package/lib/utils.ts

@@ -24,3 +24,9 @@ export class DbCache {
     }
 }
 
+// Test if value is Async Generator
+export function isHtml(value: any) {
+    return value?.next instanceof Function
+        && value.throw instanceof Function
+}
+

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jon49/sw",
-  "version": "0.13.3",
+  "version": "0.14.0",
   "description": "Packages for MVC service workers.",
   "type": "module",
   "files": [
@@ -8,7 +8,10 @@
     "bin"
   ],
   "exports": {
-    "./routes.js": "./lib/routes.ts",
+    "./routes.middleware.js": "./lib/routes.middleware.ts",
+    "./htmf.middleware.js": "./lib/htmf.middleware.ts",
+    "./response.middleware.js": "./lib/response.middleware.ts",
+    "./web-framework.js": "./lib/sw-framework.ts",
     "./new-app-notifier.js": "./lib/new-app-notifier.ts",
     "./validation.js": "./lib/validation.ts",
     "./utils.js": "./lib/utils.ts",