@resolveio/server-lib 22.3.40 → 22.3.42

package/src/util/customer-portal-password.ts

@@ -0,0 +1,183 @@
+import { CustomerPortalPasswords } from '../collections/customer-portal-password.collection';
+import { UserModel } from '../models/user.model';
+import { ResolveIOServer } from '../resolveio-server-app';
+const crypto = require('crypto');
+
+const ALGORITHM = 'aes-256-gcm';
+const ENCRYPTION_KEY_VERSION = 1;
+const IV_LENGTH_BYTES = 12;
+
+interface PasswordCipherPayload {
+	cipherText: string;
+	iv: string;
+	authTag: string;
+	keyVersion: number;
+}
+
+interface PasswordRecordMeta {
+	updatedByUserId?: string;
+	updatedByUser?: string;
+}
+
+export function isCustomerPortalUser(user: UserModel | any): boolean {
+	if (!user || typeof user !== 'object') {
+		return false;
+	}
+
+	const other = user.other || {};
+	if (other.id_customer) {
+		return true;
+	}
+
+	if (Array.isArray(other.customers) && other.customers.length > 0) {
+		return true;
+	}
+
+	const groups = Array.isArray(user?.roles?.groups) ? user.roles.groups : [];
+	if (groups.some(group => {
+		if (!group || typeof group.name !== 'string') {
+			return false;
+		}
+
+		const normalized = group.name.trim().toLowerCase();
+		return normalized === 'customer portal' || normalized === 'customer-portal';
+	})) {
+		return true;
+	}
+
+	return false;
+}
+
+export async function saveCustomerPortalPassword(user: UserModel | any, password: string, meta?: PasswordRecordMeta): Promise<void> {
+	if (!user?._id) {
+		return;
+	}
+
+	if (!CustomerPortalPasswords) {
+		return;
+	}
+
+	if (!isCustomerPortalUser(user)) {
+		await clearCustomerPortalPassword(user._id);
+		return;
+	}
+
+	if (!password || typeof password !== 'string') {
+		await clearCustomerPortalPassword(user._id);
+		return;
+	}
+
+	const payload = encryptPassword(password);
+	const setData: any = {
+		id_user: user._id,
+		cipher_text: payload.cipherText,
+		iv: payload.iv,
+		auth_tag: payload.authTag,
+		key_version: payload.keyVersion,
+		last_set_at: new Date()
+	};
+
+	if (meta?.updatedByUserId) {
+		setData.updated_by_user_id = meta.updatedByUserId;
+	}
+
+	if (meta?.updatedByUser) {
+		setData.updated_by_user = meta.updatedByUser;
+	}
+
+	await CustomerPortalPasswords.updateOne(
+		{id_user: user._id},
+		{
+			$set: setData
+		},
+		{upsert: true}
+	);
+}
+
+export async function clearCustomerPortalPassword(userId: string): Promise<void> {
+	if (!userId || !CustomerPortalPasswords) {
+		return;
+	}
+
+	await CustomerPortalPasswords.deleteOne({id_user: userId});
+}
+
+export async function getDecryptedCustomerPortalPassword(userId: string): Promise<{password: string; lastSetAt?: Date}> {
+	if (!userId) {
+		throw new Error('Customer portal user id is required.');
+	}
+
+	if (!CustomerPortalPasswords) {
+		throw new Error('Customer portal password store is not available.');
+	}
+
+	const record = await CustomerPortalPasswords.findOne({id_user: userId});
+	if (!record) {
+		throw new Error('No stored customer portal password is available for this user.');
+	}
+
+	const password = decryptPassword({
+		cipherText: record.cipher_text,
+		iv: record.iv,
+		authTag: record.auth_tag,
+		keyVersion: record.key_version
+	});
+
+	return {
+		password,
+		lastSetAt: record.last_set_at
+	};
+}
+
+function encryptPassword(plainText: string): PasswordCipherPayload {
+	const key = resolveEncryptionKey();
+	const ivBuffer = crypto.randomBytes(IV_LENGTH_BYTES);
+	const cipher = crypto.createCipheriv(ALGORITHM, key, ivBuffer);
+	const encrypted = Buffer.concat([cipher.update(plainText, 'utf8'), cipher.final()]);
+	const authTag = cipher.getAuthTag();
+
+	return {
+		cipherText: encrypted.toString('base64'),
+		iv: ivBuffer.toString('base64'),
+		authTag: authTag.toString('base64'),
+		keyVersion: ENCRYPTION_KEY_VERSION
+	};
+}
+
+function decryptPassword(payload: PasswordCipherPayload): string {
+	if (!payload || payload.keyVersion !== ENCRYPTION_KEY_VERSION) {
+		throw new Error('Unsupported customer portal password encryption version.');
+	}
+
+	const key = resolveEncryptionKey();
+	const decipher = crypto.createDecipheriv(
+		ALGORITHM,
+		key,
+		Buffer.from(payload.iv, 'base64')
+	);
+	decipher.setAuthTag(Buffer.from(payload.authTag, 'base64'));
+
+	const decrypted = Buffer.concat([
+		decipher.update(Buffer.from(payload.cipherText, 'base64')),
+		decipher.final()
+	]);
+
+	return decrypted.toString('utf8');
+}
+
+function resolveEncryptionKey(): Buffer {
+	const config = ResolveIOServer.getServerConfig ? ResolveIOServer.getServerConfig() : {};
+	const secret = String(
+		(config && config['CUSTOMER_PORTAL_PASSWORD_SECRET'])
+		|| process.env.CUSTOMER_PORTAL_PASSWORD_SECRET
+		|| (config && config['JWT_SECRET'])
+		|| process.env.JWT_SECRET
+		|| ''
+	).trim();
+
+	if (!secret) {
+		throw new Error('Missing CUSTOMER_PORTAL_PASSWORD_SECRET (or JWT_SECRET) for customer portal password encryption.');
+	}
+
+	return crypto.createHash('sha256').update(secret, 'utf8').digest();
+}

