@confect/cli 9.0.0-next.8 → 9.0.0

package/src/GroupPath.ts

@@ -1,116 +0,0 @@
-import { type GroupSpec, type Spec } from "@confect/core";
-import * as Path from "@effect/platform/Path";
-import { pipe } from "effect/Function";
-import * as Array from "effect/Array";
-import * as Data from "effect/Data";
-import * as Effect from "effect/Effect";
-import * as Option from "effect/Option";
-import * as Record from "effect/Record";
-import * as Schema from "effect/Schema";
-import * as String from "effect/String";
-
-/**
- * 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}`;
-  }
-}

package/src/GroupPaths.ts

@@ -1,7 +0,0 @@
-import * as Schema from "effect/Schema";
-import * as GroupPath from "./GroupPath";
-
-export const GroupPaths = Schema.HashSetFromSelf(GroupPath.GroupPath).pipe(
-  Schema.brand("@confect/cli/GroupPaths"),
-);
-export type GroupPaths = typeof GroupPaths.Type;

package/src/LeafModule.ts

@@ -1,323 +0,0 @@
-import { GroupSpec, Registry } from "@confect/core";
-import * as GroupImpl from "@confect/server/GroupImpl";
-import * as FileSystem from "@effect/platform/FileSystem";
-import * as Path from "@effect/platform/Path";
-import type { Context } from "effect";
-import * as Array from "effect/Array";
-import * as Effect from "effect/Effect";
-import * as Layer from "effect/Layer";
-import * as Option from "effect/Option";
-import * as Ref from "effect/Ref";
-import * as String from "effect/String";
-import { fromBundlerError } from "./BuildError";
-import * as Bundler from "./Bundler";
-import {
-  ImplMissingDefaultLayerError,
-  ImplMissingFunctionsError,
-  ImplMissingSpecImportError,
-  ImplNotFinalizedError,
-  SpecMissingDefaultGroupSpecError,
-  SpecRuntimeMismatchError,
-} from "./CodegenError";
-import { ConfectDirectory } from "./ConfectDirectory";
-import { removePathExtension } from "./utils";
-
-export interface LeafModule {
-  readonly relativePath: string;
-  readonly pathSegments: readonly [string, ...string[]];
-  readonly groupPathDot: string;
-  readonly registryGroupPathDot: string;
-  readonly exportName: string;
-  readonly runtime: "Convex" | "Node";
-  readonly specImportPath: string;
-}
-
-export const SPEC_SUFFIX = ".spec.ts";
-export const IMPL_SUFFIX = ".impl.ts";
-
-const swapModuleSuffix = (
-  relativePath: string,
-  fromSuffix: string,
-  toSuffix: string,
-) =>
-  Effect.gen(function* () {
-    const path = yield* Path.Path;
-    const { dir, name, ext } = path.parse(relativePath);
-    if (ext !== ".ts" || !name.endsWith(fromSuffix.slice(0, -".ts".length))) {
-      return relativePath;
-    }
-
-    const stem = name.slice(0, -fromSuffix.slice(0, -".ts".length).length);
-    const nextName = `${stem}${toSuffix.slice(0, -".ts".length)}`;
-    return dir.length > 0
-      ? path.join(dir, `${nextName}${ext}`)
-      : `${nextName}${ext}`;
-  });
-
-export const isLeafSpecPath = (relativePath: string) =>
-  relativePath.endsWith(SPEC_SUFFIX);
-
-export const isLeafImplPath = (relativePath: string) =>
-  relativePath.endsWith(IMPL_SUFFIX);
-
-export const exportNameFromModulePath = (relativePath: string) =>
-  Effect.gen(function* () {
-    const path = yield* Path.Path;
-    const { name, ext } = path.parse(relativePath);
-    if (ext !== ".ts") {
-      return name;
-    }
-    return name.endsWith(".spec") ? name.slice(0, -".spec".length) : name;
-  });
-
-export const groupPathFromRelativeModulePath = (relativePath: string) =>
-  Effect.gen(function* () {
-    const path = yield* Path.Path;
-    const { dir, name, ext } = path.parse(relativePath);
-    const stem =
-      ext === ".ts" && name.endsWith(".spec")
-        ? name.slice(0, -".spec".length)
-        : name;
-    const dirSegments = Array.filter(
-      String.split(dir, path.sep),
-      String.isNonEmpty,
-    );
-    const pathSegments = Array.append(dirSegments, stem) as [
-      string,
-      ...string[],
-    ];
-    return {
-      pathSegments,
-      groupPathDot: Array.join(pathSegments, "."),
-    };
-  });
-
-export const specImportPathFromGenerated = (specRelativePath: string) =>
-  Effect.gen(function* () {
-    const withoutExt = yield* removePathExtension(specRelativePath);
-    return `../${withoutExt}`;
-  });
-
-export const specPathForImpl = (implRelativePath: string) =>
-  swapModuleSuffix(implRelativePath, IMPL_SUFFIX, SPEC_SUFFIX);
-
-export const implPathForSpec = (specRelativePath: string) =>
-  swapModuleSuffix(specRelativePath, SPEC_SUFFIX, IMPL_SUFFIX);
-
-export const isNodeLeafModule = (relativePath: string) =>
-  relativePath.startsWith("node/") || relativePath.startsWith("node\\");
-
-export const toNodeRegistryLeaf = (leaf: LeafModule): LeafModule => ({
-  ...leaf,
-  pathSegments: [leaf.exportName],
-  groupPathDot: leaf.exportName,
-});
-
-export const registeredFunctionsRelativePath = (leaf: LeafModule) =>
-  Effect.gen(function* () {
-    const path = yield* Path.Path;
-    return (
-      path.join(
-        "registeredFunctions",
-        ...leaf.pathSegments.slice(leaf.runtime === "Node" ? 1 : 0),
-      ) + ".ts"
-    );
-  });
-
-export const discoverLeafSpecFiles = Effect.gen(function* () {
-  const fs = yield* FileSystem.FileSystem;
-  const path = yield* Path.Path;
-  const confectDirectory = yield* ConfectDirectory.get;
-
-  const excludedDirs = new Set(["_generated", "tables"]);
-  const excludedFiles = new Set(["nodeSpec.ts", "spec.ts"]);
-
-  const allPaths = yield* fs.readDirectory(confectDirectory, {
-    recursive: true,
-  });
-
-  return Array.filter(allPaths, (relativePath) => {
-    if (!isLeafSpecPath(relativePath)) {
-      return false;
-    }
-
-    if (excludedFiles.has(relativePath)) {
-      return false;
-    }
-
-    const segments = String.split(relativePath, path.sep);
-    return !Array.some(segments, (segment) => excludedDirs.has(segment));
-  });
-});
-
-export const discoverLeafImplFiles = Effect.gen(function* () {
-  const fs = yield* FileSystem.FileSystem;
-  const path = yield* Path.Path;
-  const confectDirectory = yield* ConfectDirectory.get;
-
-  const excludedDirs = new Set(["_generated", "tables"]);
-
-  const allPaths = yield* fs.readDirectory(confectDirectory, {
-    recursive: true,
-  });
-
-  return Array.filter(allPaths, (relativePath) => {
-    if (!isLeafImplPath(relativePath)) {
-      return false;
-    }
-
-    const segments = String.split(relativePath, path.sep);
-    return !Array.some(segments, (segment) => excludedDirs.has(segment));
-  });
-});
-
-export const toLeafModule = (specRelativePath: string) =>
-  Effect.gen(function* () {
-    const exportName = yield* exportNameFromModulePath(specRelativePath);
-    const { pathSegments, groupPathDot } =
-      yield* groupPathFromRelativeModulePath(specRelativePath);
-    const specImportPath = yield* specImportPathFromGenerated(specRelativePath);
-    const runtime = isNodeLeafModule(specRelativePath) ? "Node" : "Convex";
-
-    return {
-      relativePath: specRelativePath,
-      pathSegments,
-      groupPathDot,
-      exportName,
-      runtime,
-      registryGroupPathDot: runtime === "Node" ? exportName : groupPathDot,
-      specImportPath,
-    } satisfies LeafModule;
-  });
-
-const absoluteModulePath = (relativePath: string) =>
-  Effect.gen(function* () {
-    const confectDirectory = yield* ConfectDirectory.get;
-    const path = yield* Path.Path;
-    return path.resolve(confectDirectory, relativePath);
-  });
-
-/**
- * Validate that the leaf's spec file default-exports a `GroupSpec` whose
- * runtime matches the leaf's location (`Convex` for files outside
- * `confect/node/`, `Node` for files inside it). Returns the validated
- * `GroupSpec` so callers can avoid re-bundling for later inspection (e.g.
- * parent/child name-collision checks at codegen time).
- */
-export const validateSpec = (leaf: LeafModule) =>
-  Effect.gen(function* () {
-    const absolutePath = yield* absoluteModulePath(leaf.relativePath);
-    const { module } = yield* Bundler.bundle(absolutePath).pipe(
-      Effect.mapError((error) => fromBundlerError(leaf.relativePath, error)),
-    );
-
-    const groupSpec = module.default;
-
-    if (!GroupSpec.isGroupSpec(groupSpec)) {
-      return yield* new SpecMissingDefaultGroupSpecError({
-        specPath: leaf.relativePath,
-      });
-    }
-
-    if (groupSpec.runtime !== leaf.runtime) {
-      return yield* new SpecRuntimeMismatchError({
-        specPath: leaf.relativePath,
-        expectedRuntime: leaf.runtime,
-        actualRuntime: groupSpec.runtime,
-      });
-    }
-
-    return groupSpec;
-  });
-
-/**
- * Walk the built `Context` for a `Finalized` `GroupImpl` service value. The
- * lookup is value-shaped (via `GroupImpl.isFinalizedGroupImpl`) so we don't
- * need to know the group's path up front to construct a typed tag for it.
- */
-const findFinalizedGroupImpl = <S>(
-  context: Context.Context<S>,
-): Option.Option<GroupImpl.AnyFinalized> =>
-  Array.findFirst(context.unsafeMap.values(), GroupImpl.isFinalizedGroupImpl);
-
-/**
- * Build the impl layer with a fresh `Registry` so each validation is
- * isolated from prior validations' `FunctionImpl.make` writes. The CLI no
- * longer reads the registry directly — `GroupImpl.finalize` snapshots the
- * registered function names onto the produced `Finalized` `GroupImpl`
- * service value — but a fresh `Ref` is still required because the default
- * `Context.Reference` is cached globally and would otherwise accumulate
- * items across impls.
- */
-const buildImplLayer = (implLayer: Layer.Layer<unknown>) =>
-  Effect.gen(function* () {
-    const registry = Ref.unsafeMake<Registry.RegistryItems>({});
-    return yield* Layer.build(
-      implLayer as Layer.Layer<unknown, never, never>,
-    ).pipe(Effect.provideService(Registry.Registry, registry));
-  }).pipe(Effect.scoped);
-
-/**
- * Validate that the leaf's sibling impl file imports the spec, default-exports
- * a finalized `GroupImpl` layer, and provides a `FunctionImpl` for every
- * function declared by the spec.
- */
-export const validateImpl = (leaf: LeafModule) =>
-  Effect.gen(function* () {
-    const implRelativePath = yield* implPathForSpec(leaf.relativePath);
-    const implAbsolutePath = yield* absoluteModulePath(implRelativePath);
-    const specAbsolutePath = yield* absoluteModulePath(leaf.relativePath);
-
-    const bundled = yield* Bundler.bundle(implAbsolutePath).pipe(
-      Effect.mapError((error) => fromBundlerError(implRelativePath, error)),
-    );
-
-    if (
-      !(yield* Bundler.directlyImports(
-        bundled,
-        implAbsolutePath,
-        specAbsolutePath,
-      ))
-    ) {
-      return yield* new ImplMissingSpecImportError({
-        implPath: implRelativePath,
-        expectedSpecPath: leaf.relativePath,
-      });
-    }
-
-    if (!Layer.isLayer(bundled.module.default)) {
-      return yield* new ImplMissingDefaultLayerError({
-        implPath: implRelativePath,
-      });
-    }
-
-    const { module: specModule } = yield* Bundler.bundle(specAbsolutePath).pipe(
-      Effect.mapError((error) => fromBundlerError(leaf.relativePath, error)),
-    );
-    const groupSpec = specModule.default as GroupSpec.AnyWithProps;
-    const expectedFunctionNames = Object.keys(groupSpec.functions);
-
-    const context = yield* buildImplLayer(
-      bundled.module.default as Layer.Layer<unknown>,
-    );
-    const finalizedGroupImpl = yield* Option.match(
-      findFinalizedGroupImpl(context),
-      {
-        onNone: () => new ImplNotFinalizedError({ implPath: implRelativePath }),
-        onSome: Effect.succeed,
-      },
-    );
-
-    const registeredSet = new Set(finalizedGroupImpl.registeredFunctionNames);
-    const missing = expectedFunctionNames.filter(
-      (name) => !registeredSet.has(name),
-    );
-
-    if (missing.length > 0) {
-      return yield* new ImplMissingFunctionsError({
-        implPath: implRelativePath,
-        groupPath: leaf.groupPathDot,
-        missingFunctionNames: missing,
-      });
-    }
-  });

