typescript-barrel-split-class-factory

Answer

Target layout — project.service.ts (504L) becomes a 1-line shim + a 3-file module directory. Zero importer changes because the shim's export * preserves the original module path and surface.

src/
  project.service.ts              # shim (1 line)
  project.service/
    index.ts                      # barrel: type block + class/factory block (the 9-symbol API)
    types.ts                      # pure type declarations — no runtime imports, cycle-proof
    project.service.ts            # class + singleton + factory (branch-3 pattern; body moved verbatim)

Step 1 — Shim (replaces the original file, same path)

// src/project.service.ts
export * from './project.service/index.js';

Because the path, name, and extension resolution (./project.service → ./project.service.ts → ./project.service/index.ts) are unchanged, every existing import { … } from '../project.service' / from './project.service' resolves without edits. export * re-exports only named symbols, so the original file must have no default export (see EVIDENCE).

Step 2 — Type block source

// src/project.service/types.ts
export interface Project {
  id: string;
  name: string;
  status: ProjectStatus;
  createdAt: string;
  updatedAt: string;
}

export type ProjectStatus = 'active' | 'archived' | 'deleted';

export interface ProjectCreateInput {
  name: string;
  status?: ProjectStatus;
}

export interface ProjectQuery {
  status?: ProjectStatus;
  search?: string;
  limit?: number;
  offset?: number;
}

types.ts imports nothing — pure type surface. This breaks the type↔runtime cycle that made the 504-line monolith fragile, and lets the barrel emit the type block as a compile-time-erased unit.

Step 3 — Class / factory block source (branch-3 pattern)

// src/project.service/project.service.ts
import type { Project, ProjectCreateInput, ProjectQuery } from './types.js';

export class ProjectService {
  // …the original ~430 lines of implementation, moved verbatim…
  // (repository wiring, create/update/archive/list methods, mapping, validation)
}

// ---- branch-3 class+singleton pattern: class, singleton, factory, accessor, reset ----

const DEFAULT_DEPS = { /* defaults extracted from the original module-level config */ };

/** Eager singleton — preserves the original `export const projectService = …` call-site contract. */
export const projectService = new ProjectService(DEFAULT_DEPS);

/** Factory — dependency injection for tests and alternate configs. */
export function createProjectService(deps: Partial<ProjectServiceDeps> = {}): ProjectService {
  return new ProjectService({ ...DEFAULT_DEPS, ...deps });
}

// Lazy accessor + reset keep the singleton deterministic under vitest worker/isolate semantics.
let _instance: ProjectService | undefined;
export function getProjectService(): ProjectService {
  _instance ??= createProjectService();
  return _instance;
}
export function resetProjectService(): void {
  _instance = undefined;
}

All internal helpers from the original file that are not part of the public API stay non-exported (module-private) here; anything that was public is re-exported by the barrel. Only type imports cross into this file, so the singleton's module-load side effects (new ProjectService(...)) never pull in a runtime cycle.

Step 4 — Barrel (index.ts)

// src/project.service/index.ts

// ── export type block (9-symbol API: 4 types) ─────────────
export type {
  Project,
  ProjectStatus,
  ProjectCreateInput,
  ProjectQuery,
} from './types.js';

// ── class/factory block (9-symbol API: 5 runtime symbols) ──
export {
  ProjectService,
  projectService,
  createProjectService,
  getProjectService,
  resetProjectService,
} from './project.service.js';

9-symbol API = Project, ProjectStatus, ProjectCreateInput, ProjectQuery (type block) + ProjectService, projectService, createProjectService, getProjectService, resetProjectService (class/factory block). The export type form is mandatory under isolatedModules/verbatimModuleSyntax and is safe under any other tsconfig.

Migration procedure

1. mkdir src/project.service
2. Cut type declarations → types.ts; cut implementation → project.service.ts; fix relative depth of cross-directory imports (../x → ../../x, same-dir ./x unchanged).
3. Write index.ts barrel; replace original file with the 1-line shim.
4. Surface audit — diff old vs new export names (script below) to confirm exactly the 9 symbols survive; run tsc → vitest → build.