@confect/cli 9.0.0-next.0 → 9.0.0-next.10

package/src/CodegenError.ts

@@ -1,344 +0,0 @@
-import { Ansi, AnsiDoc } from "@effect/printer-ansi";
-import { Effect, Match, Option, pipe, Schema } from "effect";
-import { BuildError, isBuildError, renderBuildError } from "./BuildError";
-import { formatPathDoc } from "./log";
-
-// --- Variants ---
-
-export class MissingImplFileError extends Schema.TaggedError<MissingImplFileError>()(
-  "MissingImplFileError",
-  {
-    specPath: Schema.String,
-    expectedImplPath: Schema.String,
-  },
-) {}
-
-export class MissingSpecFileError extends Schema.TaggedError<MissingSpecFileError>()(
-  "MissingSpecFileError",
-  {
-    implPath: Schema.String,
-    expectedSpecPath: Schema.String,
-  },
-) {}
-
-export class SpecMissingDefaultGroupSpecError extends Schema.TaggedError<SpecMissingDefaultGroupSpecError>()(
-  "SpecMissingDefaultGroupSpecError",
-  {
-    specPath: Schema.String,
-  },
-) {}
-
-export class SpecRuntimeMismatchError extends Schema.TaggedError<SpecRuntimeMismatchError>()(
-  "SpecRuntimeMismatchError",
-  {
-    specPath: Schema.String,
-    expectedRuntime: Schema.Literal("Convex", "Node"),
-    actualRuntime: Schema.Literal("Convex", "Node"),
-  },
-) {}
-
-export class ImplMissingSpecImportError extends Schema.TaggedError<ImplMissingSpecImportError>()(
-  "ImplMissingSpecImportError",
-  {
-    implPath: Schema.String,
-    expectedSpecPath: Schema.String,
-  },
-) {}
-
-export class ImplMissingDefaultLayerError extends Schema.TaggedError<ImplMissingDefaultLayerError>()(
-  "ImplMissingDefaultLayerError",
-  {
-    implPath: Schema.String,
-  },
-) {}
-
-export class ImplNotFinalizedError extends Schema.TaggedError<ImplNotFinalizedError>()(
-  "ImplNotFinalizedError",
-  {
-    implPath: Schema.String,
-  },
-) {}
-
-export class ImplMissingFunctionsError extends Schema.TaggedError<ImplMissingFunctionsError>()(
-  "ImplMissingFunctionsError",
-  {
-    implPath: Schema.String,
-    groupPath: Schema.String,
-    missingFunctionNames: Schema.Array(Schema.String),
-  },
-) {}
-
-export class SchemaInvalidDefaultExportError extends Schema.TaggedError<SchemaInvalidDefaultExportError>()(
-  "SchemaInvalidDefaultExportError",
-  {
-    schemaPath: Schema.String,
-  },
-) {}
-
-export class MissingSchemaFileError extends Schema.TaggedError<MissingSchemaFileError>()(
-  "MissingSchemaFileError",
-  {
-    schemaPath: Schema.String,
-  },
-) {}
-
-export const CodegenError = Schema.Union(
-  BuildError,
-  MissingImplFileError,
-  MissingSpecFileError,
-  SpecMissingDefaultGroupSpecError,
-  SpecRuntimeMismatchError,
-  ImplMissingSpecImportError,
-  ImplMissingDefaultLayerError,
-  ImplNotFinalizedError,
-  ImplMissingFunctionsError,
-  SchemaInvalidDefaultExportError,
-  MissingSchemaFileError,
-);
-export type CodegenError = typeof CodegenError.Type;
-
-export const isCodegenError = (error: unknown): error is CodegenError => {
-  if (isBuildError(error)) return true;
-  return Schema.is(CodegenError)(error);
-};
-
-// --- Per-variant rendering ---
-
-const cross = pipe(AnsiDoc.char("✘"), AnsiDoc.annotate(Ansi.red));
-
-const stemFromSpecPath = (specPath: string): string => {
-  const lastSep = Math.max(
-    specPath.lastIndexOf("/"),
-    specPath.lastIndexOf("\\"),
-  );
-  const basename = lastSep < 0 ? specPath : specPath.slice(lastSep + 1);
-  return basename.endsWith(".spec.ts")
-    ? basename.slice(0, -".spec.ts".length)
-    : basename;
-};
-
-const singleLine = (
-  ...parts: ReadonlyArray<AnsiDoc.AnsiDoc>
-): AnsiDoc.AnsiDoc => pipe(cross, AnsiDoc.catWithSpace(AnsiDoc.hcat(parts)));
-
-const renderMissingImplFileError = (
-  error: MissingImplFileError,
-): AnsiDoc.AnsiDoc =>
-  singleLine(
-    AnsiDoc.text("Spec "),
-    formatPathDoc(error.specPath),
-    AnsiDoc.text(" has no sibling impl; create "),
-    formatPathDoc(error.expectedImplPath),
-    AnsiDoc.text(" and default-export a GroupImpl layer from it."),
-  );
-
-const renderMissingSpecFileError = (
-  error: MissingSpecFileError,
-): AnsiDoc.AnsiDoc =>
-  singleLine(
-    AnsiDoc.text("Impl "),
-    formatPathDoc(error.implPath),
-    AnsiDoc.text(" has no sibling spec; create "),
-    formatPathDoc(error.expectedSpecPath),
-    AnsiDoc.text(
-      " and default-export a GroupSpec from it, or remove the impl.",
-    ),
-  );
-
-const renderSpecMissingDefaultGroupSpecError = (
-  error: SpecMissingDefaultGroupSpecError,
-): AnsiDoc.AnsiDoc =>
-  singleLine(
-    AnsiDoc.text("Spec "),
-    formatPathDoc(error.specPath),
-    AnsiDoc.text(
-      " must default-export a GroupSpec; build it with GroupSpec.make() or GroupSpec.makeNode().",
-    ),
-  );
-
-const renderSpecRuntimeMismatchError = (
-  error: SpecRuntimeMismatchError,
-): AnsiDoc.AnsiDoc => {
-  const constructor =
-    error.expectedRuntime === "Node"
-      ? "GroupSpec.makeNode()"
-      : "GroupSpec.make()";
-  const moveHint =
-    error.expectedRuntime === "Node"
-      ? " or move the file into confect/node/."
-      : " or move the file out of confect/node/.";
-  return singleLine(
-    AnsiDoc.text("Spec "),
-    formatPathDoc(error.specPath),
-    AnsiDoc.text(
-      ` declares a ${error.actualRuntime} GroupSpec but its location requires ${error.expectedRuntime}; use ${constructor}${moveHint}`,
-    ),
-  );
-};
-
-const renderImplMissingSpecImportError = (
-  error: ImplMissingSpecImportError,
-): AnsiDoc.AnsiDoc => {
-  const stem = stemFromSpecPath(error.expectedSpecPath);
-  return singleLine(
-    AnsiDoc.text("Impl "),
-    formatPathDoc(error.implPath),
-    AnsiDoc.text(
-      ` does not import its sibling spec; add \`import ${stem} from "./${stem}.spec"\` and pass it to FunctionImpl.make / GroupImpl.make.`,
-    ),
-  );
-};
-
-const renderImplMissingDefaultLayerError = (
-  error: ImplMissingDefaultLayerError,
-): AnsiDoc.AnsiDoc =>
-  singleLine(
-    AnsiDoc.text("Impl "),
-    formatPathDoc(error.implPath),
-    AnsiDoc.text(
-      " must default-export a GroupImpl layer; wrap your handlers with `GroupImpl.make(api, groupSpec).pipe(Layer.provide(...))` and `export default` it.",
-    ),
-  );
-
-const renderImplNotFinalizedError = (
-  error: ImplNotFinalizedError,
-): AnsiDoc.AnsiDoc =>
-  singleLine(
-    AnsiDoc.text("Impl "),
-    formatPathDoc(error.implPath),
-    AnsiDoc.text(
-      " is not finalized; append `GroupImpl.finalize` to the end of the pipeline (e.g. `GroupImpl.make(api, group).pipe(Layer.provide(...), GroupImpl.finalize)`).",
-    ),
-  );
-
-const renderImplMissingFunctionsError = (
-  error: ImplMissingFunctionsError,
-): AnsiDoc.AnsiDoc => {
-  const names = error.missingFunctionNames.join(", ");
-  return singleLine(
-    AnsiDoc.text("Impl "),
-    formatPathDoc(error.implPath),
-    AnsiDoc.text(
-      ` does not implement every function declared by group \`${error.groupPath}\`; missing: ${names}. Add a \`FunctionImpl.make\` for each missing function and provide it to the group layer.`,
-    ),
-  );
-};
-
-const renderSchemaInvalidDefaultExportError = (
-  error: SchemaInvalidDefaultExportError,
-): AnsiDoc.AnsiDoc =>
-  singleLine(
-    AnsiDoc.text("Schema "),
-    formatPathDoc(error.schemaPath),
-    AnsiDoc.text(
-      " must default-export a DatabaseSchema; build it with DatabaseSchema.make({ ... }).",
-    ),
-  );
-
-const renderMissingSchemaFileError = (
-  error: MissingSchemaFileError,
-): AnsiDoc.AnsiDoc =>
-  singleLine(
-    AnsiDoc.text("Schema "),
-    formatPathDoc(error.schemaPath),
-    AnsiDoc.text(
-      " is required but is missing; create it and default-export a DatabaseSchema (DatabaseSchema.make({ ... })).",
-    ),
-  );
-
-/**
- * Render any {@link CodegenError} into a styled, ready-to-print string.
- * Single-error variants render to a one-line `✘`-prefixed message;
- * `BundleFailedError` (the only multi-error variant) renders to a header
- * plus an esbuild diagnostic block.
- */
-export const renderCodegenError = (error: CodegenError): string => {
-  if (isBuildError(error)) return renderBuildError(error);
-  return Match.value(error).pipe(
-    Match.tag("MissingImplFileError", (e) =>
-      pipe(renderMissingImplFileError(e), AnsiDoc.render({ style: "pretty" })),
-    ),
-    Match.tag("MissingSpecFileError", (e) =>
-      pipe(renderMissingSpecFileError(e), AnsiDoc.render({ style: "pretty" })),
-    ),
-    Match.tag("SpecMissingDefaultGroupSpecError", (e) =>
-      pipe(
-        renderSpecMissingDefaultGroupSpecError(e),
-        AnsiDoc.render({ style: "pretty" }),
-      ),
-    ),
-    Match.tag("SpecRuntimeMismatchError", (e) =>
-      pipe(
-        renderSpecRuntimeMismatchError(e),
-        AnsiDoc.render({ style: "pretty" }),
-      ),
-    ),
-    Match.tag("ImplMissingSpecImportError", (e) =>
-      pipe(
-        renderImplMissingSpecImportError(e),
-        AnsiDoc.render({ style: "pretty" }),
-      ),
-    ),
-    Match.tag("ImplMissingDefaultLayerError", (e) =>
-      pipe(
-        renderImplMissingDefaultLayerError(e),
-        AnsiDoc.render({ style: "pretty" }),
-      ),
-    ),
-    Match.tag("ImplNotFinalizedError", (e) =>
-      pipe(renderImplNotFinalizedError(e), AnsiDoc.render({ style: "pretty" })),
-    ),
-    Match.tag("ImplMissingFunctionsError", (e) =>
-      pipe(
-        renderImplMissingFunctionsError(e),
-        AnsiDoc.render({ style: "pretty" }),
-      ),
-    ),
-    Match.tag("SchemaInvalidDefaultExportError", (e) =>
-      pipe(
-        renderSchemaInvalidDefaultExportError(e),
-        AnsiDoc.render({ style: "pretty" }),
-      ),
-    ),
-    Match.tag("MissingSchemaFileError", (e) =>
-      pipe(
-        renderMissingSchemaFileError(e),
-        AnsiDoc.render({ style: "pretty" }),
-      ),
-    ),
-    Match.exhaustive,
-  );
-};
-
-export const logCodegenError = (error: CodegenError) =>
-  Effect.sync(() => console.error(renderCodegenError(error)));
-
-// --- Effect combinators ---
-
-/**
- * Log any {@link CodegenError} thrown by `effect` and propagate the failure
- * unchanged so the caller's error channel is preserved (used by the
- * `codegen` command, which needs the failure to surface as a non-zero exit
- * code).
- */
-export const tapAndLog = <A, E, R>(
-  effect: Effect.Effect<A, E, R>,
-): Effect.Effect<A, E, R> =>
-  effect.pipe(
-    Effect.tapError((error) =>
-      isCodegenError(error) ? logCodegenError(error) : Effect.void,
-    ),
-  );
-
-/**
- * Catch any {@link CodegenError} thrown by `effect`, log it, and resolve to
- * `Option.none()` (used by the `dev` command's sync loop, which continues
- * after a failed sync rather than exiting). Success resolves to
- * `Option.some(value)`.
- */
-export const catchAndLog = <A, E, R>(
-  effect: Effect.Effect<A, E, R>,
-): Effect.Effect<Option.Option<A>, Exclude<E, CodegenError>, R> =>
-  Effect.catchIf(Effect.map(effect, Option.some<A>), isCodegenError, (error) =>
-    logCodegenError(error).pipe(Effect.as(Option.none<A>())),
-  ) as Effect.Effect<Option.Option<A>, Exclude<E, CodegenError>, R>;

