@resolveio/server-lib 22.3.11 → 22.3.13

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

@@ -1,183 +0,0 @@
-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

@@ -1,332 +0,0 @@
-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

@@ -1,79 +0,0 @@
-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 };
-}