@owox/idp-better-auth 0.5.0

package/dist/services/authentication-service.js

@@ -0,0 +1,199 @@
+export class AuthenticationService {
+    auth;
+    cryptoService;
+    userManagementService;
+    constructor(auth, cryptoService) {
+        this.auth = auth;
+        this.cryptoService = cryptoService;
+    }
+    setUserManagementService(userManagementService) {
+        this.userManagementService = userManagementService;
+    }
+    async getSession(req) {
+        try {
+            const session = await this.auth.api.getSession({
+                headers: req.headers,
+            });
+            if (!session || !session.user || !session.session) {
+                return null;
+            }
+            return {
+                user: {
+                    id: session.user.id,
+                    email: session.user.email,
+                    name: session.user.name,
+                },
+                session: {
+                    id: session.session.id,
+                    userId: session.session.userId,
+                    token: session.session.token,
+                    expiresAt: session.session.expiresAt,
+                },
+            };
+        }
+        catch (error) {
+            console.error('Failed to get session:', error);
+            throw new Error('Failed to get session');
+        }
+    }
+    async signIn(email, password, protocol, host) {
+        try {
+            const url = `${protocol}://${host}/auth/better-auth/sign-in/email`;
+            const headers = new Headers();
+            headers.set('Content-Type', 'application/json');
+            const request = new Request(url, {
+                method: 'POST',
+                headers,
+                body: JSON.stringify({ email, password }),
+            });
+            const response = await this.auth.handler(request);
+            return response;
+        }
+        catch (error) {
+            console.error('Sign-in failed:', error);
+            throw new Error('Sign-in failed');
+        }
+    }
+    async signOut(req) {
+        try {
+            await this.auth.api.signOut({
+                headers: req.headers,
+            });
+        }
+        catch (error) {
+            console.error('Sign-out failed:', error);
+            throw new Error('Sign-out failed');
+        }
+    }
+    async generateAccessToken(req) {
+        try {
+            const session = await this.getSession(req);
+            if (!session) {
+                console.error('No session found for access token generation');
+                throw new Error('No session found');
+            }
+            const cookies = req.headers.cookie || '';
+            const sessionTokenMatch = cookies.match(/refreshToken=([^;]+)/);
+            const sessionToken = sessionTokenMatch && sessionTokenMatch[1] ? decodeURIComponent(sessionTokenMatch[1]) : null;
+            if (!sessionToken) {
+                console.error('No session token found in cookies');
+                throw new Error('No session token found');
+            }
+            return await this.cryptoService.encrypt(sessionToken);
+        }
+        catch (error) {
+            console.error('Failed to generate access token:', error);
+            throw new Error('Failed to generate access token');
+        }
+    }
+    async validateSession(req) {
+        try {
+            const session = await this.getSession(req);
+            if (!session) {
+                return {
+                    isValid: false,
+                    error: 'No valid session found',
+                };
+            }
+            return {
+                isValid: true,
+                session,
+            };
+        }
+        catch (error) {
+            return {
+                isValid: false,
+                error: error instanceof Error ? error.message : 'Session validation failed',
+            };
+        }
+    }
+    async signInMiddleware(req, res, _next) {
+        try {
+            const { email, password } = req.body;
+            if (!email || !password) {
+                return res.status(400).json({ error: 'Email and password are required' });
+            }
+            const response = await this.signIn(email, password, req.protocol, req.get('host') || 'localhost');
+            if (response.ok) {
+                response.headers.forEach((value, key) => {
+                    res.set(key, value);
+                });
+                return res.redirect('/');
+            }
+            else {
+                // Redirect back to sign-in page with error message
+                const errorMessage = response.status === 401
+                    ? 'Invalid email or password. Please try again.'
+                    : 'Sign in failed. Please try again.';
+                return res.redirect(`/auth/sign-in?error=${encodeURIComponent(errorMessage)}`);
+            }
+        }
+        catch (error) {
+            console.error('Sign-in middleware error:', error);
+            const errorMessage = 'An error occurred during sign in. Please try again.';
+            return res.redirect(`/auth/sign-in?error=${encodeURIComponent(errorMessage)}`);
+        }
+    }
+    async signOutMiddleware(req, res, _next) {
+        try {
+            await this.signOut(req);
+            res.clearCookie('refreshToken');
+            res.clearCookie('better-auth.csrf_token');
+            const redirectPath = req.query.redirect || '/auth/sign-in';
+            return res.redirect(redirectPath);
+        }
+        catch (error) {
+            console.error('Sign-out middleware error:', error);
+            return res.status(500).json({ error: 'Sign-out failed' });
+        }
+    }
+    async accessTokenMiddleware(req, res, _next) {
+        try {
+            const validation = await this.validateSession(req);
+            if (!validation.isValid) {
+                return res.status(401).json({ error: 'Unauthorized' });
+            }
+            const accessToken = await this.generateAccessToken(req);
+            return res.json({ accessToken });
+        }
+        catch (error) {
+            console.error('Access token middleware error:', error);
+            return res.status(401).json({ error: 'Unauthorized' });
+        }
+    }
+    async setPassword(password, req) {
+        try {
+            return await this.auth.api.setPassword({
+                body: {
+                    newPassword: password,
+                },
+                headers: req.headers,
+            });
+        }
+        catch (error) {
+            // Don't log error if user already has a password - this is expected behavior
+            if (error && typeof error === 'object' && 'body' in error) {
+                const apiError = error;
+                if (apiError.body?.code === 'USER_ALREADY_HAS_A_PASSWORD') {
+                    throw new Error('User already has a password');
+                }
+            }
+            console.error('Failed to set password:', error);
+            throw new Error('Failed to set password');
+        }
+    }
+    async requireAuthMiddleware(req, res, next) {
+        try {
+            const session = await this.getSession(req);
+            if (!session || !session.user) {
+                const currentPath = encodeURIComponent(req.originalUrl || req.url);
+                return res.redirect(`/auth/sign-in?redirect=${currentPath}`);
+            }
+            next();
+        }
+        catch (error) {
+            console.error('Authentication middleware error:', error);
+            return res.redirect('/auth/sign-in');
+        }
+    }
+}

