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

package/package.json

@@ -1,42 +1,14 @@
 {
   "name": "@confect/cli",
-  "version": "9.0.0-next.1",
   "description": "Developer tooling for codegen and sync",
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/rjdellecese/confect.git"
-  },
-  "bugs": {
-    "url": "https://github.com/rjdellecese/confect/issues"
-  },
-  "homepage": "https://confect.dev",
-  "sideEffects": false,
-  "type": "module",
+  "version": "9.0.0-next.10",
+  "author": "RJ Dellecese",
   "bin": {
     "confect": "./dist/index.mjs"
   },
-  "files": [
-    "CHANGELOG.md",
-    "LICENSE",
-    "README.md",
-    "dist",
-    "package.json",
-    "src"
-  ],
-  "exports": {
-    ".": {
-      "types": "./dist/index.d.ts",
-      "default": "./dist/index.js"
-    },
-    "./package.json": "./package.json"
+  "bugs": {
+    "url": "https://github.com/rjdellecese/confect/issues"
   },
-  "keywords": [
-    "effect",
-    "convex",
-    "cli"
-  ],
-  "author": "RJ Dellecese",
-  "license": "ISC",
   "dependencies": {
     "@effect/cli": "^0.75.1",
     "@effect/platform": "0.96.1",
@@ -44,45 +16,56 @@
     "@effect/platform-node-shared": "0.59.0",
     "@effect/printer": "^0.49.0",
     "@effect/printer-ansi": "^0.49.0",
+    "bundle-require": "^5.1.0",
     "code-block-writer": "^13.0.3",
     "esbuild": "^0.27.3"
   },
   "devDependencies": {
     "@effect/language-service": "0.86.1",
     "@effect/vitest": "0.29.0",
-    "@eslint/js": "10.0.1",
     "@types/node": "25.3.3",
     "@vitest/coverage-v8": "3.2.4",
     "effect": "3.21.2",
-    "eslint": "10.0.2",
-    "prettier": "3.8.1",
     "tsdown": "0.20.3",
     "typescript": "5.9.3",
-    "typescript-eslint": "8.56.1",
     "vite": "7.3.1",
     "vite-tsconfig-paths": "6.1.1",
     "vitest": "3.2.4"
   },
+  "engines": {
+    "node": ">=22"
+  },
+  "exports": {
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "CHANGELOG.md",
+    "LICENSE",
+    "README.md",
+    "dist",
+    "package.json"
+  ],
+  "homepage": "https://confect.dev",
+  "keywords": [
+    "cli",
+    "convex",
+    "effect"
+  ],
+  "license": "ISC",
   "peerDependencies": {
     "effect": "^3.21.2",
-    "@confect/core": "^9.0.0-next.1",
-    "@confect/server": "^9.0.0-next.1"
+    "@confect/core": "^9.0.0-next.10",
+    "@confect/server": "^9.0.0-next.10"
   },
-  "engines": {
-    "node": ">=22",
-    "pnpm": ">=10"
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/rjdellecese/confect.git"
   },
-  "main": "./dist/index.js",
-  "module": "./dist/index.js",
-  "types": "./dist/index.d.ts",
+  "type": "module",
   "scripts": {
-    "build": "tsdown --config-loader unrun",
+    "clean": "rm -rf dist coverage node_modules",
     "dev": "tsdown --watch --config-loader unrun",
     "test": "vitest run",
-    "typecheck": "tsc --noEmit --project tsconfig.json",
-    "fix": "prettier --write . && eslint --fix . --max-warnings=0",
-    "format": "prettier --check .",
-    "lint": "eslint . --max-warnings=0",
-    "clean": "rm -rf dist coverage node_modules"
+    "typecheck": "tsc --noEmit --project tsconfig.json"
   }
 }

package/dist/index.d.mts

@@ -1 +0,0 @@
-export { };

package/src/BuildError.ts