package/src/ConfectDirectory.ts

@@ -1,42 +0,0 @@
-import { FileSystem, Path } from "@effect/platform";
-import { Effect, Ref, Schema } from "effect";
-import { ConvexDirectory } from "./ConvexDirectory";
-
-export class ConfectDirectory extends Effect.Service<ConfectDirectory>()(
-  "@confect/cli/ConfectDirectory",
-  {
-    effect: Effect.gen(function* () {
-      const convexDirectory = yield* findConfectDirectory;
-
-      const ref = yield* Ref.make<string>(convexDirectory);
-
-      return { get: Ref.get(ref) } as const;
-    }),
-    dependencies: [ConvexDirectory.Default],
-    accessors: true,
-  },
-) {}
-
-export class ConfectDirectoryNotFoundError extends Schema.TaggedError<ConfectDirectoryNotFoundError>()(
-  "ConfectDirectoryNotFoundError",
-  {},
-) {
-  override get message(): string {
-    return "Could not find Confect directory";
-  }
-}
-
-export const findConfectDirectory = Effect.gen(function* () {
-  const fs = yield* FileSystem.FileSystem;
-  const path = yield* Path.Path;
-
-  const convexDirectory = yield* ConvexDirectory.get;
-
-  const confectDirectory = path.join(path.dirname(convexDirectory), "confect");
-
-  if (yield* fs.exists(confectDirectory)) {
-    return confectDirectory;
-  } else {
-    return yield* new ConfectDirectoryNotFoundError();
-  }
-});