package/dist/services/crypto-service.d.ts

@@ -0,0 +1,18 @@
+import { createBetterAuthConfig } from '../auth/auth-config.js';
+export declare class CryptoServiceError extends Error {
+    constructor(message: string);
+}
+export declare class CryptoService {
+    private readonly secret;
+    private readonly algorithm;
+    private readonly expiresIn;
+    private readonly aesAlgorithm;
+    private readonly issuer;
+    constructor(auth: Awaited<ReturnType<typeof createBetterAuthConfig>>);
+    private deriveKey;
+    private encryptData;
+    private decryptData;
+    encrypt(data: string): Promise<string>;
+    decrypt(token: string): Promise<string>;
+}
+//# sourceMappingURL=crypto-service.d.ts.map

package/dist/services/crypto-service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"crypto-service.d.ts","sourceRoot":"","sources":["../../src/services/crypto-service.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,sBAAsB,EAAE,MAAM,wBAAwB,CAAC;AAKhE,qBAAa,kBAAmB,SAAQ,KAAK;gBAC/B,OAAO,EAAE,MAAM;CAI5B;AAED,qBAAa,aAAa;IACxB,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAS;IAChC,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAgB;IAC1C,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAS;IACnC,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAS;IACtC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAS;gBAEpB,IAAI,EAAE,OAAO,CAAC,UAAU,CAAC,OAAO,sBAAsB,CAAC,CAAC;YAQtD,SAAS;YAKT,WAAW;YAaX,WAAW;IA4BnB,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IAqBtC,OAAO,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;CAiC9C"}

package/dist/services/crypto-service.js