@@ -1,210 +0,0 @@
-import { Ansi, AnsiDoc } from "@effect/printer-ansi";
-import { Array, Effect, Match, Option, pipe, Schema, String } from "effect";
-import * as esbuild from "esbuild";
-import { formatPathDoc } from "./log";
-
-// --- Variants ---
-
-export class BundleFailedError extends Schema.TaggedError<BundleFailedError>()(
-  "BundleFailedError",
-  {
-    file: Schema.String,
-    errors: Schema.Array(Schema.Unknown),
-  },
-) {}
-
-export class ImportFailedError extends Schema.TaggedError<ImportFailedError>()(
-  "ImportFailedError",
-  {
-    file: Schema.String,
-    cause: Schema.Unknown,
-  },
-) {}
-
-export const BuildError = Schema.Union(BundleFailedError, ImportFailedError);
-export type BuildError = typeof BuildError.Type;
-
-export const isBuildError = (error: unknown): error is BuildError =>
-  Schema.is(BuildError)(error);
-
-// --- Bundler adapter ---
-
-/**
- * Internal failure produced by the esbuild bundle/import pipeline. Always
- * remapped to a {@link BuildError} (which carries enough context for the CLI
- * to render it) before reaching a user-surface boundary.
- */
-export class BundlerError extends Schema.TaggedError<BundlerError>()(
-  "BundlerError",
-  {
-    cause: Schema.Unknown,
-  },
-) {}
-
-const isEsbuildBuildFailure = (error: unknown): error is esbuild.BuildFailure =>
-  typeof error === "object" &&
-  error !== null &&
-  "errors" in error &&
-  globalThis.Array.isArray((error as esbuild.BuildFailure).errors);
-
-export const fromBundlerError = (
-  file: string,
-  error: BundlerError,
-): BuildError =>
-  isEsbuildBuildFailure(error.cause)
-    ? new BundleFailedError({ file, errors: error.cause.errors })
-    : new ImportFailedError({ file, cause: error.cause });
-
-// --- Rendering ---
-
-const cross = pipe(AnsiDoc.char("✘"), AnsiDoc.annotate(Ansi.red));
-
-const errorGutter = pipe(
-  AnsiDoc.char("│"),
-  AnsiDoc.annotate(Ansi.red),
-  AnsiDoc.render({ style: "pretty" }),
-);
-
-const withErrorGutterBlock = (output: string): string =>
-  pipe(
-    String.split(output, "\n"),
-    Array.map((line) =>
-      pipe(line, String.trim) === "" ? errorGutter : `${errorGutter} ${line}`,
-    ),
-    Array.join("\n"),
-    (guttered) => `${errorGutter}\n${guttered}\n${errorGutter}`,
-  );
-
-const formatBuildMessage = (
-  error: esbuild.Message | undefined,
-  formattedMessage: string,
-): string => {
-  const lines = String.split(formattedMessage, "\n");
-  const redErrorText = pipe(
-    AnsiDoc.text(error?.text ?? ""),
-    AnsiDoc.annotate(Ansi.red),
-    AnsiDoc.render({ style: "pretty" }),
-  );
-  const replaced = pipe(
-    Array.findFirstIndex(lines, (l) => pipe(l, String.trim, String.isNonEmpty)),
-    Option.match({
-      onNone: () => lines,
-      onSome: (index) => Array.modify(lines, index, () => redErrorText),
-    }),
-  );
-  return pipe(replaced, Array.join("\n"));
-};
-
-/**
- * Render a list of esbuild messages into a styled, gutter-prefixed block.
- * Used by both {@link renderBundleFailedError} and the dev-mode esbuild
- * watcher's `onEnd` hook (where the messages don't flow through the
- * tagged-error pipeline).
- */
-export const formatEsbuildMessages = (
-  errors: readonly esbuild.Message[],
-  formattedMessages: readonly string[],
-): string =>
-  pipe(
-    formattedMessages,
-    Array.map((message, i) => formatBuildMessage(errors[i], message)),
-    Array.join(""),
-    String.trimEnd,
-    withErrorGutterBlock,
-  );
-
-const renderImportFailedError = (error: ImportFailedError): AnsiDoc.AnsiDoc => {
-  const causeMessage =
-    error.cause instanceof Error
-      ? error.cause.message
-      : typeof error.cause === "string"
-        ? error.cause
-        : globalThis.String(error.cause);
-  const oneLineCause = pipe(
-    String.split(causeMessage, "\n"),
-    Array.findFirst((line) => pipe(line, String.trim, String.isNonEmpty)),
-    Option.map(String.trim),
-    Option.getOrElse(() => "unknown error"),
-  );
-  return pipe(
-    cross,
-    AnsiDoc.catWithSpace(
-      AnsiDoc.hcat([
-        AnsiDoc.text("Failed to load bundled module "),
-        formatPathDoc(error.file),
-        AnsiDoc.text(
-          `: ${oneLineCause}; check the file's top-level imports and side effects.`,
-        ),
-      ]),
-    ),
-  );
-};
-
-/**
- * Render a {@link BundleFailedError} as a multi-line, ANSI-styled string:
- * a one-line `✘ <file>: build errors` header followed by the
- * gutter-prefixed esbuild diagnostic block. Multi-line is appropriate
- * here because a single `BundleFailedError` carries an array of distinct
- * esbuild messages.
- */
-const renderBundleFailedError = (error: BundleFailedError): string => {
-  const messages = error.errors as readonly esbuild.Message[];
-  const formatted = esbuild.formatMessagesSync(messages as esbuild.Message[], {
-    kind: "error",
-    color: true,
-    terminalWidth: 80,
-  });
-  const header = pipe(
-    cross,
-    AnsiDoc.catWithSpace(
-      AnsiDoc.hcat([formatPathDoc(error.file), AnsiDoc.text(": build errors")]),
-    ),
-    AnsiDoc.render({ style: "pretty" }),
-  );
-  return `${header}\n${formatEsbuildMessages(messages, formatted)}`;
-};
-
-/**
- * Render any {@link BuildError} into a styled, ready-to-print string.
- * `ImportFailedError` collapses to a single line; `BundleFailedError`
- * expands to a header plus one diagnostic block per esbuild message.
- */
-export const renderBuildError = (error: BuildError): string =>
-  Match.value(error).pipe(
-    Match.tag("BundleFailedError", renderBundleFailedError),
-    Match.tag("ImportFailedError", (e) =>
-      pipe(renderImportFailedError(e), AnsiDoc.render({ style: "pretty" })),
-    ),
-    Match.exhaustive,
-  );
-
-export const logBuildError = (error: BuildError) =>
-  Effect.sync(() => console.error(renderBuildError(error)));
-
-/**
- * Render a flat list of esbuild messages as a single error block with a
- * generic `✘ Build errors` header. Used by dev-mode when multiple
- * watchers surface the same underlying error and we want to log the
- * coalesced set rather than one block per watcher.
- */
-const renderCoalescedBuildErrors = (
-  messages: readonly esbuild.Message[],
-): string => {
-  const formatted = esbuild.formatMessagesSync(messages as esbuild.Message[], {
-    kind: "error",
-    color: true,
-    terminalWidth: 80,
-  });
-  const header = pipe(
-    cross,
-    AnsiDoc.catWithSpace(AnsiDoc.text("Build errors")),
-    AnsiDoc.render({ style: "pretty" }),
-  );
-  return `${header}\n${formatEsbuildMessages(messages, formatted)}`;
-};
-
-export const logCoalescedBuildErrors = (messages: readonly esbuild.Message[]) =>
-  Effect.sync(() => {
-    if (messages.length === 0) return;
-    console.error(renderCoalescedBuildErrors(messages));
-  });

