@johnhenry/letterpress 0.0.2 → 0.0.3

package/CHANGELOG.md

@@ -6,6 +6,32 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/)
 
 This project will adhere to [Semantic Versioning](https://semver.org/spec/v2.0.0.html) once it reaches 1.0.0.
 
+## [0.0.3] - 2026-09-26
+
+### Fixed
+
+- 🐛 **Types**: `RouterExtension.endpoint` (added by the `#9` fix) was
+  declared to return `Router` directly, i.e. callable only through
+  `Route`'s `(request: Request) => Response` signature. But at runtime
+  (and per the README's own documented examples) `router.endpoint` is
+  curried: the first tagged-template call defines the match pattern
+  (method/path/headers), and the *second* call — on the value the first
+  call returns — is either another tagged template supplying a raw HTTP
+  response literal (e.g.
+  `` router.endpoint`GET /x`` `HTTP/1.1 200 OK\n\n...`` ``) or a plain
+  handler function (`(request) => Response`), both registering the route
+  and returning the same `Router`. The old declaration didn't model this
+  curried, dual-mode second call at all, forcing consumers to fall back to
+  `@ts-expect-error`/`any`. Added `RouterEndpointResponder`, a callable
+  type with two overload signatures (tagged-template and single-handler),
+  and changed `RouterExtension.endpoint`'s return type from `Router` to
+  `RouterEndpointResponder`. Extended `test/types/fixture.ts` with both
+  curried forms (verified to fail to type-check against the pre-fix
+  declaration, and to pass cleanly against the fix) so a regression here
+  is caught by `npm test`/`npm run typecheck` instead of relying on
+  someone eyeballing `types.d.ts`
+  ([#11](https://github.com/johnhenry/letterpress/issues/11))
+
 ## [0.0.2] - 2026-09-26
 
 ### Fixed

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@johnhenry/letterpress",
-  "version": "0.0.2",
+  "version": "0.0.3",
   "description": "A tagged-template-string HTTP routing library for defining and matching request handlers with plain JavaScript syntax.",
   "main": "index.mjs",
   "types": "types.d.ts",

package/test/types/fixture.ts

@@ -1,8 +1,8 @@
 /**
- * Type-only regression fixture for letterpress #9.
+ * Type-only regression fixture for letterpress #9 and #11.
  *
  * Not executed -- test/types.test.mjs spawns `tsc --noEmit` over this file
- * (via the root tsconfig.json). It exists to catch two regressions
+ * (via the root tsconfig.json). It exists to catch regressions
  * automatically instead of relying on someone eyeballing types.d.ts/fs.d.ts:
  *
  *  1. Importing "@johnhenry/letterpress" (and its "/fs" subpath) by their
@@ -19,6 +19,14 @@
  *     `import { createRouter } from '@johnhenry/letterpress'` type-checked
  *     the module specifier but `createRouter` itself was still `any`/
  *     missing (TS2305 "has no exported member").
+ *  3. `RouterExtension.endpoint`'s declared type didn't model that it's
+ *     curried at runtime (#11): the first tagged-template call returns a
+ *     responder that must be called a *second* time, either as another
+ *     tagged template (a raw HTTP response literal) or with a single
+ *     handler function, both returning `Router`. Before the fix, the first
+ *     call's return type was `Router` itself (callable only via `Route`'s
+ *     `(request: Request) => Response` signature), so both curried forms
+ *     below failed to type-check.
  */
 import {
   createRouter,
@@ -37,6 +45,27 @@ const router = createRouter({ baseUrl: "http://localhost" });
 const extended = router.endpoint`GET /ping`;
 void extended;
 
+// `.endpoint` is curried (letterpress #11): the first tagged-template call
+// (above) defines the match pattern and returns a responder that must be
+// called a *second* time, either as another tagged template (a raw HTTP
+// response literal) or with a single handler function -- both forms
+// register the route and return the same Router. Neither form below should
+// require @ts-expect-error/@ts-ignore.
+const routerAfterTemplateResponse = router.endpoint`GET /protected [Authorization: Bearer *]`
+`HTTP/1.1 200 OK
+Content-Type: text/plain
+
+This is a protected resource
+`;
+const routerAfterHandlerResponse = router.endpoint`GET /api/data`(
+  async (request: Request) => {
+    void request;
+    return new Response("ok");
+  }
+);
+void routerAfterTemplateResponse;
+void routerAfterHandlerResponse;
+
 async function checkRouter() {
   const response = await router(new Request("http://localhost/ping"));
   return response instanceof Response;

package/types.d.ts

@@ -4,12 +4,27 @@ export type Route = (
   context?: Record<string, any>
 ) => Response | Promise<Response>;
 
+// The value returned by the *first* `router.endpoint` tagged-template call
+// (the method/path/header match pattern, e.g.
+// `` router.endpoint`GET /protected [Authorization: Bearer *]` ``). That
+// return value is itself curried: it must be called a *second* time,
+// either as another tagged template supplying a raw HTTP response literal
+// (e.g. `` `HTTP/1.1 200 OK\n\n...` ``, parsed the same way createResponse
+// parses one) or with a single plain handler function
+// (`(request: Request) => Response`), per the README's documented usage
+// and create-router.mjs's actual implementation. Both forms register the
+// route and return the same `Router` so calls can be chained.
+export type RouterEndpointResponder = {
+  (template: TemplateStringsArray, ...substitutions: any[]): Router;
+  (handler: Route): Router;
+};
+
 // Extension for the Router to add endpoints
 export type RouterExtension = {
   endpoint: (
     template: TemplateStringsArray,
     ...substitutions: any[]
-  ) => Router;
+  ) => RouterEndpointResponder;
 };
 
 // Combines Route and RouterExtension