dauth-md-node 1.0.1 → 2.1.0

package/package.json

@@ -1,63 +1,67 @@
 {
-  "version": "1.0.1",
+  "name": "dauth-md-node",
+  "version": "2.1.0",
   "license": "MIT",
+  "author": "David T. Pizarro Frick",
   "main": "dist/index.js",
+  "module": "dist/index.mjs",
   "typings": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.js"
+    }
+  },
   "files": [
     "dist",
     "src"
   ],
   "engines": {
-    "node": ">=10"
+    "node": ">=18"
   },
   "scripts": {
-    "start": "tsdx watch",
-    "build": "tsdx build",
-    "test": "tsdx test",
-    "lint": "tsdx lint",
+    "start": "tsup --watch",
+    "build": "tsup",
+    "test": "vitest run",
+    "typecheck": "tsc --noEmit",
     "format": "prettier --write \"src/**/*.{ts,tsx,js,jsx,json,md}\"",
-    "prepare": "tsdx build",
+    "prepare": "tsup",
     "size": "size-limit",
     "analyze": "size-limit --why"
   },
-  "husky": {
-    "hooks": {
-      "pre-commit": "tsdx lint"
-    }
-  },
   "prettier": {
     "printWidth": 80,
     "semi": true,
     "singleQuote": true,
     "trailingComma": "es5"
   },
-  "name": "dauth-md-node",
-  "author": "David T. Pizarro Frick",
-  "module": "dist/dauth-md-node.esm.js",
+  "packageManager": "pnpm@10.30.3",
   "size-limit": [
     {
-      "path": "dist/dauth-md-node.cjs.production.min.js",
+      "path": "dist/index.js",
       "limit": "10 KB"
     },
     {
-      "path": "dist/dauth-md-node.esm.js",
+      "path": "dist/index.mjs",
       "limit": "10 KB"
     }
   ],
+  "peerDependencies": {
+    "express": "^4.18.0 || ^5.0.0"
+  },
+  "dependencies": {
+    "jsonwebtoken": "^9.0.2"
+  },
   "devDependencies": {
-    "@size-limit/preset-small-lib": "^11.0.2",
+    "@size-limit/file": "^11.0.2",
     "@types/express": "^4.17.21",
     "@types/jsonwebtoken": "^9.0.5",
-    "@types/node-fetch": "^2.6.11",
+    "@types/node": "~22.9.4",
     "husky": "^9.0.11",
     "size-limit": "^11.0.2",
-    "tsdx": "^0.14.1",
-    "tslib": "^2.6.2",
-    "typescript": "^3.9.10"
-  },
-  "dependencies": {
-    "express": "^4.18.2",
-    "jsonwebtoken": "^9.0.2",
-    "node-fetch": "^2.6.1"
+    "tsup": "~8.5.0",
+    "typescript": "~5.9.3",
+    "vitest": "~3.1.0"
   }
 }

package/src/api/dauth.api.ts

@@ -1,18 +1,24 @@
 import { getServerBasePath } from './utils/config';
-const fetch = require('node-fetch');
 