package/src/ProjectRoot.ts

@@ -1,55 +0,0 @@
-import * as FileSystem from "@effect/platform/FileSystem";
-import * as Path from "@effect/platform/Path";
-import * as NodeFileSystem from "@effect/platform-node/NodeFileSystem";
-import * as Array from "effect/Array";
-import * as Effect from "effect/Effect";
-import * as Option from "effect/Option";
-import * as Ref from "effect/Ref";
-import * as Schema from "effect/Schema";
-
-export class ProjectRoot extends Effect.Service<ProjectRoot>()(
-  "@confect/cli/ProjectRoot",
-  {
-    effect: Effect.gen(function* () {
-      const projectRoot = yield* findProjectRoot;
-
-      const ref = yield* Ref.make<string>(projectRoot);
-
-      return { get: Ref.get(ref) } as const;
-    }),
-    dependencies: [NodeFileSystem.layer],
-    accessors: true,
-  },
-) {}
-
-export const findProjectRoot = Effect.gen(function* () {
-  const fs = yield* FileSystem.FileSystem;
-  const path = yield* Path.Path;
-
-  const startDir = path.resolve(".");
-  const root = path.parse(startDir).root;
-
-  const directories = Array.unfold(startDir, (dir) =>
-    dir === root
-      ? Option.none()
-      : Option.some([dir, path.dirname(dir)] as const),
-  );
-
-  const projectRoot = yield* Effect.findFirst(directories, (dir) =>
-    fs.exists(path.join(dir, "package.json")),
-  );
-
-  return yield* Option.match(projectRoot, {
-    onNone: () => Effect.fail(new ProjectRootNotFoundError()),
-    onSome: Effect.succeed,
-  });
-});
-
-export class ProjectRootNotFoundError extends Schema.TaggedError<ProjectRootNotFoundError>()(
-  "ProjectRootNotFoundError",
-  {},
-) {
-  override get message(): string {
-    return "Could not find project root (no 'package.json' found)";
-  }
-}

