@zeltjs/auth-jwt 0.0.1 → 0.3.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 9wick / Kohei Kido
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/index.d.ts

@@ -0,0 +1,79 @@
+import { Next, RequestContext, RequestContextSchema } from "@zeltjs/core";
+import * as _$hono_utils_http_status0 from "hono/utils/http-status";
+import * as _$hono_http_exception0 from "hono/http-exception";
+
+//#region src/errors.d.ts
+type JwtConfigErrorReason = 'missing_secret';
+declare const ZeltJwtConfigError: new (context: {
+  reason: JwtConfigErrorReason;
+}, cause?: unknown) => Error & {
+  readonly name: string;
+  readonly context: {
+    reason: JwtConfigErrorReason;
+  };
+};
+//#endregion
+//#region src/exceptions.d.ts
+type UnauthorizedReason = 'missing_token' | 'invalid_token' | 'expired';
+declare const UnauthorizedException: new (context: {
+  reason: UnauthorizedReason;
+}, options?: {
+  status?: _$hono_utils_http_status0.ContentfulStatusCode;
+  cause?: unknown;
+}) => _$hono_http_exception0.HTTPException & {
+  readonly name: string;
+  readonly context: {
+    reason: UnauthorizedReason;
+  };
+};
+//#endregion
+//#region src/jwt.types.d.ts
+interface JwtPayload {
+  sub?: string;
+  iat?: number;
+  exp?: number;
+  [key: string]: unknown;
+}
+type JwtDriver = 'header' | 'cookie';
+//#endregion
+//#region src/jwt.config.d.ts
+interface ResolveUserResult {
+  user: RequestContextSchema['user'];
+  roles: RequestContextSchema['authRoles'];
+}
+declare class JwtConfig {
+  /**
+   * @throws {ZeltJwtConfigError} When JWT_SECRET is not set
+   */
+  get secret(): string;
+  get expiresIn(): string;
+  get driver(): JwtDriver;
+  get cookieName(): string;
+  get resolveUser(): (payload: JwtPayload) => Promise<ResolveUserResult>;
+}
+//#endregion
+//#region src/jwt.service.d.ts
+declare class JwtService {
+  private config;
+  constructor(config?: JwtConfig);
+  sign(payload: Record<string, unknown>): Promise<string>;
+  verify(token: string): Promise<JwtPayload>;
+  decode(token: string): JwtPayload | null;
+  private parseExpiresIn;
+}
+//#endregion
+//#region src/jwt.middleware.d.ts
+declare class JwtMiddleware {
+  private readonly jwtService;
+  private readonly config;
+  constructor(jwtService?: JwtService, config?: JwtConfig);
+  /**
+   * @throws {UnauthorizedException} When token is missing (401)
+   * @throws {UnauthorizedException} When token is invalid or expired (401)
+   */
+  use(c: RequestContext, next: Next): Promise<Response | undefined>;
+  private extractToken;
+}
+//#endregion
+export { JwtConfig, type JwtConfigErrorReason, type JwtDriver, JwtMiddleware, type JwtPayload, JwtService, type ResolveUserResult, UnauthorizedException, type UnauthorizedReason, ZeltJwtConfigError };
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","names":[],"sources":["../src/errors.ts","../src/exceptions.ts","../src/jwt.types.ts","../src/jwt.config.ts","../src/jwt.service.ts","../src/jwt.middleware.ts"],"mappings":";;;;;KAEY,oBAAA;AAAA,cAMC,kBAAA,OAAkB,OAAA;UAEb,oBAAA;AAAA;;;YAAA,oBAAA;EAAA;AAAA;;;KCRN,kBAAA;AAAA,cAQC,qBAAA,OAAqB,OAAA;UAGhB,kBAAA;AAAA;WAAkB,yBAAA,CASkgG,oBAAA;;MAAA,sBAAA,CAAA,aAAA;EAAA;;YATphG,kBAAA;EAAA;AAAA;;;UCbD,UAAA;EACf,GAAA;EACA,GAAA;EACA,GAAA;EAAA,CACC,GAAA;AAAA;AAAA,KAGS,SAAA;;;UCDK,iBAAA;EACf,IAAA,EAAM,oBAAA;EACN,KAAA,EAAO,oBAAA;AAAA;AAAA,cAII,SAAA;;;;MAIP,MAAA,CAAA;EAAA,IAQA,SAAA,CAAA;EAAA,IAIA,MAAA,CAAA,GAAU,SAAA;EAAA,IAIV,UAAA,CAAA;EAAA,IAIA,WAAA,CAAA,IAAgB,OAAA,EAAS,UAAA,KAAe,OAAA,CAAQ,iBAAA;AAAA;;;cC7BzC,UAAA;EAAA,QACS,MAAA;cAAA,MAAA,GAAM,SAAA;EAEpB,IAAA,CAAK,OAAA,EAAS,MAAA,oBAA0B,OAAA;EAaxC,MAAA,CAAO,KAAA,WAAgB,OAAA,CAAQ,UAAA;EAMrC,MAAA,CAAO,KAAA,WAAgB,UAAA;EAAA,QAQf,cAAA;AAAA;;;cC5BG,aAAA;EAAA,iBAEQ,UAAA;EAAA,iBACA,MAAA;cADA,UAAA,GAAU,UAAA,EACV,MAAA,GAAM,SAAA;;;;ALJ3B;EKWQ,GAAA,CAAI,CAAA,EAAG,cAAA,EAAgB,IAAA,EAAM,IAAA,GAAO,OAAA,CAAQ,QAAA;EAAA,QAsB1C,YAAA;AAAA"}