package/src/ConvexDirectory.ts

@@ -1,68 +0,0 @@
-import { FileSystem, Path } from "@effect/platform";
-import { Effect, Option, Ref, Schema } from "effect";
-import { ProjectRoot } from "./ProjectRoot";
-
-export class ConvexDirectory extends Effect.Service<ConvexDirectory>()(
-  "@confect/cli/ConvexDirectory",
-  {
-    effect: Effect.gen(function* () {
-      const convexDirectory = yield* findConvexDirectory;
-
-      const ref = yield* Ref.make<string>(convexDirectory);
-
-      return { get: Ref.get(ref) } as const;
-    }),
-    dependencies: [ProjectRoot.Default],
-    accessors: true,
-  },
-) {}
-
-export class ConvexDirectoryNotFoundError extends Schema.TaggedError<ConvexDirectoryNotFoundError>()(
-  "ConvexDirectoryNotFoundError",
-  {},
-) {
-  override get message(): string {
-    return "Could not find Convex directory";
-  }
-}
-
-/**
- * Schema for `convex.json` configuration file.
- * @see https://docs.convex.dev/production/project-configuration
- */
-const ConvexJsonConfig = Schema.parseJson(
-  Schema.Struct({
-    functions: Schema.optional(Schema.String),
-  }),
-);
-
-const findConvexDirectory = Effect.gen(function* () {
-  const fs = yield* FileSystem.FileSystem;
-  const path = yield* Path.Path;
-
-  const projectRoot = yield* ProjectRoot.get;
-
-  const defaultPath = path.join(projectRoot, "convex");
-
-  const convexJsonPath = path.join(projectRoot, "convex.json");
-
-  const convexDirectory = yield* Effect.if(fs.exists(convexJsonPath), {
-    onTrue: () =>
-      fs.readFileString(convexJsonPath).pipe(
-        Effect.andThen(Schema.decodeOption(ConvexJsonConfig)),
-        Effect.map((config) =>
-          Option.fromNullable(config.functions).pipe(
-            Option.map((functionsDir) => path.join(projectRoot, functionsDir)),
-          ),
-        ),
-        Effect.andThen(Option.getOrElse(() => defaultPath)),
-      ),
-    onFalse: () => Effect.succeed(defaultPath),
-  });
-
-  if (yield* fs.exists(convexDirectory)) {
-    return convexDirectory;
-  } else {
-    return yield* new ConvexDirectoryNotFoundError();
-  }
-});

