primate 0.27.4 → 0.27.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "primate",
-  "version": "0.27.4",
+  "version": "0.27.5",
   "description": "Polymorphic development platform",
   "homepage": "https://primatejs.com",
   "bugs": "https://github.com/primatejs/primate/issues",
@@ -18,7 +18,7 @@
     "directory": "packages/primate"
   },
   "dependencies": {
-    "rcompat": "^0.5.0"
+    "rcompat": "^0.5.1"
   },
   "engines": {
     "node": ">=18"

package/src/errors.json

@@ -1,10 +1,10 @@
 {
   "module": "primate",
   "errors": {
-    "CannotParseBody": {
-      "message": "cannot parse body {0} as {1}",
-      "fix": "use a different content type or fix body",
-      "level": "Warn"
+    "MismatchedBody": {
+      "message": "{0}: {1}",
+      "fix": "make sure the body payload corresponds to the used content type",
+      "level": "Error"
     },
     "DoubleFileExtension": {
       "message": "double file extension {0}",

package/src/hooks/handle.js

@@ -51,9 +51,9 @@ export default app => {
       const hooks = [...app.modules.route, guard(app, guards)];
 
       // handle request
-      const response = (await cascade(hooks, handler))(pathed);
+      const response = await (await cascade(hooks, handler))(pathed);
       const $layouts = { layouts: await get_layouts(layouts, request) };
-      return (await respond(await response))(app, $layouts, pathed);
+      return (await respond(response))(app, $layouts, pathed);
     }).orelse(async error => {
       app.log.auto(error);
 

package/src/hooks/parse.js

@@ -1,20 +1,28 @@
 import { URL, Body } from "rcompat/http";
 import { from, valmap } from "rcompat/object";
+import { tryreturn } from "rcompat/async";
+import errors from "../errors.js";
 
 const deslash = url => url.replaceAll(/(?<!http:)\/{2,}/gu, _ => "/");
 
+const parse_body = (body, headers, url) =>
+  tryreturn(async _ => {
+    console.log("HHHH");
+    return Body.parse(body, headers.get("content-type")) ?? {};
+  }).orelse(error => errors.MismatchedBody.throw(url.pathname, error.message));
+
 export default dispatch => async original => {
-  const { body, headers } = original;
+  const { headers } = original;
   const url = new URL(deslash(globalThis.decodeURIComponent(original.url)));
   const cookies = headers.get("cookie");
+  const body = await parse_body(original.body, headers, url);
 
-  return { original, url,
-    body: await Body.parse(body, headers.get("content-type")) ?? {},
+  return { original, url, body,
+    async_function: async () => "1",
     ...valmap({
-      query: [from(url.searchParams), url.search],
-      headers: [from(headers), headers, false],
-      cookies: [from(cookies?.split(";").map(cookie => cookie.trim().split("="))
-        ?? []), cookies],
-    }, value => dispatch(...value)),
-  };
+    query: [from(url.searchParams), url.search],
+    headers: [from(headers), headers, false],
+    cookies: [from(cookies?.split(";").map(cookie =>
+      cookie.trim().split("=")) ?? []), cookies],
+  }, value => dispatch(...value)) };
 };

package/src/hooks/respond/duck.js

@@ -1,4 +1,4 @@
 import { Headers } from "rcompat/http";
 
-export const isResponse = value =>
+export default value =>
   value.body !== undefined && value.headers instanceof Headers;

package/src/hooks/respond/exports.js

@@ -1,2 +1 @@
-export { isResponse } from "./duck.js";
 export { default as respond } from "./respond.js";

package/src/hooks/respond/respond.js

@@ -1,26 +1,26 @@
 import { Blob } from "rcompat/fs";
 import { URL } from "rcompat/http";
 import { text, json, stream, redirect } from "primate";
-import { isResponse as isResponseDuck } from "./duck.js";
+import is_response_duck from "./duck.js";
 
-const isText = value => {
+const is_text = value => {
   if (typeof value === "string") {
     return text(value);
   }
   throw new Error(`no handler found for ${value}`);
 };
 
-const isNonNullObject = value => typeof value === "object" && value !== null;
-const isObject = value => isNonNullObject(value)
-  ? json(value) : isText(value);
-const isResponse = value => isResponseDuck(value)
-  ? _ => value : isObject(value);
+const is_non_null_object = value => typeof value === "object" && value !== null;
+const is_object = value => is_non_null_object(value)
+  ? json(value) : is_text(value);
+const is_response = value => is_response_duck(value)
+  ? _ => value : is_object(value);
 const isStream = value => value instanceof ReadableStream
-  ? stream(value) : isResponse(value);
-const isBlob = value => value instanceof Blob
+  ? stream(value) : is_response(value);
+const is_blob = value => value instanceof Blob
   ? stream(value) : isStream(value);
-const isURL = value => value instanceof URL
-  ? redirect(value.href) : isBlob(value);
-const guess = value => isURL(value);
+const is_URL = value => value instanceof URL
+  ? redirect(value.href) : is_blob(value);
+const guess = value => is_URL(value);
 
 export default result => typeof result === "function" ? result : guess(result);

package/src/hooks/stage.js

@@ -28,23 +28,20 @@ const post = async app => {
   if (await app.path.types.exists()) {
     await app.stage(app.path.types, location.types);
   }
-  const types = await loaders.types(app.log, app.runpath(location.types));
+  const user_types = await loaders.types(app.log, app.runpath(location.types));
+  const types = { ...app.types, ...user_types };
+
   const staged = app.runpath(location.routes);
   for (const path of await staged.collect()) {
     await app.extensions[path.extension]
       ?.route(staged, path.debase(`${staged}/`), types);
   }
   const routes = await loaders.routes(app);
-
-  return {
-    ...app,
-    types,
-    routes,
-    dispatch: dispatch(app.types),
-    layout: {
-      depth: Math.max(...routes.map(({ layouts }) => layouts.length)) + 1,
-    },
+  const layout = {
+    depth: Math.max(...routes.map(({ layouts }) => layouts.length)) + 1,
   };
+
+  return { ...app, types, routes, dispatch: dispatch(types), layout };
 };
 
 export default async app =>

package/src/loaders/types.js

@@ -6,8 +6,8 @@ import fs from "./common.js";
 
 const filter = path => /^[a-z]/u.test(path.name);
 
-export default async (log, directory) => {
-  const types = (await fs({ log, directory, name: "types", filter }))
+export default async (log, directory, load = fs) => {
+  const types = (await load({ log, directory, name: "types", filter }))
     .map(([name, type]) => [name, type.default]);
 
   const resolve = name => new Path(directory, name);