package/src/SpecAssemblyNode.ts

@@ -1,88 +0,0 @@
-import type { LeafModule } from "./LeafModule";
-import { pipe } from "effect/Function";
-import * as Array from "effect/Array";
-import * as Option from "effect/Option";
-import * as Order from "effect/Order";
-import * as Record from "effect/Record";
-
-export interface SpecImportBinding {
-  readonly importPath: string;
-  readonly exportName: string;
-  readonly localName: string;
-}
-
-export interface SpecAssemblyNode {
-  readonly segment: string;
-  readonly importBinding: Option.Option<SpecImportBinding>;
-  readonly children: ReadonlyArray<SpecAssemblyNode>;
-}
-
-const importBindingFromLeaf = (leaf: LeafModule): SpecImportBinding => ({
-  importPath: leaf.specImportPath,
-  exportName: leaf.exportName,
-  localName: leaf.pathSegments.join("_"),
-});
-
-const assemblyNodesAtDepth = (
-  leaves: ReadonlyArray<LeafModule>,
-  depth: number,
-): ReadonlyArray<SpecAssemblyNode> =>
-  pipe(
-    Array.groupBy(leaves, (leaf) => leaf.pathSegments[depth]!),
-    Record.toEntries,
-    Array.sortBy(Order.mapInput(Order.string, ([segment]) => segment)),
-    Array.map(([segment, groupLeaves]) => {
-      const terminal = Array.findFirst(
-        groupLeaves,
-        (leaf) => leaf.pathSegments.length === depth + 1,
-      );
-      const descendants = Array.filter(
-        groupLeaves,
-        (leaf) => leaf.pathSegments.length > depth + 1,
-      );
-      return {
-        segment,
-        importBinding: Option.map(terminal, importBindingFromLeaf),
-        children: assemblyNodesAtDepth(descendants, depth + 1),
-      };
-    }),
-  );
-
-export const assemblyNodesFromLeaves = (
-  leaves: ReadonlyArray<LeafModule>,
-): ReadonlyArray<SpecAssemblyNode> => assemblyNodesAtDepth(leaves, 0);
-
-export const partitionByRuntime = (
-  leaves: ReadonlyArray<LeafModule>,
-): {
-  readonly convex: ReadonlyArray<LeafModule>;
-  readonly node: ReadonlyArray<LeafModule>;
-} => {
-  const [node, convex] = Array.partition(
-    leaves,
-    (leaf) => leaf.runtime === "Convex",
-  );
-  return { convex, node };
-};
-
-const importBindingsForNode = (
-  node: SpecAssemblyNode,
-): ReadonlyArray<SpecImportBinding> =>
-  pipe(node.children, Array.flatMap(importBindingsForNode), (childBindings) =>
-    Option.match(node.importBinding, {
-      onNone: () => childBindings,
-      onSome: (binding) => Array.prepend(childBindings, binding),
-    }),
-  );
-
-export const collectImportBindings = (
-  nodes: ReadonlyArray<SpecAssemblyNode>,
-): ReadonlyArray<SpecImportBinding> =>
-  pipe(
-    Array.flatMap(nodes, importBindingsForNode),
-    (bindings) =>
-      Record.fromIterableBy(bindings, (binding) => binding.importPath),
-    Record.toEntries,
-    Array.map(([, binding]) => binding),
-    Array.sortBy(Order.mapInput(Order.string, (binding) => binding.localName)),
-  );