@sylphx/flow 1.7.0 → 1.8.1

package/src/core/interfaces/repository.interface.ts

@@ -1,91 +0,0 @@
-/**
- * Repository interface for dependency inversion
- * Abstracts data access implementation
- *
- * DESIGN RATIONALE:
- * - Depend on abstractions, not concrete implementations
- * - Enables testing with in-memory implementations
- * - Separates interface from implementation
- * - Clear contract for data access
- */
-
-import type { DatabaseError } from '../functional/error-types.js';
-import type { Result } from '../functional/result.js';
-
-/**
- * Query options for filtering, sorting, pagination
- */
-export interface QueryOptions {
-  limit?: number;
-  offset?: number;
-  orderBy?: string;
-  orderDirection?: 'ASC' | 'DESC';
-  where?: Record<string, any>;
-}
-
-/**
- * Paginated result wrapper
- */
-export interface PaginatedResult<T> {
-  items: T[];
-  total: number;
-  page: number;
-  pageSize: number;
-  hasNext: boolean;
-  hasPrevious: boolean;
-}
-
-/**
- * Generic repository interface
- * All operations return Result for explicit error handling
- */
-export interface IRepository<T, ID = string | number> {
-  /**
-   * Find entity by ID
-   */
-  findById(id: ID): Promise<Result<T | null, DatabaseError>>;
-
-  /**
-   * Find multiple entities with filtering and sorting
-   */
-  findMany(options?: QueryOptions): Promise<Result<T[], DatabaseError>>;
-
-  /**
-   * Find entities with pagination
-   */
-  findPaginated(
-    page: number,
-    pageSize: number,
-    options?: Omit<QueryOptions, 'limit' | 'offset'>
-  ): Promise<Result<PaginatedResult<T>, DatabaseError>>;
-
-  /**
-   * Create a new entity
-   */
-  create(data: Partial<T>): Promise<Result<T, DatabaseError>>;
-
-  /**
-   * Update an existing entity
-   */
-  update(id: ID, data: Partial<T>): Promise<Result<T | null, DatabaseError>>;
-
-  /**
-   * Delete an entity
-   */
-  delete(id: ID): Promise<Result<boolean, DatabaseError>>;
-
-  /**
-   * Count entities matching criteria
-   */
-  count(options?: { where?: Record<string, any> }): Promise<Result<number, DatabaseError>>;
-
-  /**
-   * Check if entity exists
-   */
-  exists(id: ID): Promise<Result<boolean, DatabaseError>>;
-}
-
-/**
- * Factory function type for creating repositories
- */
-export type RepositoryFactory<T, ID = string | number> = (tableName: string) => IRepository<T, ID>;

package/src/core/interfaces/service.interface.ts

@@ -1,133 +0,0 @@
-/**
- * Service interfaces for dependency inversion
- * Core service contracts
- *
- * DESIGN RATIONALE:
- * - Depend on abstractions, not implementations
- * - Clear contracts for services
- * - Enables dependency injection
- * - Facilitates testing with mocks
- */
-
-import type { AppError } from '../functional/error-types.js';
-import type { Result } from '../functional/result.js';
-
-/**
- * Logger interface
- */
-export interface ILogger {
-  debug(message: string, ...args: any[]): void;
-  info(message: string, ...args: any[]): void;
-  warn(message: string, ...args: any[]): void;
-  error(message: string, ...args: any[]): void;
-}
-
-/**
- * Configuration service interface
- */
-export interface IConfigService {
-  /**
-   * Get configuration value
-   */
-  get<T>(key: string): Result<T, AppError>;
-
-  /**
-   * Get configuration value with default
-   */
-  getOrDefault<T>(key: string, defaultValue: T): T;
-
-  /**
-   * Set configuration value
-   */
-  set<T>(key: string, value: T): Result<void, AppError>;
-
-  /**
-   * Check if configuration key exists
-   */
-  has(key: string): boolean;
-
-  /**
-   * Load configuration from file
-   */
-  load(path: string): Promise<Result<void, AppError>>;
-
-  /**
-   * Save configuration to file
-   */
-  save(path: string): Promise<Result<void, AppError>>;
-}
-
-/**
- * File service interface
- */
-export interface IFileService {
-  /**
-   * Read file contents
-   */
-  read(path: string): Promise<Result<string, AppError>>;
-
-  /**
-   * Write file contents
-   */
-  write(path: string, content: string): Promise<Result<void, AppError>>;
-
-  /**
-   * Check if file exists
-   */
-  exists(path: string): Promise<Result<boolean, AppError>>;
-
-  /**
-   * Delete file
-   */
-  delete(path: string): Promise<Result<void, AppError>>;
-
-  /**
-   * List files in directory
-   */
-  list(path: string): Promise<Result<string[], AppError>>;
-
-  /**
-   * Create directory
-   */
-  createDir(path: string, recursive?: boolean): Promise<Result<void, AppError>>;
-}
-
-/**
- * Validation service interface
- */
-export interface IValidationService<T> {
-  /**
-   * Validate data
-   */
-  validate(data: unknown): Result<T, AppError>;
-
-  /**
-   * Validate and return errors
-   */
-  validateWithErrors(data: unknown): Result<T, string[]>;
-}
-
-/**
- * Event emitter interface for event-driven architecture
- */
-export interface IEventEmitter<EventMap extends Record<string, any>> {
-  /**
-   * Emit an event
-   */
-  emit<K extends keyof EventMap>(event: K, data: EventMap[K]): void;
-
-  /**
-   * Subscribe to an event
-   */
-  on<K extends keyof EventMap>(event: K, handler: (data: EventMap[K]) => void): () => void;
-
-  /**
-   * Subscribe to an event once
-   */
-  once<K extends keyof EventMap>(event: K, handler: (data: EventMap[K]) => void): () => void;
-
-  /**
-   * Remove all listeners for an event
-   */
-  removeAllListeners<K extends keyof EventMap>(event: K): void;
-}

