@gnosticdev/hono-actions 2.0.11 → 2.1.1

package/dist/actions.js

@@ -1,87 +0,0 @@
-import { zValidator } from '@hono/zod-validator';
-import { z } from 'astro/zod';
-import { Hono } from 'hono';
-
-// src/define-action.ts
-
-// 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({ schema, handler }) {
-  const app = new Hono();
-  const route = app.post(
-    "/",
-    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");
-        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;
-}
-
-export { HonoActionError, defineHonoAction };

package/dist/index.d.ts

@@ -1,54 +0,0 @@
-import * as astro from 'astro';
-import { z } from 'astro/zod';
-
-declare const optionsSchema: z.ZodOptional<z.ZodObject<{
-    /**
-     * The base path for the API routes
-     *
-     * @default '/api'
-     */
-    basePath: z.ZodOptional<z.ZodString>;
-    /**
-     * The path to the actions file. If not provided, the integration will automatically discover the actions file by searching for one of the following patterns:
-     * - `src/server/actions.ts`
-     * - `src/hono/actions.ts`
-     * - `src/hono/index.ts`
-     * - `src/hono.ts`
-     * - `src/hono-actions.ts`
-     *
-     * **NOTE** `src/actions.ts` is reserved for Astro Actions and will be ignored.
-     *
-     * @default 'src/server/actions.ts'
-     */
-    actionsPath: z.ZodOptional<z.ZodString>;
-}, "strip", z.ZodTypeAny, {
-    basePath?: string | undefined;
-    actionsPath?: string | undefined;
-}, {
-    basePath?: string | undefined;
-    actionsPath?: string | undefined;
-}>>;
-type IntegrationOptions = z.output<typeof optionsSchema>;
-/**
- * Astro integration for Hono Actions
- *
- * This integration automatically discovers action files in your project,
- * generates type-safe client code, and sets up API routes.
- *
- * Supprted Adapters:
- * - @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')
- * @param options.actionsPath - Custom path to actions file (optional, auto-discovered by default)
- */
-declare const _default: (options?: {
-    basePath?: string | undefined;
-    actionsPath?: string | undefined;
-} | undefined) => astro.AstroIntegration & {};
-
-export { type IntegrationOptions, _default as default };

package/dist/index.js

