@mspkapps/auth-client 0.1.0 → 0.1.2

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 PRANESH KARTHI M S
+
+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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mspkapps/auth-client",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "description": "Lightweight client for Your Auth Service",
   "type": "module",
   "main": "src/index.js",
@@ -12,15 +12,26 @@
     "README.md",
     "LICENSE"
   ],
-  "keywords": ["auth","sdk","jwt","client"],
+  "keywords": [
+    "auth",
+    "sdk",
+    "jwt",
+    "client"
+  ],
   "author": "MSPK Apps",
   "license": "MIT",
-  "publishConfig": { "access": "public" },
+  "publishConfig": {
+    "access": "public"
+  },
   "repository": {
     "type": "git",
     "url": "https://github.com/mspk5196/authServiceNpm.git"
   },
-  "bugs": { "url": "https://github.com/mspk5196/authServiceNpm/issues" },
+  "bugs": {
+    "url": "https://github.com/mspk5196/authServiceNpm/issues"
+  },
   "homepage": "https://github.com/mspk5196/authServiceNpm#readme",
-  "engines": { "node": ">=18" }
-}
+  "engines": {
+    "node": ">=18"
+  }
+}

package/src/AuthClient.js

@@ -1,73 +1,137 @@
+// ESM module
 import { AuthError } from './errors.js';
 
 export class AuthClient {
-  constructor(opts = {}) {
-    this.baseUrl = opts.baseUrl?.replace(/\/+$/,'') || 'http://localhost:5001/api/v1';
-    this.apiKey = opts.apiKey || null;        // Public key (optional)
-    this.apiSecret = opts.apiSecret || null;  // NEVER use secret in browser
-    this.token = null;
-    this.fetchFn = opts.fetch || fetch;
+  constructor({
+    apiKey,
+    apiSecret,
+    baseUrl = 'https://cpanel.backend.mspkapps.in/api/v1',
+    keyInPath = true,
+    storage,
+    fetch: fetchFn
+  } = {}) {
+    if (!apiKey) throw new Error('apiKey is required');
+    if (!apiSecret) throw new Error('apiSecret is required'); // note: avoid exposing secret in browsers if possible
+    this.apiKey = apiKey;
+    this.apiSecret = apiSecret;
+    this.baseUrl = baseUrl.replace(/\/$/, '');
+    this.keyInPath = !!keyInPath;
+    this.fetch = fetchFn || (typeof fetch !== 'undefined' ? fetch : null);
+    if (!this.fetch) throw new Error('No fetch available. Pass { fetch } or run on Node 18+/browsers.');
+
+    this.storage = storage || (typeof window !== 'undefined' ? window.localStorage : null);
+    this.tokenKey = 'auth_user_token';
+    this.token = this._load(this.tokenKey);
   }
 
-  setToken(token) {
-    this.token = token;
+  // ---------- storage helpers ----------
+  _load(key) {
+    if (!this.storage) return null;
+    try { return this.storage.getItem(key); } catch { return null; }
   }
-
-  clearToken() {
-    this.token = null;
+  _save(key, val) {
+    if (!this.storage) return;
+    try { this.storage.setItem(key, val); } catch { /* ignore */ }
   }
-
-  async register({ email, password, name, username }) {
-    return this._request('POST', '/register', { email, password, name, username });
+  _clear(key) {
+    if (!this.storage) return;
+    try { this.storage.removeItem(key); } catch { /* ignore */ }
   }
 
-  async login({ email, password }) {
-    const res = await this._request('POST', '/login', { email, password });
-    if (res?.data?.access_token) this.token = res.data.access_token;
-    return res;
+  // ---------- internal builders ----------
+  _buildUrl(path) {
+    const p = path.startsWith('/') ? path.slice(1) : path;
+    return this.keyInPath
+      ? `${this.baseUrl}/${encodeURIComponent(this.apiKey)}/${p}`
+      : `${this.baseUrl}/${p}`;
   }
 
-  async getProfile() {
-    return this._request('GET', '/user/profile');
+  _headers(extra = {}) {
+    return {
+      'Content-Type': 'application/json',
+      'X-API-Key': this.apiKey,
+      'X-API-Secret': this.apiSecret,
+      ...(this.token ? { Authorization: `UserToken ${this.token}` } : {}),
+      ...extra
+    };
   }
 
-  async verifyEmail(token) {
-    return this._request('GET', `/verify-email?token=${encodeURIComponent(token)}`);
+  setToken(token) {
+    this.token = token || null;
+    if (token) this._save(this.tokenKey, token);
+    else this._clear(this.tokenKey);
   }
 
-  // Generic authed request to your protected API (public layer)
-  async authed(path, options = {}) {
-    return this._request(options.method || 'GET', path, options.body, options);
+  getAuthHeader() {
+    return this.token ? { Authorization: `UserToken ${this.token}` } : {};
   }
 
-  async _request(method, path, body, extra = {}) {
-    const headers = { 'Content-Type': 'application/json' };
+  logout() {
+    this.setToken(null);
+  }
 
-    // Optional API key/secret (only server-side for secret)
-    if (this.apiKey) headers['X-API-Key'] = this.apiKey;
-    if (this.apiSecret) headers['X-API-Secret'] = this.apiSecret;
+  // ---------- public API methods ----------
+  async register({ email, username, password, name }) {
+    const resp = await this.fetch(this._buildUrl('auth/register'), {
+      method: 'POST',
+      headers: this._headers(),
+      body: JSON.stringify({ email, username, password, name })
+    });
+    const json = await safeJson(resp);
+    if (!resp.ok || json?.success === false) throw toError(resp, json, 'Register failed');
+    const token = json?.data?.user_token;
+    if (token) this.setToken(token);
+    return json;
+  }
 
-    if (this.token) headers['Authorization'] = `Bearer ${this.token}`;
+  async login({ email, username, password }) {
+    const payload = email ? { email, password } : { username, password };
+    const resp = await this.fetch(this._buildUrl('auth/login'), {
+      method: 'POST',
+      headers: this._headers(),
+      body: JSON.stringify(payload)
+    });
+    const json = await safeJson(resp);
+    if (!resp.ok || json?.success === false) throw toError(resp, json, 'Login failed');
+    const token = json?.data?.user_token;
+    if (token) this.setToken(token);
+    return json;
+  }
 
-    const url = path.startsWith('http') ? path : this.baseUrl + path;
+  async getProfile() {
+    const resp = await this.fetch(this._buildUrl('user/profile'), {
+      method: 'GET',
+      headers: this._headers()
+    });
+    const json = await safeJson(resp);
+    if (!resp.ok || json?.success === false) throw toError(resp, json, 'Profile failed');
+    return json;
+  }
 
-    const resp = await this.fetchFn(url, {
+  // Generic authorized call for extra endpoints
+  async authed(path, { method = 'GET', body, headers } = {}) {
+    const resp = await this.fetch(this._buildUrl(path), {
       method,
-      headers,
-      body: body && method !== 'GET' ? JSON.stringify(body) : undefined
+      headers: this._headers(headers),
+      body: body ? JSON.stringify(body) : undefined
     });
-
-    const json = await resp.json().catch(() => ({}));
-
-    if (!resp.ok || json.success === false) {
-      throw new AuthError(
-        json.message || 'Request failed',
-        resp.status,
-        json.error || 'REQUEST_FAILED',
-        json
-      );
-    }
-
+    const json = await safeJson(resp);
+    if (!resp.ok || json?.success === false) throw toError(resp, json, 'Request failed');
     return json;
   }
+}
+
+// ---------- helpers ----------
+async function safeJson(resp) {
+  try { return await resp.json(); } catch { return null; }
+}
+
+function toError(resp, json, fallback) {
+  const err = new AuthError(
+    json?.message || fallback || 'Request failed',
+    resp.status,
+    json?.code || json?.error || 'REQUEST_FAILED',
+    json
+  );
+  return err;
 }