@gnosticdev/hono-actions 2.0.7 → 2.0.8

package/dist/actions.d.ts

@@ -80,14 +80,14 @@ type HonoActionParams<TSchema extends HonoActionSchema, TReturn, TEnv extends Ho
 declare function defineHonoAction<TEnv extends HonoEnv, TSchema extends HonoActionSchema, TReturn, TContext extends Context<TEnv, any, any>>({ schema, handler }: HonoActionParams<TSchema, TReturn, TEnv, TContext>): hono_hono_base.HonoBase<TEnv, {
     "/": {
         $post: {
-            input: unknown extends ((undefined extends z.input<TSchema | z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>> ? true : false) extends true ? {
-                json?: z.input<TSchema | z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>> | undefined;
+            input: unknown extends ((undefined extends z.input<TSchema> ? true : false) extends true ? {
+                json?: z.input<TSchema> | undefined;
             } : {
-                json: z.input<TSchema | z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>>;
-            }) ? {} : (undefined extends z.input<TSchema | z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>> ? true : false) extends true ? {
-                json?: z.input<TSchema | z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>> | undefined;
+                json: z.input<TSchema>;
+            }) ? {} : (undefined extends z.input<TSchema> ? true : false) extends true ? {
+                json?: z.input<TSchema> | undefined;
             } : {
-                json: z.input<TSchema | z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>>;
+                json: z.input<TSchema>;
             };
             output: {
                 data: null;
@@ -99,14 +99,14 @@ declare function defineHonoAction<TEnv extends HonoEnv, TSchema extends HonoActi
             outputFormat: "json";
             status: 500;
         } | {
-            input: unknown extends ((undefined extends z.input<TSchema | z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>> ? true : false) extends true ? {
-                json?: z.input<TSchema | z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>> | undefined;
+            input: unknown extends ((undefined extends z.input<TSchema> ? true : false) extends true ? {
+                json?: z.input<TSchema> | undefined;
             } : {
-                json: z.input<TSchema | z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>>;
-            }) ? {} : (undefined extends z.input<TSchema | z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>> ? true : false) extends true ? {
-                json?: z.input<TSchema | z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>> | undefined;
+                json: z.input<TSchema>;
+            }) ? {} : (undefined extends z.input<TSchema> ? true : false) extends true ? {
+                json?: z.input<TSchema> | undefined;
             } : {
-                json: z.input<TSchema | z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>>;
+                json: z.input<TSchema>;
             };
             output: unknown extends (Awaited<TReturn> | null extends bigint | readonly bigint[] ? never : { [K in keyof {
                 data: Awaited<TReturn>;
@@ -155,6 +155,6 @@ declare function defineHonoAction<TEnv extends HonoEnv, TSchema extends HonoActi
             status: 200;
         };
     };
-}, "/">;
+}, "/", "/">;
 
 export { type Bindings, HonoActionError, type HonoEnv, type MergeActionKeyIntoPath, type Variables, defineHonoAction };

package/dist/actions.js

@@ -25,23 +25,27 @@ function defineHonoAction({ schema, handler }) {
   const app = new Hono();
   const route = app.post(
     "/",
-    zValidator("json", schema ?? z.object({}), async (result, c) => {
-      if (!result.success) {
-        console.error(result.error.issues);
-        const firstIssue = result.error.issues[0];
-        return c.json(
-          {
-            data: null,
-            error: new HonoActionError({
-              message: firstIssue?.message || "Validation error",
-              code: "INPUT_VALIDATION_ERROR",
-              issue: firstIssue
-            })
-          },
-          400
-        );
+    zValidator(
+      "json",
+      schema ?? z.any(),
+      async (result, c) => {
+        if (!result.success) {
+          console.error(result.error.issues);
+          const firstIssue = result.error.issues[0];
+          return c.json(
+            {
+              data: null,
+              error: new HonoActionError({
+                message: firstIssue?.message || "Validation error",
+                code: "INPUT_VALIDATION_ERROR",
+                issue: firstIssue
+              })
+            },
+            400
+          );
+        }
       }
-    }),
+    ),
     async (c) => {
       try {
         const json = c.req.valid("json");

package/dist/index.d.ts

@@ -33,8 +33,11 @@ type IntegrationOptions = z.output<typeof optionsSchema>;
  * generates type-safe client code, and sets up API routes.
  *
  * Supprted Adapters:
- * - Cloudflare
- * - (more to come)
+ * - @astrojs/cloudflare
+ * - @astrojs/node
+ * - @astrojs/vercel
+ * - @astrojs/netlify
+ *
  *
  * @param options - Configuration options for the integration
  * @param options.basePath - Base path for API routes (default: '/api')

package/dist/index.js

@@ -9,9 +9,9 @@ import { glob } from 'tinyglobby';
 // src/integration-files.ts
 function generateRouter(opts) {
   const { basePath, relativeActionsPath, adapter } = opts;
-  let exportedApp = `export default app`;
+  let exportedApp = "export default app";
   if (adapter === "@astrojs/netlify") {
-    exportedApp = `export default handle(app)`;
+    exportedApp = "export default handle(app)";
   }
   return `import type { HonoEnv, MergeActionKeyIntoPath } from '@gnosticdev/hono-actions/actions'
 import { Hono } from 'hono'
@@ -103,26 +103,34 @@ export { handler as ALL }
 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'
+import { parseResponse, hc } from 'hono/client'
+import type { DetailedError, ClientRequestOptions } from 'hono/client'
 
 function getBaseUrl() {
-    // client side can just use the base path
+    // client side can just use the origin
     if (typeof window !== 'undefined') {
-        return '/'
+        return window.location.origin
     }
 
     // dev server (dev server) needs to know the port
     if (import.meta.env.DEV) {
-        return \`http://localhost:\${${port}}\`
+        return 'http://localhost:${port}'
     }
 
     // server side (production) needs full url
-    return import.meta.env.SITE ?? ''
+    if (import.meta.env.SITE) {
+        return import.meta.env.SITE
+    }
+
+    return '/'
+}
+
+export { parseResponse }
+export type { DetailedError, ClientRequestOptions, HonoRouter }
+export const honoClient = createHonoClient<HonoRouter>(getBaseUrl())
+export function createHonoClient<T extends HonoRouter = HonoRouter>(basePath: string, fetchOptions?: ClientRequestOptions) {
+    return hc<T>(basePath, fetchOptions)
 }
-export { parseResponse, hc }
-export type { DetailedError }
-export const honoClient = hc<HonoRouter>(getBaseUrl())
 `;
 var generateIntegrationTypes = (adapter) => {
   let actionTypes = `
@@ -137,9 +145,26 @@ var generateIntegrationTypes = (adapter) => {
   let clientTypes = `
 // Generated by Hono Actions Integration
 declare module '@gnosticdev/hono-actions/client' {
+    /**
+     * Default hono client using the base url from the environment
+     * **Note** if running in production, the \`siteUrl\` option from the astro config will be used.
+     * If customization is needed, use the \`createHonoClient\` function instead.
+     */
     export const honoClient: typeof import('./client').honoClient
+    /**
+     * Helper function to parse the response from the Hono client
+     */
     export const parseResponse: typeof import('./client').parseResponse
+    /**
+     * Create a new hono client with custom base url + fetch options
+     */
+    export const createHonoClient: typeof import('./client').createHonoClient
     export type DetailedError = import('./client').DetailedError
+    export type ClientRequestOptions = import('./client').ClientRequestOptions
+    /**
+     * The hono actions routes. for use in the hono client
+     */
+    export type HonoRouter = import('./client').HonoRouter
 }
 `;
   switch (adapter) {
@@ -276,6 +301,9 @@ ${ACTION_PATTERNS.map((p) => ` - ${p}`).join("\n")}`
             codeGenDir.pathname,
             "client.ts"
           );
+          if (!config.site) {
+            logger.warn("No site url found in astro config, add one if you want to use the hono client with SSR");
+          }
           const clientContent = generateHonoClient(config.server.port);
           await fs.writeFile(clientPathAbs, clientContent, "utf-8");
           addVirtualImports(params, {

package/package.json

@@ -7,20 +7,18 @@
     "@hono/standard-validator": "^0.2.0",
     "@hono/zod-validator": "^0.2.2",
     "astro-integration-kit": "^0.19.0",
-    "hono": "^4.10.6",
     "tinyglobby": "^0.2.15"
   },
   "description": "Define server actions with built-in validation, error handling, and a pre-built hono client for calling the routes.",
   "devDependencies": {
-    "tsup": "^8.5.0",
-    "typescript": "catalog:",
-    "vitest": "catalog:",
     "@astrojs/cloudflare": "catalog:",
     "@astrojs/netlify": "catalog:",
     "@astrojs/node": "catalog:",
     "@astrojs/vercel": "catalog:",
+    "@biomejs/biome": "catalog:",
     "astro": "catalog:",
-    "@biomejs/biome": "catalog:"
+    "tsup": "^8.5.0",
+    "typescript": "catalog:"
   },
   "exports": {
     ".": {
@@ -50,7 +48,8 @@
   "main": "./dist/index.js",
   "name": "@gnosticdev/hono-actions",
   "peerDependencies": {
-    "astro": "^5.13.0"
+    "astro": "^5.13.0",
+    "hono": "^4.10.6"
   },
   "publishConfig": {
     "access": "public"
@@ -62,5 +61,5 @@
   },
   "type": "module",
   "types": "./dist/index.d.ts",
-  "version": "2.0.7"
+  "version": "2.0.8"
 }