import { Injectable } from '@nestjs/common';
import { createHash } from 'crypto';
import {
OAuthSession,
OAuthUserProfile,
} from '../providers/oauth-provider.interface';
import type {
AuthorizationCode,
IOAuthStore,
OAuthClient,
} from './oauth-store.interface';
// In-memory storage (in production, use a database)
@Injectable()
export class MemoryStore implements IOAuthStore {
private clients = new Map<string, OAuthClient>();
private authCodes = new Map<string, AuthorizationCode>();
private oauthSessions = new Map<string, OAuthSession>();
private userProfiles = new Map<
string,
OAuthUserProfile & { profile_id: string; provider: string }
>(); // profile_id -> profile
private providerUserIndex = new Map<string, string>(); // key(provider:userId) -> profile_id
async storeClient(client: OAuthClient): Promise<OAuthClient> {
this.clients.set(client.client_id, client);
return client;
}
async getClient(client_id: string): Promise<OAuthClient | undefined> {
return this.clients.get(client_id);
}
async findClient(client_name: string): Promise<OAuthClient | undefined> {
for (const client of this.clients.values()) {
if (client.client_name === client_name) {
return client;
}
}
return undefined;
}
async storeAuthCode(code: AuthorizationCode): Promise<void> {
this.authCodes.set(code.code, code);
}
async getAuthCode(code: string): Promise<AuthorizationCode | undefined> {
return this.authCodes.get(code);
}
async removeAuthCode(code: string): Promise<void> {
this.authCodes.delete(code);
}
// New OAuth session methods for provider-agnostic flow
async storeOAuthSession(
sessionId: string,
session: OAuthSession,
): Promise<void> {
this.oauthSessions.set(sessionId, session);
}
async getOAuthSession(sessionId: string): Promise<OAuthSession | undefined> {
const session = this.oauthSessions.get(sessionId);
if (session && session.expiresAt < Date.now()) {
this.oauthSessions.delete(sessionId);
return undefined;
}
return session;
}
async removeOAuthSession(sessionId: string): Promise<void> {
this.oauthSessions.delete(sessionId);
}
generateClientId(client: OAuthClient): string {
// Create deterministic client ID based on entire client object
const normalizedClient = this.normalizeClientObject(client);
const clientString = JSON.stringify(normalizedClient);
const hash = createHash('sha256').update(clientString).digest('hex');
// Use first 16 characters of hash with client name prefix for readability
const normalizedName = client.client_name
.toLowerCase()
.replace(/[^a-z0-9]/g, '');
return `${normalizedName}_${hash.substring(0, 16)}`;
}
private normalizeClientObject(client: OAuthClient): any {
// Create a normalized version of the client object for consistent hashing
const normalized: any = {};
// Sort object keys to ensure consistent ordering
const sortedKeys = Object.keys(client).sort();
for (const key of sortedKeys) {
const value = (client as any)[key];
if (Array.isArray(value)) {
// Sort arrays to ensure consistent ordering
normalized[key] = [...value].sort();
} else {
normalized[key] = value;
}
}
return normalized;
}
// User profile management
async upsertUserProfile(
profile: OAuthUserProfile,
provider: string,
): Promise<string> {
const key = `${provider}:${profile.id}`;
let profileId = this.providerUserIndex.get(key);
if (!profileId) {
// create new
profileId = this.generateProfileId(provider, profile.id);
this.providerUserIndex.set(key, profileId);
}
this.userProfiles.set(profileId, {
profile_id: profileId,
provider,
...profile,
});
return profileId;
}
async getUserProfileById(
profileId: string,
): Promise<
(OAuthUserProfile & { profile_id: string; provider: string }) | undefined
> {
return this.userProfiles.get(profileId);
}
private generateProfileId(provider: string, providerUserId: string): string {
const input = `${provider}:${providerUserId}`;
return createHash('sha256').update(input).digest('hex').slice(0, 24);
}
}
