authx-sdk 1.0.0

package/README.md

@@ -0,0 +1,56 @@
+# AuthX Node.js SDK
+
+Backend-to-backend SDK for AuthX APIs.
+
+## Install
+
+```bash
+npm install authx-sdk
+```
+
+## Connection config
+
+- `clientId` and `clientSecret` are required.
+- `baseUrl` is optional.
+- Resolution order for base URL:
+1. `baseUrl` passed to constructor
+2. `AUTHX_BASE_URL` environment variable
+3. `http://localhost:8080`
+
+## Quick start
+
+```javascript
+const { AuthXClient, authMiddleware } = require("authx-sdk");
+
+const authx = new AuthXClient({
+  clientId: process.env.AUTHX_CLIENT_ID,
+  clientSecret: process.env.AUTHX_CLIENT_SECRET,
+  baseUrl: process.env.AUTHX_BASE_URL, // optional
+});
+
+app.post("/api/signup", async (req, res) => {
+  const { email, username, password } = req.body;
+  const result = await authx.signup({ email, username, password });
+  res.json(result);
+});
+
+app.post("/api/login", async (req, res) => {
+  const { identifier, password } = req.body; // identifier can be email or username
+  const result = await authx.login({ identifier, password });
+  res.json(result);
+});
+
+const protect = authMiddleware(authx);
+app.get("/api/me", protect, (req, res) => {
+  res.json({ email: req.user.email, userId: req.user.sub });
+});
+```
+
+## API
+
+- `new AuthXClient({ clientId, clientSecret, baseUrl? })`
+- `authx.signup({ email, username, password })`
+- `authx.login({ identifier, password })`
+- `authx.introspect(token)`
+- `authx.verifyEmail(token)`
+- `authMiddleware(client)`

package/dist/index.d.ts

@@ -0,0 +1,47 @@
+export interface AuthXConfig {
+    clientId: string;
+    clientSecret: string;
+    baseUrl?: string;
+}
+export interface SignupParams {
+    email: string;
+    username: string;
+    password: string;
+}
+export interface LoginParams {
+    identifier: string;
+    password: string;
+}
+export interface LoginResponse {
+    access_token: string;
+    token_type: string;
+    expires_in: number;
+}
+export interface IntrospectResponse {
+    active: boolean;
+    sub?: string;
+    email?: string;
+    exp?: number;
+}
+export interface ApiResponse {
+    message: string;
+    [key: string]: any;
+}
+export declare class AuthXError extends Error {
+    statusCode: number;
+    body: any;
+    constructor(message: string, statusCode: number, body?: any);
+}
+export declare class AuthXClient {
+    private clientId;
+    private clientSecret;
+    private baseUrl;
+    constructor(config: AuthXConfig);
+    private request;
+    signup(params: SignupParams): Promise<ApiResponse>;
+    login(params: LoginParams): Promise<LoginResponse>;
+    introspect(token: string): Promise<IntrospectResponse>;
+    verifyEmail(token: string): Promise<ApiResponse>;
+}
+export declare function authMiddleware(client: AuthXClient): (req: any, res: any, next: any) => Promise<any>;
+export default AuthXClient;

package/dist/index.js

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AuthXClient = exports.AuthXError = void 0;
+exports.authMiddleware = authMiddleware;
+class AuthXError extends Error {
+    constructor(message, statusCode, body) {
+        super(message);
+        this.name = "AuthXError";
+        this.statusCode = statusCode;
+        this.body = body;
+    }
+}
+exports.AuthXError = AuthXError;
+class AuthXClient {
+    constructor(config) {
+        if (!config.clientId || !config.clientSecret) {
+            throw new Error("AuthX: clientId and clientSecret are required");
+        }
+        this.clientId = config.clientId;
+        this.clientSecret = config.clientSecret;
+        this.baseUrl = (config.baseUrl || process.env.AUTHX_BASE_URL || "http://localhost:8080").replace(/\/$/, "");
+    }
+    async request(path, body) {
+        const credentials = Buffer.from(`${this.clientId}:${this.clientSecret}`).toString("base64");
+        const res = await fetch(`${this.baseUrl}/api/v1/auth${path}`, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                Authorization: `Basic ${credentials}`,
+            },
+            body: JSON.stringify(body),
+        });
+        const raw = await res.text();
+        let data = {};
+        try {
+            data = raw ? JSON.parse(raw) : {};
+        }
+        catch {
+            data = { message: raw };
+        }
+        if (!res.ok) {
+            throw new AuthXError(data.message || `AuthX request failed with status ${res.status}`, res.status, data);
+        }
+        return data;
+    }
+    async signup(params) {
+        return this.request("/signup", params);
+    }
+    async login(params) {
+        return this.request("/login", params);
+    }
+    async introspect(token) {
+        return this.request("/introspect", { token });
+    }
+    async verifyEmail(token) {
+        return this.request("/verify-email", { token });
+    }
+}
+exports.AuthXClient = AuthXClient;
+function authMiddleware(client) {
+    return async (req, res, next) => {
+        const authHeader = req.headers?.authorization;
+        if (!authHeader?.startsWith("Bearer ")) {
+            return res.status(401).json({ error: "No token provided" });
+        }
+        const token = authHeader.substring(7);
+        try {
+            const result = await client.introspect(token);
+            if (!result.active) {
+                return res.status(401).json({ error: "Token expired or invalid" });
+            }
+            req.user = result;
+            next();
+        }
+        catch {
+            return res.status(401).json({ error: "Authentication failed" });
+        }
+    };
+}
+exports.default = AuthXClient;

package/package.json

@@ -0,0 +1,30 @@
+{
+    "name": "authx-sdk",
+    "version": "1.0.0",
+    "description": "Official AuthX Node.js SDK for backend authentication",
+    "main": "dist/index.js",
+    "types": "dist/index.d.ts",
+    "files": [
+        "dist"
+    ],
+    "scripts": {
+        "build": "tsc",
+        "prepublishOnly": "npm run build"
+    },
+    "keywords": [
+        "authx",
+        "authentication",
+        "jwt",
+        "sdk",
+        "auth"
+    ],
+    "license": "MIT",
+    "engines": {
+        "node": ">=18"
+    },
+    "dependencies": {},
+    "devDependencies": {
+        "typescript": "^5.0.0",
+        "@types/node": "^20.0.0"
+    }
+}