@gnosticdev/hono-actions 1.0.0 → 1.0.2

package/README.md

@@ -1,32 +1,69 @@
-# @gnosticdev/define-hono-action
+# Astro Actions with Hono and Valibot
 
-Type-safe Hono action definitions with Valibot validation.
+Define server actions with built-in validation, error handling, and a pre-built hono client for calling the routes.
 
 ## Installation
 
 ```bash
-npm install @gnosticdev/define-hono-action
+npm install @gnosticdev/hono-actions
+# or
+pnpm add @gnosticdev/hono-actions
+# or
+bun add @gnosticdev/hono-actions
 ```
 
-## Peer Dependencies
+## Requirements
 
-This package requires the following peer dependencies:
+This package requires:
 
-- `@hono/valibot-validator`: ^0.2.0
-- `hono`: ^4.0.0
-- `valibot`: ^0.30.0
+- `astro`: ^5.13.3
+
+All other dependencies (`hono`, `valibot`, `@hono/valibot-validator`, etc.) are bundled with the integration.
+
+## Setup
+
+### 1. Add the integration to your Astro config
+
+```typescript
+// astro.config.ts
+import { defineConfig } from 'astro/config'
+import honoActions from '@gnosticdev/hono-actions'
+
+export default defineConfig({
+  integrations: [
+    honoActions({
+      basePath: '/api', // Optional: default is '/api'
+      actionsPath: 'src/server/actions.ts' // Optional: custom path to your actions file
+    })
+  ]
+})
+```
+
+### 2. Create your actions file
+
+Create a file at one of these locations (the integration will auto-discover):
+
+- `src/server/actions.ts`
+- `src/hono/actions.ts`
+- `src/hono/index.ts`
+- `src/hono.ts`
 
 ## Usage
 
 ```typescript
-import { defineHonoAction, ActionError } from '@gnosticdev/define-hono-action'
+// src/server/actions.ts
+import { defineHonoAction, ActionError } 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()
+  }),
   handler: async (input, ctx) => {
-    return { message: 'Hello World!' }
+    // input is automatically typed based on schema
+    return { message: `Hello ${input.name}!` }
   }
 })
 
@@ -57,7 +94,7 @@ export const errorAction = defineHonoAction({
   }
 })
 
-// Export all actions
+// Export all actions in a honoActions object
 export const honoActions = {
   simpleAction,
   validatedAction,
@@ -65,24 +102,95 @@ export const honoActions = {
 }
 ```
 
-## Types
+### 3. Use actions in your Astro components or pages
+
+```typescript
+// src/pages/example.astro or any .astro file
+---
+import { honoClient } from '@gnosticdev/hono-actions/client'
+
+const response = await honoClient.simpleAction.$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
+}
+---
+
+<div>
+  {result && <p>{result.message}</p>}
+</div>
+```
+
+### 4. Use in client-side JavaScript
+
+```typescript
+// In a client-side script or component
+import { honoClient } from '@gnosticdev/hono-actions/client'
+
+// Make requests from the browser
+const handleSubmit = async (formData: FormData) => {
+  const response = await honoClient.validatedAction.$post({
+    json: {
+      name: formData.get('name') as string,
+      email: formData.get('email') as string
+    }
+  })
+
+  if (response.ok) {
+    const result = await response.json()
+    console.log('Success:', result)
+  } else {
+    const error = await response.text()
+    console.error('Error:', error)
+  }
+}
+```
+
+## Configuration Options
+
+The integration accepts the following options:
+
+- **`basePath`** (optional): The base path for your API routes. Default: `'/api'`
+- **`actionsPath`** (optional): Custom path to your actions file if not using auto-discovery
+
+## Features
+
+- ✅ **Type-safe**: Full TypeScript support with automatic type inference
+- ✅ **Validation**: Built-in request validation using Valibot 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
+
+## Troubleshooting
+
+### Actions not found
+
+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
+3. The file path matches the `actionsPath` option if you specified one
+
+### Type errors
 
-The package exports the following types:
+If you're getting TypeScript errors:
 
-- `ActionErrorCode`: Union type of possible error codes
-- `ActionError`: Custom error class for action errors
-- `HonoActions`: Type for collections of actions
+1. Make sure all peer dependencies are installed
+2. Run `astro sync` to regenerate types
+3. Restart your TypeScript server in your editor
 
-## Error Codes
+### Module resolution errors
 
-Available error codes:
+If you get module resolution errors during development:
 
-- `INPUT_VALIDATION_ERROR`: Validation failed for input data
-- `EXTERNAL_API_ERROR`: Error calling external API
-- `INTERNAL_SERVER_ERROR`: Internal server error
-- `UNKNOWN_ERROR`: Unknown error occurred
-- `LOCATION_NOT_FOUND`: Location not found
-- `SESSION_NOT_FOUND`: Session not found
+1. Try clearing your node_modules and reinstalling
+2. Make sure you're using compatible versions of the peer dependencies
 
 ## License
 