package/src/Bundler.ts

@@ -1,144 +0,0 @@
-import { createRequire } from "node:module";
-import { pathToFileURL } from "node:url";
-import { Path } from "@effect/platform";
-import { Array, Effect, Option, pipe } from "effect";
-import * as esbuild from "esbuild";
-import { BundlerError } from "./BuildError";
-
-export interface Bundled {
-  readonly module: any;
-  readonly metafile: esbuild.Metafile;
-}
-
-export const EXTERNAL_PACKAGES = [
-  "@confect/core",
-  "@confect/server",
-  "effect",
-  "@effect/*",
-];
-
-const isExternalImport = (path: string) =>
-  EXTERNAL_PACKAGES.some((p) => {
-    if (p.endsWith("/*")) {
-      return path.startsWith(p.slice(0, -1));
-    }
-    return path === p || path.startsWith(p + "/");
-  });
-
-export const absoluteExternalsPlugin: esbuild.Plugin = {
-  name: "absolute-externals",
-  setup(build) {
-    build.onResolve({ filter: /.*/ }, async (args) => {
-      if (args.kind !== "import-statement" && args.kind !== "dynamic-import")
-        return;
-      if (!isExternalImport(args.path)) return;
-      // `import.meta.resolve`'s second argument is silently ignored in modern
-      // Node, so resolution would always walk up from the CLI's bundled file
-      // (`packages/cli/dist/utils.mjs`) instead of from the user's project.
-      // Use `createRequire` keyed on the importing file's directory so we
-      // resolve out of *their* `node_modules`. The synthetic filename is just
-      // a CommonJS resolution anchor; the file does not need to exist.
-      const parentFile = pathToFileURL(args.resolveDir + "/_").href;
-      const require_ = createRequire(parentFile);
-      const resolvedPath = require_.resolve(args.path);
-      const resolved = pathToFileURL(resolvedPath).href;
-      return { path: resolved, external: true };
-    });
-  },
-};
-
-const buildEntry = (entryPoint: string) =>
-  Effect.tryPromise({
-    try: () =>
-      esbuild.build({
-        entryPoints: [entryPoint],
-        bundle: true,
-        write: false,
-        platform: "node",
-        format: "esm",
-        logLevel: "silent",
-        metafile: true,
-        plugins: [absoluteExternalsPlugin],
-      }),
-    catch: (cause) => new BundlerError({ cause }),
-  });
-
-const importBundledModule = (result: esbuild.BuildResult) => {
-  const code = result.outputFiles![0]!.text;
-  const dataUrl =
-    "data:text/javascript;base64," + Buffer.from(code).toString("base64");
-  return import(dataUrl);
-};
-
-/**
- * Bundle a TypeScript entry point with esbuild and import the result via a
- * data URL. This handles extensionless `.ts` imports regardless of whether
- * the user's project sets `"type": "module"` in package.json. The returned
- * pair carries both the imported module and the esbuild metafile so callers
- * can inspect the import graph (see {@link directlyImports}).
- */
-export const bundle = (
-  entryPoint: string,
-): Effect.Effect<Bundled, BundlerError> =>
-  Effect.gen(function* () {
-    const result = yield* buildEntry(entryPoint);
-    const module = yield* Effect.tryPromise({
-      try: () => importBundledModule(result),
-      catch: (cause) => new BundlerError({ cause }),
-    });
-    if (!result.metafile) {
-      return yield* Effect.dieMessage("esbuild metafile missing");
-    }
-    return { module, metafile: result.metafile };
-  });
-
-const findMetafileInputKey = (
-  metafile: esbuild.Metafile,
-  absolutePath: string,
-) =>
-  Effect.gen(function* () {
-    const path = yield* Path.Path;
-    const resolved = path.resolve(absolutePath);
-    return Array.findFirst(
-      Object.keys(metafile.inputs),
-      (key) => path.resolve(key) === resolved,
-    );
-  });
-
-/**
- * Returns `true` when the module bundled from `sourceAbsolutePath` declares a
- * direct import of `targetAbsolutePath` (according to the bundle's esbuild
- * metafile). Returns `false` if either path is missing from the metafile.
- */
-export const directlyImports = (
-  bundled: Bundled,
-  sourceAbsolutePath: string,
-  targetAbsolutePath: string,
-) =>
-  Effect.gen(function* () {
-    const path = yield* Path.Path;
-    const sourceKey = yield* findMetafileInputKey(
-      bundled.metafile,
-      sourceAbsolutePath,
-    );
-    const targetKey = yield* findMetafileInputKey(
-      bundled.metafile,
-      targetAbsolutePath,
-    );
-
-    return pipe(
-      Option.all([sourceKey, targetKey]),
-      Option.flatMap(([sourceKey_, targetKey_]) =>
-        Option.fromNullable(bundled.metafile.inputs[sourceKey_]).pipe(
-          Option.map((sourceInput) => {
-            const targetResolved = path.resolve(targetKey_);
-            return sourceInput.imports.some(
-              (importedFile) =>
-                path.resolve(importedFile.path) === targetResolved,
-            );
-          }),
-        ),
-      ),
-      Option.getOrElse(() => false),
-    );
-  });