package/src/FunctionPath.ts

@@ -1,27 +0,0 @@
-import { Schema } from "effect";
-import * as GroupPath from "./GroupPath";
-
-/**
- * The path to a function in the Confect API.
- */
-export class FunctionPath extends Schema.Class<FunctionPath>("FunctionPath")({
-  groupPath: GroupPath.GroupPath,
-  name: Schema.NonEmptyString,
-}) {}
-
-/**
- * Get the group path from a function path.
- */
-export const groupPath = (functionPath: FunctionPath): GroupPath.GroupPath =>
-  functionPath.groupPath;
-
-/**
- * Get the function name from a function path.
- */
-export const name = (functionPath: FunctionPath): string => functionPath.name;
-
-/**
- * Get the function path as a string.
- */
-export const toString = (functionPath: FunctionPath): string =>
-  `${GroupPath.toString(functionPath.groupPath)}.${functionPath.name}`;

package/src/FunctionPaths.ts

@@ -1,103 +0,0 @@
-import type { GroupSpec, Spec } from "@confect/core";
-import { HashSet, Option, pipe, Record, Schema } from "effect";
-import * as FunctionPath from "./FunctionPath";
-import * as GroupPath from "./GroupPath";
-import * as GroupPaths from "./GroupPaths";
-
-export const FunctionPaths = Schema.HashSetFromSelf(
-  FunctionPath.FunctionPath,
-).pipe(Schema.brand("@confect/cli/FunctionPaths"));
-export type FunctionPaths = typeof FunctionPaths.Type;
-
-export const make = (spec: Spec.AnyWithProps): FunctionPaths =>
-  makeHelper(spec.groups, Option.none(), FunctionPaths.make(HashSet.empty()));
-
-const makeHelper = (
-  groups: {
-    [key: string]: GroupSpec.AnyWithProps;
-  },
-  currentGroupPath: Option.Option<GroupPath.GroupPath>,
-  apiPaths: FunctionPaths,
-): FunctionPaths =>
-  Record.reduce(groups, apiPaths, (acc, group, groupName) => {
-    const groupPath = Option.match(currentGroupPath, {
-      onNone: () => GroupPath.make([groupName]),
-      onSome: (path) => GroupPath.append(path, groupName),
-    });
-
-    const accWithFunctions = Record.reduce(
-      group.functions,
-      acc,
-      (acc_, _fn, functionName) =>
-        FunctionPaths.make(
-          HashSet.add(
-            acc_,
-            FunctionPath.FunctionPath.make({
-              groupPath,
-              name: functionName,
-            }),
-          ),
-        ),
-    );
-
-    return makeHelper(group.groups, Option.some(groupPath), accWithFunctions);
-  });
-
-export const groupPaths = (
-  functionPaths: FunctionPaths,
-): GroupPaths.GroupPaths =>
-  pipe(
-    functionPaths,
-    HashSet.map(FunctionPath.groupPath),
-    GroupPaths.GroupPaths.make,
-  );
-
-export const diff = (
-  previousFunctions: FunctionPaths,
-  currentFunctions: FunctionPaths,
-): {
-  functionsAdded: FunctionPaths;
-  functionsRemoved: FunctionPaths;
-  groupsRemoved: GroupPaths.GroupPaths;
-  groupsAdded: GroupPaths.GroupPaths;
-  groupsChanged: GroupPaths.GroupPaths;
-} => {
-  const currentGroups = groupPaths(currentFunctions);
-  const previousGroups = groupPaths(previousFunctions);
-
-  const groupsAdded = GroupPaths.GroupPaths.make(
-    HashSet.difference(currentGroups, previousGroups),
-  );
-  const groupsRemoved = GroupPaths.GroupPaths.make(
-    HashSet.difference(previousGroups, currentGroups),
-  );
-
-  const functionsAdded = FunctionPaths.make(
-    HashSet.difference(currentFunctions, previousFunctions),
-  );
-  const existingGroupsToWhichFunctionsWereAdded = GroupPaths.GroupPaths.make(
-    HashSet.intersection(currentGroups, groupPaths(functionsAdded)),
-  );
-
-  const functionsRemoved = FunctionPaths.make(
-    HashSet.difference(previousFunctions, currentFunctions),
-  );
-  const existingGroupsToWhichFunctionsWereRemoved = GroupPaths.GroupPaths.make(
-    HashSet.intersection(previousGroups, groupPaths(functionsRemoved)),
-  );
-
-  const groupsChanged = pipe(
-    existingGroupsToWhichFunctionsWereAdded,
-    HashSet.union(existingGroupsToWhichFunctionsWereRemoved),
-    HashSet.difference(HashSet.union(groupsAdded, groupsRemoved)),
-    GroupPaths.GroupPaths.make,
-  );
-
-  return {
-    functionsAdded,
-    functionsRemoved,
-    groupsRemoved,
-    groupsAdded,
-    groupsChanged,
-  };
-};

