ignotum 0.0.0 → 0.0.2

package/src/cli/command.ts

@@ -0,0 +1,155 @@
+import { NodeRuntime, NodeServices } from "@effect/platform-node";
+import { Effect, Path, Schema, Terminal } from "effect";
+import { Argument, CliError, Command, Flag } from "effect/unstable/cli";
+
+import packageJson from "../../package.json" with { type: "json" };
+import { generate } from "./codegen.js";
+import { resetDevDatabase } from "../dev-runtime/dev-database.js";
+import { dev as runDev } from "./dev.js";
+import { createProject } from "./new-project.js";
+import { installDependencies } from "./package-manager.js";
+
+const DevPort = Schema.Int.check(Schema.isBetween({ minimum: 1, maximum: 65_535 }));
+
+const codegen = Command.make(
+  "codegen",
+  {},
+  Effect.fn("codegen")(function* () {
+    const path = yield* Path.Path;
+    const terminal = yield* Terminal.Terminal;
+    const result = yield* generate(path.resolve(".")).pipe(
+      Effect.mapError((error) =>
+        CliError.UserError.make({ cause: error, userMessage: error.message }),
+      ),
+    );
+
+    yield* terminal.display(
+      `Generated ${result.written.length} file${result.written.length === 1 ? "" : "s"}; ${result.unchanged.length} unchanged.\n`,
+    );
+  }),
+);
+
+const resetDevDatabaseCommand = Command.make(
+  "reset",
+  {},
+  Effect.fn("dev db reset")(function* () {
+    const path = yield* Path.Path;
+    const terminal = yield* Terminal.Terminal;
+    const result = yield* resetDevDatabase(path.resolve(".")).pipe(
+      Effect.mapError((error) =>
+        CliError.UserError.make({ cause: error, userMessage: error.message }),
+      ),
+    );
+    const message =
+      result.removed === 0
+        ? `Development database is already empty: ${result.databasePath}\n`
+        : `Reset development database: ${result.databasePath}\n`;
+    yield* terminal.display(message);
+  }),
+).pipe(Command.withDescription("Delete the local SQLite development database."));
+
+const devDatabase = Command.make("db").pipe(
+  Command.withDescription("Manage the local development database."),
+  Command.withSubcommands([resetDevDatabaseCommand]),
+);
+
+const dev = Command.make(
+  "dev",
+  {
+    host: Flag.string("host").pipe(Flag.withDefault("127.0.0.1")),
+    open: Flag.boolean("open").pipe(Flag.withDefault(false)),
+    port: Flag.integer("port").pipe(Flag.withSchema(DevPort), Flag.withDefault(3210)),
+  },
+  Effect.fn("dev")(function* ({ host, open, port }) {
+    const path = yield* Path.Path;
+
+    return yield* runDev({
+      host,
+      open,
+      port,
+      projectDirectory: path.resolve("."),
+    }).pipe(
+      Effect.mapError((error) =>
+        CliError.UserError.make({ cause: error, userMessage: error.message }),
+      ),
+    );
+  }),
+).pipe(
+  Command.withDescription("Run the local Ignotum development server."),
+  Command.withSubcommands([devDatabase]),
+);
+
+const install = Command.make(
+  "install",
+  {},
+  Effect.fn("install")(function* () {
+    const path = yield* Path.Path;
+    const terminal = yield* Terminal.Terminal;
+    const packageManager = yield* installDependencies(path.resolve(".")).pipe(
+      Effect.mapError((error) =>
+        CliError.UserError.make({ cause: error, userMessage: error.message }),
+      ),
+    );
+
+    yield* terminal.display(`Installed dependencies with ${packageManager}.\n`);
+  }),
+).pipe(Command.withDescription("Install dependencies with pnpm, or npm when pnpm is unavailable."));
+
+const newProject = Command.make(
+  "new",
+  {
+    directory: Argument.string("directory").pipe(
+      Argument.withDescription('Directory to create. Use "." for the current directory.'),
+    ),
+    git: Flag.boolean("git").pipe(
+      Flag.withDescription("Initialize a Git repository. Use --no-git to skip it."),
+      Flag.withDefault(true),
+    ),
+    install: Flag.boolean("install").pipe(
+      Flag.withDescription("Install dependencies. Use --no-install to skip it."),
+      Flag.withDefault(true),
+    ),
+  },
+  Effect.fn("new")(function* ({ directory, git, install }) {
+    const path = yield* Path.Path;
+    const terminal = yield* Terminal.Terminal;
+    const currentDirectory = path.resolve(".");
+    const result = yield* createProject({ currentDirectory, directory, git, install }).pipe(
+      Effect.mapError((error) =>
+        CliError.UserError.make({ cause: error, userMessage: error.message }),
+      ),
+    );
+    const changeDirectory = result.directory === currentDirectory ? "" : `  cd ${directory}\n`;
+
+    const installCommand = result.packageManager === null ? "  npx ignotum install\n" : "";
+
+    yield* terminal.display(
+      `Created ${result.projectName} in ${result.directory}.\n\nNext steps:\n${changeDirectory}${installCommand}  npx ignotum dev\n`,
+    );
+  }),
+).pipe(
+  Command.withDescription("Create a new Ignotum app in an empty directory."),
+  Command.withExamples([
+    {
+      command: "ignotum new my-app",
+      description: "Create an app in a new directory.",
+    },
+    {
+      command: "ignotum new . --no-git --no-install",
+      description: "Create an app in the current directory without Git or dependency installation.",
+    },
+  ]),
+);
+
+const ignotum = Command.make("ignotum").pipe(
+  Command.withSubcommands([newProject, install, codegen, dev]),
+);
+
+export const main = (): void => {
+  ignotum.pipe(
+    Command.run({ version: packageJson.version }),
+    // @effect-diagnostics-next-line strictEffectProvide:off
+    Effect.provide(NodeServices.layer),
+    NodeRuntime.runMain,
+  );
+};