package/dist/index.d.ts

@@ -1,5 +1,144 @@
-import type { Bindings, HonoEnv } from './define-action.js';
-import { defineHonoAction } from './define-action.js';
-import { HonoActionError } from './error.js';
-export type { Bindings, HonoEnv };
-export { defineHonoAction, HonoActionError };
+import * as hono_hono_base from 'hono/hono-base';
+import * as hono_utils_types from 'hono/utils/types';
+import * as hono_types from 'hono/types';
+import { Context } from 'hono';
+import * as v from 'valibot';
+import * as astro from 'astro';
+
+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`
+ */
+interface HonoEnv {
+    Bindings: Bindings;
+    Variables: Record<string, any>;
+}
+type HonoActionSchema = v.ObjectSchema<v.ObjectEntries, v.ErrorMessage<v.ObjectIssue> | undefined> | v.NeverSchema<undefined>;
+interface HonoActionContext<TEnv extends HonoEnv, TPath extends string, TSchema extends HonoActionSchema> extends Context<TEnv, TPath, {
+    input: v.InferInput<TSchema>;
+    output: v.InferOutput<TSchema>;
+    outputFormat: 'json';
+}> {
+    env: TEnv['Bindings'];
+}
+type HonoActionParams<TPath extends string, TSchema extends HonoActionSchema, TReturn, TEnv extends HonoEnv = HonoEnv> = {
+    path: TPath;
+    schema?: TSchema;
+    handler: (params: v.InferOutput<TSchema>, context: HonoActionContext<TEnv, TPath, TSchema>) => Promise<TReturn>;
+};
+/**
+ * Defines a type-safe Hono action using Valibot for input validation.
+ *
+ * @param path - The path of the action.
+ * @param schema - The object schema for Valibot validation.
+ * @default never
+ * @param handler - The handler function for the action.
+ * @returns A Hono app instance with the defined route
+ */
+declare function defineHonoAction<TPath extends string, TSchema extends HonoActionSchema, TReturn, TEnv extends HonoEnv = HonoEnv>({ path, schema, handler }: HonoActionParams<TPath, TSchema, TReturn, TEnv>): hono_hono_base.HonoBase<TEnv, { [K in hono_types.MergePath<"/", TPath>]: {
+    $post: {
+        input: hono_types.AddParam<unknown extends ((undefined extends v.InferInput<TSchema | v.UnionSchema<[v.NeverSchema<undefined>, v.ObjectSchema<{}, undefined>], undefined>> ? true : false) extends true ? {
+            json?: (v.InferInput<TSchema | v.UnionSchema<[v.NeverSchema<undefined>, v.ObjectSchema<{}, undefined>], undefined>> extends infer T_1 ? T_1 extends v.InferInput<TSchema | v.UnionSchema<[v.NeverSchema<undefined>, v.ObjectSchema<{}, undefined>], undefined>> ? T_1 extends any ? T_1 : { [K2 in keyof T_1]?: any; } : never : never) | undefined;
+        } : {
+            json: v.InferInput<TSchema | v.UnionSchema<[v.NeverSchema<undefined>, v.ObjectSchema<{}, undefined>], undefined>> extends infer T_2 ? T_2 extends v.InferInput<TSchema | v.UnionSchema<[v.NeverSchema<undefined>, v.ObjectSchema<{}, undefined>], undefined>> ? T_2 extends any ? T_2 : { [K2_1 in keyof T_2]: any; } : never : never;
+        }) ? {} : (undefined extends v.InferInput<TSchema | v.UnionSchema<[v.NeverSchema<undefined>, v.ObjectSchema<{}, undefined>], undefined>> ? true : false) extends true ? {
+            json?: (v.InferInput<TSchema | v.UnionSchema<[v.NeverSchema<undefined>, v.ObjectSchema<{}, undefined>], undefined>> extends infer T_3 ? T_3 extends v.InferInput<TSchema | v.UnionSchema<[v.NeverSchema<undefined>, v.ObjectSchema<{}, undefined>], undefined>> ? T_3 extends any ? T_3 : { [K2_2 in keyof T_3]?: any; } : never : never) | undefined;
+        } : {
+            json: v.InferInput<TSchema | v.UnionSchema<[v.NeverSchema<undefined>, v.ObjectSchema<{}, undefined>], undefined>> extends infer T_4 ? T_4 extends v.InferInput<TSchema | v.UnionSchema<[v.NeverSchema<undefined>, v.ObjectSchema<{}, undefined>], undefined>> ? T_4 extends any ? T_4 : { [K2_3 in keyof T_4]: any; } : never : never;
+        }, hono_types.MergePath<"/", TPath>>;
+        output: unknown extends ({
+            data: Awaited<TReturn>;
+            error: null;
+        } extends hono_utils_types.JSONValue ? { [K_2 in keyof {
+            data: Awaited<TReturn>;
+            error: null;
+        } as ({
+            data: Awaited<TReturn>;
+            error: null;
+        }[K_2] extends infer T_5 ? T_5 extends {
+            data: Awaited<TReturn>;
+            error: null;
+        }[K_2] ? T_5 extends hono_utils_types.InvalidJSONValue ? true : false : never : never) extends true ? never : K_2]: boolean extends ({
+            data: Awaited<TReturn>;
+            error: null;
+        }[K_2] extends infer T_6 ? T_6 extends {
+            data: Awaited<TReturn>;
+            error: null;
+        }[K_2] ? T_6 extends hono_utils_types.InvalidJSONValue ? true : false : never : never) ? hono_utils_types.JSONParsed<{
+            data: Awaited<TReturn>;
+            error: null;
+        }[K_2]> | undefined : hono_utils_types.JSONParsed<{
+            data: Awaited<TReturn>;
+            error: null;
+        }[K_2]>; } : never) ? {} : {
+            data: Awaited<TReturn>;
+            error: null;
+        } extends hono_utils_types.JSONValue ? { [K_2 in keyof {
+            data: Awaited<TReturn>;
+            error: null;
+        } as ({
+            data: Awaited<TReturn>;
+            error: null;
+        }[K_2] extends infer T_5 ? T_5 extends {
+            data: Awaited<TReturn>;
+            error: null;
+        }[K_2] ? T_5 extends hono_utils_types.InvalidJSONValue ? true : false : never : never) extends true ? never : K_2]: boolean extends ({
+            data: Awaited<TReturn>;
+            error: null;
+        }[K_2] extends infer T_6 ? T_6 extends {
+            data: Awaited<TReturn>;
+            error: null;
+        }[K_2] ? T_6 extends hono_utils_types.InvalidJSONValue ? true : false : never : never) ? hono_utils_types.JSONParsed<{
+            data: Awaited<TReturn>;
+            error: null;
+        }[K_2]> | undefined : hono_utils_types.JSONParsed<{
+            data: Awaited<TReturn>;
+            error: null;
+        }[K_2]>; } : never;
+        outputFormat: "json";
+        status: 200;
+    } | {
+        input: hono_types.AddParam<unknown extends ((undefined extends v.InferInput<TSchema | v.UnionSchema<[v.NeverSchema<undefined>, v.ObjectSchema<{}, undefined>], undefined>> ? true : false) extends true ? {
+            json?: (v.InferInput<TSchema | v.UnionSchema<[v.NeverSchema<undefined>, v.ObjectSchema<{}, undefined>], undefined>> extends infer T_5 ? T_5 extends v.InferInput<TSchema | v.UnionSchema<[v.NeverSchema<undefined>, v.ObjectSchema<{}, undefined>], undefined>> ? T_5 extends any ? T_5 : { [K2_4 in keyof T_5]?: any; } : never : never) | undefined;
+        } : {
+            json: v.InferInput<TSchema | v.UnionSchema<[v.NeverSchema<undefined>, v.ObjectSchema<{}, undefined>], undefined>> extends infer T_6 ? T_6 extends v.InferInput<TSchema | v.UnionSchema<[v.NeverSchema<undefined>, v.ObjectSchema<{}, undefined>], undefined>> ? T_6 extends any ? T_6 : { [K2_5 in keyof T_6]: any; } : never : never;
+        }) ? {} : (undefined extends v.InferInput<TSchema | v.UnionSchema<[v.NeverSchema<undefined>, v.ObjectSchema<{}, undefined>], undefined>> ? true : false) extends true ? {
+            json?: (v.InferInput<TSchema | v.UnionSchema<[v.NeverSchema<undefined>, v.ObjectSchema<{}, undefined>], undefined>> extends infer T_7 ? T_7 extends v.InferInput<TSchema | v.UnionSchema<[v.NeverSchema<undefined>, v.ObjectSchema<{}, undefined>], undefined>> ? T_7 extends any ? T_7 : { [K2_6 in keyof T_7]?: any; } : never : never) | undefined;
+        } : {
+            json: v.InferInput<TSchema | v.UnionSchema<[v.NeverSchema<undefined>, v.ObjectSchema<{}, undefined>], undefined>> extends infer T_8 ? T_8 extends v.InferInput<TSchema | v.UnionSchema<[v.NeverSchema<undefined>, v.ObjectSchema<{}, undefined>], undefined>> ? T_8 extends any ? T_8 : { [K2_7 in keyof T_8]: any; } : never : never;
+        }, hono_types.MergePath<"/", TPath>>;
+        output: {
+            data: null;
+            error: {
+                message: string;
+                code: string;
+            };
+        };
+        outputFormat: "json";
+        status: 500;
+    };
+}; } extends infer T ? { [KeyType in keyof T]: T[KeyType]; } : never, "/">;
+
+/**
+ * Standard error codes for actions
+ */
+type ActionErrorCode = 'INPUT_VALIDATION_ERROR' | 'EXTERNAL_API_ERROR' | 'INTERNAL_SERVER_ERROR' | 'UNKNOWN_ERROR' | 'LOCATION_NOT_FOUND' | 'SESSION_NOT_FOUND';
+declare class HonoActionError<TSchema extends v.ObjectSchema<v.ObjectEntries, v.ErrorMessage<v.ObjectIssue> | undefined>, TMessage extends string, TCode extends ActionErrorCode, TIssue extends v.InferIssue<TSchema>> extends Error {
+    code: TCode;
+    issue?: TIssue;
+    constructor({ message, code, issue }: {
+        message: TMessage;
+        code: TCode;
+        issue?: TIssue;
+    });
+}
+
+declare const _default: (options?: {
+    basePath?: string | undefined;
+    actionsPath?: string | undefined;
+} | undefined) => astro.AstroIntegration & {};
+
+export { type Bindings, HonoActionError, type HonoEnv, _default as default, defineHonoAction };

package/dist/index.js

@@ -1,3 +1,306 @@
-import { defineHonoAction } from './define-action.js';
-import { HonoActionError } from './error.js';
-export { defineHonoAction, HonoActionError };
+// src/define-action.ts
+import { vValidator } from "@hono/valibot-validator";
+import { createFactory } from "hono/factory";
+import * as v from "valibot";
+
+// src/error.ts
+var HonoActionError = class extends Error {
+  code;
+  issue;
+  constructor({
+    message,
+    code,
+    issue
+  }) {
+    super(message);
+    this.name = "HonoActionError";
+    this.code = code;
+    this.issue = issue;
+  }
+};
+
+// src/define-action.ts
+function defineHonoAction({ path: path2, schema, handler }) {
+  const factory = createFactory();
+  const app = factory.createApp();
+  const route = app.post(
+    path2,
+    vValidator(
+      "json",
+      schema ?? v.union([v.never(), v.object({})]),
+      async (result, c) => {
+        if (!result.success) {
+          console.error(result.issues);
+          return c.json(
+            {
+              data: null,
+              error: new HonoActionError({
+                message: result.issues[0].message,
+                code: "INPUT_VALIDATION_ERROR",
+                issue: result.issues[0]
+              })
+            },
+            400
+          );
+        }
+      }
+    ),
+    async (c) => {
+      try {
+        const json = c.req.valid("json");
+        const result = await handler(
+          json,
+          c
+        );
+        return c.json(
+          {
+            data: result,
+            error: null
+          },
+          200
+        );
+      } catch (error) {
+        console.error(error);
+        let errorMessage = "Internal server error";
+        let errorCode = "INTERNAL_SERVER_ERROR";
+        if (error instanceof HonoActionError) {
+          errorMessage = error.message;
+          errorCode = error.code;
+        }
+        return c.json(
+          {
+            data: null,
+            error: {
+              message: errorMessage,
+              code: errorCode
+            }
+          },
+          500
+        );
+      }
+    }
+  );
+  return route;
+}
+
+// src/integration.ts
+import {
+  addVirtualImports,
+  createResolver,
+  defineIntegration
+} from "astro-integration-kit";
+import { z } from "astro/zod";
+import fg from "fast-glob";
+import fs from "fs/promises";
+import path from "path";
+
+// src/integration-files.ts
+function generateRouter(opts) {
+  const { basePath, relativeActionsPath } = opts;
+  return `import type { HonoEnv } from '@gnosticdev/hono-actions'
+import { Hono } from 'hono'
+import { cors } from 'hono/cors'
+import { showRoutes } from 'hono/dev'
+import { logger } from 'hono/logger'
+import { prettyJSON } from 'hono/pretty-json'
+import type { ExtractSchema, MergeSchemaPath } from 'hono/types'
+
+export async function buildRouter(){
+    type ActionSchema = ExtractSchema<typeof honoActions[keyof typeof honoActions]>
+    const { honoActions} = await import('${relativeActionsPath}')
+    const app = new Hono<HonoEnv, MergeSchemaPath<ActionSchema, '${basePath}'>>().basePath('${basePath}')
+
+    app.use('*', cors(), logger(), prettyJSON())
+
+    for (const [path, action] of Object.entries(honoActions)) {
+        app.route(path, action)
+    }
+
+    showRoutes(app)
+    return app
+}
+
+export type HonoRouter = Awaited<ReturnType<typeof buildRouter>>
+
+const app = await buildRouter()
+export default app`;
+}
+var getAstroHandler = (adapter) => {
+  switch (adapter) {
+    case "cloudflare":
+      return `
+// Generated by Hono Actions Integration
+import router from 'virtual:hono-actions/router'
+import type { APIContext, APIRoute } from 'astro'
+
+const handler: APIRoute<APIContext> = async (ctx) => {
+    return router.fetch(
+        ctx.request,
+        ctx.locals.runtime.env,
+        ctx.locals.runtime.ctx,
+    )
+}
+
+export { handler as ALL }
+`;
+    default:
+      throw new Error(`Unsupported adapter: ${adapter}`);
+  }
+};
+var getHonoClient = (port) => `
+// Generated by Hono Actions Integration
+import type { HonoRouter } from './router.js'
+import { hc } from 'hono/client'
+
+export function getBaseUrl() {
+    // client side can just use the base path
+    if (typeof window !== 'undefined') {
+        return '/'
+    }
+
+    // dev server (dev server) needs to know the port
+    if (import.meta.env.DEV) {
+        return \`http://localhost:\${${port}}\`
+    }
+
+    // server side (production) needs full url
+    return import.meta.env.SITE
+}
+
+export const honoClient = hc<HonoRouter>(getBaseUrl())
+`;
+
+// src/lib/utils.ts
+var reservedRoutes = ["_astro", "_actions", "_server_islands"];
+
+// src/integration.ts
+var optionsSchema = z.object({
+  basePath: z.string().optional(),
+  actionsPath: z.string().optional()
+}).optional();
+var VIRTUAL_MODULE_ID_CLIENT = "@gnostic/hono-actions/client";
+var VIRTUAL_MODULE_ID_ROUTER = "virtual:hono-actions/router";
+var ACTION_PATTERNS = [
+  "src/**/server/actions.ts",
+  "src/**/hono/actions.ts",
+  "src/**/hono/index.ts",
+  "src/**/hono.ts"
+];
+var integration_default = defineIntegration({
+  name: "@gnostic/hono-actions",
+  optionsSchema,
+  setup: ({ options = {}, name }) => {
+    const basePath = options.basePath ?? "/api";
+    if (reservedRoutes.includes(basePath)) {
+      throw new Error(
+        `Base path ${basePath} is reserved by Astro; pick another (e.g. /api2).`
+      );
+    }
+    const { resolve } = createResolver(import.meta.url);
+    return {
+      name,
+      hooks: {
+        "astro:config:setup": async (params) => {
+          const { logger, injectRoute, createCodegenDir, config } = params;
+          const root = config.root.pathname;
+          const files = await fg(ACTION_PATTERNS, {
+            cwd: root,
+            absolute: true
+          });
+          const actionsPath = options.actionsPath ?? files[0];
+          if (!actionsPath) {
+            throw new Error(
+              `No actions found. Create one of:
+${ACTION_PATTERNS.map((p) => ` - ${p}`).join("\n")}`
+            );
+          }
+          const resolvedActionsPath = path.isAbsolute(actionsPath) ? actionsPath : path.join(root, actionsPath);
+          params.addWatchFile(resolvedActionsPath);
+          logger.info(
+            `Found actions: ${path.relative(root, resolvedActionsPath)}`
+          );
+          const codeGenDir = createCodegenDir();
+          const routerPathAbs = path.join(
+            codeGenDir.pathname,
+            "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"
+          );
+          if (!params.config.adapter?.name)
+            throw new Error("No Astro adapter found");
+          const astroHandlerContent = getAstroHandler("cloudflare");
+          await fs.writeFile(
+            astroHandlerPathAbs,
+            astroHandlerContent,
+            "utf-8"
+          );
+          const clientPathAbs = path.join(
+            codeGenDir.pathname,
+            "client.ts"
+          );
+          const clientContent = getHonoClient(config.server.port);
+          await fs.writeFile(clientPathAbs, clientContent, "utf-8");
+          addVirtualImports(params, {
+            name,
+            imports: {
+              [VIRTUAL_MODULE_ID_CLIENT]: `export * from '${clientPathAbs}';`,
+              [VIRTUAL_MODULE_ID_ROUTER]: `export * from '${routerPathAbs}';`
+            }
+          });
+          injectRoute({
+            pattern: `${basePath}/[...slug]`,
+            entrypoint: astroHandlerPathAbs,
+            prerender: false
+          });
+          logger.info(
+            `\u2705 Hono Actions route mounted at ${basePath}/[...slug]`
+          );
+        },
+        "astro:config:done": async ({ injectTypes }) => {
+          injectTypes({
+            filename: "actions.d.ts",
+            content: `
+  declare module '@gnosticdev/hono-actions' {
+    interface Bindings extends Env { ASTRO_LOCALS: App.Locals }
+    interface HonoEnv { Bindings: Bindings }
+  }
+  export {}
+  `
+          });
+          injectTypes({
+            filename: "types.d.ts",
+            content: `
+  // Generated by Hono Actions Integration
+
+  declare module 'virtual:hono-actions/router' {
+    export type HonoRouter = import('./router.ts').HonoRouter
+    const app: typeof import('./router.ts').default
+    export default app
+  }
+
+  declare module '@gnostic/hono-actions/client' {
+    export const honoClient: typeof import('./client').honoClient
+  }
+  `
+          });
+        }
+      }
+    };
+  }
+});
+
+// src/index.ts
+var index_default = integration_default;
+export {
+  HonoActionError,
+  index_default as default,
+  defineHonoAction
+};

package/package.json

@@ -6,11 +6,15 @@
   "dependencies": {
     "@hono/valibot-validator": "0.5.3",
     "astro-integration-kit": "^0.19.0",
-    "hono": "^4.9.4"
+    "fast-glob": "^3.3.3",
+    "hono": "^4.9.4",
+    "valibot": "^1.1.0"
   },
   "description": "Type-safe Hono server actions with build-in validation",
   "devDependencies": {
+    "@biomejs/biome": "^2.2.2",
     "@types/bun": "^1.2.20",
+    "tsup": "^8.5.0",
     "typescript": "5.9.2"
   },
   "engineStrict": true,
@@ -19,16 +23,12 @@
   },
   "exports": {
     ".": {
-      "default": "./dist/index.js",
-      "types": "./dist/index.d.ts"
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
     },
-    "./define-action": {
-      "default": "./dist/define-action.js",
-      "types": "./dist/define-action.d.ts"
-    },
-    "./error": {
-      "default": "./dist/error.js",
-      "types": "./dist/error.d.ts"
+    "./*": {
+      "types": "./dist/*.d.ts",
+      "default": "./dist/*.js"
     }
   },
   "files": [
@@ -52,11 +52,11 @@
     "access": "public"
   },
   "scripts": {
-    "build": "rm -rf dist && tsc",
-    "dev": "rm -rf dist && tsc --watch",
+    "build": "tsup",
+    "dev": "tsup --watch",
     "prepublishOnly": "bun run build"
   },
   "type": "module",
   "types": "dist/index.d.ts",
-  "version": "1.0.0"
+  "version": "1.0.2"
 }

package/dist/define-action.d.ts

@@ -1,119 +0,0 @@
-import type { Context } from 'hono';
-import * as v from 'valibot';
-export 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`
- */
-export interface HonoEnv {
-    Bindings: Bindings;
-    Variables: Record<string, any>;
-}
-type HonoActionSchema = v.ObjectSchema<v.ObjectEntries, v.ErrorMessage<v.ObjectIssue> | undefined> | v.NeverSchema<undefined>;
-interface HonoActionContext<TEnv extends HonoEnv, TPath extends string, TSchema extends HonoActionSchema> extends Context<TEnv, TPath, {
-    input: v.InferInput<TSchema>;
-    output: v.InferOutput<TSchema>;
-    outputFormat: 'json';
-}> {
-    env: TEnv['Bindings'];
-}
-type HonoActionParams<TPath extends string, TSchema extends HonoActionSchema, TReturn, TEnv extends HonoEnv = HonoEnv> = {
-    path: TPath;
-    schema?: TSchema;
-    handler: (params: v.InferOutput<TSchema>, context: HonoActionContext<TEnv, TPath, TSchema>) => Promise<TReturn>;
-};
-/**
- * Defines a type-safe Hono action using Valibot for input validation.
- *
- * @param path - The path of the action.
- * @param schema - The object schema for Valibot validation.
- * @default never
- * @param handler - The handler function for the action.
- * @returns A Hono app instance with the defined route
- */
-export declare function defineHonoAction<TPath extends string, TSchema extends HonoActionSchema, TReturn, TEnv extends HonoEnv = HonoEnv>({ path, schema, handler }: HonoActionParams<TPath, TSchema, TReturn, TEnv>): import("hono/hono-base").HonoBase<TEnv, { [K in import("hono/types").MergePath<"/", TPath>]: {
-    $post: {
-        input: import("hono/types").AddParam<unknown extends ((undefined extends v.InferInput<TSchema | v.UnionSchema<[v.NeverSchema<undefined>, v.ObjectSchema<{}, undefined>], undefined>> ? true : false) extends true ? {
-            json?: (v.InferInput<TSchema | v.UnionSchema<[v.NeverSchema<undefined>, v.ObjectSchema<{}, undefined>], undefined>> extends infer T_1 ? T_1 extends v.InferInput<TSchema | v.UnionSchema<[v.NeverSchema<undefined>, v.ObjectSchema<{}, undefined>], undefined>> ? T_1 extends any ? T_1 : { [K2 in keyof T_1]?: any; } : never : never) | undefined;
-        } : {
-            json: v.InferInput<TSchema | v.UnionSchema<[v.NeverSchema<undefined>, v.ObjectSchema<{}, undefined>], undefined>> extends infer T_2 ? T_2 extends v.InferInput<TSchema | v.UnionSchema<[v.NeverSchema<undefined>, v.ObjectSchema<{}, undefined>], undefined>> ? T_2 extends any ? T_2 : { [K2_1 in keyof T_2]: any; } : never : never;
-        }) ? {} : (undefined extends v.InferInput<TSchema | v.UnionSchema<[v.NeverSchema<undefined>, v.ObjectSchema<{}, undefined>], undefined>> ? true : false) extends true ? {
-            json?: (v.InferInput<TSchema | v.UnionSchema<[v.NeverSchema<undefined>, v.ObjectSchema<{}, undefined>], undefined>> extends infer T_3 ? T_3 extends v.InferInput<TSchema | v.UnionSchema<[v.NeverSchema<undefined>, v.ObjectSchema<{}, undefined>], undefined>> ? T_3 extends any ? T_3 : { [K2_2 in keyof T_3]?: any; } : never : never) | undefined;
-        } : {
-            json: v.InferInput<TSchema | v.UnionSchema<[v.NeverSchema<undefined>, v.ObjectSchema<{}, undefined>], undefined>> extends infer T_4 ? T_4 extends v.InferInput<TSchema | v.UnionSchema<[v.NeverSchema<undefined>, v.ObjectSchema<{}, undefined>], undefined>> ? T_4 extends any ? T_4 : { [K2_3 in keyof T_4]: any; } : never : never;
-        }, import("hono/types").MergePath<"/", TPath>>;
-        output: unknown extends ({
-            data: Awaited<TReturn>;
-            error: null;
-        } extends import("hono/utils/types").JSONValue ? { [K_2 in keyof {
-            data: Awaited<TReturn>;
-            error: null;
-        } as ({
-            data: Awaited<TReturn>;
-            error: null;
-        }[K_2] extends infer T_5 ? T_5 extends {
-            data: Awaited<TReturn>;
-            error: null;
-        }[K_2] ? T_5 extends import("hono/utils/types").InvalidJSONValue ? true : false : never : never) extends true ? never : K_2]: boolean extends ({
-            data: Awaited<TReturn>;
-            error: null;
-        }[K_2] extends infer T_6 ? T_6 extends {
-            data: Awaited<TReturn>;
-            error: null;
-        }[K_2] ? T_6 extends import("hono/utils/types").InvalidJSONValue ? true : false : never : never) ? import("hono/utils/types").JSONParsed<{
-            data: Awaited<TReturn>;
-            error: null;
-        }[K_2]> | undefined : import("hono/utils/types").JSONParsed<{
-            data: Awaited<TReturn>;
-            error: null;
-        }[K_2]>; } : never) ? {} : {
-            data: Awaited<TReturn>;
-            error: null;
-        } extends import("hono/utils/types").JSONValue ? { [K_2 in keyof {
-            data: Awaited<TReturn>;
-            error: null;
-        } as ({
-            data: Awaited<TReturn>;
-            error: null;
-        }[K_2] extends infer T_5 ? T_5 extends {
-            data: Awaited<TReturn>;
-            error: null;
-        }[K_2] ? T_5 extends import("hono/utils/types").InvalidJSONValue ? true : false : never : never) extends true ? never : K_2]: boolean extends ({
-            data: Awaited<TReturn>;
-            error: null;
-        }[K_2] extends infer T_6 ? T_6 extends {
-            data: Awaited<TReturn>;
-            error: null;
-        }[K_2] ? T_6 extends import("hono/utils/types").InvalidJSONValue ? true : false : never : never) ? import("hono/utils/types").JSONParsed<{
-            data: Awaited<TReturn>;
-            error: null;
-        }[K_2]> | undefined : import("hono/utils/types").JSONParsed<{
-            data: Awaited<TReturn>;
-            error: null;
-        }[K_2]>; } : never;
-        outputFormat: "json";
-        status: 200;
-    } | {
-        input: import("hono/types").AddParam<unknown extends ((undefined extends v.InferInput<TSchema | v.UnionSchema<[v.NeverSchema<undefined>, v.ObjectSchema<{}, undefined>], undefined>> ? true : false) extends true ? {
-            json?: (v.InferInput<TSchema | v.UnionSchema<[v.NeverSchema<undefined>, v.ObjectSchema<{}, undefined>], undefined>> extends infer T_5 ? T_5 extends v.InferInput<TSchema | v.UnionSchema<[v.NeverSchema<undefined>, v.ObjectSchema<{}, undefined>], undefined>> ? T_5 extends any ? T_5 : { [K2_4 in keyof T_5]?: any; } : never : never) | undefined;
-        } : {
-            json: v.InferInput<TSchema | v.UnionSchema<[v.NeverSchema<undefined>, v.ObjectSchema<{}, undefined>], undefined>> extends infer T_6 ? T_6 extends v.InferInput<TSchema | v.UnionSchema<[v.NeverSchema<undefined>, v.ObjectSchema<{}, undefined>], undefined>> ? T_6 extends any ? T_6 : { [K2_5 in keyof T_6]: any; } : never : never;
-        }) ? {} : (undefined extends v.InferInput<TSchema | v.UnionSchema<[v.NeverSchema<undefined>, v.ObjectSchema<{}, undefined>], undefined>> ? true : false) extends true ? {
-            json?: (v.InferInput<TSchema | v.UnionSchema<[v.NeverSchema<undefined>, v.ObjectSchema<{}, undefined>], undefined>> extends infer T_7 ? T_7 extends v.InferInput<TSchema | v.UnionSchema<[v.NeverSchema<undefined>, v.ObjectSchema<{}, undefined>], undefined>> ? T_7 extends any ? T_7 : { [K2_6 in keyof T_7]?: any; } : never : never) | undefined;
-        } : {
-            json: v.InferInput<TSchema | v.UnionSchema<[v.NeverSchema<undefined>, v.ObjectSchema<{}, undefined>], undefined>> extends infer T_8 ? T_8 extends v.InferInput<TSchema | v.UnionSchema<[v.NeverSchema<undefined>, v.ObjectSchema<{}, undefined>], undefined>> ? T_8 extends any ? T_8 : { [K2_7 in keyof T_8]: any; } : never : never;
-        }, import("hono/types").MergePath<"/", TPath>>;
-        output: {
-            data: null;
-            error: {
-                message: string;
-                code: string;
-            };
-        };
-        outputFormat: "json";
-        status: 500;
-    };
-}; } extends infer T ? { [KeyType in keyof T]: T[KeyType]; } : never, "/">;
-export {};

package/dist/define-action.js

@@ -1,57 +0,0 @@
-import { vValidator } from '@hono/valibot-validator';
-import { createFactory } from 'hono/factory';
-import * as v from 'valibot';
-import { HonoActionError } from './error.js';
-/**
- * Defines a type-safe Hono action using Valibot for input validation.
- *
- * @param path - The path of the action.
- * @param schema - The object schema for Valibot validation.
- * @default never
- * @param handler - The handler function for the action.
- * @returns A Hono app instance with the defined route
- */
-export function defineHonoAction({ path, schema, handler }) {
-    const factory = createFactory();
-    const app = factory.createApp();
-    const route = app.post(path, vValidator('json', schema ?? v.union([v.never(), v.object({})]), async (result, c) => {
-        if (!result.success) {
-            console.error(result.issues);
-            return c.json({
-                data: null,
-                error: new HonoActionError({
-                    message: result.issues[0].message,
-                    code: 'INPUT_VALIDATION_ERROR',
-                    issue: result.issues[0]
-                })
-            }, 400);
-        }
-    }), async (c) => {
-        try {
-            const json = c.req.valid('json');
-            // context is validated after the middleware, but we only need the original definition to be passed back in to the handler here.
-            const result = await handler(json, c);
-            return c.json({
-                data: result,
-                error: null
-            }, 200);
-        }
-        catch (error) {
-            console.error(error);
-            let errorMessage = 'Internal server error';
-            let errorCode = 'INTERNAL_SERVER_ERROR';
-            if (error instanceof HonoActionError) {
-                errorMessage = error.message;
-                errorCode = error.code;
-            }
-            return c.json({
-                data: null,
-                error: {
-                    message: errorMessage,
-                    code: errorCode
-                }
-            }, 500);
-        }
-    });
-    return route;
-}

package/dist/error.d.ts

@@ -1,14 +0,0 @@
-import type * as v from 'valibot';
-/**
- * Standard error codes for actions
- */
-export type ActionErrorCode = 'INPUT_VALIDATION_ERROR' | 'EXTERNAL_API_ERROR' | 'INTERNAL_SERVER_ERROR' | 'UNKNOWN_ERROR' | 'LOCATION_NOT_FOUND' | 'SESSION_NOT_FOUND';
-export declare class HonoActionError<TSchema extends v.ObjectSchema<v.ObjectEntries, v.ErrorMessage<v.ObjectIssue> | undefined>, TMessage extends string, TCode extends ActionErrorCode, TIssue extends v.InferIssue<TSchema>> extends Error {
-    code: TCode;
-    issue?: TIssue;
-    constructor({ message, code, issue }: {
-        message: TMessage;
-        code: TCode;
-        issue?: TIssue;
-    });
-}

package/dist/error.js

@@ -1,10 +0,0 @@
-export class HonoActionError extends Error {
-    code;
-    issue;
-    constructor({ message, code, issue }) {
-        super(message);
-        this.name = 'HonoActionError';
-        this.code = code;
-        this.issue = issue;
-    }
-}