@brt-innovation/aether 1.2.0

package/README.dev.md

@@ -0,0 +1,67 @@
+# Publishing Guide
+
+This document outlines the steps to publish the `@brt-innovation/aether` package.
+
+## Pre-requisites
+
+- Ensure you are logged in to the npm registry:
+  ```bash
+  npm login
+  ```
+
+## Deployment Workflow
+
+### 1. Verify Build (Optional)
+
+Before merging, ensure the project builds correctly locally.
+
+```bash
+npm install
+npm run build
+```
+
+### 2. Merge to Main
+
+- Create a Pull Request (PR) with your changes targeting the `main` branch.
+- Review and merge the PR.
+
+### 3. Prepare Release
+
+Switch to the `main` branch and pull the latest changes.
+
+```bash
+git checkout main
+git pull origin main
+```
+
+### 4. Bump Version
+
+Update the package version. This command updates `package.json`, `package-lock.json`, creates a git commit, and adds a git tag.
+
+```bash
+npm version <patch|minor|major>
+```
+
+Examples:
+
+- `npm version patch` (1.0.0 -> 1.0.1)
+- `npm version minor` (1.0.0 -> 1.1.0)
+- `npm version major` (1.0.0 -> 2.0.0)
+
+### 5. Publish
+
+Publish the package to the registry.
+
+```bash
+npm run publish
+```
+
+> **Note:** This runs custom script `npm publish --access public`. The `prepare` script will automatically run the build process before publishing.
+
+### 6. Push Tags
+
+Push the new version commit and tags to the repository.
+
+```bash
+git push origin main --tags
+```

package/README.md

@@ -0,0 +1,118 @@
+# @brt-innovation/aether
+
+Shared library for Aether microservices.
+
+This repository contains reusable components such as:
+
+- Hono middlewares
+- Common utilities
+- Shared types and constants
+
+The library is published as a public npm package and is intended to be shared across Aether microservices.
+
+---
+
+## Installation
+
+```bash
+npm install @brt-innovation/aether
+```
+---
+
+## Usage
+
+### Importing the library
+
+```ts
+import { authMiddleware, responseMiddleware , onAppError } from '@brt-innovation/aether';
+```
+
+---
+
+## Features
+
+### Hono Middleware
+
+#### authMiddleware
+
+Authentication middleware for Hono using JWT.
+
+**Supported token sources**
+- `Authorization` header (Bearer token)
+- Cookie (fallback if header is missing)
+
+**Example (inline usage)**
+
+```ts
+import { Hono } from 'hono';
+import { authMiddleware } from '@brt-innovation/aether';
+
+const app = new Hono();
+
+app.use('*', authMiddleware({
+  jwtSecret: process.env.JWT_SECRET,
+}));
+```
+
+**Example (reusable middleware instance)**
+
+```ts
+import { Hono } from 'hono';
+import { authMiddleware } from '@brt-innovation/aether';
+
+const authMid = authMiddleware({
+  jwtSecret: process.env.JWT_SECRET,
+});
+
+const app = new Hono();
+app.use('*', authMid);
+```
+
+**Behavior**
+- Extracts access token from `Authorization` header or cookies
+- Verifies JWT signature and algorithm
+- Stores `userId` in Hono context (`c.set('userId', payload.sub)`)
+- Returns `401 Unauthorized` for invalid or missing token
+
+---
+
+#### responseMiddleware
+
+Standard response formatter middleware to ensure consistent API responses across services.
+
+**Example**
+
+```ts
+import { Hono } from 'hono';
+import { responseMiddleware } from '@brt-innovation/aether';
+
+const app = new Hono();
+
+app.use('*', responseMiddleware);
+```
+
+---
+
+#### onAppError
+
+Global error handler for Hono applications.
+
+This handler catches unhandled errors thrown during request processing
+and transforms them into a standardized API error response.
+
+**Example**
+
+```ts
+import { Hono } from 'hono';
+import { onAppError } from '@brt-innovation/aether';
+
+const app = new Hono();
+
+app.onError(onAppError);
+```
+
+---
+
+## License
+
+UNLICENSED - Internal use only for BRT Innovation

package/dist/index.d.ts

@@ -0,0 +1,34 @@
+import * as hono from 'hono';
+import { Context, MiddlewareHandler } from 'hono';
+import { SignatureAlgorithm } from 'hono/utils/jwt/jwa';
+import { VerifyOptionsWithAlg } from 'hono/utils/jwt/jwt';
+
+declare const responseMiddleware: (c: Context, next: () => Promise<void>) => Promise<void>;
+declare const onAppError: (err: any, c: Context) => Response & hono.TypedResponse<{
+    message: string;
+}, 200 | 201 | 400 | 401 | 403 | 404 | 409 | 422 | 500 | 502 | 503 | 300 | 100 | 102 | 103 | 202 | 203 | 206 | 207 | 208 | 226 | 301 | 302 | 303 | 305 | 306 | 307 | 308 | 402 | 405 | 406 | 407 | 408 | 410 | 411 | 412 | 413 | 414 | 415 | 416 | 417 | 418 | 421 | 423 | 424 | 425 | 426 | 428 | 429 | 431 | 451 | 501 | 504 | 505 | 506 | 507 | 508 | 510 | 511 | -1, "json">;
+
+interface AuthMiddlewareOptions {
+    jwtSecret: string;
+    algorithm?: SignatureAlgorithm | VerifyOptionsWithAlg;
+    tokenCookieName?: string;
+}
+declare const authMiddleware: (options: AuthMiddlewareOptions) => MiddlewareHandler;
+
+declare const httpStatusCode: {
+    ok: string;
+    created: string;
+    noContent: string;
+    badRequest: string;
+    unauthorized: string;
+    forbidden: string;
+    notFound: string;
+    conflict: string;
+    unprocessableEntity: string;
+    internalServerError: string;
+    badGateway: string;
+    serviceUnavailable: string;
+};
+declare const httpStatusCodeMapping: Record<number, string>;
+
+export { type AuthMiddlewareOptions, authMiddleware, httpStatusCode, httpStatusCodeMapping, onAppError, responseMiddleware };