package/src/util/error-reporter.ts

@@ -0,0 +1,332 @@
+import { createHash } from 'crypto';
+import { ResolveIOServer } from '../resolveio-server-app';
+
+// eslint-disable-next-line no-unused-vars
+type FetchLike = (input: RequestInfo, init?: RequestInit) => Promise<Response>;
+
+export interface ErrorReportAttachment {
+	name: string;
+	url?: string;
+	contentType?: string;
+	size?: number;
+}
+
+export interface ErrorReportOptions {
+	sourceApp?: string;
+	message?: string;
+	subject?: string;
+	environment?: string;
+	clientId?: string;
+	clientSlug?: string;
+	clientName?: string;
+	clientRepo?: string;
+	clientEmail?: string;
+	severity?: string;
+	stack?: string | Error;
+	error?: unknown;
+	context?: Record<string, any> | string | null;
+	metadata?: Record<string, any> | string | null;
+	attachments?: ErrorReportAttachment[];
+	fingerprint?: string;
+	idempotencyKey?: string;
+	reportedBy?: string;
+	reportedAt?: string | Date;
+	reportedFor?: string;
+	reportedCount?: number;
+	reportedSourceHost?: string;
+	reportedSourceIp?: string;
+	reportedSourceVersion?: string;
+	reportedSourcePid?: number;
+	reportedSourceInstance?: string;
+	reportedSourceRegion?: string;
+	reportedSourceCluster?: string;
+	reportedSourceProcess?: string;
+	reportedSourceEnv?: Record<string, any>;
+	correlationId?: string;
+	apiUrl?: string;
+	fetch?: FetchLike;
+	logger?: Pick<typeof console, 'error' | 'warn' | 'info' | 'log'>;
+}
+
+export interface ErrorReportResult {
+	delivered: boolean;
+	status?: number;
+	reason?: string;
+}
+
+interface ErrorReportPayload {
+	sourceApp: string;
+	message: string;
+	environment?: string;
+	clientId?: string;
+	clientSlug?: string;
+	clientName?: string;
+	clientRepo?: string;
+	clientEmail?: string;
+	severity: string;
+	stack?: string;
+	context?: Record<string, any> | string;
+	metadata?: Record<string, any> | string;
+	attachments?: ErrorReportAttachment[];
+	fingerprint?: string;
+	idempotencyKey?: string;
+	reportedBy?: string;
+	reportedAt?: Date;
+	reportedFor?: string;
+	reportedCount?: number;
+	reportedSourceHost?: string;
+	reportedSourceIp?: string;
+	reportedSourceVersion?: string;
+	reportedSourcePid?: number;
+	reportedSourceInstance?: string;
+	reportedSourceRegion?: string;
+	reportedSourceCluster?: string;
+	reportedSourceProcess?: string;
+	reportedSourceEnv?: Record<string, any>;
+}
+
+export class ErrorReporter {
+	public static async report(options: ErrorReportOptions): Promise<ErrorReportResult> {
+		const logger = options.logger || console;
+		const config = getServerConfig();
+		const clientName = options.clientName || config?.CLIENT_NAME || ResolveIOServer.getClientName?.() || 'resolveio';
+		const sourceApp = options.sourceApp || clientName || 'resolveio-server-lib';
+		const environment = options.environment || process.env.RESOLVEIO_ENV || config?.RESOLVEIO_ENV || config?.ENVIRONMENT || config?.ROOT_URL || process.env.NODE_ENV || 'unknown';
+		const message = options.message || options.subject || 'ResolveIO Error Detected';
+		const severity = options.severity || 'error';
+		const stack = normalizeStack(options.stack || options.error);
+		const context = normalizeStructured(options.context, options.correlationId);
+		const metadata = normalizeStructured(mergeMetadata(options.metadata, options.correlationId));
+		const attachments = Array.isArray(options.attachments) ? normalizeAttachments(options.attachments) : undefined;
+		const fingerprint = options.fingerprint || computeFingerprint(sourceApp, environment, message, stack);
+		const idempotencyKey = options.idempotencyKey;
+		const reportedAt = normalizeReportedAtDate(options.reportedAt);
+		const normalizedReportedSourceEnv = normalizeStructured(options.reportedSourceEnv);
+		const payload: ErrorReportPayload = removeEmptyFields({
+			sourceApp,
+			message,
+			environment,
+			clientId: options.clientId,
+			clientSlug: options.clientSlug,
+			clientName,
+			clientRepo: options.clientRepo,
+			clientEmail: options.clientEmail,
+			severity,
+			stack,
+			context,
+			metadata,
+			attachments,
+			fingerprint,
+			idempotencyKey,
+			reportedBy: options.reportedBy,
+			reportedAt,
+			reportedFor: options.reportedFor,
+			reportedCount: options.reportedCount,
+			reportedSourceHost: options.reportedSourceHost,
+			reportedSourceIp: options.reportedSourceIp,
+			reportedSourceVersion: options.reportedSourceVersion,
+			reportedSourcePid: options.reportedSourcePid,
+			reportedSourceInstance: options.reportedSourceInstance,
+			reportedSourceRegion: options.reportedSourceRegion,
+			reportedSourceCluster: options.reportedSourceCluster,
+			reportedSourceProcess: options.reportedSourceProcess,
+			reportedSourceEnv: typeof normalizedReportedSourceEnv === 'string' ? undefined : normalizedReportedSourceEnv as Record<string, any>
+		});
+
+		const manager = ResolveIOServer['AutoFixManager'];
+		if (!manager || typeof manager.ingestErrorReport !== 'function') {
+			logger.error('ErrorReporter failed: local AutoFixManager is not available');
+			logger.error('ErrorReporter payload (not ingested):', payload);
+			return { delivered: false, reason: 'local-manager-missing' };
+		}
+		if (typeof manager.isReady === 'function' && !manager.isReady()) {
+			logger.error('ErrorReporter failed: local AutoFixManager is not enabled');
+			logger.error('ErrorReporter payload (not ingested):', payload);
+			return { delivered: false, reason: 'local-manager-not-ready' };
+		}
+		try {
+			const result = await manager.ingestErrorReport(payload);
+			return {
+				delivered: true,
+				status: 200,
+				reason: result?.status || 'recorded'
+			};
+		}
+		catch (err) {
+			logger.error('ErrorReporter local ingestion failed', err);
+			logger.error('ErrorReporter payload (not ingested):', payload);
+			return { delivered: false, reason: 'local-ingest-failed' };
+		}
+	}
+}
+
+function getServerConfig(): Record<string, any> | null {
+	try {
+		return ResolveIOServer.getServerConfig?.() || null;
+	}
+	catch (err) {
+		console.error('Failed to read ResolveIO server config', err);
+		return null;
+	}
+}
+
+function normalizeStack(stack?: string | Error | unknown): string | undefined {
+	if (!stack) {
+		return undefined;
+	}
+
+	if (typeof stack === 'string') {
+		return stack;
+	}
+
+	if (stack instanceof Error) {
+		return stack.stack || stack.message;
+	}
+
+	if (typeof stack === 'object' && stack !== null && typeof (stack as Record<string, any>).stack === 'string') {
+		return (stack as Record<string, any>).stack;
+	}
+
+	if (typeof stack === 'object' && stack !== null && typeof (stack as Record<string, any>).message === 'string') {
+		return (stack as Record<string, any>).message;
+	}
+
+	return JSON.stringify(stack);
+}
+
+function normalizeStructured(value: any, correlationId?: string): Record<string, any> | string | undefined {
+	if (value === null || value === undefined) {
+		return undefined;
+	}
+
+	if (typeof value === 'string') {
+		return value;
+	}
+
+	const serialized = serializeValue(value);
+	if (correlationId && typeof serialized === 'object' && serialized !== null && !serialized.correlationId) {
+		serialized.correlationId = correlationId;
+	}
+	return serialized;
+}
+
+function serializeValue(value: any, seen: WeakSet<object> = new WeakSet()): any {
+	if (value === null || value === undefined) {
+		return value;
+	}
+
+	if (typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean') {
+		return value;
+	}
+
+	if (typeof value === 'bigint') {
+		return value.toString();
+	}
+
+	if (value instanceof Date) {
+		return isNaN(value.getTime()) ? null : value.toISOString();
+	}
+
+	if (value instanceof Error) {
+		const base = {
+			name: value.name,
+			message: value.message,
+			stack: value.stack
+		};
+		return Object.assign({}, base, serializeValue(Object.assign({}, value), seen));
+	}
+
+	if (Array.isArray(value)) {
+		if (seen.has(value)) {
+			return '[Circular]';
+		}
+		seen.add(value);
+		const arr = value.map(item => serializeValue(item, seen));
+		seen.delete(value);
+		return arr;
+	}
+
+	if (typeof value === 'object') {
+		if (seen.has(value)) {
+			return '[Circular]';
+		}
+		seen.add(value);
+		const obj: Record<string, any> = {};
+		for (const [key, val] of Object.entries(value)) {
+			obj[key] = serializeValue(val, seen);
+		}
+		seen.delete(value);
+		return obj;
+	}
+
+	return String(value);
+}
+
+function normalizeAttachments(attachments: ErrorReportAttachment[]): ErrorReportAttachment[] {
+	return attachments
+		.filter(att => !!att && typeof att === 'object')
+		.map(att => removeEmptyFields({
+			name: att.name,
+			url: att.url,
+			contentType: att.contentType,
+			size: typeof att.size === 'number' ? att.size : undefined
+		}))
+		.filter(att => !!att.name);
+}
+
+function normalizeReportedAtDate(value?: string | Date): Date {
+	if (!value) {
+		return new Date();
+	}
+
+	if (value instanceof Date) {
+		return isNaN(value.getTime()) ? new Date() : value;
+	}
+
+	const date = new Date(value);
+	if (!isNaN(date.getTime())) {
+		return date;
+	}
+
+	return new Date();
+}
+
+function computeFingerprint(sourceApp: string, environment: string | undefined, message: string, stack?: string): string | undefined {
+	const signature = `${sourceApp || ''}:${environment || ''}:${message || ''}:${stack ? stack.split('\n').slice(0, 5).join('|') : ''}`;
+	return createHash('sha256').update(signature).digest('hex');
+}
+
+function removeEmptyFields<T extends Record<string, any>>(obj: T): T {
+	const cleaned: Record<string, any> = {};
+	for (const [key, value] of Object.entries(obj || {})) {
+		if (value === undefined || value === null || value === '') {
+			continue;
+		}
+		cleaned[key] = value;
+	}
+	return cleaned as T;
+}
+
+function mergeMetadata(metadata: Record<string, any> | string | null | undefined, correlationId?: string) {
+	if (!metadata && !correlationId) {
+		return undefined;
+	}
+
+	const base = metadata ? normalizeStructured(metadata) : undefined;
+	if (!correlationId) {
+		return base;
+	}
+
+	if (typeof base === 'string') {
+		return {
+			correlationId,
+			message: base
+		};
+	}
+
+	const metadataObj = (base || {}) as Record<string, any>;
+	if (!metadataObj.correlationId) {
+		metadataObj.correlationId = correlationId;
+	}
+	return metadataObj;
+}

