@hyperspan/framework 1.0.21 → 1.0.23

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hyperspan/framework",
-  "version": "1.0.21",
+  "version": "1.0.23",
   "description": "Hyperspan Web Framework",
   "main": "src/server.ts",
   "types": "src/server.ts",
@@ -84,6 +84,6 @@
     "@hyperspan/html": "^1.0.1",
     "debug": "^4.4.3",
     "isbot": "^5.1.32",
-    "zod": "^4.1.12"
+    "zod": "^4.4.3"
   }
 }

package/src/actions.test.ts

@@ -2,7 +2,7 @@ import { test, expect, describe } from 'bun:test';
 import { createAction } from './actions';
 import { html, render, type HSHtml } from '@hyperspan/html';
 import { createContext } from './server';
-import * as z from 'zod/v4';
+import * as z from 'zod';
 
 describe('createAction', () => {
   test('creates an action with a simple form and no schema', async () => {
@@ -71,6 +71,34 @@ describe('createAction', () => {
     expect(responseText).toContain('<p>Hello, John Doe!</p>');
   });
 
+  test('returns HSHtml directly from POST handler', async () => {
+    const action = createAction({
+      name: 'test',
+    }).form((c) => {
+      return html`
+          <form>
+            <input type="text" name="name" />
+            <button type="submit">Submit</button>
+          </form>
+        `;
+    }).post(async (c, { data }) => {
+      return html`<p>Hello, ${data?.name}!</p>`;
+    });
+
+    const formData = new FormData();
+    formData.append('name', 'Jane Doe');
+
+    const request = new Request(`http://localhost:3000${action._path()}`, {
+      method: 'POST',
+      body: formData,
+    });
+    const response = await action.fetch(request);
+    expect(response).toBeInstanceOf(Response);
+    expect(response.status).toBe(200);
+    const responseText = await response.text();
+    expect(responseText).toContain('<p>Hello, Jane Doe!</p>');
+  });
+
   test('errors thrown on POST handler provided by user are caught and rendered', async () => {
     const action = createAction({
       name: 'test',

package/src/actions.ts

@@ -1,6 +1,6 @@
 import { html } from '@hyperspan/html';
 import { createRoute, HTTPResponseException, returnHTMLResponse } from './server';
-import * as z from 'zod/v4';
+import * as z from 'zod';
 import type { Hyperspan as HS } from './types';
 import { assetHash, formDataToJSON } from './utils';
 import { buildClientJS } from './client/js';
@@ -23,12 +23,20 @@ const actionsClientJS = await buildClientJS(import.meta.resolve('./client/_hs/hy
  * 5. Replaces form content in place with HTML response content from server via the Idiomorph library
  * 6. Handles any Exception thrown on server as error displayed back to user on the page
  */
-export function createAction<T extends z.ZodObject<any, any>>(params: { name: string; schema?: T }): HS.Action<T> {
+export function createAction<S extends z.ZodType>(
+  params: { name: string; schema: S }
+): HS.Action<S>;
+export function createAction(
+  params: { name: string; schema?: undefined }
+): HS.Action<undefined>;
+export function createAction<S extends z.ZodType>(
+  params: { name: string; schema?: S }
+): HS.Action<S | undefined> {
   const { name, schema } = params;
   const path = `/__actions/${assetHash(name)}`;
 
-  let _handler: Parameters<HS.Action<T>['post']>[0] | null = null;
-  let _errorHandler: Parameters<HS.Action<T>['errorHandler']>[0] | null = null;
+  let _handler: Parameters<HS.Action<S | undefined>['post']>[0] | null = null;
+  let _errorHandler: Parameters<HS.Action<S | undefined>['errorHandler']>[0] | null = null;
 
   const route = createRoute({ path, name })
     .get((c: HS.Context) => api.render(c))
@@ -37,7 +45,7 @@ export function createAction<T extends z.ZodObject<any, any>>(params: { name: st
         throw new Error('Action POST handler not set! Every action must have a POST handler.');
       }
 
-      const data = c.vars.body as z.infer<T> || formDataToJSON(await c.req.formData()) || {};
+      const data = c.vars.body as HS.InferActionData<S> || formDataToJSON(await c.req.formData()) || {};
       log('POST handler', { data });
       const response = await _handler(c, { data });
       log('POST handler response', { response });
@@ -57,7 +65,7 @@ export function createAction<T extends z.ZodObject<any, any>>(params: { name: st
      * Custom error handler for the action since validateBody() throws a HTTPResponseException
      */
     .errorHandler(async (c: HS.Context, err: HTTPResponseException) => {
-      const data = c.vars.body as z.infer<T> || formDataToJSON(await c.req.formData()) || {};
+      const data = c.vars.body as HS.InferActionData<S> || formDataToJSON(await c.req.formData()) || {};
       const error = err._error as ZodValidationError || err;
 
       // Set the status to 400 if it's a ZodValidationError, otherwise 500 (Error thrown by user POST handler)
@@ -73,7 +81,7 @@ export function createAction<T extends z.ZodObject<any, any>>(params: { name: st
   // Set the name of the action for the route
   route._config.name = name;
 
-  const api: HS.Action<T> = {
+  const api: HS.Action<S | undefined> = {
     _kind: 'hsAction',
     _config: route._config,
     _path() {

package/src/middleware.ts

@@ -1,8 +1,8 @@
 import { formDataToJSON } from './utils';
-import { z, flattenError, prettifyError } from 'zod/v4';
+import { z, flattenError, prettifyError } from 'zod';
 import { HTTPResponseException } from './server';
 
-import type { ZodAny, ZodObject, ZodError } from 'zod/v4';
+import type { ZodAny, ZodObject, ZodError } from 'zod';
 import type { Hyperspan as HS } from './types';
 
 export type TValidationType = 'json' | 'form' | 'urlencoded';

package/src/types.ts

@@ -1,5 +1,5 @@
 import { HSHtml } from '@hyperspan/html';
-import * as z from 'zod/v4';
+import * as z from 'zod';
 
 /**
  * Hyperspan Types
@@ -175,30 +175,41 @@ export namespace Hyperspan {
   /**
    * Action = Form + route handler
    */
+  /** Raw form field values when an action has no schema */
+  export type ActionFormValues = Record<string, string | string[]>;
+  /** Infer validated action data from an optional schema */
+  export type InferActionData<S extends z.ZodType | undefined> =
+    S extends z.ZodType ? z.output<S> : ActionFormValues;
   // Form renderer
   export type ActionFormResponse = HSHtml | void | null | Promise<HSHtml | void | null>;
-  export type ActionFormProps<T extends z.ZodTypeAny> = { data?: Partial<z.infer<T>>; error?: ZodValidationError };
-  export type ActionForm<T extends z.ZodTypeAny> = (
-    c: Context, props: ActionFormProps<T>
+  export type ActionFormProps<S extends z.ZodType | undefined = undefined> = {
+    data?: Partial<InferActionData<S>>;
+    error?: ZodValidationError;
+  };
+  export type ActionForm<S extends z.ZodType | undefined = undefined> = (
+    c: Context, props: ActionFormProps<S>
   ) => ActionFormResponse;
   // Form handler
-  export type ActionFormHandlerResponse = ActionFormResponse | Response | Promise<Response>;
-  export type ActionFormHandlerProps<T extends z.ZodTypeAny> = { data: z.infer<T>; error?: ZodValidationError | Error };
-  export type ActionFormHandler<T extends z.ZodTypeAny> = (
-    c: Context, props: ActionFormHandlerProps<T>
-  ) => ActionFormHandlerResponse;
+  export type ActionFormHandlerReturn = RouteHandlerReturn;
+  export type ActionFormHandlerProps<S extends z.ZodType | undefined = undefined> = {
+    data: InferActionData<S>;
+    error?: ZodValidationError | Error;
+  };
+  export type ActionFormHandler<S extends z.ZodType | undefined = undefined> = (
+    c: Context, props: ActionFormHandlerProps<S>
+  ) => ActionFormHandlerReturn | Promise<ActionFormHandlerReturn>;
   // Action API
-  export interface Action<T extends z.ZodTypeAny> {
+  export interface Action<S extends z.ZodType | undefined = undefined> {
     _kind: 'hsAction';
     _config: Partial<Hyperspan.RouteConfig>;
     _path(): string;
-    _form: null | ActionForm<T>;
-    form(form: ActionForm<T>): Action<T>;
-    render: (c: Context, props?: ActionFormProps<T>) => ActionFormResponse;
-    post: (handler: ActionFormHandler<T>) => Action<T>;
-    errorHandler: (handler: ActionFormHandler<T>) => Action<T>;
-    use: (middleware: Hyperspan.MiddlewareFunction, opts?: Hyperspan.MiddlewareMethodOptions) => Action<T>;
-    middleware: (middleware: Array<Hyperspan.MiddlewareFunction>, opts?: Hyperspan.MiddlewareMethodOptions) => Action<T>;
+    _form: null | ActionForm<S>;
+    form(form: ActionForm<S>): Action<S>;
+    render: (c: Context, props?: ActionFormProps<S>) => ActionFormResponse;
+    post: (handler: ActionFormHandler<S>) => Action<S>;
+    errorHandler: (handler: ActionFormHandler<S>) => Action<S>;
+    use: (middleware: Hyperspan.MiddlewareFunction, opts?: Hyperspan.MiddlewareMethodOptions) => Action<S>;
+    middleware: (middleware: Array<Hyperspan.MiddlewareFunction>, opts?: Hyperspan.MiddlewareMethodOptions) => Action<S>;
     fetch: (request: Request) => Promise<Response>;
   }