package/dist/index.js

@@ -0,0 +1,116 @@
+import { defineError } from "@zeltjs/core/internal-bridge/errors";
+import { Config, Injectable, Middleware, defineHttpException, inject, setUser } from "@zeltjs/core";
+import { getCookie } from "hono/cookie";
+import { SignJWT, decodeJwt, jwtVerify } from "jose";
+//#region src/errors.ts
+const messages$1 = { missing_secret: "JWT_SECRET environment variable is required" };
+const ZeltJwtConfigError = defineError("ZeltJwtConfigError", (ctx) => messages$1[ctx.reason]);
+//#endregion
+//#region src/exceptions.ts
+const messages = {
+	missing_token: "Authorization token is required",
+	invalid_token: "Invalid authorization token",
+	expired: "Authorization token has expired"
+};
+const UnauthorizedException = defineHttpException("UnauthorizedException", 401, (ctx) => messages[ctx.reason], { buildResponse: (ctx, status, message) => Response.json({
+	code: "UNAUTHORIZED",
+	reason: ctx.reason,
+	message
+}, {
+	status,
+	headers: { "WWW-Authenticate": "Bearer" }
+}) });
+//#endregion
+//#region src/jwt.config.ts
+var JwtConfig = @Config class {
+	/**
+	* @throws {ZeltJwtConfigError} When JWT_SECRET is not set
+	*/
+	get secret() {
+		const secret = process.env["JWT_SECRET"];
+		if (!secret) throw new ZeltJwtConfigError({ reason: "missing_secret" });
+		return secret;
+	}
+	get expiresIn() {
+		return "1h";
+	}
+	get driver() {
+		return "header";
+	}
+	get cookieName() {
+		return "jwt";
+	}
+	get resolveUser() {
+		return async (payload) => ({
+			user: payload.sub,
+			roles: []
+		});
+	}
+};
+//#endregion
+//#region src/jwt.service.ts
+var JwtService = @Injectable() class {
+	constructor(config = inject(JwtConfig)) {
+		this.config = config;
+	}
+	async sign(payload) {
+		const secret = new TextEncoder().encode(this.config.secret);
+		const expiresIn = this.parseExpiresIn(this.config.expiresIn);
+		return await new SignJWT(payload).setProtectedHeader({ alg: "HS256" }).setIssuedAt().setExpirationTime(expiresIn).sign(secret);
+	}
+	async verify(token) {
+		const { payload } = await jwtVerify(token, new TextEncoder().encode(this.config.secret));
+		return payload;
+	}
+	decode(token) {
+		try {
+			return decodeJwt(token);
+		} catch {
+			return null;
+		}
+	}
+	parseExpiresIn(expiresIn) {
+		const match = /^(\d+)([smhd])$/.exec(expiresIn);
+		if (match) return `${parseInt(match[1] ?? "0", 10)} ${{
+			s: "seconds",
+			m: "minutes",
+			h: "hours",
+			d: "days"
+		}[match[2] ?? ""]}`;
+		return expiresIn;
+	}
+};
+//#endregion
+//#region src/jwt.middleware.ts
+var JwtMiddleware = @Middleware class {
+	constructor(jwtService = inject(JwtService), config = inject(JwtConfig)) {
+		this.jwtService = jwtService;
+		this.config = config;
+	}
+	/**
+	* @throws {UnauthorizedException} When token is missing (401)
+	* @throws {UnauthorizedException} When token is invalid or expired (401)
+	*/
+	async use(c, next) {
+		const token = this.extractToken(c);
+		if (!token) throw new UnauthorizedException({ reason: "missing_token" });
+		const verified = await this.jwtService.verify(token).then((payload) => ({
+			ok: true,
+			payload
+		}), () => ({ ok: false }));
+		if (!verified.ok) throw new UnauthorizedException({ reason: "invalid_token" });
+		const { user, roles } = await this.config.resolveUser(verified.payload);
+		setUser(user, roles);
+		await next();
+	}
+	extractToken(c) {
+		if (this.config.driver === "cookie") return getCookie(c, this.config.cookieName) ?? null;
+		const authHeader = c.req.header("Authorization");
+		if (!authHeader?.startsWith("Bearer ")) return null;
+		return authHeader.slice(7);
+	}
+};
+//#endregion
+export { JwtConfig, JwtMiddleware, JwtService, UnauthorizedException, ZeltJwtConfigError };
+
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":["messages"],"sources":["../src/errors.ts","../src/exceptions.ts","../src/jwt.config.ts","../src/jwt.service.ts","../src/jwt.middleware.ts"],"sourcesContent":["import { defineError } from '@zeltjs/core/internal-bridge/errors';\n\nexport type JwtConfigErrorReason = 'missing_secret';\n\nconst messages: Record<JwtConfigErrorReason, string> = {\n  missing_secret: 'JWT_SECRET environment variable is required',\n};\n\nexport const ZeltJwtConfigError = defineError(\n  'ZeltJwtConfigError',\n  (ctx: { reason: JwtConfigErrorReason }) => messages[ctx.reason],\n);\n","import { defineHttpException } from '@zeltjs/core';\n\nexport type UnauthorizedReason = 'missing_token' | 'invalid_token' | 'expired';\n\nconst messages: Record<UnauthorizedReason, string> = {\n  missing_token: 'Authorization token is required',\n  invalid_token: 'Invalid authorization token',\n  expired: 'Authorization token has expired',\n};\n\nexport const UnauthorizedException = defineHttpException(\n  'UnauthorizedException',\n  401,\n  (ctx: { reason: UnauthorizedReason }) => messages[ctx.reason],\n  {\n    buildResponse: (ctx, status, message) =>\n      Response.json(\n        { code: 'UNAUTHORIZED', reason: ctx.reason, message },\n        { status, headers: { 'WWW-Authenticate': 'Bearer' } },\n      ),\n  },\n);\n","import type { RequestContextSchema } from '@zeltjs/core';\nimport { Config } from '@zeltjs/core';\n\nimport { ZeltJwtConfigError } from './errors';\nimport type { JwtDriver, JwtPayload } from './jwt.types';\n\nexport interface ResolveUserResult {\n  user: RequestContextSchema['user'];\n  roles: RequestContextSchema['authRoles'];\n}\n\n@Config\nexport class JwtConfig {\n  /**\n   * @throws {ZeltJwtConfigError} When JWT_SECRET is not set\n   */\n  get secret(): string {\n    const secret = process.env['JWT_SECRET'];\n    if (!secret) {\n      throw new ZeltJwtConfigError({ reason: 'missing_secret' });\n    }\n    return secret;\n  }\n\n  get expiresIn(): string {\n    return '1h';\n  }\n\n  get driver(): JwtDriver {\n    return 'header';\n  }\n\n  get cookieName(): string {\n    return 'jwt';\n  }\n\n  get resolveUser(): (payload: JwtPayload) => Promise<ResolveUserResult> {\n    return async (payload) => ({\n      user: payload.sub,\n      roles: [],\n    });\n  }\n}\n","import { Injectable, inject } from '@zeltjs/core';\nimport { decodeJwt, jwtVerify, SignJWT } from 'jose';\n\nimport { JwtConfig } from './jwt.config';\nimport type { JwtPayload } from './jwt.types';\n\n@Injectable()\nexport class JwtService {\n  constructor(private config = inject(JwtConfig)) {}\n\n  async sign(payload: Record<string, unknown>): Promise<string> {\n    const secret = new TextEncoder().encode(this.config.secret);\n    const expiresIn = this.parseExpiresIn(this.config.expiresIn);\n\n    const jwt = await new SignJWT(payload)\n      .setProtectedHeader({ alg: 'HS256' })\n      .setIssuedAt()\n      .setExpirationTime(expiresIn)\n      .sign(secret);\n\n    return jwt;\n  }\n\n  async verify(token: string): Promise<JwtPayload> {\n    const secret = new TextEncoder().encode(this.config.secret);\n    const { payload } = await jwtVerify<JwtPayload>(token, secret);\n    return payload;\n  }\n\n  decode(token: string): JwtPayload | null {\n    try {\n      return decodeJwt<JwtPayload>(token);\n    } catch {\n      return null;\n    }\n  }\n\n  private parseExpiresIn(expiresIn: string): string | number {\n    const match = /^(\\d+)([smhd])$/.exec(expiresIn);\n    if (match) {\n      const value = parseInt(match[1] ?? '0', 10);\n      const unit = match[2] ?? '';\n      const unitMap: Record<string, string> = {\n        s: 'seconds',\n        m: 'minutes',\n        h: 'hours',\n        d: 'days',\n      };\n      return `${value} ${unitMap[unit]}`;\n    }\n    return expiresIn;\n  }\n}\n","import type { Next, RequestContext } from '@zeltjs/core';\nimport { inject, Middleware, setUser } from '@zeltjs/core';\nimport { getCookie } from 'hono/cookie';\n\nimport { UnauthorizedException } from './exceptions';\nimport { JwtConfig } from './jwt.config';\nimport { JwtService } from './jwt.service';\n\n@Middleware\nexport class JwtMiddleware {\n  constructor(\n    private readonly jwtService = inject(JwtService),\n    private readonly config = inject(JwtConfig),\n  ) {}\n\n  /**\n   * @throws {UnauthorizedException} When token is missing (401)\n   * @throws {UnauthorizedException} When token is invalid or expired (401)\n   */\n  async use(c: RequestContext, next: Next): Promise<Response | undefined> {\n    const token = this.extractToken(c);\n\n    if (!token) {\n      throw new UnauthorizedException({ reason: 'missing_token' });\n    }\n\n    const verified = await this.jwtService.verify(token).then(\n      (payload) => ({ ok: true as const, payload }),\n      () => ({ ok: false as const }),\n    );\n\n    if (!verified.ok) {\n      throw new UnauthorizedException({ reason: 'invalid_token' });\n    }\n\n    const { user, roles } = await this.config.resolveUser(verified.payload);\n    setUser(user, roles);\n    await next();\n    return undefined;\n  }\n\n  private extractToken(c: RequestContext): string | null {\n    if (this.config.driver === 'cookie') {\n      return getCookie(c, this.config.cookieName) ?? null;\n    }\n\n    const authHeader = c.req.header('Authorization');\n    if (!authHeader?.startsWith('Bearer ')) {\n      return null;\n    }\n    return authHeader.slice(7);\n  }\n}\n"],"mappings":"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"}