package/src/util/error-tracking.ts

@@ -0,0 +1,79 @@
+import { AsyncLocalStorage } from 'async_hooks';
+import { objectIdHexString } from './common';
+
+export interface ErrorContextData {
+	correlationId?: string;
+}
+
+const errorContext = new AsyncLocalStorage<ErrorContextData>();
+
+export function getCorrelationId(): string | undefined {
+	return errorContext.getStore()?.correlationId;
+}
+
+export function setCorrelationId(correlationId: string) {
+	const store = errorContext.getStore();
+	if (store) {
+		store.correlationId = correlationId;
+	}
+}
+
+export function ensureCorrelationId(fallbackId?: string): string {
+	let correlationId = getCorrelationId();
+	if (!correlationId) {
+		correlationId = fallbackId || objectIdHexString();
+		errorContext.enterWith({ correlationId });
+	}
+	return correlationId;
+}
+
+export async function runWithCorrelationContext<T>(correlationId: string, fn: () => Promise<T> | T): Promise<T> {
+	const store = errorContext.getStore();
+	if (store && store.correlationId === correlationId) {
+		return await fn();
+	}
+
+	return await errorContext.run({ correlationId }, async () => await fn());
+}
+
+type NormalizedError = Error & Record<string, any>;
+
+function coerceError(error: unknown): NormalizedError {
+	if (error instanceof Error) {
+		return error as NormalizedError;
+	}
+
+	if (typeof error === 'object' && error !== null) {
+		const errObject = error as Record<string, any>;
+		if (typeof errObject.message !== 'string') {
+			errObject.message = JSON.stringify(errObject);
+		}
+		if (typeof errObject.name !== 'string') {
+			errObject.name = errObject.constructor && errObject.constructor.name !== 'Object' ? errObject.constructor.name : 'Error';
+		}
+		if (typeof errObject.stack !== 'string') {
+			errObject.stack = new Error(errObject.message).stack;
+		}
+		return errObject as NormalizedError;
+	}
+
+	const wrappedError = new Error(String(error));
+	(wrappedError as Record<string, any>).originalValue = error;
+	return wrappedError as NormalizedError;
+}
+
+export function ensureErrorWithCorrelation(error: unknown, fallbackId?: string): { error: NormalizedError, correlationId: string } {
+	const normalizedError = coerceError(error);
+	let correlationId: string = normalizedError.errorId || normalizedError.correlationId;
+
+	if (typeof correlationId !== 'string' || !correlationId) {
+		correlationId = getCorrelationId() || fallbackId || objectIdHexString();
+	}
+
+	normalizedError.errorId = correlationId;
+	normalizedError.correlationId = correlationId;
+
+	setCorrelationId(correlationId);
+
+	return { error: normalizedError, correlationId };
+}