@revealui/core 0.0.1-pre.0

package/dist/core/result/adapters.ts

@@ -0,0 +1,254 @@
+/**
+ * Result Type Adapters
+ *
+ * Adapter functions to convert Core UnifiedResult to other result types
+ * used throughout the codebase. Enables gradual migration to UnifiedResult.
+ */
+
+import type {Result} from '../result';
+import {isSuccess} from '../result';
+import type {ApiResponse,ServiceResult} from '../types/contracts';
+
+// Extended service result types
+export interface ServiceContext {
+  serviceName?: string;
+  operation?: string;
+  userId?: string;
+  [key: string]: unknown;
+}
+
+// Import ServiceMetrics from BaseService to avoid duplication
+import type {ServiceMetrics} from '../services/BaseService';
+
+export interface EnhancedServiceResult<T> {
+  success: boolean;
+  data?: T;
+  error?: string;
+  metadata?: Record<string, unknown>;
+  context?: ServiceContext;
+  metrics?: ServiceMetrics;
+}
+
+// ApiMetadata type - defined inline if not available
+export interface ApiMetadata {
+  requestId?: string;
+  timestamp?: Date;
+  version?: string;
+  [key: string]: unknown;
+}
+
+// ======
+// SERVICE RESULT ADAPTERS
+// ======
+
+/**
+ * Convert Result<T, E> to ServiceResult<T>
+ * Simple adapter for basic service results
+ */
+export function toServiceResult<T, E = Error>(result: Result<T, E>): ServiceResult<T> {
+  if (isSuccess(result)) {
+    return {
+      success: true,
+      data: result.value,
+    };
+  }
+  return {
+    success: false,
+    error: result.error instanceof Error ? result.error.message : String(result.error),
+  };
+}
+
+/**
+ * Convert ServiceResult<T> to Result<T, Error>
+ */
+export function fromServiceResult<T>(serviceResult: ServiceResult<T>): Result<T, Error> {
+  if (serviceResult.success && serviceResult.data !== undefined) {
+    return { _tag: 'Success', value: serviceResult.data, success: true };
+  }
+  return {
+    _tag: 'Failure',
+    error: new Error(serviceResult.error ?? 'Unknown service error'),
+    success: false,
+  };
+}
+
+// ======
+// ENHANCED SERVICE RESULT ADAPTERS
+// ======
+
+/**
+ * Convert Result<T, E> to EnhancedServiceResult<T>
+ * Includes metrics and context for infrastructure services
+ */
+export function toEnhancedServiceResult<T, E = Error>(
+  result: Result<T, E>,
+  metrics?: ServiceMetrics,
+  context?: ServiceContext
+): EnhancedServiceResult<T> {
+  if (isSuccess(result)) {
+    return {
+      success: true,
+      data: result.value,
+      ...(metrics ? { metadata: { ...metrics } as Record<string, unknown> } : {}),
+      ...(context ? { context } : {}),
+      ...(metrics ? { metrics } : {}),
+    };
+  }
+  const error = result.error instanceof Error ? result.error : new Error(String(result.error));
+
+  return {
+    success: false,
+    error: error.message || String(error),
+    metadata: {
+      code: 'SERVICE_ERROR',
+      details: error instanceof Error ? { stack: error.stack } : {},
+      timestamp: new Date(),
+      ...(context ? { context } : {}),
+      ...(error instanceof Error && error.stack ? { stack: error.stack } : {}),
+      ...(metrics ? { metrics } : {}),
+    },
+    ...(context ? { context } : {}),
+    ...(metrics ? { metrics } : {}),
+  };
+}
+
+/**
+ * Convert EnhancedServiceResult<T> to Result<T, Error>
+ */
+export function fromEnhancedServiceResult<T>(
+  enhancedResult: EnhancedServiceResult<T>
+): Result<T, Error> {
+  if (enhancedResult.success && enhancedResult.data !== undefined) {
+    return { _tag: 'Success', value: enhancedResult.data, success: true };
+  }
+  const error = enhancedResult.error
+    ? new Error(
+        typeof enhancedResult.error === 'string'
+          ? enhancedResult.error
+          : String(enhancedResult.error)
+      )
+    : new Error('Unknown service error');
+  return { _tag: 'Failure', error, success: false };
+}
+
+// ======
+// API RESPONSE ADAPTERS
+// ======
+
+/**
+ * Convert Result<T, E> to ApiResponse<T>
+ * For presentation layer API responses
+ */
+export function toApiResponse<T, E = Error>(
+  result: Result<T, E>,
+  meta?: ApiMetadata
+): ApiResponse<T> {
+  if (isSuccess(result)) {
+    return {
+      status: 200,
+      data: result.value,
+      ...(meta ? { meta } : {}),
+    };
+  }
+  const error = result.error instanceof Error ? result.error : new Error(String(result.error));
+  // Using Record<string, unknown> because error may have statusCode property but structure varies
+  const errorRecord =
+    error as unknown as /* Using Record<string, unknown> because error may have statusCode property but structure varies */ Record<
+      string,
+      unknown
+    >;
+  const statusCode = (errorRecord.statusCode as number | undefined) || 500;
+
+  return {
+    status: statusCode,
+    error: error.message,
+    details: error instanceof Error ? { stack: error.stack } : {},
+  };
+}
+
+/**
+ * Convert ApiResponse<T> to Result<T, Error>
+ */
+export function fromApiResponse<T>(apiResponse: ApiResponse<T>): Result<T, Error> {
+  if (
+    (apiResponse.status === undefined || (apiResponse.status >= 200 && apiResponse.status < 300)) &&
+    apiResponse.data !== undefined
+  ) {
+    return { _tag: 'Success', value: apiResponse.data, success: true };
+  }
+  const error = new Error(apiResponse.error ?? 'Unknown API error');
+  return { _tag: 'Failure', error, success: false };
+}
+
+// ======
+// UTILITY FUNCTIONS
+// ======
+
+/**
+ * Create a success Result from a value
+ */
+export function successResult<T>(value: T): Result<T, never> {
+  return { _tag: 'Success', value, success: true };
+}
+
+/**
+ * Create a failure Result from an error
+ */
+export function failureResult<E>(error: E): Result<never, E> {
+  return { _tag: 'Failure', error, success: false };
+}
+
+/**
+ * Convert multiple Results to a single Result with array
+ */
+export function combineResults<T, E = Error>(results: Result<T, E>[]): Result<T[], E> {
+  const values: T[] = [];
+  const errors: E[] = [];
+
+  for (const result of results) {
+    if (isSuccess(result)) {
+      values.push(result.value);
+    } else {
+      errors.push(result.error);
+    }
+  }
+
+  if (errors.length > 0) {
+    // Return first error (could be enhanced to return all errors)
+    const firstError = errors[0];
+    if (firstError === undefined) {
+      // Type assertion needed because E could be any type, but we need to return something
+      return { _tag: 'Failure', error: new Error('Unknown error') as E, success: false };
+    }
+    return { _tag: 'Failure', error: firstError, success: false };
+  }
+
+  return { _tag: 'Success', value: values, success: true };
+}
+
+/**
+ * Convert Result to a promise that resolves with the value or rejects with error
+ */
+export async function resultToPromise<T, E = Error>(result: Result<T, E>): Promise<T> {
+  if (isSuccess(result)) {
+    return result.value;
+  }
+  throw result.error instanceof Error ? result.error : new Error(String(result.error));
+}
+
+/**
+ * Convert a promise to a Result
+ */
+export async function promiseToResult<T>(promise: Promise<T>): Promise<Result<T, Error>> {
+  try {
+    const value = await promise;
+    return { _tag: 'Success', value, success: true };
+  } catch (error) {
+    return {
+      _tag: 'Failure',
+      error: error instanceof Error ? error : new Error(String(error)),
+      success: false,
+    };
+  }
+}
+

