@confect/cli 1.0.0-next.0

package/src/log.ts

@@ -0,0 +1,106 @@
+import { Path } from "@effect/platform";
+import { Ansi, AnsiDoc } from "@effect/printer-ansi";
+import { Console, Effect, pipe, String } from "effect";
+import type * as FunctionPath from "./FunctionPath";
+import * as GroupPath from "./GroupPath";
+import { ProjectRoot } from "./services/ProjectRoot";
+
+// --- File operation logs ---
+
+const logFile = (char: string, color: Ansi.Ansi) => (fullPath: string) =>
+  Effect.gen(function* () {
+    const projectRoot = yield* ProjectRoot.get;
+    const path = yield* Path.Path;
+
+    const prefix = projectRoot + path.sep;
+    const suffix = pipe(fullPath, String.startsWith(prefix))
+      ? pipe(fullPath, String.slice(prefix.length))
+      : fullPath;
+
+    yield* Console.log(
+      pipe(
+        AnsiDoc.char(char),
+        AnsiDoc.annotate(color),
+        AnsiDoc.catWithSpace(
+          AnsiDoc.hcat([
+            pipe(AnsiDoc.text(prefix), AnsiDoc.annotate(Ansi.blackBright)),
+            pipe(AnsiDoc.text(suffix), AnsiDoc.annotate(color)),
+          ]),
+        ),
+        AnsiDoc.render({ style: "pretty" }),
+      ),
+    );
+  });
+
+export const logFileAdded = logFile("+", Ansi.green);
+
+export const logFileRemoved = logFile("-", Ansi.red);
+
+export const logFileModified = logFile("~", Ansi.yellow);
+
+// --- Function subline logs ---
+
+const logFunction =
+  (char: string, color: Ansi.Ansi) =>
+  (functionPath: FunctionPath.FunctionPath) =>
+    Console.log(
+      pipe(
+        AnsiDoc.text("  "),
+        AnsiDoc.cat(pipe(AnsiDoc.char(char), AnsiDoc.annotate(color))),
+        AnsiDoc.catWithSpace(
+          AnsiDoc.hcat([
+            pipe(
+              AnsiDoc.text(GroupPath.toString(functionPath.groupPath) + "."),
+              AnsiDoc.annotate(Ansi.blackBright),
+            ),
+            pipe(AnsiDoc.text(functionPath.name), AnsiDoc.annotate(color)),
+          ]),
+        ),
+        AnsiDoc.render({ style: "pretty" }),
+      ),
+    );
+
+export const logFunctionAdded = logFunction("+", Ansi.green);
+
+export const logFunctionRemoved = logFunction("-", Ansi.red);
+
+// --- Process status logs ---
+
+const logStatus =
+  (
+    char: string,
+    charColor: Ansi.Ansi,
+    messageText: string,
+    messageColor: Ansi.Ansi,
+  ) =>
+  (message: string) =>
+    Console.log(
+      pipe(
+        AnsiDoc.char(char),
+        AnsiDoc.annotate(charColor),
+        AnsiDoc.catWithSpace(
+          pipe(
+            AnsiDoc.char(" "),
+            AnsiDoc.cat(AnsiDoc.text(messageText)),
+            AnsiDoc.cat(AnsiDoc.char(" ")),
+            AnsiDoc.annotate(messageColor),
+          ),
+        ),
+        AnsiDoc.catWithSpace(AnsiDoc.text(message)),
+        AnsiDoc.render({ style: "pretty" }),
+      ),
+    );
+
+export const logCompleted = logStatus(
+  "✔︎",
+  Ansi.green,
+  "SUCCESS",
+  Ansi.combine(Ansi.green, Ansi.bgGreenBright),
+);
+
+export const logFailed = logStatus(
+  "✘",
+  Ansi.red,
+  "FAILURE",
+  Ansi.combine(Ansi.red, Ansi.bgRedBright),
+);

package/src/services/ConfectDirectory.ts

@@ -0,0 +1,41 @@
+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/services/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",
+)("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* Effect.fail(new ConfectDirectoryNotFoundError());
+  }
+});

package/src/services/ConvexDirectory.ts

@@ -0,0 +1,67 @@
+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/services/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",
+)("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* Effect.fail(new ConvexDirectoryNotFoundError());
+  }
+});

package/src/services/ProjectRoot.ts

