@gnosticdev/hono-actions 1.2.4 → 2.0.0

package/README.md

@@ -1,4 +1,4 @@
-# Astro Actions with Hono and Valibot
+# Astro Actions with Hono
 
 Define server actions with built-in validation, error handling, and a pre-built hono client for calling the routes.
 
@@ -16,20 +16,96 @@ bun add @gnosticdev/hono-actions
 
 This package requires:
 
-- `astro`: ^5.13.3
+- `astro`: ^5.13.0
 
-All other dependencies (`hono`, `valibot`, `@hono/valibot-validator`, etc.) are bundled with the integration.
+## Supported Adapters
+
+This integration works with all supported Astro adapters:
+
+- `@astrojs/cloudflare`
+- `@astrojs/node`
+- `@astrojs/vercel`
+- `@astrojs/netlify`
 
 ## Setup
 
 ### 1. Add the integration to your Astro config
 
+The integration works with all Astro adapters. Here are examples for each:
+
+#### Cloudflare
+
+```typescript
+// astro.config.ts
+import { defineConfig } from 'astro/config'
+import cloudflare from '@astrojs/cloudflare'
+import honoActions from '@gnosticdev/hono-actions/integration'
+
+export default defineConfig({
+  output: 'server',
+  adapter: cloudflare(),
+  integrations: [
+    honoActions({
+      basePath: '/api', // Optional: default is '/api'
+      actionsPath: 'src/server/actions.ts' // Optional: custom path to your actions file
+    })
+  ]
+})
+```
+
+#### Node.js
+
+```typescript
+// astro.config.ts
+import { defineConfig } from 'astro/config'
+import node from '@astrojs/node'
+import honoActions from '@gnosticdev/hono-actions/integration'
+
+export default defineConfig({
+  output: 'server',
+  adapter: node({
+    mode: 'standalone' // or 'middleware'
+  }),
+  integrations: [
+    honoActions({
+      basePath: '/api', // Optional: default is '/api'
+      actionsPath: 'src/server/actions.ts' // Optional: custom path to your actions file
+    })
+  ]
+})
+```
+
+#### Vercel
+
 ```typescript
 // astro.config.ts
 import { defineConfig } from 'astro/config'
+import vercel from '@astrojs/vercel/serverless'
 import honoActions from '@gnosticdev/hono-actions/integration'
 
 export default defineConfig({
+  output: 'server',
+  adapter: vercel(),
+  integrations: [
+    honoActions({
+      basePath: '/api', // Optional: default is '/api'
+      actionsPath: 'src/server/actions.ts' // Optional: custom path to your actions file
+    })
+  ]
+})
+```
+
+#### Netlify
+
+```typescript
+// astro.config.ts
+import { defineConfig } from 'astro/config'
+import netlify from '@astrojs/netlify'
+import honoActions from '@gnosticdev/hono-actions/integration'
+
+export default defineConfig({
+  output: 'server',
+  adapter: netlify(),
   integrations: [
     honoActions({
       basePath: '/api', // Optional: default is '/api'
@@ -41,7 +117,7 @@ export default defineConfig({
 
 ### 2. Create your actions file
 
-Create a file at one of these locations (the integration will auto-discover):
+If not using a custom actions path, create a file at one of these locations:
 
 - `src/server/actions.ts`
 - `src/hono/actions.ts`
@@ -51,57 +127,61 @@ Create a file at one of these locations (the integration will auto-discover):
 ## Usage
 
 ```typescript