package/src/GroupPath.ts

@@ -1,118 +0,0 @@
-import { type GroupSpec, type Spec } from "@confect/core";
-import { Path } from "@effect/platform";
-import {
-  Array,
-  Data,
-  Effect,
-  Option,
-  pipe,
-  Record,
-  Schema,
-  String,
-} from "effect";
-
-/**
- * The path to a group in the Confect API.
- */
-export class GroupPath extends Schema.Class<GroupPath>("GroupPath")({
-  pathSegments: Schema.Data(Schema.NonEmptyArray(Schema.NonEmptyString)),
-}) {}
-
-/**
- * Create a GroupPath from path segments.
- */
-export const make = (pathSegments: readonly [string, ...string[]]): GroupPath =>
-  GroupPath.make({ pathSegments: Data.array(pathSegments) });
-
-/**
- * Append a group name to a GroupPath to create a new GroupPath.
- */
-export const append = (groupPath: GroupPath, groupName: string): GroupPath =>
-  make([...groupPath.pathSegments, groupName]);
-
-/**
- * Expects a path string of the form `./group1/group2.ts`, relative to the Convex functions directory.
- */
-export const fromGroupModulePath = (groupModulePath: string) =>
-  Effect.gen(function* () {
-    const path = yield* Path.Path;
-
-    const { dir, name, ext } = path.parse(groupModulePath);
-
-    if (ext === ".ts") {
-      const dirSegments = Array.filter(
-        String.split(dir, path.sep),
-        String.isNonEmpty,
-      );
-      yield* Effect.logDebug(Array.append(dirSegments, name));
-      return make(Array.append(dirSegments, name));
-    } else {
-      return yield* new GroupModulePathIsNotATypeScriptFileError({
-        path: groupModulePath,
-      });
-    }
-  });
-
-/**
- * Get the module path for a group, relative to the Convex functions directory.
- */
-export const modulePath = (groupPath: GroupPath) =>
-  Effect.gen(function* () {
-    const path = yield* Path.Path;
-
-    return path.join(...groupPath.pathSegments) + ".ts";
-  });
-
-export const getGroupSpec = (
-  spec: Spec.AnyWithProps,
-  groupPath: GroupPath,
-): Option.Option<GroupSpec.AnyWithProps> =>
-  pipe(
-    groupPath.pathSegments,
-    Array.matchLeft({
-      onEmpty: () => Option.none(),
-      onNonEmpty: (head, tail) =>
-        pipe(
-          Record.get(spec.groups, head),
-          Option.flatMap((group) =>
-            Array.isNonEmptyArray(tail)
-              ? getGroupSpecHelper(group, tail)
-              : Option.some(group),
-          ),
-        ),
-    }),
-  );
-
-const getGroupSpecHelper = (
-  group: GroupSpec.AnyWithProps,
-  remainingPath: ReadonlyArray<string>,
-): Option.Option<GroupSpec.AnyWithProps> =>
-  pipe(
-    remainingPath,
-    Array.matchLeft({
-      onEmpty: () => Option.some(group),
-      onNonEmpty: (head, tail) =>
-        pipe(
-          Record.get(group.groups, head),
-          Option.flatMap((subGroup) =>
-            Array.isNonEmptyArray(tail)
-              ? getGroupSpecHelper(subGroup, tail)
-              : Option.some(subGroup),
-          ),
-        ),
-    }),
-  );
-
-export const toString = (groupPath: GroupPath) =>
-  Array.join(groupPath.pathSegments, ".");
-
-export class GroupModulePathIsNotATypeScriptFileError extends Schema.TaggedError<GroupModulePathIsNotATypeScriptFileError>()(
-  "GroupModulePathIsNotATypeScriptFileError",
-  {
-    path: Schema.NonEmptyString,
-  },
-) {
-  override get message(): string {
-    return `Expected group module path to end with .ts, got ${this.path}`;
-  }
-}