@gnosticdev/hono-actions 1.2.0 → 1.2.2

package/dist/actions.d.ts

@@ -38,7 +38,7 @@ type HonoActionSchema = z.ZodTypeAny;
  *
  * Example:
  * ```ts
- * declare const honoActions: {
+ * const honoActions: {
  *   myAction: Hono<HonoEnv, { '/': { $post: any } }, '/'>
  *   anotherAction: Hono<HonoEnv, { '/': { $post: any } }, '/'>
  * }
@@ -53,16 +53,9 @@ type HonoActionSchema = z.ZodTypeAny;
 type MergeActionKeyIntoPath<TActions extends Record<string, Hono<any, any, any>>> = {
     [K in keyof TActions]: TActions[K] extends Hono<infer TEnv, infer TSchema, infer TBase> ? Hono<TEnv, MergeSchemaPath<TSchema, `/${Extract<K, string>}`>, TBase> : never;
 };
-interface HonoActionContext<TEnv extends HonoEnv, TSchema extends HonoActionSchema> extends Context<TEnv, '/', {
-    input: z.input<TSchema>;
-    output: z.output<TSchema>;
-    outputFormat: 'json';
-}> {
-    env: TEnv['Bindings'];
-}
-type HonoActionParams<TSchema extends HonoActionSchema, TReturn, TEnv extends HonoEnv = HonoEnv> = {
+type HonoActionParams<TSchema extends HonoActionSchema, TReturn, TEnv extends HonoEnv, TContext extends Context<TEnv, any, any>> = {
     schema?: TSchema;
-    handler: (params: z.output<TSchema>, context: HonoActionContext<TEnv, TSchema>) => Promise<TReturn>;
+    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.
@@ -71,7 +64,7 @@ type HonoActionParams<TSchema extends HonoActionSchema, TReturn, TEnv extends Ho
  * @param handler - The handler function for the action.
  * @returns A Hono app instance with the defined route
  */
-declare function defineHonoAction<TEnv extends HonoEnv, TSchema extends HonoActionSchema, TReturn>({ schema, handler }: HonoActionParams<TSchema, TReturn, TEnv>): hono_hono_base.HonoBase<TEnv, {
+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 ? {
@@ -83,10 +76,26 @@ declare function defineHonoAction<TEnv extends HonoEnv, TSchema extends HonoActi
             } : {
                 json: z.input<TSchema | z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>>;
             };
-            output: unknown extends ({
-                data: Awaited<TReturn>;
-                error: null;
-            } extends hono_utils_types.JSONValue ? { [K in keyof {
+            output: {
+                data: null;
+                error: {
+                    message: string;
+                    code: string;
+                };
+            };
+            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;
+            } : {
+                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 | z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>>;
+            };
+            output: unknown extends (Awaited<TReturn> | null extends bigint | readonly bigint[] ? never : { [K in keyof {
                 data: Awaited<TReturn>;
                 error: null;
             } as ({
@@ -104,13 +113,10 @@ declare function defineHonoAction<TEnv extends HonoEnv, TSchema extends HonoActi
             }[K] ? T_1 extends hono_utils_types.InvalidJSONValue ? true : false : never : never) ? hono_utils_types.JSONParsed<{
                 data: Awaited<TReturn>;
                 error: null;
-            }[K]> | undefined : hono_utils_types.JSONParsed<{
+            }[K], bigint | readonly bigint[]> | undefined : hono_utils_types.JSONParsed<{
                 data: Awaited<TReturn>;
                 error: null;
-            }[K]>; } : never) ? {} : {
-                data: Awaited<TReturn>;
-                error: null;
-            } extends hono_utils_types.JSONValue ? { [K in keyof {
+            }[K], bigint | readonly bigint[]>; }) ? {} : Awaited<TReturn> | null extends bigint | readonly bigint[] ? never : { [K in keyof {
                 data: Awaited<TReturn>;
                 error: null;
             } as ({
@@ -128,31 +134,12 @@ declare function defineHonoAction<TEnv extends HonoEnv, TSchema extends HonoActi
             }[K] ? T_1 extends hono_utils_types.InvalidJSONValue ? true : false : never : never) ? hono_utils_types.JSONParsed<{
                 data: Awaited<TReturn>;
                 error: null;
-            }[K]> | undefined : hono_utils_types.JSONParsed<{
+            }[K], bigint | readonly bigint[]> | undefined : hono_utils_types.JSONParsed<{
                 data: Awaited<TReturn>;
                 error: null;
-            }[K]>; } : never;
+            }[K], bigint | readonly bigint[]>; };
             outputFormat: "json";
             status: 200;
-        } | {
-            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;
-            } : {
-                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 | z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>>;
-            };
-            output: {
-                data: null;
-                error: {
-                    message: string;
-                    code: string;
-                };
-            };
-            outputFormat: "json";
-            status: 500;
         };
     };
 }, "/">;

package/dist/actions.js

@@ -1,7 +1,7 @@
 // src/actions.ts
 import { zValidator } from "@hono/zod-validator";
 import { z } from "astro/zod";
-import { Hono } from "hono/quick";
+import { Hono } from "hono";
 
 // src/error.ts
 var HonoActionError = class extends Error {

package/dist/index.js

@@ -1553,7 +1553,9 @@ import fs from "node:fs/promises";
 import path2 from "node:path";
 
 // ../node_modules/tinyglobby/dist/index.mjs
+import nativeFs2 from "fs";
 import path, { posix } from "path";
+import { fileURLToPath } from "url";
 
 // ../node_modules/fdir/dist/index.mjs
 import { createRequire } from "module";
@@ -2066,34 +2068,37 @@ var Builder = class {
 
 // ../node_modules/tinyglobby/dist/index.mjs
 var import_picomatch = __toESM(require_picomatch2(), 1);
+var isReadonlyArray = Array.isArray;
+var isWin = process.platform === "win32";
 var ONLY_PARENT_DIRECTORIES = /^(\/?\.\.)+$/;
-function getPartialMatcher(patterns, options) {
+function getPartialMatcher(patterns, options = {}) {
   const patternsCount = patterns.length;
   const patternsParts = Array(patternsCount);
-  const regexes = Array(patternsCount);
+  const matchers = Array(patternsCount);
+  const globstarEnabled = !options.noglobstar;
   for (let i = 0; i < patternsCount; i++) {
     const parts = splitPattern(patterns[i]);
     patternsParts[i] = parts;
     const partsCount = parts.length;
-    const partRegexes = Array(partsCount);
-    for (let j = 0; j < partsCount; j++) partRegexes[j] = import_picomatch.default.makeRe(parts[j], options);
-    regexes[i] = partRegexes;
+    const partMatchers = Array(partsCount);
+    for (let j = 0; j < partsCount; j++) partMatchers[j] = (0, import_picomatch.default)(parts[j], options);
+    matchers[i] = partMatchers;
   }
   return (input) => {
     const inputParts = input.split("/");
     if (inputParts[0] === ".." && ONLY_PARENT_DIRECTORIES.test(input)) return true;
     for (let i = 0; i < patterns.length; i++) {
       const patternParts = patternsParts[i];
-      const regex = regexes[i];
+      const matcher = matchers[i];
       const inputPatternCount = inputParts.length;
       const minParts = Math.min(inputPatternCount, patternParts.length);
       let j = 0;
       while (j < minParts) {
         const part = patternParts[j];
         if (part.includes("/")) return true;
-        const match = regex[j].test(inputParts[j]);
+        const match = matcher[j](inputParts[j]);
         if (!match) break;
-        if (part === "**") return true;
+        if (globstarEnabled && part === "**") return true;
         j++;
       }
       if (j === inputPatternCount) return true;
@@ -2101,13 +2106,42 @@ function getPartialMatcher(patterns, options) {
     return false;
   };
 }
+var WIN32_ROOT_DIR = /^[A-Z]:\/$/i;
+var isRoot = isWin ? (p) => WIN32_ROOT_DIR.test(p) : (p) => p === "/";
+function buildFormat(cwd, root, absolute) {
+  if (cwd === root || root.startsWith(`${cwd}/`)) {
+    if (absolute) {
+      const start = isRoot(cwd) ? cwd.length : cwd.length + 1;
+      return (p, isDir) => p.slice(start, isDir ? -1 : void 0) || ".";
+    }
+    const prefix = root.slice(cwd.length + 1);
+    if (prefix) return (p, isDir) => {
+      if (p === ".") return prefix;
+      const result = `${prefix}/${p}`;
+      return isDir ? result.slice(0, -1) : result;
+    };
+    return (p, isDir) => isDir && p !== "." ? p.slice(0, -1) : p;
+  }
+  if (absolute) return (p) => posix.relative(cwd, p) || ".";
+  return (p) => posix.relative(cwd, `${root}/${p}`) || ".";
+}
+function buildRelative(cwd, root) {
+  if (root.startsWith(`${cwd}/`)) {
+    const prefix = root.slice(cwd.length + 1);
+    return (p) => `${prefix}/${p}`;
+  }
+  return (p) => {
+    const result = posix.relative(cwd, `${root}/${p}`);
+    if (p.endsWith("/") && result !== "") return `${result}/`;
+    return result || ".";
+  };
+}
 var splitPatternOptions = { parts: true };
 function splitPattern(path$1) {
   var _result$parts;
   const result = import_picomatch.default.scan(path$1, splitPatternOptions);
   return ((_result$parts = result.parts) === null || _result$parts === void 0 ? void 0 : _result$parts.length) ? result.parts : [path$1];
 }
-var isWin = process.platform === "win32";
 var POSIX_UNESCAPED_GLOB_SYMBOLS = /(?<!\\)([()[\]{}*?|]|^!|[!+@](?=\()|\\(?![()[\]{}!*+?@|]))/g;
 var WIN32_UNESCAPED_GLOB_SYMBOLS = /(?<!\\)([()[\]{}]|^!|[!+@](?=\())/g;
 var escapePosixPath = (path$1) => path$1.replace(POSIX_UNESCAPED_GLOB_SYMBOLS, "\\$&");
@@ -2163,13 +2197,12 @@ function normalizePattern(pattern, expandDirectories, cwd, props, isIgnore) {
     }
     props.depthOffset = newCommonPath.length;
     props.commonPath = newCommonPath;
-    props.root = newCommonPath.length > 0 ? path.posix.join(cwd, ...newCommonPath) : cwd;
+    props.root = newCommonPath.length > 0 ? posix.join(cwd, ...newCommonPath) : cwd;
   }
   return result;
 }
-function processPatterns({ patterns, ignore = [], expandDirectories = true }, cwd, props) {
+function processPatterns({ patterns = ["**/*"], ignore = [], expandDirectories = true }, cwd, props) {
   if (typeof patterns === "string") patterns = [patterns];
-  else if (!patterns) patterns = ["**/*"];
   if (typeof ignore === "string") ignore = [ignore];
   const matchPatterns = [];
   const ignorePatterns = [];
@@ -2187,66 +2220,88 @@ function processPatterns({ patterns, ignore = [], expandDirectories = true }, cw
     ignore: ignorePatterns
   };
 }
-function getRelativePath(path$1, cwd, root) {
-  return posix.relative(cwd, `${root}/${path$1}`) || ".";
-}
-function processPath(path$1, cwd, root, isDirectory, absolute) {
-  const relativePath = absolute ? path$1.slice(root === "/" ? 1 : root.length + 1) || "." : path$1;
-  if (root === cwd) return isDirectory && relativePath !== "." ? relativePath.slice(0, -1) : relativePath;
-  return getRelativePath(relativePath, cwd, root);
-}
-function formatPaths(paths, cwd, root) {
+function formatPaths(paths, relative2) {
   for (let i = paths.length - 1; i >= 0; i--) {
     const path$1 = paths[i];
-    paths[i] = getRelativePath(path$1, cwd, root) + (!path$1 || path$1.endsWith("/") ? "/" : "");
+    paths[i] = relative2(path$1);
   }
   return paths;
 }
-function crawl(options, cwd, sync2) {
-  if (process.env.TINYGLOBBY_DEBUG) options.debug = true;
-  if (options.debug) log("globbing with options:", options, "cwd:", cwd);
-  if (Array.isArray(options.patterns) && options.patterns.length === 0) return sync2 ? [] : Promise.resolve([]);
+function normalizeCwd(cwd) {
+  if (!cwd) return process.cwd().replace(BACKSLASHES, "/");
+  if (cwd instanceof URL) return fileURLToPath(cwd).replace(BACKSLASHES, "/");
+  return path.resolve(cwd).replace(BACKSLASHES, "/");
+}
+function getCrawler(patterns, inputOptions = {}) {
+  const options = process.env.TINYGLOBBY_DEBUG ? {
+    ...inputOptions,
+    debug: true
+  } : inputOptions;
+  const cwd = normalizeCwd(options.cwd);
+  if (options.debug) log("globbing with:", {
+    patterns,
+    options,
+    cwd
+  });
+  if (Array.isArray(patterns) && patterns.length === 0) return [{
+    sync: () => [],
+    withPromise: async () => []
+  }, false];
   const props = {
     root: cwd,
     commonPath: null,
     depthOffset: 0
   };
-  const processed = processPatterns(options, cwd, props);
-  const nocase = options.caseSensitiveMatch === false;
+  const processed = processPatterns({
+    ...options,
+    patterns
+  }, cwd, props);
   if (options.debug) log("internal processing patterns:", processed);
-  const matcher = (0, import_picomatch.default)(processed.match, {
+  const matchOptions = {
     dot: options.dot,
-    nocase,
+    nobrace: options.braceExpansion === false,
+    nocase: options.caseSensitiveMatch === false,
+    noextglob: options.extglob === false,
+    noglobstar: options.globstar === false,
+    posix: true
+  };
+  const matcher = (0, import_picomatch.default)(processed.match, {
+    ...matchOptions,
     ignore: processed.ignore
   });
-  const ignore = (0, import_picomatch.default)(processed.ignore, {
-    dot: options.dot,
-    nocase
-  });
-  const partialMatcher = getPartialMatcher(processed.match, {
-    dot: options.dot,
-    nocase
-  });
+  const ignore = (0, import_picomatch.default)(processed.ignore, matchOptions);
+  const partialMatcher = getPartialMatcher(processed.match, matchOptions);
+  const format = buildFormat(cwd, props.root, options.absolute);
+  const formatExclude = options.absolute ? format : buildFormat(cwd, props.root, true);
   const fdirOptions = {
     filters: [options.debug ? (p, isDirectory) => {
-      const path$1 = processPath(p, cwd, props.root, isDirectory, options.absolute);
+      const path$1 = format(p, isDirectory);
       const matches = matcher(path$1);
       if (matches) log(`matched ${path$1}`);
       return matches;
-    } : (p, isDirectory) => matcher(processPath(p, cwd, props.root, isDirectory, options.absolute))],
+    } : (p, isDirectory) => matcher(format(p, isDirectory))],
     exclude: options.debug ? (_, p) => {
-      const relativePath = processPath(p, cwd, props.root, true, true);
+      const relativePath = formatExclude(p, true);
       const skipped = relativePath !== "." && !partialMatcher(relativePath) || ignore(relativePath);
       if (skipped) log(`skipped ${p}`);
       else log(`crawling ${p}`);
       return skipped;
     } : (_, p) => {
-      const relativePath = processPath(p, cwd, props.root, true, true);
+      const relativePath = formatExclude(p, true);
       return relativePath !== "." && !partialMatcher(relativePath) || ignore(relativePath);
     },
+    fs: options.fs ? {
+      readdir: options.fs.readdir || nativeFs2.readdir,
+      readdirSync: options.fs.readdirSync || nativeFs2.readdirSync,
+      realpath: options.fs.realpath || nativeFs2.realpath,
+      realpathSync: options.fs.realpathSync || nativeFs2.realpathSync,
+      stat: options.fs.stat || nativeFs2.stat,
+      statSync: options.fs.statSync || nativeFs2.statSync
+    } : void 0,
     pathSeparator: "/",
     relativePaths: true,
-    resolveSymlinks: true
+    resolveSymlinks: true,
+    signal: options.signal
   };
   if (options.deep !== void 0) fdirOptions.maxDepth = Math.round(options.deep - props.depthOffset);
   if (options.absolute) {
@@ -2265,18 +2320,17 @@ function crawl(options, cwd, sync2) {
   props.root = props.root.replace(BACKSLASHES, "");
   const root = props.root;
   if (options.debug) log("internal properties:", props);
-  const api = new Builder(fdirOptions).crawl(root);
-  if (cwd === root || options.absolute) return sync2 ? api.sync() : api.withPromise();
-  return sync2 ? formatPaths(api.sync(), cwd, root) : api.withPromise().then((paths) => formatPaths(paths, cwd, root));
+  const relative2 = cwd !== root && !options.absolute && buildRelative(cwd, props.root);
+  return [new Builder(fdirOptions).crawl(root), relative2];
 }
 async function glob(patternsOrOptions, options) {
   if (patternsOrOptions && (options === null || options === void 0 ? void 0 : options.patterns)) throw new Error("Cannot pass patterns as both an argument and an option");
-  const opts = Array.isArray(patternsOrOptions) || typeof patternsOrOptions === "string" ? {
-    ...options,
-    patterns: patternsOrOptions
-  } : patternsOrOptions;
-  const cwd = opts.cwd ? path.resolve(opts.cwd).replace(BACKSLASHES, "/") : process.cwd().replace(BACKSLASHES, "/");
-  return crawl(opts, cwd, false);
+  const isModern = isReadonlyArray(patternsOrOptions) || typeof patternsOrOptions === "string";
+  const opts = isModern ? options : patternsOrOptions;
+  const patterns = isModern ? patternsOrOptions : patternsOrOptions.patterns;
+  const [crawler, relative2] = getCrawler(patterns, opts);
+  if (!relative2) return crawler.withPromise();
+  return formatPaths(await crawler.withPromise(), relative2);
 }
 
 // src/integration-files.ts
@@ -2313,10 +2367,11 @@ showRoutes(app)
 console.log('---------------------------')
 export default app`;
 }