package/src/CodeBlockWriter.ts

@@ -1,65 +0,0 @@
-import type { Options as CodeBlockWriterOptions } from "code-block-writer";
-import CodeBlockWriter_ from "code-block-writer";
-import { Effect } from "effect";
-
-export class CodeBlockWriter {
-  private readonly writer: CodeBlockWriter_;
-
-  constructor(opts?: Partial<CodeBlockWriterOptions>) {
-    this.writer = new CodeBlockWriter_(opts);
-  }
-
-  indent<E = never, R = never>(
-    effect: Effect.Effect<void, E, R>,
-  ): Effect.Effect<void, E, R> {
-    return Effect.gen(this, function* () {
-      const indentationLevel = this.writer.getIndentationLevel();
-      this.writer.setIndentationLevel(indentationLevel + 1);
-      yield* effect;
-      this.writer.setIndentationLevel(indentationLevel);
-    });
-  }
-
-  writeLine<E = never, R = never>(line: string): Effect.Effect<void, E, R> {
-    return Effect.sync(() => {
-      this.writer.writeLine(line);
-    });
-  }
-
-  write<E = never, R = never>(text: string): Effect.Effect<void, E, R> {
-    return Effect.sync(() => {
-      this.writer.write(text);
-    });
-  }
-
-  quote<E = never, R = never>(text: string): Effect.Effect<void, E, R> {
-    return Effect.sync(() => {
-      this.writer.quote(text);
-    });
-  }
-
-  conditionalWriteLine<E = never, R = never>(
-    condition: boolean,
-    text: string,
-  ): Effect.Effect<void, E, R> {
-    return Effect.sync(() => {
-      this.writer.conditionalWriteLine(condition, text);
-    });
-  }
-
-  newLine<E = never, R = never>(): Effect.Effect<void, E, R> {
-    return Effect.sync(() => {
-      this.writer.newLine();
-    });
-  }
-
-  blankLine<E = never, R = never>(): Effect.Effect<void, E, R> {
-    return Effect.sync(() => {
-      this.writer.blankLine();
-    });
-  }
-
-  toString<E = never, R = never>(): Effect.Effect<string, E, R> {
-    return Effect.sync(() => this.writer.toString());
-  }
-}