@confect/cli 1.0.0-next.0

package/src/GroupPath.ts

@@ -0,0 +1,117 @@
+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* Effect.fail(
+        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",
+)("GroupModulePathIsNotATypeScriptFileError", {
+  path: Schema.NonEmptyString,
+}) {
+  override get message(): string {
+    return `Expected group module path to end with .ts, got ${this.path}`;
+  }
+}

package/src/GroupPaths.ts

@@ -0,0 +1,7 @@
+import { Schema } from "effect";
+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/cliApp.ts

@@ -0,0 +1,8 @@
+import { Command } from "@effect/cli";
+import packageJson from "../package.json" with { type: "json" };
+import { confect } from "./confect";
+
+export const cliApp = Command.run(confect, {
+  name: "Confect",
+  version: packageJson.version,
+});

package/src/confect/codegen.ts

@@ -0,0 +1,228 @@
+import { Spec } from "@confect/core";
+import { DatabaseSchema } from "@confect/server";
+import { Command } from "@effect/cli";
+import { FileSystem, Path } from "@effect/platform";
+import { Effect, Match, Option } from "effect";
+import * as tsx from "tsx/esm/api";
+import { logCompleted, logFileAdded, logFileModified } from "../log";
+import { ConfectDirectory } from "../services/ConfectDirectory";
+import { ConvexDirectory } from "../services/ConvexDirectory";
+import * as templates from "../templates";
+import {
+  generateAuthConfig,
+  generateConvexConfig,
+  generateCrons,
+  generateFunctions,
+  generateHttp,
+  removePathExtension,
+  writeFileStringAndLog,
+} from "../utils";
+
+export const codegen = Command.make("codegen", {}, () =>
+  Effect.gen(function* () {
+    yield* codegenHandler;
+    yield* logCompleted("Generated files are up-to-date");
+  }),
+).pipe(
+  Command.withDescription(
+    "Generate `confect/_generated` files and the contents of the `convex` directory (except `tsconfig.json`)",
+  ),
+);
+
+export const codegenHandler = Effect.gen(function* () {
+  yield* generateConfectGeneratedDirectory;
+  yield* Effect.all(
+    [generateApi, generateRefs, generateRegisteredFunctions, generateServices],
+    { concurrency: "unbounded" },
+  );
+  const [functionPaths] = yield* Effect.all(
+    [
+      generateFunctionModules,
+      generateSchema,
+      logGenerated(generateHttp),
+      logGenerated(generateConvexConfig),
+      logGenerated(generateCrons),
+      logGenerated(generateAuthConfig),
+    ],
+    { concurrency: "unbounded" },
+  );
+  return functionPaths;
+});
+
+const generateConfectGeneratedDirectory = Effect.gen(function* () {
+  const fs = yield* FileSystem.FileSystem;
+  const path = yield* Path.Path;
+  const confectDirectory = yield* ConfectDirectory.get;
+
+  if (!(yield* fs.exists(path.join(confectDirectory, "_generated")))) {
+    yield* fs.makeDirectory(path.join(confectDirectory, "_generated"), {
+      recursive: true,
+    });
+    yield* logFileAdded(path.join(confectDirectory, "_generated") + "/");
+  }
+});
+
+const generateApi = Effect.gen(function* () {
+  const path = yield* Path.Path;
+  const confectDirectory = yield* ConfectDirectory.get;
+
+  const apiPath = path.join(confectDirectory, "_generated", "api.ts");
+
+  const schemaImportPath = yield* removePathExtension(
+    path.relative(
+      path.dirname(apiPath),
+      path.join(confectDirectory, "schema.ts"),
+    ),
+  );
+
+  const specImportPath = yield* removePathExtension(
+    path.relative(
+      path.dirname(apiPath),
+      path.join(confectDirectory, "spec.ts"),
+    ),
+  );
+
+  const apiContents = yield* templates.api({
+    schemaImportPath,
+    specImportPath,
+  });
+
+  yield* writeFileStringAndLog(apiPath, apiContents);
+});
+
+const generateFunctionModules = Effect.gen(function* () {
+  const path = yield* Path.Path;
+  const confectDirectory = yield* ConfectDirectory.get;
+
+  const specPath = path.join(confectDirectory, "spec.ts");
+  const specPathUrl = yield* path.toFileUrl(specPath);
+
+  const specModule = yield* Effect.promise(() =>
+    tsx.tsImport(specPathUrl.href, import.meta.url),
+  );
+  const spec = specModule.default;
+
+  if (!Spec.isSpec(spec)) {
+    return yield* Effect.die("spec.ts does not export a valid Spec");
+  }
+
+  return yield* generateFunctions(spec);
+});
+
+const generateSchema = Effect.gen(function* () {
+  const path = yield* Path.Path;
+  const confectDirectory = yield* ConfectDirectory.get;
+  const convexDirectory = yield* ConvexDirectory.get;
+
+  const confectSchemaPath = path.join(confectDirectory, "schema.ts");
+  const confectSchemaUrl = yield* path.toFileUrl(confectSchemaPath);
+
+  yield* Effect.promise(() =>
+    tsx.tsImport(confectSchemaUrl.href, import.meta.url),
+  ).pipe(
+    Effect.andThen((schemaModule) => {
+      const defaultExport = schemaModule.default;
+
+      return DatabaseSchema.isSchema(defaultExport)
+        ? Effect.succeed(defaultExport)
+        : Effect.die("Invalid schema module");
+    }),
+  );
+
+  const convexSchemaPath = path.join(convexDirectory, "schema.ts");
+
+  const relativeImportPath = path.relative(
+    path.dirname(convexSchemaPath),
+    confectSchemaPath,
+  );
+  const importPathWithoutExt = yield* removePathExtension(relativeImportPath);
+  const schemaContents = yield* templates.schema({
+    schemaImportPath: importPathWithoutExt,
+  });
+
+  yield* writeFileStringAndLog(convexSchemaPath, schemaContents);
+});
+
+const generateServices = Effect.gen(function* () {
+  const path = yield* Path.Path;
+  const confectDirectory = yield* ConfectDirectory.get;
+
+  const confectGeneratedDirectory = path.join(confectDirectory, "_generated");
+
+  const servicesPath = path.join(confectGeneratedDirectory, "services.ts");
+  const schemaImportPath = path.relative(
+    path.dirname(servicesPath),
+    path.join(confectDirectory, "schema"),
+  );
+
+  const servicesContentsString = yield* templates.services({
+    schemaImportPath,
+  });
+
+  yield* writeFileStringAndLog(servicesPath, servicesContentsString);
+});
+
+const generateRegisteredFunctions = Effect.gen(function* () {
+  const path = yield* Path.Path;
+  const confectDirectory = yield* ConfectDirectory.get;
+
+  const confectGeneratedDirectory = path.join(confectDirectory, "_generated");
+
+  const registeredFunctionsPath = path.join(
+    confectGeneratedDirectory,
+    "registeredFunctions.ts",
+  );
+  const implImportPath = yield* removePathExtension(
+    path.relative(
+      path.dirname(registeredFunctionsPath),
+      path.join(confectDirectory, "impl.ts"),
+    ),
+  );
+
+  const registeredFunctionsContents = yield* templates.registeredFunctions({
+    implImportPath,
+  });
+
+  yield* writeFileStringAndLog(
+    registeredFunctionsPath,
+    registeredFunctionsContents,
+  );
+});
+
+const generateRefs = Effect.gen(function* () {
+  const path = yield* Path.Path;
+  const confectDirectory = yield* ConfectDirectory.get;
+
+  const confectGeneratedDirectory = path.join(confectDirectory, "_generated");
+
+  const confectSpecPath = path.join(confectDirectory, "spec.ts");
+  const refsPath = path.join(confectGeneratedDirectory, "refs.ts");
+
+  const relativeImportPath = path.relative(
+    path.dirname(refsPath),
+    confectSpecPath,
+  );
+  const importPathWithoutExt = yield* removePathExtension(relativeImportPath);
+
+  const refsContents = yield* templates.refs({
+    specImportPath: importPathWithoutExt,
+  });
+
+  yield* writeFileStringAndLog(refsPath, refsContents);
+});
+
+const logGenerated = (effect: typeof generateHttp) =>
+  effect.pipe(
+    Effect.tap(
+      Option.match({
+        onNone: () => Effect.void,
+        onSome: ({ change, convexFilePath }) =>
+          Match.value(change).pipe(
+            Match.when("Added", () => logFileAdded(convexFilePath)),
+            Match.when("Modified", () => logFileModified(convexFilePath)),
+            Match.when("Unchanged", () => Effect.void),
+            Match.exhaustive,
+          ),
+      }),
+    ),
+  );