brustjs 0.1.24-alpha → 0.1.25-alpha

package/runtime/treaty.ts

@@ -1,4 +1,4 @@
-import type { ActionsBuilder } from './define-actions.ts'
+import type { ActionsBuilder, EndpointEntry } from './define-actions.ts'
 
 const METHODS = new Set(['get', 'post', 'put', 'patch', 'delete', 'head'])
 
@@ -15,12 +15,6 @@ export interface ClientOptions {
   fetch?: typeof fetch
 }
 
-type FirstSegment<S extends string> = S extends `/${infer Rest}`
-  ? FirstSegment<Rest>
-  : S extends `${infer T}/${infer _U}`
-    ? T
-    : S
-
 export type PermissiveProxy = {
   (arg?: any): PermissiveProxy
   [key: string]: PermissiveProxy
@@ -33,10 +27,53 @@ export type PermissiveProxy = {
   head: (options?: any) => Promise<TreatyResponse<any, any>>
 }
 
+// ─── Typed Treaty<App> (B2, descoped) ───────────────────────────────────────
+// Static paths get fully-typed methods (output + discriminated error union);
+// any param path (`{...}`) or unknown segment falls through to PermissiveProxy.
+// Reference shape proven by spike5 (EXIT=0).
+
+/** Per-method client signatures for one endpoint-entry map (the `{ GET, POST, … }`
+ * object for a single path). Bodyless methods (GET/HEAD) take only options. */
+type Methods<E> = {
+  [M in keyof E & string as Lowercase<M>]: M extends 'GET' | 'HEAD'
+    ? E[M] extends EndpointEntry
+      ? (o?: {
+          query?: Record<string, string>
+          headers?: Record<string, string>
+        }) => Promise<TreatyResponse<E[M]['output'], E[M]['error']>>
+      : never
+    : E[M] extends EndpointEntry
+      ? (
+          b?: E[M]['input'],
+          o?: { headers?: Record<string, string> },
+        ) => Promise<TreatyResponse<E[M]['output'], E[M]['error']>>
+      : never
+}
+
+/** A path is static iff it contains no `{param}` segment. */
+type IsStatic<K extends string> = K extends `${string}{${string}}${string}` ? false : true
+/** Keep only the static path keys of the accumulator. */
+type StaticAcc<Acc> = {
+  [K in keyof Acc as K extends string ? (IsStatic<K> extends true ? K : never) : never]: Acc[K]
+}
+/** Given a path key `K` and the accumulated prefix `P`, the next segment after `P`. */
+type Tail<K extends string, P extends string> = K extends `${P}/${infer Rest}`
+  ? Rest extends `${infer H}/${string}`
+    ? H
+    : Rest
+  : never
+/** All immediate child segments under prefix `P`. */
+type ChildSegs<SA, P extends string> = { [K in keyof SA]: Tail<K & string, P> }[keyof SA]
+/** The entry map for the exact path `P`, if one exists. */
+// biome-ignore lint/complexity/noBannedTypes: `{}` is the empty-methods identity when no exact endpoint matches the prefix
+type ExactEntry<SA, P extends string> = P extends keyof SA ? SA[P] : {}
+/** A treaty node: methods of the exact path + child segment nodes + permissive fallback. */
+type TNode<SA, P extends string> = Methods<ExactEntry<SA, P>> & {
+  [Seg in ChildSegs<SA, P> & string]: TNode<SA, `${P}/${Seg}`>
+} & PermissiveProxy
+
 export type Treaty<App> =
-  App extends ActionsBuilder<infer Acc>
-    ? { [K in FirstSegment<keyof Acc & string>]: PermissiveProxy } & PermissiveProxy
-    : PermissiveProxy
+  App extends ActionsBuilder<infer Acc> ? TNode<StaticAcc<Acc>, ''> : PermissiveProxy
 
 function resolvePrefix(opts?: ClientOptions): string {
   if (opts?.prefix) return opts.prefix

package/runtime/treaty.type-test.ts

@@ -0,0 +1,69 @@
+// Isolated TYPE TEST for the B2 typed treaty client. Not executed — every
+// assertion is a pure type check inside an un-called async function. Run via:
+//   bun run typecheck:treaty   →   tsc -p tsconfig.typecheck.json --noEmit
+//
+// It exercises: (1) static-path methods are fully typed (output + error union),
+// (2) the discriminated error union narrows on `code`, (3) accessing a
+// non-existent output field is a type error, (4) a wrong error code / field is a
+// type error, (5) param paths stay permissive (no type error, the fallback).
+import { z } from 'zod'
+import { defineActions } from './define-actions.ts'
+import { client } from './treaty.ts'
+
+const actions = defineActions()
+  .get('/team', () => ({ team: [{ id: 1 }], max: 6 }))
+  .post('/team', ({ body }: { body: { id: number } }) => ({ team: [{ id: body.id }], max: 6 }), {
+    body: z.object({ id: z.number() }),
+    errors: {
+      TEAM_FULL: z.object({ max: z.number() }),
+      DUPLICATE: z.object({ existingId: z.number() }),
+    },
+  })
+  .delete('/team/{id}', () => ({ ok: true }))
+
+const api = client<typeof actions>()
+
+// Never called — purely for type checking.
+export async function _typeTest() {
+  // (1) static POST → output typed.
+  const r = await api.team.post({ id: 5 })
+  if (r.data) {
+    const max: number = r.data.max
+    void max
+    // (3) non-existent output field → must be a type error.
+    // @ts-expect-error `nope` is not a field of the typed output
+    void r.data.nope
+  }
+
+  // (2) error union narrows on the discriminant `code` to the SPECIFIC branch,
+  // and that branch's `data` is typed (multi-member union: TEAM_FULL | DUPLICATE).
+  if (r.error && r.error.value.code === 'TEAM_FULL') {
+    const m: number = r.error.value.data.max
+    void m
+    // (4a) non-existent error-data field → must be a type error.
+    // @ts-expect-error `min` is not a field of the TEAM_FULL error data
+    void r.error.value.data.min
+    // (4c) narrowing is per-branch: DUPLICATE's `existingId` is NOT on TEAM_FULL.
+    // @ts-expect-error `existingId` belongs to the DUPLICATE branch, not TEAM_FULL
+    void r.error.value.data.existingId
+  }
+  if (r.error && r.error.value.code === 'DUPLICATE') {
+    const e: number = r.error.value.data.existingId
+    void e
+  }
+  // (4b) comparing against an undeclared error code → must be a type error.
+  if (r.error) {
+    // @ts-expect-error 'NOPE' is not a declared error code
+    void (r.error.value.code === 'NOPE')
+  }
+
+  // GET → output typed.
+  const g = await api.team.get()
+  if (g.data) {
+    const max2: number = g.data.max
+    void max2
+  }
+
+  // (5) param path stays permissive — MUST NOT error (locks the fallback).
+  await api.team({ id: '5' }).delete()
+}

package/runtime/tsconfig.typecheck.json

@@ -0,0 +1,15 @@
+{
+  "compilerOptions": {
+    "strict": true,
+    "skipLibCheck": true,
+    "target": "ES2022",
+    "lib": ["ES2022", "DOM"],
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "allowImportingTsExtensions": true,
+    "noEmit": true,
+    "jsx": "react-jsx",
+    "types": []
+  },
+  "files": ["treaty.ts", "define-actions.ts", "standard-schema.ts", "treaty.type-test.ts"]
+}