@confect/cli 9.0.0-next.9 → 9.0.1

package/src/utils.ts

@@ -1,435 +0,0 @@
-import type { FunctionSpec, Spec } from "@confect/core";
-import * as FileSystem from "@effect/platform/FileSystem";
-import * as Path from "@effect/platform/Path";
-import type { PlatformError } from "@effect/platform/Error";
-import { pipe } from "effect/Function";
-import * as Array from "effect/Array";
-import * as Context from "effect/Context";
-import * as Effect from "effect/Effect";
-import * as HashSet from "effect/HashSet";
-import * as Option from "effect/Option";
-import * as Order from "effect/Order";
-import * as Record from "effect/Record";
-import * as Ref from "effect/Ref";
-import * as String from "effect/String";
-import * as FunctionPaths from "./FunctionPaths";
-import * as GroupPath from "./GroupPath";
-import * as GroupPaths from "./GroupPaths";
-import { logFileAdded, logFileModified, logFileRemoved } from "./log";
-import { ConfectDirectory } from "./ConfectDirectory";
-import { ConvexDirectory } from "./ConvexDirectory";
-import * as templates from "./templates";
-
-/**
- * Tracks whether the current codegen run wrote anything to disk. Set to
- * `true` by every helper that actually overwrites a file (skipping the
- * content-unchanged case). `codegenHandler` provides a fresh `Ref` per
- * run and reads it back to report `anyWritesHappened`; callers outside a
- * codegen pass hit the cached default `Ref` and need not interact with
- * the tracker.
- */
-export class WriteTracker extends Context.Reference<WriteTracker>()(
-  "@confect/cli/WriteTracker",
-  { defaultValue: () => Ref.unsafeMake(false) },
-) {}
-
-const markWritten = Effect.gen(function* () {
-  const tracker = yield* WriteTracker;
-  yield* Ref.set(tracker, true);
-});
-
-export const removePathExtension = (pathStr: string) =>
-  Effect.gen(function* () {
-    const path = yield* Path.Path;
-
-    return String.slice(0, -path.extname(pathStr).length)(pathStr);
-  });
-
-/** Ensures a relative path is a valid ESM/TS module specifier (e.g. `spec` → `./spec`). */
-export const toModuleImportPath = (relativePath: string) =>
-  Effect.gen(function* () {
-    const withoutExt = yield* removePathExtension(relativePath);
-    return withoutExt.startsWith(".") ? withoutExt : `./${withoutExt}`;
-  });
-
-export const writeFileStringAndLog = (filePath: string, contents: string) =>
-  Effect.gen(function* () {
-    const fs = yield* FileSystem.FileSystem;
-    if (!(yield* fs.exists(filePath))) {
-      yield* fs.writeFileString(filePath, contents);
-      yield* markWritten;
-      yield* logFileAdded(filePath);
-      return;
-    }
-    const existing = yield* fs.readFileString(filePath);
-    if (existing !== contents) {
-      yield* fs.writeFileString(filePath, contents);
-      yield* markWritten;
-      yield* logFileModified(filePath);
-    }
-  });
-
-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 Option.getOrElse(projectRoot, () => startDir);
-});
-
-export type WriteChange = "Added" | "Modified" | "Unchanged";
-
-export const writeFileString = (
-  filePath: string,
-  contents: string,
-): Effect.Effect<WriteChange, PlatformError, FileSystem.FileSystem> =>
-  Effect.gen(function* () {
-    const fs = yield* FileSystem.FileSystem;
-
-    if (!(yield* fs.exists(filePath))) {
-      yield* fs.writeFileString(filePath, contents);
-      yield* markWritten;
-      return "Added";
-    }
-    const existing = yield* fs.readFileString(filePath);
-    if (existing !== contents) {
-      yield* fs.writeFileString(filePath, contents);
-      yield* markWritten;
-      return "Modified";
-    }
-    return "Unchanged";
-  });
-
-export const removePathIfExists = (
-  filePath: string,
-): Effect.Effect<void, PlatformError, FileSystem.FileSystem> =>
-  Effect.gen(function* () {
-    const fs = yield* FileSystem.FileSystem;
-
-    if (!(yield* fs.exists(filePath))) {
-      return;
-    }
-
-    yield* fs
-      .remove(filePath)
-      .pipe(
-        Effect.catchTag("SystemError", (error) =>
-          error.reason === "NotFound" ? Effect.void : Effect.fail(error),
-        ),
-      );
-  });
-
-/**
- * Bump the mtime of `convex/schema.ts` so the Convex CLI's chokidar watcher
- * emits a `change` event after every successful Confect codegen run. Without
- * this, a codegen that doesn't change any file content (for example,
- * recovering from a transient broken state in `confect/`) leaves Convex
- * stuck on its previous error because nothing it observes has changed.
- */
-export const touchConvexSchema = Effect.gen(function* () {
-  const fs = yield* FileSystem.FileSystem;
-  const path = yield* Path.Path;
-  const convexDirectory = yield* ConvexDirectory.get;
-  const schemaPath = path.join(convexDirectory, "schema.ts");
-
-  if (!(yield* fs.exists(schemaPath))) {
-    return;
-  }
-
-  const now = new Date();
-  yield* fs.utimes(schemaPath, now, now);
-});
-
-export const generateGroupModule = ({
-  groupPath,
-  functionNames,
-  registeredFunctionsImportPath,
-  useNode = false,
-}: {
-  groupPath: GroupPath.GroupPath;
-  functionNames: string[];
-  registeredFunctionsImportPath: string;
-  useNode?: boolean;
-}) =>
-  Effect.gen(function* () {
-    const fs = yield* FileSystem.FileSystem;
-    const path = yield* Path.Path;
-    const convexDirectory = yield* ConvexDirectory.get;
-
-    const relativeModulePath = yield* GroupPath.modulePath(groupPath);
-    const modulePath = path.join(convexDirectory, relativeModulePath);
-
-    const directoryPath = path.dirname(modulePath);
-    if (!(yield* fs.exists(directoryPath))) {
-      yield* fs.makeDirectory(directoryPath, { recursive: true });
-    }
-
-    const functionsContentsString = yield* templates.functions({
-      functionNames,
-      registeredFunctionsImportPath,
-      useNode,
-    });
-
-    if (!(yield* fs.exists(modulePath))) {
-      yield* fs.writeFileString(modulePath, functionsContentsString);
-      yield* markWritten;
-      return "Added" as const;
-    }
-    const existing = yield* fs.readFileString(modulePath);
-    if (existing !== functionsContentsString) {
-      yield* fs.writeFileString(modulePath, functionsContentsString);
-      yield* markWritten;
-      return "Modified" as const;
-    }
-    return "Unchanged" as const;
-  });
-
-/**
- * Compute the module import specifier (relative to `modulePath`) for a group's
- * registry file under `confect/_generated/registeredFunctions/`. The registry
- * path mirrors the group's path one-to-one (see `registeredFunctionsRelativePath`
- * in `LeafModule.ts`) for both Convex and Node groups. Centralizing this here
- * keeps the "overlapping" and "new" group branches of `generateFunctions` from
- * drifting apart.
- */
-const registeredFunctionsImportPathForGroup = (
-  groupPath: GroupPath.GroupPath,
-  modulePath: string,
-) =>
-  Effect.gen(function* () {
-    const path = yield* Path.Path;
-    const confectDirectory = yield* ConfectDirectory.get;
-
-    const registeredFunctionsPath =
-      path.join(
-        confectDirectory,
-        "_generated",
-        "registeredFunctions",
-        ...groupPath.pathSegments,
-      ) + ".ts";
-
-    return yield* toModuleImportPath(
-      path.relative(path.dirname(modulePath), registeredFunctionsPath),
-    );
-  });
-
-const logGroupPaths = <R>(
-  groupPaths: GroupPaths.GroupPaths,
-  logFn: (fullPath: string) => Effect.Effect<void, never, R>,
-) =>
-  Effect.gen(function* () {
-    const path = yield* Path.Path;
-    const convexDirectory = yield* ConvexDirectory.get;
-
-    yield* Effect.forEach(groupPaths, (gp) =>
-      Effect.gen(function* () {
-        const relativeModulePath = yield* GroupPath.modulePath(gp);
-        yield* logFn(path.join(convexDirectory, relativeModulePath));
-      }),
-    );
-  });
-
-export const generateFunctions = (spec: Spec.AnyWithProps) =>
-  Effect.gen(function* () {
-    const path = yield* Path.Path;
-    const convexDirectory = yield* ConvexDirectory.get;
-
-    const groupPathsFromFs = yield* getGroupPathsFromFs;
-    const functionPaths = FunctionPaths.make(spec);
-    const groupPathsFromSpec = FunctionPaths.groupPaths(functionPaths);
-
-    const overlappingGroupPaths = GroupPaths.GroupPaths.make(
-      HashSet.intersection(groupPathsFromFs, groupPathsFromSpec),
-    );
-    yield* Effect.forEach(overlappingGroupPaths, (groupPath) =>
-      Effect.gen(function* () {
-        const group = yield* GroupPath.getGroupSpec(spec, groupPath);
-        const functionNames = pipe(
-          group.functions,
-          Record.values,
-          Array.sortBy(
-            Order.mapInput(
-              Order.string,
-              (fn: FunctionSpec.AnyWithProps) => fn.name,
-            ),
-          ),
-          Array.map((fn) => fn.name),
-        );
-        const relativeModulePath = yield* GroupPath.modulePath(groupPath);
-        const modulePath = path.join(convexDirectory, relativeModulePath);
-        const registeredFunctionsImportPath =
-          yield* registeredFunctionsImportPathForGroup(groupPath, modulePath);
-        const result = yield* generateGroupModule({
-          groupPath,
-          functionNames,
-          registeredFunctionsImportPath,
-          useNode: group.runtime === "Node",
-        });
-        if (result === "Modified") {
-          yield* logFileModified(modulePath);
-        }
-      }),
-    );
-
-    const extinctGroupPaths = GroupPaths.GroupPaths.make(
-      HashSet.difference(groupPathsFromFs, groupPathsFromSpec),
-    );
-    yield* removeGroups(extinctGroupPaths);
-    yield* logGroupPaths(extinctGroupPaths, logFileRemoved);
-
-    const newGroupPaths = GroupPaths.GroupPaths.make(
-      HashSet.difference(groupPathsFromSpec, groupPathsFromFs),
-    );
-    yield* writeGroups(spec, newGroupPaths);
-    yield* logGroupPaths(newGroupPaths, logFileAdded);
-
-    return functionPaths;
-  });
-
-const getGroupPathsFromFs = Effect.gen(function* () {
-  const fs = yield* FileSystem.FileSystem;
-  const path = yield* Path.Path;
-  const convexDirectory = yield* ConvexDirectory.get;
-
-  const RESERVED_CONVEX_TS_FILE_NAMES = new Set([
-    "schema.ts",
-    "http.ts",
-    "crons.ts",
-    "auth.config.ts",
-    "convex.config.ts",
-  ]);
-
-  const allConvexPaths = yield* fs.readDirectory(convexDirectory, {
-    recursive: true,
-  });
-  const groupPathArray = yield* pipe(
-    allConvexPaths,
-    Array.filter(
-      (convexPath) =>
-        path.extname(convexPath) === ".ts" &&
-        !RESERVED_CONVEX_TS_FILE_NAMES.has(path.basename(convexPath)) &&
-        path.basename(path.dirname(convexPath)) !== "_generated",
-    ),
-    Effect.forEach((groupModulePath) =>
-      GroupPath.fromGroupModulePath(groupModulePath),
-    ),
-  );
-  return pipe(groupPathArray, HashSet.fromIterable, GroupPaths.GroupPaths.make);
-});
-
-export const removeGroups = (groupPaths: GroupPaths.GroupPaths) =>
-  Effect.gen(function* () {
-    const path = yield* Path.Path;
-    const convexDirectory = yield* ConvexDirectory.get;
-
-    yield* Effect.all(
-      HashSet.map(groupPaths, (groupPath) =>
-        Effect.gen(function* () {
-          const relativeModulePath = yield* GroupPath.modulePath(groupPath);
-          const modulePath = path.join(convexDirectory, relativeModulePath);
-
-          yield* Effect.logDebug(`Removing group '${relativeModulePath}'...`);
-
-          yield* removePathIfExists(modulePath);
-          yield* Effect.logDebug(`Group '${relativeModulePath}' removed`);
-        }),
-      ),
-      { concurrency: "unbounded" },
-    );
-  });
-
-export const writeGroups = (
-  spec: Spec.AnyWithProps,
-  groupPaths: GroupPaths.GroupPaths,
-) =>
-  Effect.forEach(groupPaths, (groupPath) =>
-    Effect.gen(function* () {
-      const path = yield* Path.Path;
-      const convexDirectory = yield* ConvexDirectory.get;
-      const group = yield* GroupPath.getGroupSpec(spec, groupPath);
-
-      const functionNames = pipe(
-        group.functions,
-        Record.values,
-        Array.sortBy(
-          Order.mapInput(
-            Order.string,
-            (fn: FunctionSpec.AnyWithProps) => fn.name,
-          ),
-        ),
-        Array.map((fn) => fn.name),
-      );
-
-      const relativeModulePath = yield* GroupPath.modulePath(groupPath);
-      const modulePath = path.join(convexDirectory, relativeModulePath);
-      const registeredFunctionsImportPath =
-        yield* registeredFunctionsImportPathForGroup(groupPath, modulePath);
-
-      yield* Effect.logDebug(`Generating group ${groupPath}...`);
-      yield* generateGroupModule({
-        groupPath,
-        functionNames,
-        registeredFunctionsImportPath,
-        useNode: group.runtime === "Node",
-      });
-      yield* Effect.logDebug(`Group ${groupPath} generated`);
-    }),
-  );
-
-const generateOptionalFile = (
-  confectFile: string,
-  convexFile: string,
-  generateContents: (importPath: string) => Effect.Effect<string>,
-) =>
-  Effect.gen(function* () {
-    const fs = yield* FileSystem.FileSystem;
-    const path = yield* Path.Path;
-    const confectDirectory = yield* ConfectDirectory.get;
-    const convexDirectory = yield* ConvexDirectory.get;
-
-    const confectFilePath = path.join(confectDirectory, confectFile);
-
-    if (!(yield* fs.exists(confectFilePath))) {
-      return Option.none();
-    }
-
-    const convexFilePath = path.join(convexDirectory, convexFile);
-    const relativeImportPath = path.relative(
-      path.dirname(convexFilePath),
-      confectFilePath,
-    );
-    const importPathWithoutExt = yield* removePathExtension(relativeImportPath);
-    const contents = yield* generateContents(importPathWithoutExt);
-    const change = yield* writeFileString(convexFilePath, contents);
-    return Option.some({ change, convexFilePath });
-  });
-
-export const generateHttp = generateOptionalFile(
-  "http.ts",
-  "http.ts",
-  (importPath) => templates.http({ httpImportPath: importPath }),
-);
-
-export const generateCrons = generateOptionalFile(
-  "crons.ts",
-  "crons.ts",
-  (importPath) => templates.crons({ cronsImportPath: importPath }),
-);
-
-export const generateAuthConfig = generateOptionalFile(
-  "auth.ts",
-  "auth.config.ts",
-  (importPath) => templates.authConfig({ authImportPath: importPath }),
-);