@@ -0,0 +1,49 @@
+import { FileSystem, Path } from "@effect/platform";
+import { NodeFileSystem } from "@effect/platform-node";
+import { Array, Effect, Option, Ref, Schema } from "effect";
+
+export class ProjectRoot extends Effect.Service<ProjectRoot>()(
+  "@confect/cli/services/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",
+)("ProjectRootNotFoundError", {}) {
+  override get message(): string {
+    return "Could not find project root (no 'package.json' found)";
+  }
+}

package/src/templates.ts

@@ -0,0 +1,380 @@
+import type { Options as CodeBlockWriterOptions } from "code-block-writer";
+import CodeBlockWriter_ from "code-block-writer";
+import { Array, Effect } from "effect";
+import type * as GroupPath from "./GroupPath";
+
+export const functions = ({
+  groupPath,
+  functionNames,
+  registeredFunctionsImportPath,
+}: {
+  groupPath: GroupPath.GroupPath;
+  functionNames: string[];
+  registeredFunctionsImportPath: string;
+}) =>
+  Effect.gen(function* () {
+    const cbw = new CodeBlockWriter({ indentNumberOfSpaces: 2 });
+
+    yield* cbw.writeLine(
+      `import registeredFunctions from "${registeredFunctionsImportPath}";`,
+    );
+    yield* cbw.newLine();
+    for (const functionName of functionNames) {
+      yield* cbw.writeLine(
+        `export const ${functionName} = registeredFunctions.${Array.join([...groupPath.pathSegments, functionName], ".")};`,
+      );
+    }
+
+    return yield* cbw.toString();
+  });
+
+export const schema = ({ schemaImportPath }: { schemaImportPath: string }) =>
+  Effect.gen(function* () {
+    const cbw = new CodeBlockWriter({ indentNumberOfSpaces: 2 });
+
+    yield* cbw.writeLine(`import schemaDefinition from "${schemaImportPath}";`);
+    yield* cbw.newLine();
+    yield* cbw.writeLine(
+      `export default schemaDefinition.convexSchemaDefinition;`,
+    );
+
+    return yield* cbw.toString();
+  });
+
+export const http = ({ httpImportPath }: { httpImportPath: string }) =>
+  Effect.gen(function* () {
+    const cbw = new CodeBlockWriter({ indentNumberOfSpaces: 2 });
+
+    yield* cbw.writeLine(`import http from "${httpImportPath}";`);
+    yield* cbw.newLine();
+    yield* cbw.writeLine(`export default http;`);
+
+    return yield* cbw.toString();
+  });
+
+export const convexConfig = ({ appImportPath }: { appImportPath: string }) =>
+  Effect.gen(function* () {
+    const cbw = new CodeBlockWriter({ indentNumberOfSpaces: 2 });
+
+    yield* cbw.writeLine(`import app from "${appImportPath}";`);
+    yield* cbw.newLine();
+    yield* cbw.writeLine(`export default app;`);
+
+    return yield* cbw.toString();
+  });
+
+export const crons = ({ cronsImportPath }: { cronsImportPath: string }) =>
+  Effect.gen(function* () {
+    const cbw = new CodeBlockWriter({ indentNumberOfSpaces: 2 });
+
+    yield* cbw.writeLine(`import crons from "${cronsImportPath}";`);
+    yield* cbw.newLine();
+    yield* cbw.writeLine(`export default crons;`);
+
+    return yield* cbw.toString();
+  });
+
+export const authConfig = ({ authImportPath }: { authImportPath: string }) =>
+  Effect.gen(function* () {
+    const cbw = new CodeBlockWriter({ indentNumberOfSpaces: 2 });
+
+    yield* cbw.writeLine(`import auth from "${authImportPath}";`);
+    yield* cbw.newLine();
+    yield* cbw.writeLine(`export default auth;`);
+
+    return yield* cbw.toString();
+  });
+
+export const refs = ({ specImportPath }: { specImportPath: string }) =>
+  Effect.gen(function* () {
+    const cbw = new CodeBlockWriter({ indentNumberOfSpaces: 2 });
+
+    yield* cbw.writeLine(`import { Refs } from "@confect/core";`);
+    yield* cbw.writeLine(`import spec from "${specImportPath}";`);
+    yield* cbw.blankLine();
+    yield* cbw.writeLine(
+      `export const { public: api, internal } = Refs.make(spec);`,
+    );
+
+    return yield* cbw.toString();
+  });
+
+export const api = ({
+  schemaImportPath,
+  specImportPath,
+}: {
+  schemaImportPath: string;
+  specImportPath: string;
+}) =>
+  Effect.gen(function* () {
+    const cbw = new CodeBlockWriter({ indentNumberOfSpaces: 2 });
+
+    yield* cbw.writeLine(`import { Api } from "@confect/server";`);
+    yield* cbw.writeLine(`import schema from "${schemaImportPath}";`);
+    yield* cbw.writeLine(`import spec from "${specImportPath}";`);
+    yield* cbw.blankLine();
+    yield* cbw.writeLine(`export default Api.make(schema, spec);`);
+
+    return yield* cbw.toString();
+  });
+
+export const registeredFunctions = ({
+  implImportPath,
+}: {
+  implImportPath: string;
+}) =>
+  Effect.gen(function* () {
+    const cbw = new CodeBlockWriter({ indentNumberOfSpaces: 2 });
+
+    yield* cbw.writeLine(
+      `import { RegisteredFunctions } from "@confect/server";`,
+    );
+    yield* cbw.writeLine(`import impl from "${implImportPath}";`);
+    yield* cbw.blankLine();
+    yield* cbw.writeLine(`export default RegisteredFunctions.make(impl);`);
+
+    return yield* cbw.toString();
+  });
+
+export const services = ({ schemaImportPath }: { schemaImportPath: string }) =>
+  Effect.gen(function* () {
+    const cbw = new CodeBlockWriter({ indentNumberOfSpaces: 2 });
+
+    // Imports
+    yield* cbw.writeLine("import {");
+    yield* cbw.indent(
+      Effect.gen(function* () {
+        yield* cbw.writeLine("ActionCtx as ActionCtx_,");
+        yield* cbw.writeLine("ActionRunner as ActionRunner_,");
+        yield* cbw.writeLine("Auth as Auth_,");
+        yield* cbw.writeLine("type DataModel,");
+        yield* cbw.writeLine("DatabaseReader as DatabaseReader_,");
+        yield* cbw.writeLine("DatabaseWriter as DatabaseWriter_,");
+        yield* cbw.writeLine("MutationCtx as MutationCtx_,");
+        yield* cbw.writeLine("MutationRunner as MutationRunner_,");
+        yield* cbw.writeLine("QueryCtx as QueryCtx_,");
+        yield* cbw.writeLine("QueryRunner as QueryRunner_,");
+        yield* cbw.writeLine("Scheduler as Scheduler_,");
+        yield* cbw.writeLine("Storage,");
+        yield* cbw.writeLine("VectorSearch as VectorSearch_,");
+      }),
+    );
+    yield* cbw.writeLine(`} from "@confect/server";`);
+    yield* cbw.writeLine(
+      `import type schemaDefinition from "${schemaImportPath}";`,
+    );
+    yield* cbw.blankLine();
+
+    // Auth
+    yield* cbw.writeLine("export const Auth = Auth_.Auth;");
+    yield* cbw.writeLine("export type Auth = typeof Auth.Identifier;");
+    yield* cbw.blankLine();
+
+    // Scheduler
+    yield* cbw.writeLine("export const Scheduler = Scheduler_.Scheduler;");
+    yield* cbw.writeLine(
+      "export type Scheduler = typeof Scheduler.Identifier;",
+    );
+    yield* cbw.blankLine();
+
+    // StorageReader
+    yield* cbw.writeLine("export const StorageReader = Storage.StorageReader;");
+    yield* cbw.writeLine(
+      "export type StorageReader = typeof StorageReader.Identifier;",
+    );
+    yield* cbw.blankLine();
+
+    // StorageWriter
+    yield* cbw.writeLine("export const StorageWriter = Storage.StorageWriter;");
+    yield* cbw.writeLine(
+      "export type StorageWriter = typeof StorageWriter.Identifier;",
+    );
+    yield* cbw.blankLine();
+
+    // StorageActionWriter
+    yield* cbw.writeLine(
+      "export const StorageActionWriter = Storage.StorageActionWriter;",
+    );
+    yield* cbw.writeLine(
+      "export type StorageActionWriter = typeof StorageActionWriter.Identifier;",
+    );
+    yield* cbw.blankLine();
+
+    // VectorSearch
+    yield* cbw.writeLine("export const VectorSearch =");
+    yield* cbw.indent(
+      cbw.writeLine(
+        "VectorSearch_.VectorSearch<DataModel.FromSchema<typeof schemaDefinition>>();",
+      ),
+    );
+    yield* cbw.writeLine(
+      "export type VectorSearch = typeof VectorSearch.Identifier;",
+    );
+    yield* cbw.blankLine();
+
+    // DatabaseReader
+    yield* cbw.writeLine("export const DatabaseReader =");
+    yield* cbw.indent(
+      cbw.writeLine(
+        "DatabaseReader_.DatabaseReader<typeof schemaDefinition>();",
+      ),
+    );
+    yield* cbw.writeLine(
+      "export type DatabaseReader = typeof DatabaseReader.Identifier;",
+    );
+    yield* cbw.blankLine();
+
+    // DatabaseWriter
+    yield* cbw.writeLine("export const DatabaseWriter =");
+    yield* cbw.indent(
+      cbw.writeLine(
+        "DatabaseWriter_.DatabaseWriter<typeof schemaDefinition>();",
+      ),
+    );
+    yield* cbw.writeLine(
+      "export type DatabaseWriter = typeof DatabaseWriter.Identifier;",
+    );
+    yield* cbw.blankLine();
+
+    // QueryRunner
+    yield* cbw.writeLine(
+      "export const QueryRunner = QueryRunner_.QueryRunner;",
+    );
+    yield* cbw.writeLine(
+      "export type QueryRunner = typeof QueryRunner.Identifier;",
+    );
+    yield* cbw.blankLine();
+
+    // MutationRunner
+    yield* cbw.writeLine(
+      "export const MutationRunner = MutationRunner_.MutationRunner;",
+    );
+    yield* cbw.writeLine(
+      "export type MutationRunner = typeof MutationRunner.Identifier;",
+    );
+    yield* cbw.blankLine();
+
+    // ActionRunner
+    yield* cbw.writeLine(
+      "export const ActionRunner = ActionRunner_.ActionRunner;",
+    );
+    yield* cbw.writeLine(
+      "export type ActionRunner = typeof ActionRunner.Identifier;",
+    );
+    yield* cbw.blankLine();
+
+    // QueryCtx
+    yield* cbw.writeLine("export const QueryCtx =");
+    yield* cbw.indent(
+      Effect.gen(function* () {
+        yield* cbw.writeLine("QueryCtx_.QueryCtx<");
+        yield* cbw.indent(
+          cbw.writeLine(
+            "DataModel.ToConvex<DataModel.FromSchema<typeof schemaDefinition>>",
+          ),
+        );
+        yield* cbw.writeLine(">();");
+      }),
+    );
+    yield* cbw.writeLine("export type QueryCtx = typeof QueryCtx.Identifier;");
+    yield* cbw.blankLine();
+
+    // MutationCtx
+    yield* cbw.writeLine("export const MutationCtx =");
+    yield* cbw.indent(
+      Effect.gen(function* () {
+        yield* cbw.writeLine("MutationCtx_.MutationCtx<");
+        yield* cbw.indent(
+          cbw.writeLine(
+            "DataModel.ToConvex<DataModel.FromSchema<typeof schemaDefinition>>",
+          ),
+        );
+        yield* cbw.writeLine(">();");
+      }),
+    );
+    yield* cbw.writeLine(
+      "export type MutationCtx = typeof MutationCtx.Identifier;",
+    );
+    yield* cbw.blankLine();
+
+    // ActionCtx
+    yield* cbw.writeLine("export const ActionCtx =");
+    yield* cbw.indent(
+      Effect.gen(function* () {
+        yield* cbw.writeLine("ActionCtx_.ActionCtx<");
+        yield* cbw.indent(
+          cbw.writeLine(
+            "DataModel.ToConvex<DataModel.FromSchema<typeof schemaDefinition>>",
+          ),
+        );
+        yield* cbw.writeLine(">();");
+      }),
+    );
+    yield* cbw.writeLine(
+      "export type ActionCtx = typeof ActionCtx.Identifier;",
+    );
+
+    return yield* cbw.toString();
+  });
+
+class CodeBlockWriter {
+  private readonly writer: CodeBlockWriter_;
+
+  constructor(opts?: Partial<CodeBlockWriterOptions>) {
+    this.writer = new CodeBlockWriter_(opts);
+  }
+
+  indent<E = never, R = never>(
+    eff: 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* eff;
+      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());
+  }
+}