package/src/core/interfaces.ts

@@ -1,96 +0,0 @@
-/**
- * Core service interfaces for dependency injection
- */
-
-// Logger interface
-export interface ILogger {
-  info(message: string, ...args: unknown[]): void;
-  warn(message: string, ...args: unknown[]): void;
-  error(message: string, error?: Error | unknown, ...args: unknown[]): void;
-  debug(message: string, ...args: unknown[]): void;
-  success(message: string, ...args: unknown[]): void;
-}
-
-// Configuration interface
-export interface IConfiguration {
-  get<T = unknown>(key: string, defaultValue?: T): T;
-  getRequired<T = unknown>(key: string): T;
-  has(key: string): boolean;
-  set(key: string, value: unknown): void;
-  reload(): Promise<void>;
-}
-
-// Database connection interface
-export interface IDatabaseConnection {
-  connect(): Promise<void>;
-  disconnect(): Promise<void>;
-  healthCheck(): Promise<{ healthy: boolean; error?: string }>;
-  execute(sql: string, params?: unknown[]): Promise<DatabaseQueryResult>;
-}
-
-// Database query result
-export interface DatabaseQueryResult {
-  rows: Record<string, unknown>[];
-  rowCount: number;
-  command: string;
-}
-
-// Storage interface for memory and cache
-export interface IStorage<T = unknown> {
-  initialize(): Promise<void>;
-  get(key: string, namespace?: string): Promise<T | null>;
-  set(key: string, value: T, namespace?: string): Promise<void>;
-  delete(key: string, namespace?: string): Promise<void>;
-  clear(namespace?: string): Promise<void>;
-  list(namespace?: string): Promise<string[]>;
-  healthCheck(): Promise<{ healthy: boolean; error?: string }>;
-}
-
-// Target manager interface
-export interface ITargetManager {
-  getTarget(id: string): Target | null;
-  getAllTargets(): Target[];
-  registerTarget(target: Target): void;
-}
-
-// Target definition
-export interface Target {
-  id: string;
-  name: string;
-  type: string;
-  config: Record<string, unknown>;
-  enabled: boolean;
-}
-
-// Embedding provider interface
-export interface IEmbeddingProvider {
-  name: string;
-  embed(text: string): Promise<number[]>;
-  isAvailable(): Promise<boolean>;
-}
-
-// MCP service interface
-export interface IMCPService {
-  initialize(): Promise<void>;
-  installServers(serverIds: string[], options?: MCPServerInstallOptions): Promise<void>;
-  getAvailableServers(): MCPServerInfo[];
-  getInstalledServers(): MCPServerInfo[];
-}
-
-// MCP server installation options
-export interface MCPServerInstallOptions {
-  force?: boolean;
-  autoStart?: boolean;
-  config?: Record<string, unknown>;
-}
-
-// MCP server information
-export interface MCPServerInfo {
-  id: string;
-  name: string;
-  version: string;
-  description?: string;
-  installed: boolean;
-  enabled: boolean;
-  config?: Record<string, unknown>;
-}

