typescript-refactor-barrel-split

Answer

Refactor: types/error.types.ts (510L, 12 public named exports) → types/error.types/ module directory (10 domain files + 1-line shim) + unchanged parent barrel/importers.

The key mechanical trick: TypeScript/bundler resolution lets '../types/error.types' (the original path, extensionless) fall back from the deleted error.types.ts to error.types/index.ts. So the two src importers (utils/validation.ts, errors/mythos-error.ts) and the parent barrel (types/index.ts) keep their original import strings unchanged — only the git file's relative import moves one level deeper. Verified working config: moduleResolution: "bundler" (tsc) + tsx/esbuild runtime, which accept both extensionless dir-index resolution and .js→.ts substitution.

Target layout:

types/
  error.types.ts          # DELETED (was 510L monolith)
  error.types/
    index.ts              # 1-LINE SHIM — the only "new" entry point
    codes.ts              # ErrorCode enum
    base.ts               # MythosError (+ MythosErrorOptions interface)
    validation.ts         # ValidationError
    not-found.ts          # NotFoundError (+ module-private findSimilarIds)
    provider.ts           # ProviderError
    git.ts                # GitError  ← imports ../git.types.js (only shifted import)
    generation.ts         # GenerationError
    storage.ts            # StorageError
    network.ts            # NetworkError
    handlers.ts           # isMythosError, toErrorMessage, getErrorCode
  index.ts                # parent barrel — UNCHANGED, still re-exports all 12
  git.types.ts            # stays outside the split dir

The 1-line shim (types/error.types/index.ts) — 10 chained export *s, the entire public surface in one line:

export * from './codes.js';export * from './base.js';export * from './validation.js';export * from './not-found.js';export * from './provider.js';export * from './git.js';export * from './generation.js';export * from './storage.js';export * from './network.js';export * from './handlers.js';

Representative domain files — each class file pins its own code and stays a leaf in the dependency DAG (codes.ts ← base.ts ← subclasses ← handlers.ts; no cycles):

// types/error.types/codes.ts
export enum ErrorCode { UNKNOWN='UNKNOWN', VALIDATION='VALIDATION', NOT_FOUND='NOT_FOUND',
  PROVIDER='PROVIDER', GIT='GIT', GENERATION='GENERATION', STORAGE='STORAGE', NETWORK='NETWORK' }

// types/error.types/base.ts
import { ErrorCode } from './codes.js';
export class MythosError extends Error {
  readonly code: ErrorCode; readonly details: Record<string, unknown>; readonly cause?: unknown;
  constructor(message: string, options: { code?: ErrorCode; cause?: unknown; details?: Record<string, unknown> } = {}) {
    super(message); this.name = new.target.name;
    this.code = options.code ?? ErrorCode.UNKNOWN;
    this.details = options.details ?? {}; this.cause = options.cause;
    Object.setPrototypeOf(this, new.target.prototype);
  }
}

// types/error.types/validation.ts — pattern repeated for all 8 subclasses
import { ErrorCode } from './codes.js';
import { MythosError, type MythosErrorOptions } from './base.js';
export class ValidationError extends MythosError {
  constructor(message: string, options: Omit<MythosErrorOptions,'code'> = {}) {
    super(message, { ...options, code: ErrorCode.VALIDATION });
  }
}

The only shifted import — git.ts lives one level deeper, so its sibling reference walks up:

// types/error.types/git.ts  (was: import type {...} from './git.types')
import { ErrorCode } from './codes.js';
import { MythosError, type MythosErrorOptions } from './base.js';
import type { GitOperation, GitRef } from '../git.types.js';   // ← ./git.types → ../git.types.js

export class GitError extends MythosError {
  readonly operation: GitOperation; readonly ref?: GitRef;
  constructor(operation: GitOperation, message: string,
              options: Omit<MythosErrorOptions,'code'> & { ref?: GitRef } = {}) {
    super(message, { ...options, code: ErrorCode.GIT, details: { operation, ref: options.ref } });
    this.operation = operation; this.ref = options.ref;
  }
}

findSimilarIds goes module-private — it was hoisted into the public surface by the monolith's single namespace; now it lives un-exported inside not-found.ts, where NotFoundError uses it for "did you mean?" suggestions:

// types/error.types/not-found.ts
function findSimilarIds(missingId: string, candidates: readonly string[]): string[] {
  const target = missingId.toLowerCase();
  return candidates.filter(c => { const x = c.toLowerCase();
    return x.includes(target) || target.includes(x) || levenshtein(target, x) <= 2; });
}
export class NotFoundError extends MythosError { /* uses findSimilarIds, exports only the class */ }

Importers & parent barrel — byte-identical import strings (original-path parity):

// utils/validation.ts (importer 1) — unchanged
import { ValidationError } from '../types/error.types';
// errors/mythos-error.ts (importer 2) — unchanged
import { MythosError, isMythosError, getErrorCode, toErrorMessage } from '../types/error.types';
// types/index.ts (parent barrel) — unchanged, re-exports all 12
export * from './error.types';

Full surface = 12 named: ErrorCode (1 enum) + MythosError, ValidationError, NotFoundError, ProviderError, GitError, GenerationError, StorageError, NetworkError (8 classes) + isMythosError, toErrorMessage, getErrorCode (3 fns). findSimilarIds is not among them.