@revealui/core 0.0.1-pre.1 → 0.0.1-pre.2

package/dist/core/result/adapters.ts

@@ -1,254 +0,0 @@
-/**
- * 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

@@ -1,332 +0,0 @@
-/**
- * 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));
-}
-