hono-utils 0.2.0 → 0.3.1

package/README.md

@@ -2,7 +2,7 @@
 
 Hono Utils - Utilities for Hono framework
 
-A collection of helpers to simplify building Hono-based applications, including crypto helpers, middleware utilities, and queue integration.
+A collection of helpers to simplify building Hono-based applications, including crypto helpers, middleware utilities, queue integration and RPC client.
 
 ## Installation
 
@@ -37,6 +37,12 @@ import { QueueHandler } from 'hono-utils';
 import { pbkdf2, sha } from 'hono-utils';
 ```
 
+### Client
+
+```ts
+import { createTypedClient } from 'hono-utils';
+```
+
 ### Router
 
 ```ts
@@ -45,6 +51,9 @@ import { onError, onNotFound } from 'hono-utils';
 
 ## Detailed Documentation
 
+- Client
+  - [createTypedClient](docs/client/createTypedClient.md)
+
 - Crypto
   - [pbkdf2](docs/crypto/pbkdf2.md)
   - [sha](docs/crypto/sha.md)

package/dist/index.cjs

@@ -13957,6 +13957,10 @@ var response = _factory.createMiddleware.call(void 0, async (c, next) => {
   await next();
 });
 
+// src/middleware/clientInfo.ts
+
+var _uaparserjs = require('ua-parser-js');
+
 // src/crypto/pbkdf2.ts
 var pbkdf2_exports = {};
 __export(pbkdf2_exports, {
@@ -14038,6 +14042,91 @@ async function hash3({
   return hashedString;
 }
 
+// src/middleware/clientInfo.ts
+var clientInfo = (config2) => _factory.createMiddleware.call(void 0, async ({ env, req, set: set2 }, next) => {
+  if (!req.raw.cf) {
+    throw new Error("Cloudflare data is not available");
+  }
+  const hashSecret = env[_nullishCoalesce(_optionalChain([config2, 'optionalAccess', _189 => _189.hashSecretBinding]), () => ( "HASH_SECRET"))];
+  if (!hashSecret) {
+    throw new Error("Hash secret is not available");
+  }
+  const {
+    latitude,
+    longitude,
+    city,
+    country,
+    continent,
+    colo,
+    asn,
+    isEUCountry,
+    region,
+    regionCode,
+    postalCode,
+    timezone
+  } = req.raw.cf;
+  const cf = {
+    latitude,
+    longitude,
+    city,
+    country,
+    continent,
+    colo,
+    asn,
+    isEUCountry: Boolean(isEUCountry),
+    region,
+    regionCode,
+    postalCode,
+    timezone
+  };
+  const userAgent = _nullishCoalesce(req.raw.headers.get("user-agent"), () => ( "Unknown"));
+  const parser = new (0, _uaparserjs.UAParser)(userAgent);
+  const userAgentParsed = parser.getResult();
+  const { browser, device, engine, os, cpu } = userAgentParsed;
+  const ua = {
+    browser: {
+      name: _nullishCoalesce(browser.name, () => ( "Unknown")),
+      version: _nullishCoalesce(browser.version, () => ( "Unknown"))
+    },
+    device: {
+      model: _nullishCoalesce(device.model, () => ( "Unknown")),
+      vendor: _nullishCoalesce(device.vendor, () => ( "Unknown")),
+      type: _nullishCoalesce(device.type, () => ( "desktop"))
+    },
+    engine: {
+      name: _nullishCoalesce(engine.name, () => ( "Unknown")),
+      version: _nullishCoalesce(engine.version, () => ( "Unknown"))
+    },
+    os: {
+      name: _nullishCoalesce(os.name, () => ( "Unknown")),
+      version: _nullishCoalesce(os.version, () => ( "Unknown"))
+    },
+    cpu: _nullishCoalesce(cpu.architecture, () => ( "Unknown"))
+  };
+  const ip = _nullishCoalesce(req.raw.headers.get("CF-Connecting-IP"), () => ( "127.0.0.1"));
+  const clientContent = { ...cf, ...ua, ip };
+  set2("client", {
+    ...clientContent,
+    userAgent,
+    securityHash: await sha_exports.hash({
+      input: _nullishCoalesce(_optionalChain([config2, 'optionalAccess', _190 => _190.securityHashString, 'optionalCall', _191 => _191(clientContent)]), () => ( `${ip}${city}${country}${userAgent}`)),
+      algorithm: "SHA-512",
+      pepper: hashSecret
+    })
+  });
+  next();
+});
+
+// src/middleware/hydrateVariable.ts
+
+var hydrateVariable = ({
+  variableName,
+  hydrate
+}) => _factory.createMiddleware.call(void 0, async ({ set: set2, env, get }, next) => {
+  set2(variableName, hydrate({ ...env, get }));
+  await next();
+});
+
 // src/queue/QueueHandler.ts
 var _cuid22 = require('@paralleldrive/cuid2');
 var QueueHandler = (_class = class {
@@ -14120,14 +14209,18 @@ var defaultMessageMap = {
 };
 
 // src/router/onError.ts
-var onError = (err, { json: json2, var: { logger: logger2 } }) => {
+var onError = (parseError) => async (err, { json: json2, env, get }) => {
   try {
-    const { error: error48 } = logger2.getArea(`error`);
-    error48(err.message, err);
     const status = "status" in err ? err.status : 500;
-    return json2({ message: err.message }, status);
-  } catch (err2) {
-    console.error(err2);
+    return json2(
+      {
+        message: !parseError ? err.message : await parseError(err, env, get)
+      },
+      status
+    );
+  } catch (error48) {
+    console.error("Failed on error handler:", err);
+    console.error("Failed to parse error:", error48);
     return json2({ message: defaultMessageMap.internalError }, 500);
   }
 };
@@ -14142,6 +14235,50 @@ var onNotFound = async (c) => {
   );
 };
 
+// src/client/createTypedClient.ts
+var _client = require('hono/client');
+
+
+var createTypedClient = (options) => {
+  const client = _client.hc.call(void 0, options.url, {
+    headers: options.headers,
+    fetch: options.fetch
+  });
+  const rpcClient = async (fn) => {
+    _optionalChain([options, 'access', _192 => _192.callbacks, 'optionalAccess', _193 => _193.onStart, 'optionalCall', _194 => _194()]);
+    let responseHeaders = new Headers();
+    try {
+      const response2 = await fn(client);
+      responseHeaders = response2.headers;
+      const data = await _client.parseResponse.call(void 0, response2);
+      _optionalChain([options, 'access', _195 => _195.callbacks, 'optionalAccess', _196 => _196.onSuccess, 'optionalCall', _197 => _197(data, responseHeaders)]);
+      return data;
+    } catch (err) {
+      const errorBody = { message: err.message };
+      let status = 500;
+      if (err instanceof _client.DetailedError) {
+        const { detail, statusCode } = err;
+        status = _nullishCoalesce(statusCode, () => ( 500));
+        if (!detail) {
+          _optionalChain([options, 'access', _198 => _198.callbacks, 'optionalAccess', _199 => _199.errorHandler, 'optionalCall', _200 => _200(500, {
+            message: "Fetch malformed"
+          })]);
+          throw new (0, _httpexception.HTTPException)(500, { message: "Fetch malformed" });
+        }
+      }
+      _optionalChain([options, 'access', _201 => _201.callbacks, 'optionalAccess', _202 => _202.onError, 'optionalCall', _203 => _203(errorBody, responseHeaders)]);
+      _optionalChain([options, 'access', _204 => _204.callbacks, 'optionalAccess', _205 => _205.errorHandler, 'optionalCall', _206 => _206(status, errorBody)]);
+      throw new (0, _httpexception.HTTPException)(status, errorBody);
+    } finally {
+      _optionalChain([options, 'access', _207 => _207.callbacks, 'optionalAccess', _208 => _208.onEnd, 'optionalCall', _209 => _209()]);
+    }
+  };
+  return rpcClient;
+};
+
+
+
+
 
 
 
@@ -14154,5 +14291,5 @@ var onNotFound = async (c) => {
 
 
 
-exports.PBKDF2 = pbkdf2_exports; exports.QueueHandler = QueueHandler; exports.SHA = sha_exports; exports.i18n = i18n; exports.isBot = isBot; exports.jsonValidator = jsonValidator; exports.logger = logger; exports.onError = onError; exports.onNotFound = onNotFound; exports.queue = queue; exports.response = response; exports.withLogger = withLogger;
+exports.PBKDF2 = pbkdf2_exports; exports.QueueHandler = QueueHandler; exports.SHA = sha_exports; exports.clientInfo = clientInfo; exports.createTypedClient = createTypedClient; exports.hydrateVariable = hydrateVariable; exports.i18n = i18n; exports.isBot = isBot; exports.jsonValidator = jsonValidator; exports.logger = logger; exports.onError = onError; exports.onNotFound = onNotFound; exports.queue = queue; exports.response = response; exports.withLogger = withLogger;
 //# sourceMappingURL=index.cjs.map