package/package.json

@@ -1,10 +1,44 @@
 {
   "name": "@zeltjs/auth-jwt",
-  "version": "0.0.1",
-  "description": "OIDC trusted publishing setup package for @zeltjs/auth-jwt",
-  "keywords": [
-    "oidc",
-    "trusted-publishing",
-    "setup"
-  ]
-}
+  "version": "0.3.0",
+  "type": "module",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/zeltjs/zelt.git",
+    "directory": "packages/auth-jwt"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "peerDependencies": {
+    "hono": "^4.0.0",
+    "@zeltjs/core": "0.3.0"
+  },
+  "dependencies": {
+    "jose": "6.0.11"
+  },
+  "devDependencies": {
+    "@types/node": "22.19.17",
+    "hono": "4.12.16",
+    "@zeltjs/core": "0.3.0",
+    "@zeltjs/testing": "0.3.0"
+  },
+  "volta": {
+    "extends": "../../package.json"
+  },
+  "scripts": {
+    "build": "tsdown",
+    "test": "vitest run",
+    "typecheck": "tsc -b"
+  }
+}

package/README.md

@@ -1,45 +0,0 @@
-# @zeltjs/auth-jwt
-
-## ⚠️ IMPORTANT NOTICE ⚠️
-
-**This package is created solely for the purpose of setting up OIDC (OpenID Connect) trusted publishing with npm.**
-
-This is **NOT** a functional package and contains **NO** code or functionality beyond the OIDC setup configuration.
-
-## Purpose
-
-This package exists to:
-1. Configure OIDC trusted publishing for the package name `@zeltjs/auth-jwt`
-2. Enable secure, token-less publishing from CI/CD workflows
-3. Establish provenance for packages published under this name
-
-## What is OIDC Trusted Publishing?
-
-OIDC trusted publishing allows package maintainers to publish packages directly from their CI/CD workflows without needing to manage npm access tokens. Instead, it uses OpenID Connect to establish trust between the CI/CD provider (like GitHub Actions) and npm.
-
-## Setup Instructions
-
-To properly configure OIDC trusted publishing for this package:
-
-1. Go to [npmjs.com](https://www.npmjs.com/) and navigate to your package settings
-2. Configure the trusted publisher (e.g., GitHub Actions)
-3. Specify the repository and workflow that should be allowed to publish
-4. Use the configured workflow to publish your actual package
-
-## DO NOT USE THIS PACKAGE
-
-This package is a placeholder for OIDC configuration only. It:
-- Contains no executable code
-- Provides no functionality
-- Should not be installed as a dependency
-- Exists only for administrative purposes
-
-## More Information
-
-For more details about npm's trusted publishing feature, see:
-- [npm Trusted Publishing Documentation](https://docs.npmjs.com/generating-provenance-statements)
-- [GitHub Actions OIDC Documentation](https://docs.github.com/en/actions/deployment/security-hardening-your-deployments/about-security-hardening-with-openid-connect)
-
----
-
-**Maintained for OIDC setup purposes only**