package/src/cli/dev.ts

@@ -0,0 +1,206 @@
+import { createRequire } from "node:module";
+import { fileURLToPath } from "node:url";
+
+import prefresh from "@prefresh/vite";
+import tailwindcss from "@tailwindcss/vite";
+import { Effect, FileSystem, Path, Schema } from "effect";
+import { createServer, defaultClientConditions, normalizePath } from "vite";
+import type { Alias, ViteDevServer } from "vite";
+
+import { generate } from "./codegen.js";
+import { ignotumClientPlugin } from "./client-plugin.js";
+import { acquireDevDatabaseLock, devDatabasePath } from "../dev-runtime/dev-database.js";
+import { ignotumSyncPlugin } from "../dev-runtime/sync.js";
+
+const requiredClientFiles = ["App.tsx", "styles.css"] as const;
+const preactSpecifiers = [
+  "preact/jsx-dev-runtime",
+  "preact/jsx-runtime",
+  "preact/devtools",
+  "preact/debug",
+  "preact/hooks",
+  "preact",
+] as const;
+const prefreshSpecifiers = ["@prefresh/core", "@prefresh/utils"] as const;
+
+export class ClientFileNotFound extends Schema.TaggedError<ClientFileNotFound>()(
+  "ClientFileNotFound",
+  {
+    message: Schema.String,
+    path: Schema.String,
+  },
+) {}
+
+export class ClientRuntimeResolutionFailed extends Schema.TaggedError<ClientRuntimeResolutionFailed>()(
+  "ClientRuntimeResolutionFailed",
+  {
+    cause: Schema.Defect(),
+    message: Schema.String,
+  },
+) {}
+
+export class ViteStartupFailed extends Schema.TaggedError<ViteStartupFailed>()(
+  "ViteStartupFailed",
+  {
+    cause: Schema.Defect(),
+    message: Schema.String,
+  },
+) {}
+
+export interface DevOptions {
+  readonly host: string;
+  readonly open: boolean;
+  readonly port: number;
+  readonly projectDirectory: string;
+}
+
+const validateClientFiles = Effect.fn("Dev.validateClientFiles")(function* (
+  projectDirectory: string,
+) {
+  const fileSystem = yield* FileSystem.FileSystem;
+  const path = yield* Path.Path;
+  const clientDirectory = path.join(projectDirectory, "client");
+
+  yield* Effect.forEach(
+    requiredClientFiles,
+    Effect.fn("Dev.validateClientFile")(function* (fileName) {
+      const filePath = path.join(clientDirectory, fileName);
+      const exists = yield* fileSystem.exists(filePath);
+
+      if (!exists) {
+        return yield* ClientFileNotFound.make({
+          message: `Required client file not found: ${filePath}`,
+          path: filePath,
+        });
+      }
+    }),
+    { discard: true },
+  );
+});
+
+const resolveClientAliases = Effect.fn("Dev.resolveClientAliases")(function* () {
+  return yield* Effect.try({
+    try: (): Array<Alias> => {
+      const prefreshRequire = createRequire(import.meta.resolve("@prefresh/vite"));
+
+      return [
+        {
+          find: /^tailwindcss$/,
+          replacement: normalizePath(fileURLToPath(import.meta.resolve("tailwindcss/index.css"))),
+        },
+        ...preactSpecifiers.map((specifier) => ({
+          find: specifier,
+          replacement: normalizePath(fileURLToPath(import.meta.resolve(specifier))),
+        })),
+        ...prefreshSpecifiers.map((specifier) => ({
+          find: specifier,
+          replacement: normalizePath(prefreshRequire.resolve(specifier)),
+        })),
+      ];
+    },
+    catch: (cause) =>
+      ClientRuntimeResolutionFailed.make({
+        cause,
+        message: "Ignotum could not resolve its client runtime.",
+      }),
+  });
+});
+
+const acquireViteServer = Effect.fn("Dev.acquireViteServer")(function* (options: DevOptions) {
+  const fileSystem = yield* FileSystem.FileSystem;
+  const path = yield* Path.Path;
+  const aliases = yield* resolveClientAliases();
+  const clientDirectory = path.join(options.projectDirectory, "client");
+  const databasePath = yield* devDatabasePath(options.projectDirectory);
+  const stateDirectory = path.dirname(databasePath);
+  const sourceClientEntry = fileURLToPath(new URL("../../src/client/index.ts", import.meta.url));
+  const sourceContractsEntry = fileURLToPath(
+    new URL("../../../contracts/src/schema/index.ts", import.meta.url),
+  );
+  const hasSourceClient = yield* fileSystem.exists(sourceClientEntry);
+  const hasSourceContracts = yield* fileSystem.exists(sourceContractsEntry);
+  const hasWorkspaceSourceExports = hasSourceClient && hasSourceContracts;
+
+  yield* fileSystem.makeDirectory(stateDirectory, { recursive: true });
+
+  return yield* Effect.acquireRelease(
+    Effect.tryPromise({
+      try: () =>
+        prefresh().then((prefreshPlugin) =>
+          createServer({
+            appType: "spa",
+            configFile: false,
+            mode: "development",
+            root: clientDirectory,
+            plugins: [
+              ignotumSyncPlugin(options.projectDirectory, databasePath),
+              ignotumClientPlugin(),
+              prefreshPlugin,
+              tailwindcss(),
+            ],
+            oxc: {
+              jsx: {
+                importSource: "ignotum/client",
+                runtime: "automatic",
+              },
+            },
+            resolve: {
+              alias: aliases,
+              conditions: [
+                ...(hasWorkspaceSourceExports ? ["@ignotum/source"] : []),
+                ...defaultClientConditions,
+              ],
+              dedupe: ["preact"],
+              tsconfigPaths: true,
+            },
+            server: {
+              forwardConsole: {
+                logLevels: ["warn", "error"],
+                unhandledErrors: true,
+              },
+              host: options.host,
+              open: options.open,
+              port: options.port,
+              strictPort: true,
+            },
+          }),
+        ),
+      catch: (cause) =>
+        ViteStartupFailed.make({
+          cause,
+          message: "Ignotum could not create the Vite development server.",
+        }),
+    }),
+    (server) => Effect.promise(() => server.close()),
+  );
+});
+
+const listen = Effect.fn("Dev.listen")(function* (server: ViteDevServer) {
+  yield* Effect.tryPromise({
+    try: () => server.listen(),
+    catch: (cause) =>
+      ViteStartupFailed.make({
+        cause,
+        message: "Ignotum could not start the Vite development server.",
+      }),
+  });
+});
+
+export const dev = Effect.fn("Dev.run")(function* (options: DevOptions) {
+  yield* validateClientFiles(options.projectDirectory);
+  yield* generate(options.projectDirectory);
+
+  return yield* Effect.scoped(
+    Effect.gen(function* () {
+      yield* acquireDevDatabaseLock(options.projectDirectory);
+      const server = yield* acquireViteServer(options);
+
+      yield* listen(server);
+      yield* Effect.sync(() => {
+        server.printUrls();
+        server.bindCLIShortcuts({ print: true });
+      });
+      return yield* Effect.never;
+    }),
+  );
+});