feat(0.1.0): release candidate for Router

This change pulls the core ideas of pick into a single router.ts file
and implements what I think is a decent interface for the original
Router. In the process I moved the indexed async state either monad, now
called Effect, to the fun library. Effect is now variadic in a clever
but very useful way. Many of the interfaces for Handler, Route, and
Router have breaking changes. I've implemented a very basic but quite
performant default router that does fallthrough routing after matching
on the request method.

There is also the majority of the initial SiteBuilder work done. The
idea behind a site builder was to point it at a directory and have it
turn .tsx files into a SPA, .ts files into api routes, and everything
else into static assets. It's construction should be extensible enough
that new RouteBuilders can be created externally so that other filetypes
can be turned into routes. ie. Markdown files can be pre-rendered, image
files can be compressed, etc etc. It's also meant to be generic enough
that it can be run on any platform and not just on Deno.

Currently, the SiteBuilder only has a static route builder. The
following is intended to be done soon:

* Server route builders should be straightforward, but I'd like to add
  some degree of type checking to make them break at app start and not
  at runtime.
* Client route builders are simple enough to build, since they will all
  serve the same index file.. but there is a chicken and egg issue here.
* I need to spec types for a ClientBuilder/ClientBundler that takes the
  array of ClientRoutes and turns them into a bundle! Hopefully it's
  easy enough.

Once these features are complete and test coverage is at 100% I will
likey take a break from pick for awhile, but I do want to return at a
later date to implement the following features:

* Routes should take optional input/output schemas that match OpenAPI
  definitions. Or default to unknown.
* Routers should have a get_description method that returns a sorted
  list of all Routes without their Handlers.
* We should have some tooling for converting a Route list to a sitemap
  or an OpenAPI spec.
* SiteBuilder should have an option to mount an OpenAPI spec or a
  sitemap at unused paths (and probably write those files into the root
  site path).

All in all, a good amount of cleanup and work is done now. Should have
the bare minimum of what I need soon. I think capnweb is going to pull
me away from swagger/openapi generators and client generators for
awhile. This SiteBuilder approach resolves tons of issues with cors,
versioning, and type safety.

Author: baetheus

.github/workflows/format.yml

@@ -0,0 +1,24 @@
+name: Check Format
+
+on: [workflow_call]
+
+jobs:
+  format:
+    strategy:
+      matrix:
+        deno: ["v2.2.12"]
+        os: [ubuntu-latest]
+
+    runs-on: ${{ matrix.os }}
+
+    steps:
+      - name: Setup repo
+        uses: actions/checkout@v2
+
+      - name: Setup Deno
+        uses: denoland/setup-deno@v1
+        with:
+          deno-version: ${{ matrix.deno }}
+
+      - name: Run Deno Check Formatting
+        run: deno fmt --check

.github/workflows/publish.yml

@@ -0,0 +1,23 @@
+name: Publish
+
+on: [workflow_call]
+
+jobs:
+  publish:
+    permissions:
+      contents: read
+      id-token: write
+
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Setup repo
+        uses: actions/checkout@v4
+
+      - name: Setup Deno
+        uses: denoland/setup-deno@v1
+        with:
+          deno-version: "v2.2.12"
+
+      - name: Publish package
+        run: deno publish

.github/workflows/pull_request.yml

@@ -0,0 +1,10 @@
+name: PR
+
+on: [pull_request]
+
+jobs:
+  call-format:
+    uses: ./.github/workflows/format.yml
+
+  call-test:
+    uses: ./.github/workflows/test.yml

.github/workflows/push.yml

@@ -0,0 +1,20 @@
+name: Push Main
+
+on:
+  push:
+    branches: [main]
+
+jobs:
+  call-format:
+    uses: ./.github/workflows/format.yml
+
+  call-test:
+    uses: ./.github/workflows/test.yml
+    secrets: inherit
+
+  call-publish:
+    needs: [call-format, call-test]
+    uses: ./.github/workflows/publish.yml
+    permissions:
+      contents: read
+      id-token: write

.github/workflows/test.yml

@@ -0,0 +1,34 @@
+name: Test
+
+on: [workflow_call]
+
+jobs:
+  test:
+    strategy:
+      matrix:
+        deno: ["v2.2.12"]
+        os: [macOS-latest, windows-latest, ubuntu-latest]
+
+    runs-on: ${{ matrix.os }}
+
+    steps:
+      - name: Setup repo
+        uses: actions/checkout@v2
+
+      - name: Setup Deno
+        uses: denoland/setup-deno@v1
+        with:
+          deno-version: ${{ matrix.deno }}
+
+      - name: Run Deno Tests
+        run: deno test --parallel --coverage=coverage
+
+      - name: Generate Coverage
+        run: deno coverage --unstable ./coverage --lcov > ./coverage/lcov.info
+
+      - name: Coveralls
+        uses: coverallsapp/github-action@master
+        with:
+          flag-name: run-${{ matrix.deno }}-${{ matrix.os }}
+          github-token: ${{ secrets.GITHUB_TOKEN }}
+          base-path: /

.gitignore

@@ -1,2 +1,4 @@
 /.direnv
 .jj
+.vscode
+tmp

LICENSE

@@ -1,7 +1,5 @@
 The MIT License (MIT)
 
-Copyright (c) 2017 Giulio Canti
-Copyright (c) 2018 Tom Crockett
 Copyright (c) 2019 Brandon Blaylock
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
@@ -21,4 +19,3 @@ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE.
-

README.md

@@ -58,19 +58,17 @@ generally, the router in pick expects the more specific Handler that looks like:
 
 ```ts
 // Context
-// Request is the web standard HTTP request type
 // S is the application state
-// V is a collection of variables parsed from the request path
-type Context<S, V> = {
-  readonly request: Request;
+type Context<S> = {
   readonly state: S;
-  readonly path: V;
 };
 
-type RouteHandler<S, V, O> = Handler<Context<S, V>, Response, O>;
-
-// Or, if we substitute the types ourselves
-type RouteHandlerSub<S, V, O> = (ctx: Context<S, V>) => Promise<[Response, O]>;
+// A route handler receives the request, parsed path parameters, and context
+type RouteHandler<S, V> = (
+  request: Request,
+  path: V,
+  ctx: Context<S>,
+) => Response | Promise<Response>;
 ```
 
 The Router in pick doesn't really care about the output state `O` of the Handler
@@ -91,25 +89,23 @@ that can be trivial "simplified" to a very useful minimal implementation.
 Put this all together and a simple router can be set up like so:
 
 ```ts
-import * as R from "../router.ts";
-import { html } from "../response.ts";
-import { pipe } from "fun/fn.ts";
-
-const router = pipe(
-  // Create a Router
-  R.router<{ count: number }>(),
-  // Add a Route
-  R.respond(
-    "GET /hello/:name",
-    (ctx) =>
-      html(
-        `<h1>Hello ${ctx.path.name}, you are number ${++ctx.state.count}</h1>`,
-      ),
-  ),
-  R.withState({ count: 0 }),
-);
-
-Deno.serve(router);
+import { context, html, right, router } from "./router.ts";
+
+const ctx = context({ count: 0 });
+
+const myRouter = router(ctx, {
+  routes: [
+    right("GET /hello/:name", (request, params, ctx) => {
+      ctx.state.count++;
+      return html(
+        `<h1>Hello ${params.name}, you are visitor number ${ctx.state.count}</h1>`,
+      );
+    }),
+  ],
+});
+
+// Start the server:
+// Deno.serve(myRouter.handle);
 ```
 
 ## Contributing