package/dist/index.js

@@ -0,0 +1,163 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  authMiddleware: () => authMiddleware,
+  httpStatusCode: () => httpStatusCode,
+  httpStatusCodeMapping: () => httpStatusCodeMapping,
+  onAppError: () => onAppError,
+  responseMiddleware: () => responseMiddleware
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/constant/response.constant.ts
+var httpStatusCode = {
+  ok: "ok",
+  created: "created",
+  noContent: "no_content",
+  badRequest: "bad_request",
+  unauthorized: "unauthorized",
+  forbidden: "forbidden",
+  notFound: "not_found",
+  conflict: "conflict",
+  unprocessableEntity: "unprocessable_entity",
+  internalServerError: "internal_server_error",
+  badGateway: "bad_gateway",
+  serviceUnavailable: "service_unavailable"
+};
+var httpStatusCodeMapping = {
+  200: httpStatusCode.ok,
+  201: httpStatusCode.created,
+  204: httpStatusCode.noContent,
+  400: httpStatusCode.badRequest,
+  401: httpStatusCode.unauthorized,
+  403: httpStatusCode.forbidden,
+  404: httpStatusCode.notFound,
+  409: httpStatusCode.conflict,
+  422: httpStatusCode.unprocessableEntity,
+  500: httpStatusCode.internalServerError,
+  502: httpStatusCode.badGateway,
+  503: httpStatusCode.serviceUnavailable
+};
+
+// src/hono/middlewares/response.middleware.ts
+var import_http_exception = require("hono/http-exception");
+var resolveCodeFromStatus = (status) => {
+  if (httpStatusCodeMapping[status]) {
+    return httpStatusCodeMapping[status];
+  }
+  if (status >= 200 && status < 300) return "success";
+  if (status >= 400 && status < 500) return "client_error";
+  if (status >= 500) return "server_error";
+  return "unknown";
+};
+var responseMiddleware = async (c, next) => {
+  await next();
+  const contentType = c.res.headers.get("content-type") || "";
+  if (!contentType.includes("application/json")) return;
+  const status = c.res.status;
+  const originalBody = await c.res.clone().json();
+  const wrapped = {
+    statusCode: status,
+    code: resolveCodeFromStatus(status),
+    timestamp: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  if (status < 400) {
+    wrapped.message = "success";
+    wrapped.data = originalBody;
+  } else {
+    wrapped.message = originalBody?.message || "error";
+    if (originalBody?.message) delete originalBody.message;
+    wrapped.data = originalBody;
+  }
+  c.res = new Response(JSON.stringify(wrapped), {
+    status,
+    headers: {
+      ...Object.fromEntries(c.res.headers),
+      "content-type": "application/json"
+    }
+  });
+};
+var onAppError = (err, c) => {
+  let status = 500;
+  let message = "Internal Server Error";
+  if (err instanceof import_http_exception.HTTPException) {
+    status = err.status;
+    message = err.message;
+  } else if (err instanceof Error) {
+    message = err.message;
+  }
+  return c.json(
+    {
+      message
+    },
+    status
+  );
+};
+
+// src/hono/middlewares/auth.middleware.ts
+var import_jwt = require("hono/jwt");
+var getToken = (c, cookieName) => {
+  const authHeader = c.req.header("authorization");
+  if (authHeader?.startsWith("Bearer ")) {
+    return authHeader.split(" ")[1];
+  }
+  const cookieHeader = c.req.header("cookie");
+  if (!cookieHeader) return null;
+  const cookies = Object.fromEntries(
+    cookieHeader.split(";").map((cookie) => {
+      const [key, ...value] = cookie.trim().split("=");
+      return [key, decodeURIComponent(value.join("="))];
+    })
+  );
+  return cookies[cookieName] ?? null;
+};
+var authMiddleware = (options) => {
+  const {
+    jwtSecret,
+    algorithm = "HS256",
+    tokenCookieName = "access_token"
+  } = options;
+  return async (c, next) => {
+    const token = getToken(c, tokenCookieName);
+    if (!token) {
+      return c.json({ message: "Unauthorized" }, 401);
+    }
+    if (!jwtSecret) {
+      return c.json({ message: "Server misconfigured" }, 500);
+    }
+    try {
+      const payload = await (0, import_jwt.verify)(token, jwtSecret, algorithm);
+      c.set("userId", payload.sub);
+      await next();
+    } catch (e) {
+      return c.json({ message: "Invalid token" }, 401);
+    }
+  };
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  authMiddleware,
+  httpStatusCode,
+  httpStatusCodeMapping,
+  onAppError,
+  responseMiddleware
+});

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "@brt-innovation/aether",
+  "version": "1.2.0",
+  "description": "Shared utilities and middlewares for Aether microservices",
+  "main": "dist/index.js",
+  "module": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.js"
+    }
+  },
+  "scripts": {
+    "build": "tsup src/index.ts --dts --tsconfig tsconfig.json",
+    "prepare": "npm run build",
+    "publish": "npm publish --access public"
+  },
+  "peerDependencies": {
+    "hono": "^4.0.0"
+  },
+  "devDependencies": {
+    "tsup": "^8.5.1",
+    "typescript": "^5.9.3"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/brtinnovation/aether-lib"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "license": "UNLICENSED"
+}