@hyperspan/framework 1.0.0-alpha.8 → 1.0.0

package/src/server.ts

@@ -1,15 +1,20 @@
-import { HSHtml, html, isHSHtml, renderStream, renderAsync, render } from '@hyperspan/html';
+import { HSHtml, html, isHSHtml, renderStream, renderAsync, render, _typeOf } from '@hyperspan/html';
+import { isbot } from 'isbot';
 import { executeMiddleware } from './middleware';
-import type { Hyperspan as HS } from './types';
-import { clientJSPlugin } from './plugins';
 import { parsePath } from './utils';
-export type { HS as Hyperspan };
+import { Cookies } from './cookies';
+
+import type { Hyperspan as HS } from './types';
 
 export const IS_PROD = process.env.NODE_ENV === 'production';
 
-export class HTTPException extends Error {
-  constructor(public status: number, message?: string) {
-    super(message);
+export class HTTPResponseException extends Error {
+  public _error?: Error;
+  public _response?: Response;
+  constructor(body: string | Error | undefined, options?: ResponseInit) {
+    super(body instanceof Error ? body.message : body);
+    this._error = body instanceof Error ? body : undefined;
+    this._response = new Response(body instanceof Error ? body.message : body, options);
   }
 }
 
@@ -17,11 +22,22 @@ export class HTTPException extends Error {
  * Ensures a valid config object is returned, even with an empty object or partial object passed in
  */
 export function createConfig(config: Partial<HS.Config> = {}): HS.Config {
+  const defaultConfig: HS.Config = {
+    appDir: './app',
+    publicDir: './public',
+    plugins: [],
+    responseOptions: {
+      // Disable streaming for bots by default
+      disableStreaming: (c) => isbot(c.req.raw.headers.get('user-agent') ?? ''),
+    },
+  };
   return {
+    ...defaultConfig,
     ...config,
-    appDir: config.appDir ?? './app',
-    publicDir: config.publicDir ?? './public',
-    plugins: [clientJSPlugin(), ...(config.plugins ?? [])],
+    responseOptions: {
+      ...defaultConfig.responseOptions,
+      ...config.responseOptions,
+    },
   };
 }
 
@@ -35,11 +51,33 @@ export function createContext(req: Request, route?: HS.Route): HS.Context {
   const headers = new Headers(req.headers);
   const path = route?._path() || '/';
   // @ts-ignore - Bun will put 'params' on the Request object even though it's not standardized
-  const params: HS.RouteParamsParser<path> = req?.params || {};
+  const params: HS.RouteParamsParser<path> & Record<string, string | undefined> = Object.assign({}, req?.params || {}, route?._config.params || {});
+
+  // Replace catch-all param with the value from the URL path
+  const catchAllParam = Object.keys(params).find(key => key.startsWith('...'));
+  if (catchAllParam && path.includes('/*')) {
+    const catchAllValue = url.pathname.split(path.replace('/*', '/')).pop();
+    params[catchAllParam.replace('...', '')] = catchAllValue;
+    delete params[catchAllParam];
+  }
+
+  const merge = (response: Response) => {
+    // Convert headers to plain objects and merge (response headers override context headers)
+    const mergedHeaders = {
+      ...Object.fromEntries(headers.entries()),
+      ...Object.fromEntries(response.headers.entries()),
+    };
+
+    return new Response(response.body, {
+      status: response.status,
+      headers: mergedHeaders,
+    });
+  };
 
   return {
     vars: {},
     route: {
+      name: route?._config.name || undefined,
       path,
       params: params,
       cssImports: route ? route._config.cssImports ?? [] : [],
@@ -50,20 +88,23 @@ export function createContext(req: Request, route?: HS.Route): HS.Context {
       method,
       headers,
       query,
+      cookies: new Cookies(req),
       async text() { return req.text() },
       async json<T = unknown>() { return await req.json() as T },
       async formData<T = unknown>() { return await req.formData() as T },
       async urlencoded() { return new URLSearchParams(await req.text()) },
     },
     res: {
-      headers: new Headers(),
+      cookies: new Cookies(req, headers),
+      headers,
       raw: new Response(),
-      html: (html: string, options?: { status?: number; headers?: Headers | Record<string, string> }) => new Response(html, { ...options, headers: { 'Content-Type': 'text/html; charset=UTF-8', ...options?.headers } }),
-      json: (json: any, options?: { status?: number; headers?: Headers | Record<string, string> }) => new Response(JSON.stringify(json), { ...options, headers: { 'Content-Type': 'application/json', ...options?.headers } }),
-      text: (text: string, options?: { status?: number; headers?: Headers | Record<string, string> }) => new Response(text, { ...options, headers: { 'Content-Type': 'text/plain; charset=UTF-8', ...options?.headers } }),
-      redirect: (url: string, options?: { status?: number; headers?: Headers | Record<string, string> }) => new Response(null, { status: 302, headers: { Location: url, ...options?.headers } }),
-      error: (error: Error, options?: { status?: number; headers?: Headers | Record<string, string> }) => new Response(error.message, { status: 500, ...options }),
-      notFound: (options?: { status?: number; headers?: Headers | Record<string, string> }) => new Response('Not Found', { status: 404, ...options }),
+      html: (html: string, options?: ResponseInit) => merge(new Response(html, { ...options, headers: { 'Content-Type': 'text/html; charset=UTF-8', ...options?.headers } })),
+      json: (json: any, options?: ResponseInit) => merge(new Response(JSON.stringify(json), { ...options, headers: { 'Content-Type': 'application/json', ...options?.headers } })),
+      text: (text: string, options?: ResponseInit) => merge(new Response(text, { ...options, headers: { 'Content-Type': 'text/plain; charset=UTF-8', ...options?.headers } })),
+      redirect: (url: string, options?: ResponseInit) => merge(new Response(null, { status: 302, headers: { Location: url, ...options?.headers } })),
+      error: (error: Error, options?: ResponseInit) => merge(new Response(error.message, { status: 500, ...options })),
+      notFound: (options?: ResponseInit) => merge(new Response('Not Found', { status: 404, ...options })),
+      merge,
     },
   };
 }
@@ -73,13 +114,13 @@ export function createContext(req: Request, route?: HS.Route): HS.Context {
  * Define a route that can handle a direct HTTP request.
  * Route handlers should return a HSHtml or Response object
  */
-export function createRoute(config: HS.RouteConfig = {}): HS.Route {
+export function createRoute(config: Partial<HS.RouteConfig> = {}): HS.Route {
   const _handlers: Record<string, HS.RouteHandler> = {};
+  let _errorHandler: HS.ErrorHandler | undefined = undefined;
   let _middleware: Record<string, Array<HS.MiddlewareFunction>> = { '*': [] };
 
   const api: HS.Route = {
     _kind: 'hsRoute',
-    _name: config.name,
     _config: config,
     _methods: () => Object.keys(_handlers),
     _path() {
@@ -114,14 +155,6 @@ export function createRoute(config: HS.RouteConfig = {}): HS.Route {
       _middleware['PUT'] = handlerOptions?.middleware || [];
       return api;
     },
-    /**
-     * Add a DELETE route handler (typically to delete existing data)
-     */
-    delete(handler: HS.RouteHandler, handlerOptions?: HS.RouteHandlerOptions) {
-      _handlers['DELETE'] = handler;
-      _middleware['DELETE'] = handlerOptions?.middleware || [];
-      return api;
-    },
     /**
      * Add a PATCH route handler (typically to update existing data)
      */
@@ -130,6 +163,14 @@ export function createRoute(config: HS.RouteConfig = {}): HS.Route {
       _middleware['PATCH'] = handlerOptions?.middleware || [];
       return api;
     },
+    /**
+     * Add a DELETE route handler (typically to delete existing data)
+     */
+    delete(handler: HS.RouteHandler, handlerOptions?: HS.RouteHandlerOptions) {
+      _handlers['DELETE'] = handler;
+      _middleware['DELETE'] = handlerOptions?.middleware || [];
+      return api;
+    },
     /**
      * Add a OPTIONS route handler (typically to handle CORS preflight requests)
      */
@@ -138,8 +179,11 @@ export function createRoute(config: HS.RouteConfig = {}): HS.Route {
       _middleware['OPTIONS'] = handlerOptions?.middleware || [];
       return api;
     },
-    errorHandler(handler: HS.RouteHandler) {
-      _handlers['_ERROR'] = handler;
+    /**
+     * Set a custom error handler for this route to fall back to if the route handler throws an error
+     */
+    errorHandler(handler: HS.ErrorHandler) {
+      _errorHandler = handler;
       return api;
     },
     /**
@@ -197,7 +241,14 @@ export function createRoute(config: HS.RouteConfig = {}): HS.Route {
         }
 
         if (isHTMLContent(routeContent)) {
-          return returnHTMLResponse(context, () => routeContent);
+          // Merge server and route-specific response options
+          const responseOptions = { ...(api._serverConfig?.responseOptions ?? {}), ...(api._config?.responseOptions ?? {}) };
+          return returnHTMLResponse(context, () => routeContent, responseOptions);
+        }
+
+        const contentType = _typeOf(routeContent);
+        if (contentType === 'generator') {
+          return new StreamResponse(routeContent as AsyncGenerator);
         }
 
         return routeContent;
@@ -208,8 +259,9 @@ export function createRoute(config: HS.RouteConfig = {}): HS.Route {
       try {
         return await executeMiddleware(context, [...globalMiddleware, ...methodMiddleware, methodHandler]);
       } catch (e) {
-        if (_handlers['_ERROR']) {
-          return await (_handlers['_ERROR'](context) as Promise<Response>);
+        if (_errorHandler !== undefined) {
+          const responseOptions = { ...(api._serverConfig?.responseOptions ?? {}), ...(api._config?.responseOptions ?? {}) };
+          return returnHTMLResponse(context, () => (_errorHandler as HS.ErrorHandler)(context, e as Error), responseOptions);
         }
         throw e;
       }
@@ -297,7 +349,7 @@ function isHTMLContent(response: unknown): response is Response {
 export async function returnHTMLResponse(
   context: HS.Context,
   handlerFn: () => unknown,
-  responseOptions?: { status?: number; headers?: Record<string, string> }
+  responseOptions?: { status?: number; headers?: Record<string, string>; disableStreaming?: (context: HS.Context) => boolean }
 ): Promise<Response> {
   try {
     const routeContent = await handlerFn();
@@ -309,14 +361,22 @@ export async function returnHTMLResponse(
 
     // Render HSHtml if returned from route handler
     if (isHSHtml(routeContent)) {
-      // @TODO: Move this to config or something...
-      const streamOpt = context.req.query.get('__nostream');
-      const streamingEnabled = (streamOpt !== undefined ? streamOpt : true);
+      const disableStreaming = responseOptions?.disableStreaming?.(context) ?? false;
 
       // Stream only if enabled and there is async content to stream
-      if (streamingEnabled && (routeContent as HSHtml).asyncContent?.length > 0) {
+      if (!disableStreaming && (routeContent as HSHtml).asyncContent?.length > 0) {
         return new StreamResponse(
-          renderStream(routeContent as HSHtml),
+          renderStream(routeContent as HSHtml, {
+            renderChunk: (chunk) => {
+              return html`
+              <template id="${chunk.id}_content">${html.raw(chunk.content)}<!--end--></template>
+              <script>
+                window._hsc = window._hsc || [];
+                window._hsc.push({id: "${chunk.id}" });
+              </script>
+            `;
+            }
+          }),
           responseOptions
         ) as Response;
       } else {
@@ -382,8 +442,8 @@ async function showErrorReponse(
   const message = err.message || 'Internal Server Error';
 
   // Send correct status code if HTTPException
-  if (err instanceof HTTPException) {
-    status = err.status;
+  if (err instanceof HTTPResponseException) {
+    status = err._response?.status ?? 500;
   }
 
   const stack = !IS_PROD && err.stack ? err.stack.split('\n').slice(1).join('\n') : '';

package/src/types.ts

@@ -27,36 +27,62 @@ export namespace Hyperspan {
     // For customizing the routes and adding your own...
     beforeRoutesAdded?: (server: Hyperspan.Server) => void;
     afterRoutesAdded?: (server: Hyperspan.Server) => void;
+    responseOptions?: {
+      disableStreaming?: (context: Hyperspan.Context) => boolean;
+    };
+  };
+
+  export type CookieOptions = {
+    maxAge?: number;
+    domain?: string;
+    path?: string;
+    expires?: Date;
+    httpOnly?: boolean;
+    secure?: boolean;
+    sameSite?: 'lax' | 'strict' | true;
+  };
+  export type Cookies = {
+    _req: Request;
+    _responseHeaders: Headers | undefined;
+    _parsedCookies: Record<string, any>;
+    _encrypt: ((str: string) => string) | undefined;
+    _decrypt: ((str: string) => string) | undefined;
+    get: (name: string) => string | undefined;
+    set: (name: string, value: string, options?: CookieOptions) => void;
+    delete: (name: string) => void;
+  }
+
+  export type HSRequest = {
+    url: URL;
+    raw: Request;
+    method: string; // Always uppercase
+    headers: Headers; // Case-insensitive
+    query: URLSearchParams;
+    cookies: Hyperspan.Cookies;
+    text: () => Promise<string>;
+    json<T = unknown>(): Promise<T>;
+    formData(): Promise<FormData>;
+    urlencoded(): Promise<URLSearchParams>;
+  };
+
+  export type HSResponse = {
+    cookies: Hyperspan.Cookies;
+    headers: Headers; // Headers to merge with final outgoing response
+    html: (html: string, options?: ResponseInit) => Response
+    json: (json: any, options?: ResponseInit) => Response;
+    text: (text: string, options?: ResponseInit) => Response;
+    redirect: (url: string, options?: ResponseInit) => Response;
+    error: (error: Error, options?: ResponseInit) => Response;
+    notFound: (options?: ResponseInit) => Response;
+    merge: (response: Response) => Response;
+    raw: Response;
   };
 
   export interface Context {
     vars: Record<string, any>;
-    route: {
-      path: string;
-      params: Record<string, string>;
-      cssImports?: string[];
-    }
-    req: {
-      url: URL;
-      raw: Request;
-      method: string; // Always uppercase
-      headers: Headers; // Case-insensitive
-      query: URLSearchParams;
-      text: () => Promise<string>;
-      json<T = unknown>(): Promise<T>;
-      formData<T = unknown>(): Promise<T>;
-      urlencoded(): Promise<URLSearchParams>;
-    };
-    res: {
-      headers: Headers; // Headers to merge with final outgoing response
-      html: (html: string, options?: { status?: number; headers?: Record<string, string> }) => Response
-      json: (json: any, options?: { status?: number; headers?: Record<string, string> }) => Response;
-      text: (text: string, options?: { status?: number; headers?: Record<string, string> }) => Response;
-      redirect: (url: string, options?: { status?: number; headers?: Record<string, string> }) => Response;
-      error: (error: Error, options?: { status?: number; headers?: Record<string, string> }) => Response;
-      notFound: (options?: { status?: number; headers?: Record<string, string> }) => Response;
-      raw: Response;
-    };
+    route: RouteConfig;
+    req: HSRequest;
+    res: HSResponse;
   };
 
   export type ClientIslandOptions = {
@@ -65,9 +91,13 @@ export namespace Hyperspan {
   };
 
   export type RouteConfig = {
-    name?: string;
-    path?: string;
-    cssImports?: string[];
+    name: string | undefined;
+    path: string;
+    params: Record<string, string | undefined>;
+    cssImports: string[];
+    responseOptions?: {
+      disableStreaming?: (context: Hyperspan.Context) => boolean;
+    };
   };
   export type RouteHandler = (context: Hyperspan.Context) => unknown;
   export type RouteHandlerOptions = {
@@ -89,6 +119,11 @@ export namespace Hyperspan {
    */
   export type NextFunction = () => Promise<Response>;
 
+  /**
+   * Error handler function signature
+   */
+  export type ErrorHandler = (context: Hyperspan.Context, error: Error) => unknown | undefined;
+
   /**
    * Middleware function signature
    * Accepts context and next function, returns a Response
@@ -100,7 +135,8 @@ export namespace Hyperspan {
 
   export interface Route {
     _kind: 'hsRoute';
-    _config: Hyperspan.RouteConfig;
+    _config: Partial<Hyperspan.RouteConfig>;
+    _serverConfig?: Hyperspan.Config;
     _path(): string;
     _methods(): string[];
     get: (handler: Hyperspan.RouteHandler, handlerOptions?: Hyperspan.RouteHandlerOptions) => Hyperspan.Route;
@@ -109,7 +145,7 @@ export namespace Hyperspan {
     patch: (handler: Hyperspan.RouteHandler, handlerOptions?: Hyperspan.RouteHandlerOptions) => Hyperspan.Route;
     delete: (handler: Hyperspan.RouteHandler, handlerOptions?: Hyperspan.RouteHandlerOptions) => Hyperspan.Route;
     options: (handler: Hyperspan.RouteHandler, handlerOptions?: Hyperspan.RouteHandlerOptions) => Hyperspan.Route;
-    errorHandler: (handler: Hyperspan.RouteHandler) => Hyperspan.Route;
+    errorHandler: (handler: Hyperspan.ErrorHandler) => Hyperspan.Route;
     middleware: (middleware: Array<Hyperspan.MiddlewareFunction>) => Hyperspan.Route;
     fetch: (request: Request) => Promise<Response>;
   };
@@ -124,7 +160,7 @@ export namespace Hyperspan {
   ) => ActionResponse;
   export interface Action<T extends z.ZodTypeAny> {
     _kind: 'hsAction';
-    _config: Hyperspan.RouteConfig;
+    _config: Partial<Hyperspan.RouteConfig>;
     _path(): string;
     _form: null | ActionFormHandler<T>;
     form(form: ActionFormHandler<T>): Action<T>;
@@ -134,4 +170,19 @@ export namespace Hyperspan {
     middleware: (middleware: Array<Hyperspan.MiddlewareFunction>) => Action<T>;
     fetch: (request: Request) => Promise<Response>;
   }
+
+  /**
+   * Client JS Module = ESM Module + Public Path + Render Script Tag
+   */
+  export type ClientJSBuildResult = {
+    assetHash: string; // Asset hash of the module path
+    esmName: string; // Filename of the built JavaScript file without the extension
+    publicPath: string; // Full public path of the built JavaScript file
+    /**
+     * Render a <script type="module"> tag for the JS module
+     * @param loadScript - A function that loads the module or a string of code to load the module
+     * @returns HSHtml Template with the <script type="module"> tag
+     */
+    renderScriptTag: (loadScript?: ((module: unknown) => HSHtml | string) | string) => HSHtml;
+  }
 }

package/src/utils.test.ts

@@ -0,0 +1,196 @@
+import { test, expect, describe } from 'bun:test';
+import { formDataToJSON, parsePath } from './utils';
+
+describe('formDataToJSON', () => {
+  test('formDataToJSON returns empty object for empty FormData', () => {
+    const formData = new FormData();
+    const result = formDataToJSON(formData);
+
+    expect(result).toEqual({});
+  });
+
+  test('formDataToJSON handles simple FormData object', () => {
+    const formData = new FormData();
+    formData.append('name', 'John Doe');
+    formData.append('email', 'john@example.com');
+    formData.append('age', '30');
+
+    const result = formDataToJSON(formData);
+
+    expect(result).toEqual({
+      name: 'John Doe',
+      email: 'john@example.com',
+      age: '30',
+    });
+  });
+
+  test('formDataToJSON handles complex FormData with nested fields', () => {
+    const formData = new FormData();
+    formData.append('user[firstName]', 'John');
+    formData.append('user[lastName]', 'Doe');
+    formData.append('user[email]', 'john@example.com');
+    formData.append('user[address][street]', '123 Main St');
+    formData.append('user[address][city]', 'New York');
+    formData.append('user[address][zip]', '10001');
+
+    const result = formDataToJSON(formData);
+
+    expect(result).toEqual({
+      user: {
+        firstName: 'John',
+        lastName: 'Doe',
+        email: 'john@example.com',
+        address: {
+          street: '123 Main St',
+          city: 'New York',
+          zip: '10001',
+        },
+      },
+    } as any);
+  });
+
+  test('formDataToJSON handles FormData with array of values', () => {
+    const formData = new FormData();
+    formData.append('tags', 'javascript');
+    formData.append('tags', 'typescript');
+    formData.append('tags', 'nodejs');
+    formData.append('colors[]', 'red');
+    formData.append('colors[]', 'green');
+    formData.append('colors[]', 'blue');
+
+    const result = formDataToJSON(formData);
+
+    expect(result).toEqual({
+      tags: ['javascript', 'typescript', 'nodejs'],
+      colors: ['red', 'green', 'blue'],
+    });
+  });
+});
+
+describe('parsePath', () => {
+  test('parsePath returns root path for empty string', () => {
+    const result = parsePath('');
+    expect(result.path).toBe('/');
+    expect(result.params).toEqual([]);
+  });
+
+  test('parsePath handles simple path', () => {
+    const result = parsePath('users');
+    expect(result.path).toBe('/users');
+    expect(result.params).toEqual([]);
+  });
+
+  test('parsePath removes leading slash', () => {
+    const result = parsePath('/users');
+    expect(result.path).toBe('/users');
+    expect(result.params).toEqual([]);
+  });
+
+  test('parsePath removes trailing slash', () => {
+    const result = parsePath('users/');
+    expect(result.path).toBe('/users');
+    expect(result.params).toEqual([]);
+  });
+
+  test('parsePath removes both leading and trailing slashes', () => {
+    const result = parsePath('/users/');
+    expect(result.path).toBe('/users');
+    expect(result.params).toEqual([]);
+  });
+
+  test('parsePath handles nested paths', () => {
+    const result = parsePath('users/posts');
+    expect(result.path).toBe('/users/posts');
+    expect(result.params).toEqual([]);
+  });
+
+  test('parsePath lowercases path segments', () => {
+    const result = parsePath('Users/Posts');
+    expect(result.path).toBe('/users/posts');
+    expect(result.params).toEqual([]);
+  });
+
+  test('parsePath removes .ts extension', () => {
+    const result = parsePath('users.ts');
+    expect(result.path).toBe('/users');
+    expect(result.params).toEqual([]);
+  });
+
+  test('parsePath removes .js extension', () => {
+    const result = parsePath('users.js');
+    expect(result.path).toBe('/users');
+    expect(result.params).toEqual([]);
+  });
+
+  test('parsePath removes index from path', () => {
+    const result = parsePath('index');
+    expect(result.path).toBe('/');
+    expect(result.params).toEqual([]);
+  });
+
+  test('parsePath removes index.ts from path', () => {
+    const result = parsePath('index.ts');
+    expect(result.path).toBe('/');
+    expect(result.params).toEqual([]);
+  });
+
+  test('parsePath handles dynamic param with brackets', () => {
+    const result = parsePath('users/[userId]');
+    expect(result.path).toBe('/users/:userId');
+    expect(result.params).toEqual(['userId']);
+  });
+
+  test('parsePath handles multiple dynamic params', () => {
+    const result = parsePath('users/[userId]/posts/[postId]');
+    expect(result.path).toBe('/users/:userId/posts/:postId');
+    expect(result.params).toEqual(['userId', 'postId']);
+  });
+
+  test('parsePath handles catch-all param with spread', () => {
+    const result = parsePath('users/[...slug]');
+    expect(result.path).toBe('/users/*');
+    expect(result.params).toEqual(['...slug']);
+  });
+
+  test('parsePath handles catch-all param at root', () => {
+    const result = parsePath('[...slug]');
+    expect(result.path).toBe('/*');
+    expect(result.params).toEqual(['...slug']);
+  });
+
+  test('parsePath preserves param names in path but converts format', () => {
+    const result = parsePath('users/[userId]');
+    expect(result.path).toBe('/users/:userId');
+    expect(result.params).toEqual(['userId']);
+    // Param segment should not be lowercased
+    expect(result.path).toContain(':userId');
+  });
+
+  test('parsePath handles complex nested path with params', () => {
+    const result = parsePath('/api/users/[userId]/posts/[postId]/comments');
+    expect(result.path).toBe('/api/users/:userId/posts/:postId/comments');
+    expect(result.params).toEqual(['userId', 'postId']);
+  });
+
+  test('parsePath handles path with dots in param name', () => {
+    const result = parsePath('users/[user.id]');
+    expect(result.path).toBe('/users/:user.id');
+    expect(result.params).toEqual(['user.id']);
+  });
+
+  test('parsePath handles mixed case with params', () => {
+    const result = parsePath('Users/[UserId]/Posts');
+    expect(result.path).toBe('/users/:UserId/posts');
+    expect(result.params).toEqual(['UserId']);
+    // Non-param segments should be lowercased, but param name preserved
+    expect(result.path).toContain('/users/');
+    expect(result.path).toContain('/posts');
+  });
+
+  test('parsePath handles file path format', () => {
+    const result = parsePath('/routes/users/[userId].ts');
+    expect(result.path).toBe('/routes/users/:userId');
+    expect(result.params).toEqual(['userId']);
+  });
+});
+