-export async function getUser(token: string, domainName: string) {
-  const params = {
-    method: 'GET',
-    headers: {
-      Authorization: token,
-      'Content-Type': 'application/json',
-    },
-  };
+interface GetUserResponse {
+  response: { status: number };
+  data: { user?: any; message?: string };
+}
+
+export async function getUser(
+  token: string,
+  domainName: string
+): Promise<GetUserResponse> {
   const response = await fetch(
     `${getServerBasePath()}/app/${domainName}/user`,
-    params
+    {
+      method: 'GET',
+      headers: {
+        Authorization: token,
+        'Content-Type': 'application/json',
+      },
+    }
   );
-  const data = await response.json();
-  return { response, data };
+  const data = (await response.json()) as GetUserResponse['data'];
+  return { response: { status: response.status }, data };
 }

package/src/api/utils/config.ts

@@ -1,7 +1,12 @@
 export const apiVersion = 'v1';
 export const serverDomain = 'dauth.ovh';
 
-export function getServerBasePath() {
+export function getServerBasePath(): string {
+  if (process.env.DAUTH_URL) {
+    const base = process.env.DAUTH_URL.replace(/\/+$/, '');
+    return `${base}/api/${apiVersion}`;
+  }
+
   const isLocalhost = process.env.NODE_ENV === 'development';
   const serverPort = 4012;
   const serverLocalUrl = `http://localhost:${serverPort}/api/${apiVersion}`;

package/src/cache.ts

@@ -0,0 +1,51 @@
+import { IDauthUser } from './index';
+
+interface CacheEntry {
+  user: IDauthUser;
+  expiresAt: number;
+}
+
+export interface CacheOptions {
+  ttlMs: number;
+}
+
+export class UserCache {
+  private store = new Map<string, CacheEntry>();
+  private ttlMs: number;
+
+  constructor(options: CacheOptions) {
+    this.ttlMs = options.ttlMs;
+  }
+
+  get(token: string): IDauthUser | undefined {
+    const entry = this.store.get(token);
+    if (!entry) return undefined;
+
+    if (Date.now() > entry.expiresAt) {
+      this.store.delete(token);
+      return undefined;
+    }
+
+    return entry.user;
+  }
+
+  set(token: string, user: IDauthUser): void {
+    if (this.store.size > 1000) {
+      this.sweep();
+    }
+    this.store.set(token, { user, expiresAt: Date.now() + this.ttlMs });
+  }
+
+  clear(): void {
+    this.store.clear();
+  }
+
+  private sweep(): void {
+    const now = Date.now();
+    for (const [key, entry] of this.store) {
+      if (now > entry.expiresAt) {
+        this.store.delete(key);
+      }
+    }
+  }
+}

package/src/index.ts

@@ -1,11 +1,10 @@
-import {
-  Request,
-  NextFunction,
-  Response as ExpressResponse,
-  Handler,
-} from 'express';
+import { Request, NextFunction, Response as ExpressResponse } from 'express';
 import jwt from 'jsonwebtoken';
 import { getUser } from './api/dauth.api';
+import { UserCache } from './cache';
+import type { CacheOptions } from './cache';
+
+export type AuthMethodType = 'password' | 'magic-link' | 'passkey';
 
 export interface IDauthUser {
   _id: string;
@@ -22,6 +21,10 @@ export interface IDauthUser {
   role: string;
   telPrefix: string;
   telSuffix: string;
+  birthDate?: string;
+  country?: string;
+  metadata?: Record<string, unknown>;
+  authMethods?: AuthMethodType[];
   createdAt: Date;
   updatedAt: Date;
   lastLogin: Date;
@@ -38,76 +41,99 @@ export interface IRequestDauth extends Request {
   };
 }
 
+export interface DauthOptions {
+  domainName: string;
+  tsk: string;
+  cache?: CacheOptions;
+}
+
 interface TCustomResponse extends ExpressResponse {
-  status(code: number): any;
-  send(body?: any): any;
+  status(code: number): this;
+  send(body?: unknown): this;
 }
 
-export const dauth = ({
-  domainName,
-  tsk,
-}: {
-  domainName: string;
-  tsk: string;
-}) => {
-  return (
+export { UserCache };
+export type { CacheOptions };
+
+export const dauth = ({ domainName, tsk, cache }: DauthOptions) => {
+  const userCache = cache ? new UserCache(cache) : null;
+
+  return async (
     req: IRequestDauth,
     res: TCustomResponse,
     next: NextFunction
-  ): Handler | void => {
+  ) => {
     if (!req.headers.authorization) {
       return res
         .status(403)
         .send({ status: 'token-not-found', message: 'Token not found' });
     }
+
     const token = req.headers.authorization.replace(/['"]+/g, '');
+
     try {
-      jwt.verify(token, tsk as string);
-      return getUser(token, domainName)
-        .then((getUserFetch: any) => {
-          if (getUserFetch.response.status === 404) {
-            return res.status(404).send({
-              status: 'user-not-found',
-              message: getUserFetch.data.message ?? 'User does not exist',
-            });
-          } else if (getUserFetch.response.status === 500) {
-            return res.status(500).send({
-              status: 'error',
-              message: getUserFetch.data.message ?? 'Dauth server error',
-            });
-          } else if (getUserFetch.response.status === 200) {
-            req.user = getUserFetch.data.user;
-            return next();
-          } else {
-            return res.status(501).send({
-              status: 'request-error',
-              message: getUserFetch.data.message ?? 'Dauth server error',
-            });
-          }
-        })
-        .catch((error: any) => {
-          return res.status(500).send({
-            status: 'server-error',
-            message: error.message ?? 'Dauth server error',
-          });
-        });
+      jwt.verify(token, tsk);
     } catch (error) {
-      if (error && error?.message === 'jwt expired') {
-        return res.status(401).send({
-          status: 'token-expired',
-          message: error?.message ?? 'Token expired',
-        });
+      const message =
+        error instanceof Error ? error.message : 'Token invalid';
+
+      if (message === 'jwt expired') {
+        return res
+          .status(401)
+          .send({ status: 'token-expired', message: 'jwt expired' });
       }
-      if (error && error?.message === 'invalid signature') {
+      if (message === 'invalid signature') {
         return res.status(401).send({
           status: 'tsk-not-invalid',
-          message: 'The TSK variable in the backend middleware is not valid',
+          message:
+            'The TSK variable in the backend middleware is not valid',
         });
       }
-      return res.status(401).send({
-        status: 'token-invalid',
-        message: error?.message ?? 'Token invalid',
+      return res
+        .status(401)
+        .send({ status: 'token-invalid', message });
+    }
+
+    if (userCache) {
+      const cachedUser = userCache.get(token);
+      if (cachedUser) {
+        req.user = cachedUser;
+        return next();
+      }
+    }
+
+    try {
+      const getUserFetch = await getUser(token, domainName);
+
+      if (getUserFetch.response.status === 404) {
+        return res.status(404).send({
+          status: 'user-not-found',
+          message: getUserFetch.data.message ?? 'User does not exist',
+        });
+      }
+      if (getUserFetch.response.status === 500) {
+        return res.status(500).send({
+          status: 'error',
+          message: getUserFetch.data.message ?? 'Dauth server error',
+        });
+      }
+      if (getUserFetch.response.status === 200) {
+        req.user = getUserFetch.data.user;
+        if (userCache) {
+          userCache.set(token, req.user);
+        }
+        return next();
+      }
+      return res.status(501).send({
+        status: 'request-error',
+        message: getUserFetch.data.message ?? 'Dauth server error',
       });
+    } catch (error) {
+      const message =
+        error instanceof Error ? error.message : 'Dauth server error';
+      return res
+        .status(500)
+        .send({ status: 'server-error', message });
     }
   };
 };

package/dist/api/dauth.api.d.ts

@@ -1,4 +0,0 @@
-export declare function getUser(token: string, domainName: string): Promise<{
-    response: any;
-    data: any;
-}>;

package/dist/api/utils/config.d.ts

@@ -1,3 +0,0 @@
-export declare const apiVersion = "v1";
-export declare const serverDomain = "dauth.ovh";
-export declare function getServerBasePath(): string;