clhq-auth-module 1.1.0-alpha.100 → 1.1.0-alpha.102

package/dist/auth/interfaces/auth.interface.d.ts

@@ -24,3 +24,12 @@ export interface UserPayload {
     email: string;
     role: string;
 }
+export declare abstract class UserResolver {
+    abstract resolveUserId(auth0UserId: string): Promise<string | null>;
+}
+export interface AuthenticatedUser {
+    id: string;
+    email: string;
+    auth0Id?: string;
+}
+export declare function maskSensitiveId(id: string | undefined): string;

package/dist/auth/interfaces/auth.interface.js

@@ -1,2 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.UserResolver = void 0;
+exports.maskSensitiveId = maskSensitiveId;
+class UserResolver {
+}
+exports.UserResolver = UserResolver;
+function maskSensitiveId(id) {
+    if (!id)
+        return '[none]';
+    if (id.length <= 10)
+        return '***';
+    return `${id.substring(0, 10)}***`;
+}

package/dist/index.d.ts

@@ -1,2 +1,4 @@
 export * from './auth';
 export * from './middlewares/AuthMiddleware';
+export * from './auth/interfaces/auth.interface';
+export * from './utils/uuid-resolver';

package/dist/index.js

@@ -16,3 +16,5 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./auth"), exports);
 __exportStar(require("./middlewares/AuthMiddleware"), exports);
+__exportStar(require("./auth/interfaces/auth.interface"), exports);
+__exportStar(require("./utils/uuid-resolver"), exports);

package/dist/middlewares/AuthMiddleware.d.ts

@@ -1,9 +1,11 @@
 import { NestMiddleware } from '@nestjs/common';
 import { Request, Response } from 'express';
 import { Auth0Service } from '../auth/services/auth0.service';
+import { UserResolver } from '../auth/interfaces/auth.interface';
 export declare class AuthMiddleware implements NestMiddleware {
     private readonly auth0Service;
+    private readonly userResolver?;
     private readonly logger;
-    constructor(auth0Service: Auth0Service);
+    constructor(auth0Service: Auth0Service, userResolver?: UserResolver);
     use(req: Request, res: Response, next: () => void): Promise<void>;
 }

package/dist/middlewares/AuthMiddleware.js

@@ -14,11 +14,14 @@ exports.AuthMiddleware = void 0;
 const common_1 = require("@nestjs/common");
 const lodash_1 = require("lodash");
 const auth0_service_1 = require("../auth/services/auth0.service");
+const auth_interface_1 = require("../auth/interfaces/auth.interface");
 let AuthMiddleware = AuthMiddleware_1 = class AuthMiddleware {
     auth0Service;
+    userResolver;
     logger = new common_1.Logger(AuthMiddleware_1.name);
-    constructor(auth0Service) {
+    constructor(auth0Service, userResolver) {
         this.auth0Service = auth0Service;
+        this.userResolver = userResolver;
     }
     async use(req, res, next) {
         const bearerHeader = req.headers.authorization;
@@ -33,12 +36,33 @@ let AuthMiddleware = AuthMiddleware_1 = class AuthMiddleware {
             this.logger.debug('requesting jwt verify token process');
             const decodedToken = (await this.auth0Service.validateToken(accessToken));
             const userEmail = (0, lodash_1.get)(decodedToken, 'https://clippyhq.com/email', '');
+            const auth0UserId = decodedToken?.sub;
+            this.logger.debug('token');
+            this.logger.debug({
+                sub: (0, auth_interface_1.maskSensitiveId)(auth0UserId),
+                email: userEmail,
+            });
+            let userId = auth0UserId;
+            if (this.userResolver && auth0UserId) {
+                try {
+                    const resolvedId = await this.userResolver.resolveUserId(auth0UserId);
+                    if (resolvedId) {
+                        userId = resolvedId;
+                        this.logger.debug(`Resolved Auth0 user to UUID ${userId}`);
+                    }
+                    else {
+                        this.logger.warn(`Could not resolve Auth0 user to UUID`);
+                    }
+                }
+                catch (resolveError) {
+                    this.logger.error(`Error resolving user ID for ${(0, auth_interface_1.maskSensitiveId)(auth0UserId)}:`, resolveError);
+                }
+            }
             const user = {
-                id: decodedToken?.sub,
+                id: userId,
                 email: userEmail,
+                auth0Id: auth0UserId,
             };
-            this.logger.debug('token');
-            this.logger.debug({ sub: decodedToken.sub, email: userEmail });
             if (user) {
                 res.locals.user = user;
                 res.locals.email = user?.email;
@@ -58,5 +82,6 @@ let AuthMiddleware = AuthMiddleware_1 = class AuthMiddleware {
 exports.AuthMiddleware = AuthMiddleware;
 exports.AuthMiddleware = AuthMiddleware = AuthMiddleware_1 = __decorate([
     (0, common_1.Injectable)(),
-    __metadata("design:paramtypes", [auth0_service_1.Auth0Service])
+    __metadata("design:paramtypes", [auth0_service_1.Auth0Service,
+        auth_interface_1.UserResolver])
 ], AuthMiddleware);

package/dist/utils/uuid-resolver.d.ts

@@ -0,0 +1,3 @@
+export declare function isValidUUID(value: string): boolean;
+export declare function resolveUserId(userIdOrAuth0Id: string): Promise<string | null>;
+export declare function resolveUserIds(userIds: string[]): Promise<Array<string | null>>;

package/dist/utils/uuid-resolver.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isValidUUID = isValidUUID;
+exports.resolveUserId = resolveUserId;
+exports.resolveUserIds = resolveUserIds;
+const typeorm_1 = require("typeorm");
+const clhq_postgres_module_1 = require("clhq-postgres-module");
+const UUID_REGEX = /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+let dataSource = null;
+async function getDataSource() {
+    if (dataSource && dataSource.isInitialized) {
+        return dataSource;
+    }
+    const databaseUrl = process.env.PG_SESSION_POOLER_URL;
+    if (!databaseUrl) {
+        throw new Error('PG_SESSION_POOLER_URL environment variable is not set');
+    }
+    dataSource = new typeorm_1.DataSource({
+        type: 'postgres',
+        url: databaseUrl,
+        entities: [clhq_postgres_module_1.User],
+        synchronize: false,
+        ssl: { rejectUnauthorized: false },
+    });
+    await dataSource.initialize();
+    return dataSource;
+}
+function isValidUUID(value) {
+    return UUID_REGEX.test(value);
+}
+async function resolveUserId(userIdOrAuth0Id) {
+    if (isValidUUID(userIdOrAuth0Id)) {
+        return userIdOrAuth0Id;
+    }
+    try {
+        const ds = await getDataSource();
+        const userRepository = ds.getRepository(clhq_postgres_module_1.User);
+        const user = await userRepository.findOne({
+            where: { auth0UserId: userIdOrAuth0Id },
+        });
+        return user?.id || null;
+    }
+    catch (error) {
+        console.error(`Error resolving user ID for ${userIdOrAuth0Id}:`, error);
+        return null;
+    }
+}
+async function resolveUserIds(userIds) {
+    return Promise.all(userIds.map(resolveUserId));
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "clhq-auth-module",
-  "version": "1.1.0-alpha.100",
+  "version": "1.1.0-alpha.102",
   "description": "Reusable Auth module for NestJS, ready for npm publishing.",
   "author": "clhq",
   "main": "dist/index.js",