pre 0.1.48 , checking test on deno 2.0

.github/workflows/deno.yml

@@ -17,8 +17,8 @@ jobs:
       - uses: actions/checkout@v4
       - uses: denoland/setup-deno@v1
         with:
-          deno-version: v1.x # Uses latest deno version 1
-      - run: deno add @cross/test @std/assert # Installs dependencies from jsr.io
+          deno-version: v2.x 
+      - run: deno add @cross/test @std/assert 
       - run: deno test -A
 
       - name: Verify formatting

src/composer/compose.ts

@@ -19,9 +19,26 @@ const compose =
     ((isUsing) =>
       (
         (table) =>
-          resolveF(o)(table)(p)(isUsing) as (
-            ctx: Request,
-          ) => Promise<Response> | Response
+          typeof p.onError === "function"
+            ? onError(table.isAsync)(
+              resolveF(o)(table)(p)(isUsing) as (
+                ctx: Request,
+              ) => Response,
+            )(
+              getApplyTo(table.isAsync)()(p.onError)(
+                linker(o)({
+                  ...p,
+                  f: p.onError,
+                  onError: undefined,
+                  applyTo: {
+                    type: "onError",
+                  },
+                }),
+              )(isUsing),
+            )
+            : resolveF(o)(table)(p)(isUsing) as (
+              ctx: Request,
+            ) => Promise<Response> | Response
       )(
         //elements int table
         {

src/composer/composerTools.ts

@@ -78,6 +78,7 @@ const elements = (f: Petition) =>
         "io",
         "req",
         "date",
+        "error",
         f.resolve ? "resolve" : undefined,
         "mutable",
         f.branch ? "branch" : undefined,

src/composer/linker.ts

@@ -16,7 +16,10 @@ export default (o?: specialOptions) => (p: Petition) => (isUsing: string[]) => {
   // Base case: if 'isUsing' is empty and 'branch' is not in options, return the identity function
   // TODO: change it and add the branch flag in the petition
 
-  if (isUsing.length === 0 && !(o && "branch" in o) && !isApplyTo) {
+  if (isUsing.length === 0 && !(o && "branch" in o)) {
+    if (isApplyTo) {
+      return (r: Request) => (b: unknown) => r;
+    }
     return (r: Request) => r;
   }
 
@@ -42,8 +45,8 @@ export default (o?: specialOptions) => (p: Petition) => (isUsing: string[]) => {
     .map((x) => `${x.name}=>`)
     .reduceRight(
       (acc, v) => v + acc,
-      // If applyTo is in
-      typeof p.applyTo === "object" ? "onError=>" : "",
+      // Place to add more in the future
+      "",
     );
 
   // Determine the function signature based on options
@@ -58,12 +61,9 @@ export default (o?: specialOptions) => (p: Petition) => (isUsing: string[]) => {
     functionSignature = (o && "branch" in o) || isApplyTo ? "r=>b=>" : "r=>";
   }
 
-  // Adding applyTo at the table to insert it in the final CTX object
-  const expandedTable = isApplyTo ? [...table, p.applyTo] : table;
-
   // Build the function body, injecting variables from 'table'
   const functionBody = `({${
-    expandedTable.map((x) => `${x.name}:${x.value}`).join(",")
+    table.map((x) => `${x.name}:${x.value}`).join(",")
   }})`;
 
   // Build the full function string
@@ -76,9 +76,5 @@ export default (o?: specialOptions) => (p: Petition) => (isUsing: string[]) => {
   // Reduce the functions over the generated function
   const resultFunction = functions.reduce((s, k) => s(k), generatedFunc);
 
-  if (isApplyTo) {
-    return resultFunction(p.f);
-  }
-
   return resultFunction;
 };

src/composer/nativeMaps.ts

@@ -9,6 +9,7 @@ export default (o?: FunRouterOptions<any>) =>
 (mutable: boolean) =>
   ([
     { name: "req", value: mutable ? "r[0]" : "r", type: 0 },
+    { name: "error", value: "b", type: 0 },
     {
       name: "param",
       value: mutable ? "param(r[0].url)" : "param(r.url)",
@@ -57,7 +58,6 @@ export default (o?: FunRouterOptions<any>) =>
       }`,
       type: 1,
     },
-    { name: "mutable", value: mutable ? "r[1]" : "{}", type: 0 },
     {
       name: "branch",
       value: `${

src/morphism.ts

@@ -554,9 +554,7 @@ export type BranchMap<T> = {
 };
 
 type ApplyToCTX = {
-  name: string;
-  value: string;
-  type: 0 | 1;
+  type: "onError";
 };
 
 type MapOptions = {

test/composer/linker.test.ts

@@ -242,3 +242,31 @@ test("Checking branch", async () => {
       },
     );
 });
+
+test("Checking branch", async () => {
+  // Wraps correctly
+  assertEquals(
+    linker({})({
+      type: "add",
+      path: "/1/2/:id",
+      f: mockFunction,
+      applyTo: {
+        type: "onError",
+      },
+    })([])(requestForTest)(),
+    requestForTest,
+  );
+
+  // Wraps correctly
+  assertEquals(
+    linker({})({
+      type: "add",
+      path: "/1/2/:id",
+      f: mockFunction,
+      applyTo: {
+        type: "onError",
+      },
+    })(["error"])(requestForTest)("world").error,
+    "world",
+  );
+});

test/exportable/wrap.test.ts

@@ -35,23 +35,23 @@ const opt = plugins.globalOptions({
 const wrapped = wrap(
   opt,
 )()
-  .stdPetition({
+  .get({
     path: "/stdHello",
     f: () => "stdHello",
   })
-  .stdPetition({
+  .get({
     path: "/stdPlugin",
     plugins: {
       hello: "string",
       method: "string",
     },
     f: (ctx) => ctx.hello() + ctx.method,
   })
-  .customPetition({
+  .get({
     path: "/customHello",
     f: () => new Response("customHello"),
   })
-  .route({
+  .get({
     path: "/customsPlugin",
     f: ({ hello, method }) => new Response(hello() + method),
     onError: ({ error }) =>