dauth-md-node 1.0.1 → 2.0.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,8 @@
-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 interface IDauthUser {
   _id: string;
@@ -22,6 +19,9 @@ export interface IDauthUser {
   role: string;
   telPrefix: string;
   telSuffix: string;
+  birthDate?: string;
+  country?: string;
+  metadata?: Record<string, unknown>;
   createdAt: Date;
   updatedAt: Date;
   lastLogin: Date;
@@ -38,76 +38,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;