-// src/server/actions.ts
-import { defineHonoAction, HonoActionError } from '@gnosticdev/hono-actions'
-import * as v from 'valibot'
-
-// Define a simple action
-export const simpleAction = defineHonoAction({
-  path: '/simple',
-  schema: v.object({
-    name: v.string()
+// src/hono.ts (or any of the supported locations above)
+import { defineHonoAction type HonoEnv } from '@gnosticdev/hono-actions/actions'
+import { z } from 'astro/zod'
+import { Hono } from 'hono'
+
+// Define a POST action with Zod validation (no `path` option is used anymore)
+export const myAction = defineHonoAction({
+  schema: z.object({
+    name: z.string()
   }),
   handler: async (input, ctx) => {
-    // input is automatically typed based on schema
+    // `input` is automatically typed from the schema
+    // `ctx` is a strongly-typed Hono Context with your `HonoEnv`
     return { message: `Hello ${input.name}!` }
   }
 })
 
-// Define an action with validation
-export const validatedAction = defineHonoAction({
-  path: '/validated',
-  schema: v.object({
-    name: v.string(),
-    email: v.pipe(v.string(), v.email())
-  }),
+// Define another POST action
+export const anotherAction = defineHonoAction({
+  schema: z.object({ name2: z.string() }),
   handler: async (input, ctx) => {
-    // input is automatically typed based on schema
     return {
-      message: `Hello ${input.name}!`,
-      email: input.email
+      message2: `Hello ${input.name2}!`
     }
   }
 })
 
-// Use custom error handling
-export const errorAction = defineHonoAction({
-  path: '/error',
+// Optional: Define an action without a schema (accepts any JSON)
+export const noSchemaAction = defineHonoAction({
   handler: async (input, ctx) => {
-    if (someCondition) {
+    if (!('name' in input)) {
       throw new HonoActionError({
-        message: 'Custom error message',
-        code: 'EXTERNAL_API_ERROR'
+        message: 'Name is required',
+        code: 'INPUT_VALIDATION_ERROR'
       })
     }
-    return { success: true }
+    return { message: `Hello ${String((input as any).name)}!` }
   }
 })
 
-// Export all actions in a honoActions object
+// You can also define standard Hono routes (GET/PATCH/etc.), not just POST actions.
+// This is useful where standard Astro actions are POST-only.
+const app = new Hono<HonoEnv>()
+const getRoute = app.get('/', (c) => c.json({ message: 'Hi from a get route' }))
+
+// Export all actions and routes in a single `honoActions` object.
+// Each key becomes the route name under your basePath, e.g.:
+//  - POST /api/myAction
+//  - POST /api/anotherAction
+//  - GET  /api/getRoute
 export const honoActions = {
-  simpleAction,
-  validatedAction,
-  errorAction
+  myAction,
+  anotherAction,
+  noSchemaAction,
+  getRoute
 }
 ```
 
@@ -110,22 +190,22 @@ export const honoActions = {
 ```typescript
 // src/pages/example.astro or any .astro file
 ---
-import { honoClient } from '@gnosticdev/hono-actions/client'
+import { honoClient, parseResponse } from '@gnosticdev/hono-actions/client'
 
-const response = await honoClient.simpleAction.$post({
-  json: { name: 'John' }
-})
+// Call a POST action
+const { data: actionRes } = await parseResponse(
+  await honoClient.api.myAction.$post({ json: { name: 'John' } })
+)
 
-let result = null
-if (response.ok) {
-  result = await response.json() // { message: 'Hello John!' }
-} else {
-  console.error(await response.text()) // Error message
-}
+// Call a GET route
+const { message } = await parseResponse(
+  await honoClient.api.getRoute.$get()
+)
 ---
 
 <div>
-  {result && <p>{result.message}</p>}
+  {actionRes && <p>{actionRes.message}</p>}
+  <p>{message}</p>
 </div>
 ```
 
@@ -137,10 +217,9 @@ import { honoClient } from '@gnosticdev/hono-actions/client'
 
 // Make requests from the browser
 const handleSubmit = async (formData: FormData) => {
-  const response = await honoClient.validatedAction.$post({
+  const response = await honoClient.api.anotherAction.$post({
     json: {
-      name: formData.get('name') as string,
-      email: formData.get('email') as string
+      name2: formData.get('name') as string
     }
   })
 
@@ -156,11 +235,12 @@ const handleSubmit = async (formData: FormData) => {
 
 ## Package Structure
 
-This package provides two main entry points:
+This package provides these entry points:
 
-- **`@gnosticdev/hono-actions`** (default): Action definition utilities (`defineHonoAction`, `HonoActionError`, types)
-  - Safe for browser environments
-  - Used in your action files and client-side code
+- **`@gnosticdev/hono-actions/actions`**: Action definition utilities (`defineHonoAction`, `HonoActionError`, `HonoEnv`)
+  - Used in your actions file(s)
+- **`@gnosticdev/hono-actions/client`**: Pre-built Hono client and helpers (`honoClient`, `parseResponse`)
+  - Safe for browser and server environments
 - **`@gnosticdev/hono-actions/integration`**: Astro integration
   - Uses Node.js built-ins (fs, path)
   - Only used in `astro.config.ts`
@@ -175,11 +255,12 @@ The integration accepts the following options:
 ## Features
 
 - ✅ **Type-safe**: Full TypeScript support with automatic type inference
-- ✅ **Validation**: Built-in request validation using Valibot schemas
+- ✅ **Validation**: Built-in request validation using Zod schemas
 - ✅ **Error handling**: Custom error types and automatic error responses
 - ✅ **Auto-discovery**: Automatically finds your actions file
 - ✅ **Client generation**: Pre-built client with full type safety
 - ✅ **Development**: Hot reload support during development
+- ✅ **Flexible routing**: Define standard Hono routes (GET/PATCH/etc.) alongside POST actions
 
 ## Troubleshooting
 
@@ -188,7 +269,7 @@ The integration accepts the following options:
 If you get an error that no actions were found, make sure:
 
 1. Your actions file is in one of the supported locations
-2. You export a `honoActions` object containing your actions
+2. You export a `honoActions` object containing your actions and any Hono routes
 3. The file path matches the `actionsPath` option if you specified one
 
 ### Type errors

package/dist/actions.d.ts

@@ -24,6 +24,15 @@ interface Bindings {
  * HonoEnv is passed to the Hono context to provide types on `ctx.env`.
  *
  * We are using `HonoEnv` to avoid confusion with the Cloudflare types on `Env` -> which cooresponds to `Bindings`
+ *
+ *  * **NOTE** For Cloudflare users, you can declare this in your src/env.d.ts file to get strong
+ *  typing for `ctx.env`.
+ *
+ * ```ts
+ * declare namespace App {
+ *   interface Locals extends Runtime {}
+ * }
+ * ```
  */
 interface HonoEnv {
     Bindings: Bindings;
@@ -58,7 +67,7 @@ type HonoActionParams<TSchema extends HonoActionSchema, TReturn, TEnv extends Ho
     handler: (params: z.output<TSchema>, context: TContext extends infer Ctx ? Ctx : never) => Promise<TReturn>;
 };
 /**
- * Defines a type-safe Hono action using Zod for input validation.
+ * Defines a POST route with Zod validation for the request body.
  *
  * @param schema - The Zod schema for validation (optional).
  * @param handler - The handler function for the action.

package/dist/index.js

@@ -11,7 +11,11 @@ import { glob } from "tinyglobby";
 
 // src/integration-files.ts
 function generateRouter(opts) {
-  const { basePath, relativeActionsPath } = opts;
+  const { basePath, relativeActionsPath, adapter } = opts;
+  let exportedApp = `export default app`;
+  if (adapter === "@astrojs/netlify") {
+    exportedApp = `export default handle(app)`;
+  }
   return `import type { HonoEnv, MergeActionKeyIntoPath } from '@gnosticdev/hono-actions/actions'
 import { Hono } from 'hono'
 import { cors } from 'hono/cors'
@@ -19,12 +23,13 @@ import { showRoutes } from 'hono/dev'
 import { logger } from 'hono/logger'
 import { prettyJSON } from 'hono/pretty-json'
 import type { ExtractSchema, MergeSchemaPath } from 'hono/types'
+${adapter === "@astrojs/netlify" ? "import { handle } from 'hono/netlify'" : ""}
 
 async function buildRouter(){
     type ActionsWithKeyedPaths = MergeActionKeyIntoPath<typeof honoActions>
     type ActionSchema = ExtractSchema<ActionsWithKeyedPaths[keyof ActionsWithKeyedPaths]>
     const { honoActions} = await import('${relativeActionsPath}')
-    const app = new Hono<HonoEnv, MergeSchemaPath<ActionSchema, \`${basePath}\`>>().basePath('${basePath}')
+    const app = new Hono<HonoEnv, MergeSchemaPath<ActionSchema, '${basePath}'>>().basePath('${basePath}')
 
     app.use('*', cors(), logger(), prettyJSON())
 
@@ -41,7 +46,7 @@ const app = await buildRouter()
 console.log('------- Hono Routes -------')
 showRoutes(app)
 console.log('---------------------------')
-export default app`;
+${exportedApp}`;
 }
 var generateAstroHandler = (adapter) => {
   switch (adapter) {
@@ -49,17 +54,49 @@ var generateAstroHandler = (adapter) => {
       return `
 /// <reference types="./types.d.ts" />
 // Generated by Hono Actions Integration
+// adapter: ${adapter}
+import type { APIContext, APIRoute } from 'astro'
+import router from './router.js'
+
+const handler: APIRoute<APIContext> = async (ctx) => {
+    return router.fetch(
+        ctx.request,
+        ctx.locals.runtime.env, // required for cloudflare adapter
+        ctx.locals.runtime.ctx, // required for cloudflare adapter
+    )
+}
+
+export { handler as ALL }
+`;
+    case "@astrojs/node":
+    case "@astrojs/vercel":
+      return `
+/// <reference types="./types.d.ts" />
+// Generated by Hono Actions Integration
+// adapter: ${adapter}
 import type { APIContext, APIRoute } from 'astro'
 import router from './router.js'
 
 const handler: APIRoute<APIContext> = async (ctx) => {
     return router.fetch(
         ctx.request,
-        ctx.locals.runtime.env,
-        ctx.locals.runtime.ctx,
     )
 }
 
+export { handler as ALL }
+`;
+    case "@astrojs/netlify":
+      return `
+/// <reference types="./types.d.ts" />
+// Generated by Hono Actions Integration
+// adapter: ${adapter}
+import type { APIContext, APIRoute } from 'astro'
+import netlifyHandler from './router.js'
+
+const handler: APIRoute<APIContext> = async (ctx) => {
+    return netlifyHandler(ctx.request, ctx)
+}
+
 export { handler as ALL }
 `;
     default:
@@ -70,6 +107,7 @@ var generateHonoClient = (port) => `
 // Generated by Hono Actions Integration
 import type { HonoRouter } from './router.js'
 import { hc, parseResponse } from 'hono/client'
+import type { DetailedError } from 'hono/client'
 
 function getBaseUrl() {
     // client side can just use the base path
@@ -86,11 +124,16 @@ function getBaseUrl() {
     return import.meta.env.SITE ?? ''
 }
 export { parseResponse, hc }
+export type { DetailedError }
 export const honoClient = hc<HonoRouter>(getBaseUrl())
 `;
 
 // src/lib/utils.ts
 var reservedRoutes = ["_astro", "_actions", "_server_islands"];
+var SUPPORTED_ADAPTERS = ["@astrojs/cloudflare", "@astrojs/node", "@astrojs/netlify", "@astrojs/vercel"];
+function isSupportedAdapter(adapter) {
+  return SUPPORTED_ADAPTERS.includes(adapter);
+}
 
 // src/integration.ts
 var optionsSchema = z.object({
@@ -119,10 +162,6 @@ var ACTION_PATTERNS = [
   "src/hono/index.ts",
   "src/hono.ts"
 ];
-var SUPPORTED_ADAPTERS = ["@astrojs/cloudflare"];
-function isSupportedAdapter(adapter) {
-  return SUPPORTED_ADAPTERS.includes(adapter);
-}
 var integration_default = defineIntegration({
   name: "@gnosticdev/hono-actions",
   optionsSchema,
@@ -164,33 +203,31 @@ ${ACTION_PATTERNS.map((p) => ` - ${p}`).join("\n")}`
             "router.ts"
           );
           const relFromGenToActions = path.relative(codeGenDir.pathname, resolvedActionsPath).split(path.sep).join("/");
-          const routerContent = generateRouter({
-            basePath,
-            relativeActionsPath: relFromGenToActions
-          });
-          await fs.writeFile(routerPathAbs, routerContent, "utf-8");
-          const astroHandlerPathAbs = path.join(
-            codeGenDir.pathname,
-            "api.ts"
-          );
           const adapter = params.config.adapter?.name;
           if (!adapter) {
             logger.error(
               `No Astro adapter found. Add one of:
-                            - ${SUPPORTED_ADAPTERS.join("\n - ")} to your astro.config.mjs`
+                                - ${SUPPORTED_ADAPTERS.join("\n - ")} to your astro.config.mjs`
             );
             return;
           }
-          let astroHandlerContent;
-          if (isSupportedAdapter(adapter)) {
-            astroHandlerContent = generateAstroHandler(adapter);
-          } else {
-            throw new Error(`Unsupported adapter: ${adapter}`, {
-              cause: `Only ${SUPPORTED_ADAPTERS.join(
-                ", "
-              )} are supported for now`
-            });
+          if (!isSupportedAdapter(adapter)) {
+            logger.error(
+              `Unsupported adapter: ${adapter}. Only ${SUPPORTED_ADAPTERS.join("\n - ")} are supported`
+            );
+            return;
           }
+          const routerContent = generateRouter({
+            basePath,
+            relativeActionsPath: relFromGenToActions,
+            adapter
+          });
+          await fs.writeFile(routerPathAbs, routerContent, "utf-8");
+          const astroHandlerPathAbs = path.join(
+            codeGenDir.pathname,
+            "api.ts"
+          );
+          const astroHandlerContent = generateAstroHandler(adapter);
           await fs.writeFile(
             astroHandlerPathAbs,
             astroHandlerContent,
@@ -241,22 +278,28 @@ export {}
 declare module '@gnosticdev/hono-actions/client' {
     export const honoClient: typeof import('./client').honoClient
     export const parseResponse: typeof import('./client').parseResponse
+    exoprt type DetailedError = import('./client').DetailedError
 }
 `;
-          if (!config.adapter?.name) {
+          const adapter = config.adapter?.name;
+          if (!adapter) {
             logger.warn("No adapter found...");
             return;
           }
-          if (config.adapter.name !== "@astrojs/cloudflare") {
-            logger.warn("Unsupported adapter...");
+          if (!isSupportedAdapter(adapter)) {
+            logger.warn(
+              `Unsupported adapter: ${adapter}. Only ${SUPPORTED_ADAPTERS.join("\n - ")} are supported`
+            );
             return;
           }
-          clientTypes += `
+          if (adapter === "@astrojs/cloudflare") {
+            clientTypes += `
     type Runtime = import('@astrojs/cloudflare').Runtime<Env>
-    declare namespace App {
-        interface Locals extends Runtime {}
-    }
-`;
+        declare namespace App {
+            interface Locals extends Runtime {}
+        }
+    `;
+          }
           injectTypes({
             filename: "types.d.ts",
             content: clientTypes

package/package.json

@@ -14,7 +14,12 @@
   "devDependencies": {
     "tsup": "^8.5.0",
     "typescript": "catalog:",
-    "vitest": "catalog:"
+    "vitest": "catalog:",
+    "@astrojs/cloudflare": "catalog:",
+    "@astrojs/netlify": "catalog:",
+    "@astrojs/node": "catalog:",
+    "@astrojs/vercel": "catalog:",
+    "astro": "catalog:"
   },
   "exports": {
     ".": {
@@ -56,5 +61,5 @@
   },
   "type": "module",
   "types": "./dist/index.d.ts",
-  "version": "1.2.4"
+  "version": "2.0.0"
 }