package/dist/core/result.ts

@@ -0,0 +1,332 @@
+/**
+ * Unified Result Pattern
+ *
+ * Consolidates all result implementations into a single, comprehensive system.
+ * Combines the best features from all existing result implementations.
+ */
+
+// ======
+// CORE TYPES
+// ======
+
+export type Success<T> = {
+  readonly _tag: 'Success';
+  readonly value: T;
+  readonly success: true;
+};
+
+export type Failure<E> = {
+  readonly _tag: 'Failure';
+  readonly error: E;
+  readonly success: false;
+};
+
+export type Result<T, E = Error> = Success<T> | Failure<E>;
+
+// ======
+// RESULT CLASSES
+// ======
+
+export class SuccessResult<T> implements Success<T> {
+  readonly _tag = 'Success' as const;
+  readonly success = true as const;
+
+  constructor(readonly value: T) {}
+
+  isSuccess(): this is Success<T> {
+    return true;
+  }
+
+  isFailure(): this is never {
+    return false;
+  }
+
+  map<U>(fn: (value: T) => U): Result<U, never> {
+    return new SuccessResult(fn(this.value));
+  }
+
+  flatMap<U, F>(fn: (value: T) => Result<U, F>): Result<U, F> {
+    return fn(this.value);
+  }
+
+  getOrElse<U>(_defaultValue: U): T | U {
+    return this.value;
+  }
+
+  getOrThrow(): T {
+    return this.value;
+  }
+
+  tap(fn: (value: T) => void): Result<T, never> {
+    fn(this.value);
+    return this;
+  }
+
+  mapError<F>(_fn: (error: never) => F): Result<T, F> {
+    return this as Result<T, F>;
+  }
+}
+
+export class FailureResult<E> implements Failure<E> {
+  readonly _tag = 'Failure' as const;
+  readonly success = false as const;
+
+  constructor(readonly error: E) {}
+
+  isSuccess(): this is never {
+    return false;
+  }
+
+  isFailure(): this is Failure<E> {
+    return true;
+  }
+
+  map<U>(_fn: (value: never) => U): Result<never, E> {
+    return this as Result<never, E>;
+  }
+
+  flatMap<U, F>(_fn: (value: never) => Result<U, F>): Result<never, E> {
+    return this as Result<never, E>;
+  }
+
+  getOrElse<U>(defaultValue: U): U {
+    return defaultValue;
+  }
+
+  getOrThrow(): never {
+    throw this.error instanceof Error ? this.error : new Error(String(this.error));
+  }
+
+  tap(fn: (error: E) => void): Result<never, E> {
+    fn(this.error);
+    return this;
+  }
+
+  mapError<F>(fn: (error: E) => F): Result<never, F> {
+    return new FailureResult(fn(this.error));
+  }
+}
+
+// ======
+// CONSTRUCTORS
+// ======
+
+export function success<T>(value: T): Result<T, never> {
+  return new SuccessResult(value);
+}
+
+export function failure<E>(error: E): Result<never, E> {
+  return new FailureResult(error);
+}
+
+export function ok<T>(value?: T): Result<T, never> {
+  return new SuccessResult(value as T);
+}
+
+export function fail<E>(error: E): Result<never, E> {
+  return new FailureResult(error);
+}
+
+// ======
+// TYPE GUARDS
+// ======
+
+export function isSuccess<T, E>(result: Result<T, E>): result is Success<T> {
+  return result._tag === 'Success';
+}
+
+export function isFailure<T, E>(result: Result<T, E>): result is Failure<E> {
+  return result._tag === 'Failure';
+}
+
+// ======
+// COMBINATORS
+// ======
+
+export function combine<T extends readonly unknown[], E>(
+  results: {
+    [K in keyof T]: Result<T[K], E>;
+  }
+): Result<T, E> {
+  const values: unknown[] = [];
+
+  for (let i = 0; i < results.length; i++) {
+    const result = results[i];
+    if (result && isFailure(result)) {
+      return result as Result<T, E>;
+    }
+    if (result && isSuccess(result)) {
+      values[i] = result.value;
+    }
+  }
+
+  return success(values as unknown as T);
+}
+
+export function combineWithErrors<T extends readonly unknown[], E>(
+  results: {
+    [K in keyof T]: Result<T[K], E>;
+  }
+): Result<T, E[]> {
+  const values: unknown[] = [];
+  const errors: E[] = [];
+
+  for (let i = 0; i < results.length; i++) {
+    const result = results[i];
+    if (result && isSuccess(result)) {
+      values[i] = result.value;
+    } else if (result && isFailure(result)) {
+      errors.push(result.error);
+    }
+  }
+
+  if (errors.length > 0) {
+    return failure(errors);
+  }
+
+  return success(values as unknown as T);
+}
+
+export function sequence<T, E>(results: Result<T, E>[]): Result<T[], E> {
+  const values: T[] = [];
+
+  for (const result of results) {
+    if (isFailure(result)) {
+      return result as Result<T[], E>;
+    }
+    if (isSuccess(result)) {
+      values.push(result.value);
+    }
+  }
+
+  return success(values);
+}
+
+export function traverse<T, U, E>(items: T[], fn: (item: T) => Result<U, E>): Result<U[], E> {
+  return sequence(items.map(fn));
+}
+
+// ======
+// ASYNC UTILITIES
+// ======
+
+export async function fromPromise<T>(promise: Promise<T>): Promise<Result<T>> {
+  try {
+    const value = await promise;
+    return success(value);
+  } catch (error) {
+    return failure(error instanceof Error ? error : new Error(String(error)));
+  }
+}
+
+export function fromTryCatch<T>(fn: () => T): Result<T> {
+  try {
+    return success(fn());
+  } catch (error) {
+    return failure(error instanceof Error ? error : new Error(String(error)));
+  }
+}
+
+export async function fromTryCatchAsync<T>(fn: () => Promise<T>): Promise<Result<T>> {
+  try {
+    const value = await fn();
+    return success(value);
+  } catch (error) {
+    return failure(error instanceof Error ? error : new Error(String(error)));
+  }
+}
+
+// ======
+// PATTERN MATCHING
+// ======
+
+export function match<T, E, R>(
+  result: Result<T, E>,
+  patterns: {
+    success: (value: T) => R;
+    failure: (error: E) => R;
+  }
+): R {
+  if (isSuccess(result)) {
+    return patterns.success(result.value);
+  }
+  return patterns.failure(result.error);
+}
+
+// ======
+// UTILITY FUNCTIONS
+// ======
+
+export function mapResult<T, U, E>(result: Result<T, E>, fn: (value: T) => U): Result<U, E> {
+  return result._tag === 'Success' ? success(fn(result.value)) : (result as Result<U, E>);
+}
+
+export function flatMapResult<T, U, E, F>(
+  result: Result<T, E>,
+  fn: (value: T) => Result<U, F>
+): Result<U, E | F> {
+  return result._tag === 'Success' ? fn(result.value) : (result as Result<U, E | F>);
+}
+
+export function tapResult<T, E>(result: Result<T, E>, fn: (value: T) => void): Result<T, E> {
+  if (isSuccess(result)) {
+    fn(result.value);
+  }
+  return result;
+}
+
+export function mapErrorResult<T, E, F>(result: Result<T, E>, fn: (error: E) => F): Result<T, F> {
+  return result._tag === 'Failure' ? failure(fn(result.error)) : (result as Result<T, F>);
+}
+
+export function fromNullable<T>(value: T | null | undefined): Result<T> {
+  return value !== null && value !== undefined
+    ? success(value)
+    : failure(new Error('Value is null or undefined'));
+}
+
+export function fromPredicate<T, E>(
+  value: T,
+  predicate: (value: T) => boolean,
+  error: E
+): Result<T, E> {
+  return predicate(value) ? success(value) : failure(error);
+}
+
+export function recover<T, E, F>(
+  result: Result<T, E>,
+  fn: (error: E) => Result<T, F>
+): Result<T, F> {
+  if (isSuccess(result)) {
+    return result as Result<T, F>;
+  }
+  return fn(result.error);
+}
+
+export function recoverWith<T, E>(result: Result<T, E>, defaultValue: T): Result<T, never> {
+  if (isSuccess(result)) {
+    return result;
+  }
+  return success(defaultValue);
+}
+
+/**
+ * Get value or default
+ */
+export function getOrElse<T, E>(result: Result<T, E>, defaultValue: T): T {
+  if (isSuccess(result)) {
+    return result.value;
+  }
+  return defaultValue;
+}
+
+/**
+ * Get value or throw
+ */
+export function getOrThrow<T, E>(result: Result<T, E>): T {
+  if (isSuccess(result)) {
+    return result.value;
+  }
+  throw result.error instanceof Error ? result.error : new Error(String(result.error));
+}
+