package/src/core/result.ts

@@ -1,351 +0,0 @@
-/**
- * Unified Result Type - 統一結果類型
- * Single source of truth for Result<T, E> across the entire project
- *
- * This replaces all conflicting Result type definitions:
- * - src/core/type-utils.ts
- * - src/core/functional/result.ts
- * - src/utils/functional.ts
- */
-
-// ============================================================================
-// CORE RESULT TYPE
-// ============================================================================
-
-/**
- * Result type for functional error handling
- * Represents success or failure without exceptions
- */
-export type Result<T, E = Error> =
-  | { success: true; data: T }
-  | { success: false; error: E };
-
-// ============================================================================
-// CONSTRUCTORS
-// ============================================================================
-
-/**
- * Create a successful result
- */
-export const ok = <T>(data: T): Result<T> => ({ success: true, data });
-
-/**
- * Create an error result
- */
-export const err = <E>(error: E): Result<never, E> => ({ success: false, error });
-
-// ============================================================================
-// TYPE GUARDS
-// ============================================================================
-
-/**
- * Check if result is successful
- */
-export const isOk = <T, E>(result: Result<T, E>): result is { success: true; data: T } =>
-  result.success;
-
-/**
- * Check if result is an error
- */
-export const isErr = <T, E>(result: Result<T, E>): result is { success: false; error: E } =>
-  !result.success;
-
-// ============================================================================
-// TRANSFORMATIONS
-// ============================================================================
-
-/**
- * Transform the success value
- * Error propagates unchanged
- */
-export const map =
-  <T, U, E>(fn: (data: T) => U) =>
-  (result: Result<T, E>): Result<U, E> => {
-    if (isOk(result)) {
-      return ok(fn(result.data));
-    }
-    return result;
-  };
-
-/**
- * Transform the success value with a function that returns a Result
- * Enables chaining operations that can fail
- * Error propagates unchanged
- */
-export const flatMap =
-  <T, U, E>(fn: (data: T) => Result<U, E>) =>
-  (result: Result<T, E>): Result<U, E> => {
-    if (isOk(result)) {
-      return fn(result.data);
-    }
-    return result;
-  };
-
-/**
- * Transform the error
- * Success propagates unchanged
- */
-export const mapError =
-  <T, E, F>(fn: (error: E) => F) =>
-  (result: Result<T, E>): Result<T, F> => {
-    if (isErr(result)) {
-      return err(fn(result.error));
-    }
-    return result;
-  };
-
-/**
- * Extract value or provide default
- */
-export const getOrElse =
-  <T>(defaultValue: T) =>
-  <E>(result: Result<T, E>): T => {
-    if (isOk(result)) {
-      return result.data;
-    }
-    return defaultValue;
-  };
-
-/**
- * Extract value or compute default
- */
-export const getOrElseLazy =
-  <T>(fn: () => T) =>
-  <E>(result: Result<T, E>): T => {
-    if (isOk(result)) {
-      return result.data;
-    }
-    return fn();
-  };
-
-/**
- * Pattern matching
- */
-export const match =
-  <T, E, U>(onSuccess: (data: T) => U, onError: (error: E) => U) =>
-  (result: Result<T, E>): U => {
-    if (isOk(result)) {
-      return onSuccess(result.data);
-    }
-    return onError(result.error);
-  };
-
-/**
- * Extract value or throw error
- * Use only when you're certain the result is successful
- */
-export const unwrap = <T, E>(result: Result<T, E>): T => {
-  if (isOk(result)) {
-    return result.data;
-  }
-  throw result.error;
-};
-
-/**
- * Extract error or throw
- * Use only when you're certain the result is an error
- */
-export const unwrapError = <T, E>(result: Result<T, E>): E => {
-  if (isErr(result)) {
-    return result.error;
-  }
-  throw new Error('Expected error but got success');
-};
-
-// ============================================================================
-// ASYNC SUPPORT
-// ============================================================================
-
-/**
- * Async result type
- */
-export type AsyncResult<T, E = Error> = Promise<Result<T, E>>;
-
-/**
- * Convert thrown exception to Result
- */
-export const tryCatch = <T, E = Error>(
-  fn: () => T,
-  onError: (error: unknown) => E = (error: unknown) => error as E
-): Result<T, E> => {
-  try {
-    return ok(fn());
-  } catch (error) {
-    return err(onError(error));
-  }
-};
-
-/**
- * Convert Promise to Result
- */
-export const tryCatchAsync = async <T, E = Error>(
-  fn: () => Promise<T>,
-  onError: (error: unknown) => E = (error: unknown) => error as E
-): Promise<Result<T, E>> => {
-  try {
-    const data = await fn();
-    return ok(data);
-  } catch (error) {
-    return err(onError(error));
-  }
-};
-
-/**
- * Safe async function wrapper
- */
-export const safeAsync = async <T, E = Error>(
-  fn: () => Promise<T>,
-  errorFn?: (error: unknown) => E
-): Promise<Result<T, E>> => {
-  return tryCatchAsync(fn, errorFn);
-};
-
-/**
- * Safe sync function wrapper
- */
-export const safeSync = <T, E = Error>(
-  fn: () => T,
-  errorFn?: (error: unknown) => E
-): Result<T, E> => {
-  return tryCatch(fn, errorFn);
-};
-
-// ============================================================================
-// COMBINATORS
-// ============================================================================
-
-/**
- * Combine multiple Results into a single Result containing an array
- * Fails if any Result is an error (short-circuits on first error)
- */
-export const all = <T, E>(results: Result<T, E>[]): Result<T[], E> => {
-  const values: T[] = [];
-
-  for (const result of results) {
-    if (isErr(result)) {
-      return result;
-    }
-    values.push(result.data);
-  }
-
-  return ok(values);
-};
-
-/**
- * Combine multiple Results into a single Result containing an array
- * Collects all errors instead of short-circuiting
- */
-export const allWithErrors = <T, E>(results: Result<T, E>[]): Result<T[], E[]> => {
-  const values: T[] = [];
-  const errors: E[] = [];
-
-  for (const result of results) {
-    if (isOk(result)) {
-      values.push(result.data);
-    } else {
-      errors.push(result.error);
-    }
-  }
-
-  return errors.length > 0 ? err(errors) : ok(values);
-};
-
-/**
- * Combine multiple AsyncResults
- */
-export const allAsync = async <T, E>(results: AsyncResult<T, E>[]): Promise<Result<T[], E>> => {
-  const settled = await Promise.all(results);
-  return all(settled);
-};
-
-/**
- * Race multiple AsyncResults - returns first successful result
- */
-export const raceAsync = async <T, E>(results: AsyncResult<T, E>[]): Promise<Result<T, E>> => {
-  try {
-    return await Promise.race(results);
-  } catch (error) {
-    return err(error as E);
-  }
-};
-
-// ============================================================================
-// SIDE EFFECTS
-// ============================================================================
-
-/**
- * Run side effect for success case
- */
-export const tap =
-  <T, E>(fn: (data: T) => void) =>
-  (result: Result<T, E>): Result<T, E> => {
-    if (isOk(result)) {
-      fn(result.data);
-    }
-    return result;
-  };
-
-/**
- * Run side effect for error case
- */
-export const tapError =
-  <T, E>(fn: (error: E) => void) =>
-  (result: Result<T, E>): Result<T, E> => {
-    if (isErr(result)) {
-      fn(result.error);
-    }
-    return result;
-  };
-
-/**
- * Run side effect for both cases
- */
-export const tapBoth =
-  <T, E>(onSuccess: (data: T) => void, onError: (error: E) => void) =>
-  (result: Result<T, E>): Result<T, E> => {
-    if (isOk(result)) {
-      onSuccess(result.data);
-    } else {
-      onError(result.error);
-    }
-    return result;
-  };
-
-// ============================================================================
-// LEGACY COMPATIBILITY
-// ============================================================================
-
-/**
- * Legacy compatibility aliases
- * These help migrate from old Result implementations
- */
-
-// For src/core/functional/result.ts users
-export const success = ok;
-export const failure = err;
-export const isSuccess = isOk;
-export const isFailure = isErr;
-
-// For src/utils/functional.ts users
-export const unwrapResult = unwrap;
-export const mapResult = map;
-
-// ============================================================================
-// TYPE INFERENCE HELPERS
-// ============================================================================
-
-/**
- * Helper to infer the success type from a Result
- */
-export type SuccessType<T> = T extends Result<infer U, any> ? U : never;
-
-/**
- * Helper to infer the error type from a Result
- */
-export type ErrorType<T> = T extends Result<any, infer E> ? E : never;
-
-/**
- * Create a type-safe Result from a function that might throw
- */
-export type SafeResult<T extends (...args: any[]) => any> =
-  Result<ReturnType<T>, Error>;