@@ -0,0 +1,100 @@
+import jwt from 'jsonwebtoken';
+import { createCipheriv, createDecipheriv, randomBytes, scrypt } from 'crypto';
+import { promisify } from 'util';
+export class CryptoServiceError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'CryptoServiceError';
+    }
+}
+export class CryptoService {
+    secret;
+    algorithm;
+    expiresIn;
+    aesAlgorithm;
+    issuer;
+    constructor(auth) {
+        this.secret = auth.options.secret || 'default-secret';
+        this.algorithm = 'HS256';
+        this.expiresIn = 3600;
+        this.aesAlgorithm = 'aes-256-cbc';
+        this.issuer = 'idp-better-auth';
+    }
+    async deriveKey(salt) {
+        const scryptAsync = promisify(scrypt);
+        return scryptAsync(this.secret, salt, 32);
+    }
+    async encryptData(data) {
+        const salt = randomBytes(16);
+        const iv = randomBytes(16);
+        const key = await this.deriveKey(salt);
+        const cipher = createCipheriv(this.aesAlgorithm, key, iv);
+        let encrypted = cipher.update(data, 'utf8', 'hex');
+        encrypted += cipher.final('hex');
+        const result = salt.toString('hex') + ':' + iv.toString('hex') + ':' + encrypted;
+        return Buffer.from(result).toString('base64');
+    }
+    async decryptData(encryptedData) {
+        const data = Buffer.from(encryptedData, 'base64').toString('utf8');
+        const parts = data.split(':');
+        if (parts.length !== 3) {
+            throw new CryptoServiceError('Invalid encrypted data format');
+        }
+        const saltHex = parts[0];
+        const ivHex = parts[1];
+        const encrypted = parts[2];
+        if (!saltHex || !ivHex || !encrypted) {
+            throw new CryptoServiceError('Invalid encrypted data format - missing components');
+        }
+        const salt = Buffer.from(saltHex, 'hex');
+        const iv = Buffer.from(ivHex, 'hex');
+        const key = await this.deriveKey(salt);
+        const decipher = createDecipheriv(this.aesAlgorithm, key, iv);
+        let decrypted = decipher.update(encrypted, 'hex', 'utf8');
+        decrypted += decipher.final('utf8');
+        return decrypted;
+    }
+    async encrypt(data) {
+        try {
+            const encryptedData = await this.encryptData(data);
+            const payload = { payload: encryptedData };
+            const options = {
+                algorithm: this.algorithm,
+                expiresIn: this.expiresIn,
+                issuer: this.issuer,
+            };
+            const token = jwt.sign(payload, this.secret, options);
+            return token;
+        }
+        catch (error) {
+            throw new CryptoServiceError(`Encryption failed: ${error instanceof Error ? error.message : 'Unknown error'}`);
+        }
+    }
+    async decrypt(token) {
+        try {
+            const decoded = jwt.verify(token, this.secret, {
+                algorithms: [this.algorithm],
+            });
+            if (!decoded || !decoded.exp || decoded.exp < Date.now() / 1000) {
+                throw new CryptoServiceError('Token expired');
+            }
+            if (!decoded.payload || typeof decoded.payload !== 'string') {
+                throw new CryptoServiceError('Invalid token payload - missing or invalid encrypted data');
+            }
+            if (decoded.iss !== this.issuer) {
+                throw new CryptoServiceError('Invalid token issuer');
+            }
+            const decryptedData = await this.decryptData(decoded.payload);
+            return decryptedData;
+        }
+        catch (error) {
+            if (error instanceof jwt.JsonWebTokenError) {
+                throw new CryptoServiceError(`Decryption failed: Invalid token`);
+            }
+            if (error instanceof CryptoServiceError) {
+                throw error;
+            }
+            throw new CryptoServiceError(`Decryption failed: ${error instanceof Error ? error.message : 'Unknown error'}`);
+        }
+    }
+}

package/dist/services/database-service.d.ts