-var getAstroHandler = (adapter) => {
+var generateAstroHandler = (adapter) => {
   switch (adapter) {
     case "@astrojs/cloudflare":
       return `
+/// <reference types="./types.d.ts" />
 // Generated by Hono Actions Integration
 import router from './router.js'
 import type { APIContext, APIRoute } from 'astro'
@@ -2335,7 +2390,7 @@ export { handler as ALL }
       throw new Error(`Unsupported adapter: ${adapter}`);
   }
 };
-var getHonoClient = (port) => `
+var generateHonoClient = (port) => `
 // Generated by Hono Actions Integration
 import type { HonoRouter } from './router.js'
 import { hc, parseResponse } from 'hono/client'
@@ -2354,7 +2409,7 @@ function getBaseUrl() {
     // server side (production) needs full url
     return import.meta.env.SITE ?? ''
 }
-export { parseResponse }
+export { parseResponse, hc }
 export const honoClient = hc<HonoRouter>(getBaseUrl())
 `;
 
@@ -2444,11 +2499,15 @@ ${ACTION_PATTERNS.map((p) => ` - ${p}`).join("\n")}`
           );
           const adapter = params.config.adapter?.name;
           if (!adapter) {
-            throw new Error("No Astro adapter found");
+            logger.error(
+              `No Astro adapter found. Add one of:
+                            - ${SUPPORTED_ADAPTERS.join("\n - ")} to your astro.config.mjs`
+            );
+            return;
           }
           let astroHandlerContent;
           if (isSupportedAdapter(adapter)) {
-            astroHandlerContent = getAstroHandler(adapter);
+            astroHandlerContent = generateAstroHandler(adapter);
           } else {
             throw new Error(`Unsupported adapter: ${adapter}`, {
               cause: `Only ${SUPPORTED_ADAPTERS.join(
@@ -2465,7 +2524,7 @@ ${ACTION_PATTERNS.map((p) => ` - ${p}`).join("\n")}`
             codeGenDir.pathname,
             "client.ts"
           );
-          const clientContent = getHonoClient(config.server.port);
+          const clientContent = generateHonoClient(config.server.port);
           await fs.writeFile(clientPathAbs, clientContent, "utf-8");
           addVirtualImports(params, {
             name,
@@ -2503,7 +2562,6 @@ export {}
           });
           let clientTypes = `
 // Generated by Hono Actions Integration
-// keeping separate from the main types.d.ts to avoid clobbering package exports
 declare module '@gnosticdev/hono-actions/client' {
     export const honoClient: typeof import('./client').honoClient
     export const parseResponse: typeof import('./client').parseResponse

package/package.json

@@ -1,20 +1,18 @@
 {
   "author": {
-    "email": "nynxaconsulting@gmail.com",
     "name": "gnosticdev",
     "url": "https://github.com/gnosticdev"
   },
   "dependencies": {
     "@hono/zod-validator": "^0.2.2",
     "astro-integration-kit": "^0.19.0",
-    "hono": "^4.9.5",
-    "zod": "^3.23.8"
+    "hono": "catalog:"
   },
   "description": "Define server actions with built-in validation, error handling, and a pre-built hono client for calling the routes.",
   "devDependencies": {
-    "@types/bun": "^1.2.21",
     "tsup": "^8.5.0",
-    "typescript": "^5.9.2"
+    "typescript": "catalog:",
+    "vitest": "catalog:"
   },
   "exports": {
     ".": {
@@ -41,7 +39,7 @@
   "main": "./dist/index.js",
   "name": "@gnosticdev/hono-actions",
   "peerDependencies": {
-    "astro": "^5.1.3"
+    "astro": "catalog:"
   },
   "publishConfig": {
     "access": "public"
@@ -53,5 +51,5 @@
   },
   "type": "module",
   "types": "./dist/index.d.ts",
-  "version": "1.2.0"
+  "version": "1.2.2"
 }