@@ -1,372 +0,0 @@
-import { defineIntegration, createResolver, addVirtualImports } from 'astro-integration-kit';
-import { z } from 'astro/zod';
-import fs from 'node:fs/promises';
-import path from 'node:path';
-import { glob } from 'tinyglobby';
-
-// src/integration.ts
-
-// src/integration-files.ts
-function generateRouter(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'
-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}')
-
-    app.use('*', cors(), logger(), prettyJSON())
-
-    for (const [routeName, action] of Object.entries(honoActions)) {
-        app.route(\`/\${routeName}\`, action)
-    }
-
-    return app
-}
-
-export type HonoRouter = Awaited<ReturnType<typeof buildRouter>>
-
-const app = await buildRouter()
-console.log('------- Hono Routes -------')
-showRoutes(app)
-console.log('---------------------------')
-${exportedApp}`;
-}
-var generateAstroHandler = (adapter) => {
-  switch (adapter) {
-    case "@astrojs/cloudflare":
-      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,
-    )
-}
-
-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:
-      throw new Error(`Unsupported adapter: ${adapter}`);
-  }
-};
-var generateHonoClient = (port) => `
-// Generated by Hono Actions Integration
-import type { HonoRouter } from './router.js'
-import { parseResponse, hc } from 'hono/client'
-import type { DetailedError, ClientRequestOptions } from 'hono/client'
-
-function getBaseUrl() {
-    // client side can just use the origin
-    if (typeof window !== 'undefined') {
-        return window.location.origin
-    }
-
-    // dev server (dev server) needs to know the port
-    if (import.meta.env.DEV) {
-        return 'http://localhost:${port}'
-    }
-
-    // server side (production) needs full url
-    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)
-}
-`;
-var generateIntegrationTypes = (adapter) => {
-  let actionTypes = `
-    // Generated by Hono Actions Integration
-    declare module '@gnosticdev/hono-actions/actions' {
-        interface Bindings { [key: string]: unknown }
-        interface Variables { [key: string]: unknown }
-        interface HonoEnv { Bindings: Bindings, Variables: Variables }
-    }
-    export {}
-    `;
-  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) {
-    // cloudflare uses Bindings and Variables passed in from the route handler
-    case "@astrojs/cloudflare":
-      actionTypes = `
-// Generated by Hono Actions Integration
-// keeping separate from the main types.d.ts to avoid clobbering package exports
-declare module '@gnosticdev/hono-actions/actions' {
-    interface Bindings extends Env { ASTRO_LOCALS: App.Locals }
-    interface Variables { [key: string]: unknown }
-    interface HonoEnv { Bindings: Bindings, Variables: Variables }
-}
-export {}
-`;
-      clientTypes += `
-type Runtime = import('@astrojs/cloudflare').Runtime<Env>
-
-declare namespace App {
-    interface Locals extends Runtime {}
-}
-`;
-      break;
-  }
-  return { actionTypes, clientTypes };
-};
-
-// 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({
-  /**
-   * The base path for the API routes
-   *
-   * @default '/api'
-   */
-  basePath: z.string().optional(),
-  /**
-   * The path to the actions file. If not provided, the integration will automatically discover the actions file by searching for one of the following patterns:
-   * - `src/server/actions.ts`
-   * - `src/hono/actions.ts`
-   * - `src/hono/index.ts`
-   * - `src/hono.ts`
-   * - `src/hono-actions.ts`
-   *
-   * **NOTE** `src/actions.ts` is reserved for Astro Actions and will be ignored.
-   *
-   * @default 'src/server/actions.ts'
-   */
-  actionsPath: z.string().optional()
-}).optional();
-var VIRTUAL_MODULE_ID_CLIENT = "@gnosticdev/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",
-  "src/hono-actions.ts"
-];
-var integration_default = defineIntegration({
-  name: "@gnosticdev/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);
-    const IS_DEBUG = process.env.__DEBUG__ === "true";
-    return {
-      name,
-      hooks: {
-        "astro:config:setup": async (params) => {
-          const { logger, injectRoute, createCodegenDir, config } = params;
-          const root = config.root.pathname;
-          const absPatterns = ACTION_PATTERNS.map(
-            (p) => path.join(root, p)
-          );
-          const files = await glob(absPatterns, {
-            expandDirectories: false,
-            absolute: true
-          });
-          if (IS_DEBUG) {
-            logger.info(`DEBUG: Found actions: ${files.join("\n")}`);
-          }
-          const actionsPath = options.actionsPath ?? files[0];
-          if (!actionsPath || actionsPath.includes("node_modules")) {
-            logger.warn(
-              `No actions found. Create one of:
-${ACTION_PATTERNS.map((p) => ` - ${p}`).join("\n")}`
-            );
-            return;
-          }
-          const resolvedActionsPath = resolve(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 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`
-            );
-            return;
-          }
-          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,
-            "utf-8"
-          );
-          const clientPathAbs = path.join(
-            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, {
-            name,
-            imports: {
-              [VIRTUAL_MODULE_ID_CLIENT]: `export * from '${clientPathAbs}';`,
-              [VIRTUAL_MODULE_ID_ROUTER]: `export * from '${routerPathAbs}';`
-            }
-          });
-          logger.info("\u2705 Hono Actions virtual imports added");
-          injectRoute({
-            pattern: `${basePath}/[...slug]`,
-            entrypoint: astroHandlerPathAbs,
-            prerender: false
-          });
-          logger.info(
-            `\u2705 Hono Actions route mounted at ${basePath}/[...slug]`
-          );
-        },
-        "astro:config:done": async ({
-          injectTypes,
-          config,
-          logger
-        }) => {
-          const adapter = config.adapter?.name;
-          if (!adapter) {
-            logger.warn("No adapter found...");
-            return;
-          }
-          if (!isSupportedAdapter(adapter)) {
-            logger.warn(
-              `Unsupported adapter: ${adapter}. Only ${SUPPORTED_ADAPTERS.join("\n - ")} are supported`
-            );
-            return;
-          }
-          const { actionTypes, clientTypes } = generateIntegrationTypes(adapter);
-          injectTypes({
-            filename: "actions.d.ts",
-            content: actionTypes
-          });
-          injectTypes({
-            filename: "types.d.ts",
-            content: clientTypes
-          });
-        }
-      }
-    };
-  }
-});
-
-// src/index.ts
-var src_default = integration_default;
-
-export { src_default as default };