@@ -0,0 +1,14 @@
+import { createBetterAuthConfig } from '../auth/auth-config.js';
+import { DatabaseUser, DatabaseOperationResult } from '../types/database-models.js';
+export declare class DatabaseService {
+    private readonly auth;
+    constructor(auth: Awaited<ReturnType<typeof createBetterAuthConfig>>);
+    runMigrations(): Promise<void>;
+    getUsersDirectly(): Promise<DatabaseUser[]>;
+    getUserByIdDirectly(userId: string): Promise<DatabaseUser | null>;
+    removeUserDirectly(userId: string): Promise<DatabaseOperationResult>;
+    getUserCount(): Promise<number>;
+    cleanupExpiredSessions(): Promise<DatabaseOperationResult>;
+    isDatabaseHealthy(): Promise<boolean>;
+}
+//# sourceMappingURL=database-service.d.ts.map

package/dist/services/database-service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"database-service.d.ts","sourceRoot":"","sources":["../../src/services/database-service.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,sBAAsB,EAAE,MAAM,wBAAwB,CAAC;AAEhE,OAAO,EAAE,YAAY,EAAE,uBAAuB,EAAE,MAAM,6BAA6B,CAAC;AAEpF,qBAAa,eAAe;IACd,OAAO,CAAC,QAAQ,CAAC,IAAI;gBAAJ,IAAI,EAAE,OAAO,CAAC,UAAU,CAAC,OAAO,sBAAsB,CAAC,CAAC;IAE/E,aAAa,IAAI,OAAO,CAAC,IAAI,CAAC;IAc9B,gBAAgB,IAAI,OAAO,CAAC,YAAY,EAAE,CAAC;IAuB3C,mBAAmB,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,YAAY,GAAG,IAAI,CAAC;IAqBjE,kBAAkB,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,uBAAuB,CAAC;IAmDpE,YAAY,IAAI,OAAO,CAAC,MAAM,CAAC;IAqB/B,sBAAsB,IAAI,OAAO,CAAC,uBAAuB,CAAC;IAqB1D,iBAAiB,IAAI,OAAO,CAAC,OAAO,CAAC;CAiB5C"}

package/dist/services/database-service.js

@@ -0,0 +1,142 @@
+import { getMigrations } from 'better-auth/db';
+export class DatabaseService {
+    auth;
+    constructor(auth) {
+        this.auth = auth;
+    }
+    async runMigrations() {
+        try {
+            const { runMigrations, compileMigrations } = await getMigrations(this.auth.options);
+            await runMigrations();
+            await compileMigrations();
+        }
+        catch (error) {
+            console.error('Database migration failed:', error);
+            throw new Error(`Database migration failed: ${error instanceof Error ? error.message : 'Unknown error'}`);
+        }
+    }
+    async getUsersDirectly() {
+        try {
+            const db = this.auth.options.database;
+            if (!db || typeof db.prepare !== 'function') {
+                console.error('Database adapter does not support direct operations');
+                throw new Error('Database adapter does not support direct operations');
+            }
+            const stmt = db.prepare('SELECT id, email, name, createdAt FROM user ORDER BY createdAt DESC');
+            const users = stmt.all();
+            return users;
+        }
+        catch (error) {
+            console.error('Error getting users directly from database:', error);
+            throw new Error(`Failed to get users from database: ${error instanceof Error ? error.message : 'Unknown error'}`);
+        }
+    }
+    async getUserByIdDirectly(userId) {
+        try {
+            const db = this.auth.options.database;
+            if (!db || typeof db.prepare !== 'function') {
+                console.error('Database adapter does not support direct operations');
+                throw new Error('Database adapter does not support direct operations');
+            }
+            const stmt = db.prepare('SELECT id, email, name, createdAt FROM user WHERE id = ?');
+            const user = stmt.get(userId);
+            return user || null;
+        }
+        catch (error) {
+            console.error('Error getting user by ID from database:', error);
+            throw new Error(`Failed to get user from database: ${error instanceof Error ? error.message : 'Unknown error'}`);
+        }
+    }
+    async removeUserDirectly(userId) {
+        try {
+            const db = this.auth.options.database;
+            if (!db || typeof db.prepare !== 'function') {
+                console.error('Database adapter does not support direct operations');
+                throw new Error('Database adapter does not support direct operations');
+            }
+            // Clean up user's sessions
+            try {
+                const deleteSessionsStmt = db.prepare('DELETE FROM session WHERE userId = ?');
+                deleteSessionsStmt.run(userId);
+            }
+            catch {
+                // Session cleanup may not be needed
+            }
+            // Clean up user's accounts
+            try {
+                const deleteAccountsStmt = db.prepare('DELETE FROM account WHERE userId = ?');
+                deleteAccountsStmt.run(userId);
+            }
+            catch {
+                // Account cleanup may not be needed
+            }
+            // Clean up organization memberships
+            try {
+                const deleteMembershipsStmt = db.prepare('DELETE FROM member WHERE userId = ?');
+                deleteMembershipsStmt.run(userId);
+            }
+            catch {
+                // Organization membership cleanup may not be needed
+            }
+            // Finally, remove the user
+            const deleteUserStmt = db.prepare('DELETE FROM user WHERE id = ?');
+            const result = deleteUserStmt.run(userId);
+            if (result.changes === 0) {
+                console.error(`User ${userId} not found in database`);
+                throw new Error(`User ${userId} not found`);
+            }
+            return result;
+        }
+        catch (error) {
+            console.error(`Failed to delete user ${userId} from database:`, error);
+            throw new Error(`Failed to delete user ${userId}: ${error instanceof Error ? error.message : 'Unknown error'}`);
+        }
+    }
+    async getUserCount() {
+        try {
+            const db = this.auth.options.database;
+            if (!db || typeof db.prepare !== 'function') {
+                console.error('Database adapter does not support direct operations');
+                throw new Error('Database adapter does not support direct operations');
+            }
+            const stmt = db.prepare('SELECT COUNT(*) as count FROM user');
+            const result = stmt.get();
+            return result.count;
+        }
+        catch (error) {
+            console.error('Error getting user count from database:', error);
+            throw new Error(`Failed to get user count: ${error instanceof Error ? error.message : 'Unknown error'}`);
+        }
+    }
+    async cleanupExpiredSessions() {
+        try {
+            const db = this.auth.options.database;
+            if (!db || typeof db.prepare !== 'function') {
+                console.error('Database adapter does not support direct operations');
+                throw new Error('Database adapter does not support direct operations');
+            }
+            const stmt = db.prepare('DELETE FROM session WHERE expiresAt < datetime("now")');
+            const result = stmt.run();
+            return result;
+        }
+        catch (error) {
+            console.error('Error cleaning up expired sessions:', error);
+            throw new Error(`Failed to cleanup expired sessions: ${error instanceof Error ? error.message : 'Unknown error'}`);
+        }
+    }
+    async isDatabaseHealthy() {
+        try {
+            const db = this.auth.options.database;
+            if (!db || typeof db.prepare !== 'function') {
+                return false;
+            }
+            // Simple health check - try to query the user table
+            const stmt = db.prepare('SELECT 1 FROM user LIMIT 1');
+            stmt.get();
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+}

package/dist/services/magic-link-service.d.ts

@@ -0,0 +1,10 @@
+import { betterAuth } from 'better-auth';
+import { CryptoService } from './crypto-service.js';
+export declare class MagicLinkService {
+    private readonly auth;
+    private readonly cryptoService;
+    private static readonly DEFAULT_CALLBACK_URL;
+    constructor(auth: Awaited<ReturnType<typeof betterAuth>>, cryptoService: CryptoService);
+    generateMagicLink(email: string, role?: 'admin' | 'editor' | 'viewer'): Promise<string>;
+}
+//# sourceMappingURL=magic-link-service.d.ts.map

package/dist/services/magic-link-service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"magic-link-service.d.ts","sourceRoot":"","sources":["../../src/services/magic-link-service.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AACzC,OAAO,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAEpD,qBAAa,gBAAgB;IAIzB,OAAO,CAAC,QAAQ,CAAC,IAAI;IACrB,OAAO,CAAC,QAAQ,CAAC,aAAa;IAJhC,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,oBAAoB,CAA8B;gBAGvD,IAAI,EAAE,OAAO,CAAC,UAAU,CAAC,OAAO,UAAU,CAAC,CAAC,EAC5C,aAAa,EAAE,aAAa;IAGzC,iBAAiB,CACrB,KAAK,EAAE,MAAM,EACb,IAAI,GAAE,OAAO,GAAG,QAAQ,GAAG,QAAkB,GAC5C,OAAO,CAAC,MAAM,CAAC;CAyCnB"}

package/dist/services/magic-link-service.js

@@ -0,0 +1,42 @@
+export class MagicLinkService {
+    auth;
+    cryptoService;
+    static DEFAULT_CALLBACK_URL = '/auth/magic-link-success';
+    constructor(auth, cryptoService) {
+        this.auth = auth;
+        this.cryptoService = cryptoService;
+    }
+    async generateMagicLink(email, role = 'admin') {
+        // Clear previous magic link
+        delete global.lastMagicLink;
+        // Generate magic link directly through Better Auth internals
+        const baseURL = this.auth.options.baseURL || 'http://localhost:3000';
+        const encodedRole = await this.cryptoService.encrypt(role);
+        const callbackURL = `${baseURL}${MagicLinkService.DEFAULT_CALLBACK_URL}?role=${encodedRole}`;
+        // Create a mock Request object for Better Auth
+        const mockRequest = new Request(`${baseURL}/auth/better-auth/sign-in/magic-link`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify({
+                email: email,
+                callbackURL: callbackURL,
+            }),
+        });
+        // Call Better Auth handler directly
+        const response = await this.auth.handler(mockRequest);
+        if (!response.ok) {
+            const errorText = await response.text();
+            throw new Error(`Magic link generation failed: ${response.status} ${errorText}`);
+        }
+        // Wait a moment for the sendMagicLink callback to be called
+        await new Promise(resolve => setTimeout(resolve, 200));
+        // Get the generated magic link from global storage
+        const magicLink = global.lastMagicLink;
+        if (!magicLink) {
+            throw new Error('Magic link generation failed - no link received');
+        }
+        return magicLink;
+    }
+}

package/dist/services/middleware-service.d.ts

@@ -0,0 +1,15 @@
+import { type Request, type Response, type NextFunction } from 'express';
+import { Payload } from '@owox/idp-protocol';
+import { AuthenticationService } from './authentication-service.js';
+import { PageService } from './page-service.js';
+export declare class MiddlewareService {
+    private readonly authenticationService;
+    private readonly pageService;
+    private static readonly DEFAULT_ORGANIZATION_ID;
+    constructor(authenticationService: AuthenticationService, pageService: PageService);
+    signInMiddleware(req: Request, res: Response, _next: NextFunction): Promise<void | Response>;
+    signOutMiddleware(req: Request, res: Response, next: NextFunction): Promise<void | Response>;
+    accessTokenMiddleware(req: Request, res: Response, next: NextFunction): Promise<void | Response>;
+    userApiMiddleware(req: Request, res: Response, _next: NextFunction): Promise<Response<Payload>>;
+}
+//# sourceMappingURL=middleware-service.d.ts.map

package/dist/services/middleware-service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"middleware-service.d.ts","sourceRoot":"","sources":["../../src/services/middleware-service.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,OAAO,EAAE,KAAK,QAAQ,EAAE,KAAK,YAAY,EAAE,MAAM,SAAS,CAAC;AACzE,OAAO,EAAE,OAAO,EAAE,MAAM,oBAAoB,CAAC;AAC7C,OAAO,EAAE,qBAAqB,EAAE,MAAM,6BAA6B,CAAC;AACpE,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAEhD,qBAAa,iBAAiB;IAI1B,OAAO,CAAC,QAAQ,CAAC,qBAAqB;IACtC,OAAO,CAAC,QAAQ,CAAC,WAAW;IAJ9B,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,uBAAuB,CAAkB;gBAG9C,qBAAqB,EAAE,qBAAqB,EAC5C,WAAW,EAAE,WAAW;IAGrC,gBAAgB,CACpB,GAAG,EAAE,OAAO,EACZ,GAAG,EAAE,QAAQ,EACb,KAAK,EAAE,YAAY,GAClB,OAAO,CAAC,IAAI,GAAG,QAAQ,CAAC;IAIrB,iBAAiB,CACrB,GAAG,EAAE,OAAO,EACZ,GAAG,EAAE,QAAQ,EACb,IAAI,EAAE,YAAY,GACjB,OAAO,CAAC,IAAI,GAAG,QAAQ,CAAC;IAIrB,qBAAqB,CACzB,GAAG,EAAE,OAAO,EACZ,GAAG,EAAE,QAAQ,EACb,IAAI,EAAE,YAAY,GACjB,OAAO,CAAC,IAAI,GAAG,QAAQ,CAAC;IAIrB,iBAAiB,CACrB,GAAG,EAAE,OAAO,EACZ,GAAG,EAAE,QAAQ,EACb,KAAK,EAAE,YAAY,GAClB,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC;CAsB9B"}

package/dist/services/middleware-service.js

@@ -0,0 +1,38 @@
+export class MiddlewareService {
+    authenticationService;
+    pageService;
+    static DEFAULT_ORGANIZATION_ID = 'owox-default';
+    constructor(authenticationService, pageService) {
+        this.authenticationService = authenticationService;
+        this.pageService = pageService;
+    }
+    async signInMiddleware(req, res, _next) {
+        return this.pageService.signInPage.bind(this.pageService)(req, res);
+    }
+    async signOutMiddleware(req, res, next) {
+        return this.authenticationService.signOutMiddleware(req, res, next);
+    }
+    async accessTokenMiddleware(req, res, next) {
+        return this.authenticationService.accessTokenMiddleware(req, res, next);
+    }
+    async userApiMiddleware(req, res, _next) {
+        try {
+            const validation = await this.authenticationService.validateSession(req);
+            if (!validation.isValid || !validation.session) {
+                return res.status(401).json({ error: 'Unauthorized' });
+            }
+            const payload = {
+                userId: validation.session.user.id,
+                projectId: MiddlewareService.DEFAULT_ORGANIZATION_ID,
+                email: validation.session.user.email,
+                fullName: validation.session.user.name || validation.session.user.email,
+                roles: ['editor'],
+            };
+            return res.json(payload);
+        }
+        catch (error) {
+            console.error('User API middleware error:', error);
+            return res.status(401).json({ error: 'Unauthorized' });
+        }
+    }
+}

package/dist/services/page-service.d.ts

@@ -0,0 +1,23 @@
+import { type Express, type Request as ExpressRequest, type Response as ExpressResponse } from 'express';
+import { AuthenticationService } from './authentication-service.js';
+import { UserManagementService } from './user-management-service.js';
+import { CryptoService } from './crypto-service.js';
+export declare class PageService {
+    private readonly authenticationService;
+    private readonly userManagementService;
+    private readonly cryptoService;
+    constructor(authenticationService: AuthenticationService, userManagementService: UserManagementService, cryptoService: CryptoService);
+    signInPage(req: ExpressRequest, res: ExpressResponse): Promise<void>;
+    setupPasswordPage(req: ExpressRequest, res: ExpressResponse): Promise<void>;
+    setPassword(req: ExpressRequest, res: ExpressResponse): Promise<void>;
+    magicLinkSuccess(req: ExpressRequest, res: ExpressResponse): Promise<void>;
+    registerRoutes(express: Express): void;
+    adminDashboard(req: ExpressRequest, res: ExpressResponse): Promise<void>;
+    adminUserDetails(req: ExpressRequest, res: ExpressResponse): Promise<void>;
+    adminAddUserPage(req: ExpressRequest, res: ExpressResponse): Promise<void>;
+    adminAddUser(req: ExpressRequest, res: ExpressResponse): Promise<void>;
+    adminDeleteUser(req: ExpressRequest, res: ExpressResponse): Promise<void>;
+    adminGenerateMagicLink(req: ExpressRequest, res: ExpressResponse): Promise<void>;
+    private generateNameFromEmail;
+}
+//# sourceMappingURL=page-service.d.ts.map

package/dist/services/page-service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"page-service.d.ts","sourceRoot":"","sources":["../../src/services/page-service.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,OAAO,EACZ,KAAK,OAAO,IAAI,cAAc,EAC9B,KAAK,QAAQ,IAAI,eAAe,EACjC,MAAM,SAAS,CAAC;AACjB,OAAO,EAAE,qBAAqB,EAAE,MAAM,6BAA6B,CAAC;AAEpE,OAAO,EAAE,qBAAqB,EAAE,MAAM,8BAA8B,CAAC;AACrE,OAAO,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAGpD,qBAAa,WAAW;IAEpB,OAAO,CAAC,QAAQ,CAAC,qBAAqB;IACtC,OAAO,CAAC,QAAQ,CAAC,qBAAqB;IACtC,OAAO,CAAC,QAAQ,CAAC,aAAa;gBAFb,qBAAqB,EAAE,qBAAqB,EAC5C,qBAAqB,EAAE,qBAAqB,EAC5C,aAAa,EAAE,aAAa;IAGzC,UAAU,CAAC,GAAG,EAAE,cAAc,EAAE,GAAG,EAAE,eAAe,GAAG,OAAO,CAAC,IAAI,CAAC;IAepE,iBAAiB,CAAC,GAAG,EAAE,cAAc,EAAE,GAAG,EAAE,eAAe,GAAG,OAAO,CAAC,IAAI,CAAC;IAgB3E,WAAW,CAAC,GAAG,EAAE,cAAc,EAAE,GAAG,EAAE,eAAe,GAAG,OAAO,CAAC,IAAI,CAAC;IAuCrE,gBAAgB,CAAC,GAAG,EAAE,cAAc,EAAE,GAAG,EAAE,eAAe,GAAG,OAAO,CAAC,IAAI,CAAC;IAgDhF,cAAc,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI;IA6ChC,cAAc,CAAC,GAAG,EAAE,cAAc,EAAE,GAAG,EAAE,eAAe,GAAG,OAAO,CAAC,IAAI,CAAC;IAcxE,gBAAgB,CAAC,GAAG,EAAE,cAAc,EAAE,GAAG,EAAE,eAAe,GAAG,OAAO,CAAC,IAAI,CAAC;IA6B1E,gBAAgB,CAAC,GAAG,EAAE,cAAc,EAAE,GAAG,EAAE,eAAe,GAAG,OAAO,CAAC,IAAI,CAAC;IA6B1E,YAAY,CAAC,GAAG,EAAE,cAAc,EAAE,GAAG,EAAE,eAAe,GAAG,OAAO,CAAC,IAAI,CAAC;IAqDtE,eAAe,CAAC,GAAG,EAAE,cAAc,EAAE,GAAG,EAAE,eAAe,GAAG,OAAO,CAAC,IAAI,CAAC;IA6BzE,sBAAsB,CAAC,GAAG,EAAE,cAAc,EAAE,GAAG,EAAE,eAAe,GAAG,OAAO,CAAC,IAAI,CAAC;IAsDtF,OAAO,CAAC,qBAAqB;CAoB9B"}