ignotum 0.0.2 → 0.0.4

package/src/cli/client-config.ts

@@ -0,0 +1,141 @@
+import { createRequire } from "node:module";
+import { fileURLToPath } from "node:url";
+
+import { Effect, FileSystem, Path, Schema } from "effect";
+import { defaultClientConditions, normalizePath } from "vite";
+import type { Alias } from "vite";
+
+const clientEntryFileName = "index.tsx";
+const clientIconFileName = "icon.svg";
+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 InvalidClientFile extends Schema.TaggedError<InvalidClientFile>()(
+  "InvalidClientFile",
+  {
+    message: Schema.String,
+    path: Schema.String,
+  },
+) {}
+
+export class ClientRuntimeResolutionFailed extends Schema.TaggedError<ClientRuntimeResolutionFailed>()(
+  "ClientRuntimeResolutionFailed",
+  {
+    cause: Schema.Defect(),
+    message: Schema.String,
+  },
+) {}
+
+export interface ClientBuildConfig {
+  readonly aliases: ReadonlyArray<Alias>;
+  readonly conditions: ReadonlyArray<string>;
+}
+
+export interface ClientFiles {
+  readonly clientDirectory: string;
+  readonly entryPath: string;
+  readonly iconPath: string | undefined;
+}
+
+export const validateClientFiles = Effect.fn("ClientConfig.validateFiles")(function* (
+  appDirectory: string,
+) {
+  const fileSystem = yield* FileSystem.FileSystem;
+  const path = yield* Path.Path;
+  const clientDirectory = path.join(appDirectory, "client");
+  const entryPath = path.join(clientDirectory, clientEntryFileName);
+  if (!(yield* fileSystem.exists(entryPath))) {
+    return yield* ClientFileNotFound.make({
+      message: `Required client file not found: ${entryPath}`,
+      path: entryPath,
+    });
+  }
+  const entryInfo = yield* fileSystem.stat(entryPath);
+  if (entryInfo.type !== "File") {
+    return yield* InvalidClientFile.make({
+      message: `Required client entry is not a regular file: ${entryPath}`,
+      path: entryPath,
+    });
+  }
+
+  const iconPath = path.join(clientDirectory, clientIconFileName);
+  const hasIcon = yield* fileSystem.exists(iconPath);
+  if (hasIcon) {
+    const iconInfo = yield* fileSystem.stat(iconPath);
+    if (iconInfo.type !== "File") {
+      return yield* InvalidClientFile.make({
+        message: `Optional client icon is not a regular file: ${iconPath}`,
+        path: iconPath,
+      });
+    }
+  }
+
+  return {
+    clientDirectory,
+    entryPath,
+    iconPath: hasIcon ? iconPath : undefined,
+  } satisfies ClientFiles;
+});
+
+export const resolveClientBuildConfig = Effect.fn("ClientConfig.resolve")(function* (
+  includePrefresh: boolean,
+) {
+  const fileSystem = yield* FileSystem.FileSystem;
+  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;
+
+  return yield* Effect.try({
+    try: (): ClientBuildConfig => {
+      const prefreshRequire = createRequire(import.meta.resolve("@prefresh/vite"));
+      const aliases: ReadonlyArray<Alias> = [
+        {
+          find: /^tailwindcss$/,
+          replacement: normalizePath(fileURLToPath(import.meta.resolve("tailwindcss/index.css"))),
+        },
+        ...preactSpecifiers.map((specifier) => ({
+          find: specifier,
+          replacement: normalizePath(fileURLToPath(import.meta.resolve(specifier))),
+        })),
+        ...(includePrefresh
+          ? prefreshSpecifiers.map((specifier) => ({
+              find: specifier,
+              replacement: normalizePath(prefreshRequire.resolve(specifier)),
+            }))
+          : []),
+      ];
+
+      return {
+        aliases,
+        conditions: [
+          ...(hasWorkspaceSourceExports ? ["@ignotum/source"] : []),
+          ...defaultClientConditions,
+        ],
+      };
+    },
+    catch: (cause) =>
+      ClientRuntimeResolutionFailed.make({
+        cause,
+        message: "Ignotum could not resolve its client runtime.",
+      }),
+  });
+});

package/src/cli/client-entry.ts

@@ -0,0 +1,152 @@
+import { Effect, FileSystem, Predicate, Result, Schema } from "effect";
+import { parseSync, type Node, type ObjectProperty, type ObjectPropertyKind } from "oxc-parser";
+
+export class InvalidClientEntry extends Schema.TaggedError<InvalidClientEntry>()(
+  "InvalidClientEntry",
+  {
+    column: Schema.Int,
+    line: Schema.Int,
+    message: Schema.String,
+    path: Schema.String,
+  },
+) {}
+
+export interface ClientEntrySource {
+  readonly path: string;
+  readonly source: string;
+}
+
+const requiredForm = 'export default app({ title: "My App", component: App });';
+
+const location = (source: string, offset: number) => {
+  const prefix = source.slice(0, offset);
+  const line = prefix.split("\n").length;
+  const lastNewline = prefix.lastIndexOf("\n");
+  return { column: offset - lastNewline, line };
+};
+
+const invalid = (entry: ClientEntrySource, node: Pick<Node, "start">, detail: string) => {
+  const position = location(entry.source, node.start);
+  return InvalidClientEntry.make({
+    ...position,
+    message: `${entry.path}:${position.line}:${position.column}: ${detail} Required form: ${requiredForm}`,
+    path: entry.path,
+  });
+};
+
+const isNamedProperty = (property: ObjectProperty, name: string): boolean =>
+  property.kind === "init" &&
+  !property.computed &&
+  !property.method &&
+  !property.shorthand &&
+  property.key.type === "Identifier" &&
+  property.key.name === name;
+
+const isObjectProperty = (property: ObjectPropertyKind): property is ObjectProperty =>
+  property.type === "Property";
+
+export const extractClientEntryTitle = (
+  entry: ClientEntrySource,
+): Result.Result<string, InvalidClientEntry> => {
+  const parsed = parseSync(entry.path, entry.source, {
+    lang: "tsx",
+    preserveParens: true,
+    showSemanticErrors: true,
+    sourceType: "module",
+  });
+  const parserError = parsed.errors[0];
+  if (parserError !== undefined) {
+    const label = parserError.labels[0];
+    return Result.fail(
+      invalid(
+        entry,
+        { start: label?.start ?? 0 },
+        `The client entry is invalid: ${parserError.message}.`,
+      ),
+    );
+  }
+
+  const importsApp = parsed.program.body.some(
+    (statement) =>
+      statement.type === "ImportDeclaration" &&
+      statement.source.value === "ignotum/client" &&
+      statement.importKind !== "type" &&
+      statement.specifiers.some(
+        (specifier) =>
+          specifier.type === "ImportSpecifier" &&
+          specifier.importKind !== "type" &&
+          specifier.imported.type === "Identifier" &&
+          specifier.imported.name === "app" &&
+          specifier.local.name === "app",
+      ),
+  );
+  if (!importsApp) {
+    return Result.fail(
+      invalid(entry, parsed.program, 'Import { app } from "ignotum/client" without an alias.'),
+    );
+  }
+
+  const defaultExports = parsed.program.body.filter(
+    (statement) => statement.type === "ExportDefaultDeclaration",
+  );
+  const defaultExport = defaultExports[0];
+  if (defaultExports.length !== 1 || defaultExport === undefined) {
+    return Result.fail(
+      invalid(entry, parsed.program, "The client entry needs one default export."),
+    );
+  }
+  const call = defaultExport.declaration;
+  if (
+    call.type !== "CallExpression" ||
+    call.optional ||
+    call.typeArguments != null ||
+    call.callee.type !== "Identifier" ||
+    call.callee.name !== "app" ||
+    call.arguments.length !== 1
+  ) {
+    return Result.fail(invalid(entry, defaultExport, "The default export must be an app call."));
+  }
+  const definition = call.arguments[0];
+  if (definition?.type !== "ObjectExpression" || definition.properties.length !== 2) {
+    return Result.fail(
+      invalid(entry, call, "The app call needs exactly title and component properties."),
+    );
+  }
+  const properties = definition.properties;
+  if (!properties.every(isObjectProperty)) {
+    return Result.fail(invalid(entry, definition, "Spread properties are not supported."));
+  }
+  const titleProperties = properties.filter((property) => isNamedProperty(property, "title"));
+  const componentProperties = properties.filter((property) =>
+    isNamedProperty(property, "component"),
+  );
+  if (titleProperties.length !== 1 || componentProperties.length !== 1) {
+    return Result.fail(
+      invalid(entry, definition, "Use unquoted title and component properties with no extras."),
+    );
+  }
+  const titleProperty = titleProperties[0];
+  if (titleProperty === undefined) {
+    return Result.fail(invalid(entry, definition, "The title property is missing."));
+  }
+  const title = titleProperty.value;
+  if (
+    title.type !== "Literal" ||
+    !Predicate.isString(title.value) ||
+    (title.raw?.startsWith('"') !== true && title.raw?.startsWith("'") !== true)
+  ) {
+    return Result.fail(invalid(entry, title, "The title must be a quoted string literal."));
+  }
+  if (title.value.trim().length === 0) {
+    return Result.fail(invalid(entry, title, "The title must contain a non-whitespace character."));
+  }
+  return Result.succeed(title.value);
+};
+
+export const loadClientEntryTitle = Effect.fn("ClientEntry.loadTitle")(function* (path: string) {
+  const fileSystem = yield* FileSystem.FileSystem;
+  const source = yield* fileSystem.readFileString(path);
+  const extracted = extractClientEntryTitle({ path, source });
+  if (Result.isFailure(extracted)) return yield* extracted.failure;
+  return extracted.success;
+});

package/src/cli/client-plugin.ts

@@ -1,29 +1,70 @@
 import type { Plugin } from "vite";
 
-const clientEntryId = "virtual:ignotum/client-entry";
+export const clientEntryId = "virtual:ignotum/client-entry";
 const resolvedClientEntryId = `\0${clientEntryId}`;
+export const clientStylesId = "virtual:ignotum/_styles.css";
+const resolvedClientStylesId = `\0${clientStylesId}`;
+export const clientStylesSource = '@import "tailwindcss";\n';
 
-const document = `<!doctype html>
+interface ExternalClientScript {
+  readonly source: string;
+  readonly type: "External";
+}
+
+interface InlineClientScript {
+  readonly source: string;
+  readonly type: "Inline";
+}
+
+interface ClientDocumentOptions {
+  readonly icon: string | undefined;
+  readonly scripts: ReadonlyArray<ExternalClientScript | InlineClientScript>;
+  readonly styles: ReadonlyArray<string>;
+  readonly title: string;
+}
+
+export interface ClientPluginOptions {
+  readonly development: boolean;
+  readonly icon: string | undefined;
+  readonly loadTitle: (() => Promise<string>) | undefined;
+}
+
+const escapeHtml = (value: string): string =>
+  value
+    .replaceAll("&", "&amp;")
+    .replaceAll("<", "&lt;")
+    .replaceAll(">", "&gt;")
+    .replaceAll('"', "&quot;")
+    .replaceAll("'", "&#39;");
+
+export const renderClientDocument = (options: ClientDocumentOptions): string => `<!doctype html>
 <html lang="en">
   <head>
     <meta charset="UTF-8" />
     <meta name="viewport" content="width=device-width, initial-scale=1.0" />
-    <title>Ignotum</title>
+    <title>${escapeHtml(options.title)}</title>
+${options.icon === undefined ? "" : `    <link rel="icon" type="image/svg+xml" href="${escapeHtml(options.icon)}" />`}
+${options.styles.map((href) => `    <link rel="stylesheet" crossorigin href="/${escapeHtml(href)}" />`).join("\n")}
   </head>
   <body>
     <div id="app"></div>
-    <script type="module">
-      import "${clientEntryId}"
-    </script>
+${options.scripts
+  .map((script) =>
+    script.type === "External"
+      ? `    <script type="module" crossorigin src="/${escapeHtml(script.source)}"></script>`
+      : `    <script type="module">\n      ${script.source}\n    </script>`,
+  )
+  .join("\n")}
   </body>
 </html>`;
 
-const clientEntry = `import "preact/debug"
-import { render } from "preact"
+export const renderClientEntry = (
+  development: boolean,
+): string => `${development ? 'import "preact/debug"\n' : ""}import { render } from "preact"
 import { jsx } from "preact/jsx-runtime"
 
-import "/styles.css"
-import App from "/App.tsx"
+import "${clientStylesId}"
+import application from "/index.tsx"
 
 const root = document.getElementById("app")
 
@@ -31,10 +72,23 @@ if (root === null) {
   throw new Error("Ignotum mount element is missing.")
 }
 
-render(jsx(App, {}), root)
+document.title = application.title
+render(jsx(application.component, {}), root)
 `;
 
-export const ignotumClientPlugin = (): Plugin => ({
+const loadClientModule = (id: string, development: boolean): string | undefined => {
+  if (id === resolvedClientEntryId) return renderClientEntry(development);
+  if (id === resolvedClientStylesId) return clientStylesSource;
+  return undefined;
+};
+
+export const resolveClientModule = (id: string): string | undefined => {
+  if (id === clientEntryId) return resolvedClientEntryId;
+  if (id === clientStylesId) return resolvedClientStylesId;
+  return undefined;
+};
+
+export const ignotumClientPlugin = (options: ClientPluginOptions): Plugin => ({
   name: "ignotum:client",
 
   configureServer: (server) => {
@@ -49,8 +103,24 @@ export const ignotumClientPlugin = (): Plugin => ({
 
       const requestUrl = request.originalUrl ?? request.url ?? "/";
 
-      void server
-        .transformIndexHtml(requestUrl, document)
+      const loadTitle = options.loadTitle;
+      if (loadTitle === undefined) {
+        next(new Error("Ignotum's development title loader is missing."));
+        return;
+      }
+
+      void loadTitle()
+        .then((title) =>
+          server.transformIndexHtml(
+            requestUrl,
+            renderClientDocument({
+              icon: options.icon,
+              scripts: [{ source: `import "${clientEntryId}"`, type: "Inline" }],
+              styles: [],
+              title,
+            }),
+          ),
+        )
         .then((html) => {
           response.statusCode = 200;
           response.setHeader("Content-Type", "text/html; charset=utf-8");
@@ -60,7 +130,7 @@ export const ignotumClientPlugin = (): Plugin => ({
     });
   },
 
-  load: (id) => (id === resolvedClientEntryId ? clientEntry : undefined),
+  load: (id) => loadClientModule(id, options.development),
 
-  resolveId: (id) => (id === clientEntryId ? resolvedClientEntryId : undefined),
+  resolveId: resolveClientModule,
 });

package/src/cli/codegen.ts

@@ -152,10 +152,10 @@ const writeOutput = Effect.fn("Codegen.writeOutput")(function* (output: Generate
   );
 });
 
-export const generate = Effect.fn("Codegen.generate")(function* (projectDirectory: string) {
+export const generate = Effect.fn("Codegen.generate")(function* (appDirectory: string) {
   const fileSystem = yield* FileSystem.FileSystem;
   const path = yield* Path.Path;
-  const serverDirectory = path.join(projectDirectory, "server");
+  const serverDirectory = path.join(appDirectory, "server");
   const schemaPath = path.join(serverDirectory, "schema.ts");
   const schemaExists = yield* fileSystem.exists(schemaPath);
 
@@ -174,15 +174,15 @@ export const generate = Effect.fn("Codegen.generate")(function* (projectDirector
   const outputs: ReadonlyArray<GeneratedOutput> = [
     {
       content: renderServerBindings(),
-      path: path.join(projectDirectory, "_generated", "server.ts"),
+      path: path.join(appDirectory, "_generated", "server.ts"),
     },
     {
       content: renderApi(functionModules),
-      path: path.join(projectDirectory, "_generated", "api.ts"),
+      path: path.join(appDirectory, "_generated", "api.ts"),
     },
     {
       content: renderTypes(),
-      path: path.join(projectDirectory, "_generated", "types.ts"),
+      path: path.join(appDirectory, "_generated", "types.ts"),
     },
   ];
   const inspections = yield* Effect.forEach(outputs, inspectOutput);

package/src/cli/command.ts

@@ -1,12 +1,16 @@
-import { NodeRuntime, NodeServices } from "@effect/platform-node";
-import { Effect, Path, Schema, Terminal } from "effect";
+import { NodeHttpClient, NodeRuntime, NodeServices } from "@effect/platform-node";
+import { Effect, Layer, Option, Path, Schema, Terminal } from "effect";
 import { Argument, CliError, Command, Flag } from "effect/unstable/cli";
+import { AppSlug } from "@ignotum/contracts/control";
+import { IdGenerator } from "@ignotum/shared/id";
 
 import packageJson from "../../package.json" with { type: "json" };
 import { generate } from "./codegen.js";
+import { ControlClient } from "./control-client.js";
+import { deploy as runDeploy } from "./deploy.js";
 import { resetDevDatabase } from "../dev-runtime/dev-database.js";
 import { dev as runDev } from "./dev.js";
-import { createProject } from "./new-project.js";
+import { createApp } from "./new-app.js";
 import { installDependencies } from "./package-manager.js";
 
 const DevPort = Schema.Int.check(Schema.isBetween({ minimum: 1, maximum: 65_535 }));
@@ -67,7 +71,7 @@ const dev = Command.make(
       host,
       open,
       port,
-      projectDirectory: path.resolve("."),
+      appDirectory: path.resolve("."),
     }).pipe(
       Effect.mapError((error) =>
         CliError.UserError.make({ cause: error, userMessage: error.message }),
@@ -79,6 +83,32 @@ const dev = Command.make(
   Command.withSubcommands([devDatabase]),
 );
 
+const deploy = Command.make(
+  "deploy",
+  {
+    app: Flag.string("app").pipe(
+      Flag.withDescription("Create or link this app slug on the first deploy."),
+      Flag.withSchema(AppSlug),
+      Flag.optional,
+    ),
+  },
+  Effect.fn("deploy")(function* ({ app }) {
+    const path = yield* Path.Path;
+    const terminal = yield* Terminal.Terminal;
+    const result = yield* runDeploy(path.resolve("."), Option.getOrUndefined(app)).pipe(
+      // @effect-diagnostics-next-line strictEffectProvide:off The deploy subcommand owns this client layer for its full lifetime.
+      Effect.provide(ControlClient.layer),
+      Effect.mapError((error) =>
+        CliError.UserError.make({ cause: error, userMessage: error.message }),
+      ),
+    );
+
+    yield* terminal.display(
+      `Deployed ${result.clientAssets} client artifact${result.clientAssets === 1 ? "" : "s"} and ${result.serverFunctions} server function${result.serverFunctions === 1 ? "" : "s"}.\n\nApp: ${result.appUrl}\nDeployment: ${result.deploymentId}\n`,
+    );
+  }),
+).pipe(Command.withDescription("Build and deploy the application to Ignotum Cloud."));
+
 const install = Command.make(
   "install",
   {},
@@ -95,7 +125,7 @@ const install = Command.make(
   }),
 ).pipe(Command.withDescription("Install dependencies with pnpm, or npm when pnpm is unavailable."));
 
-const newProject = Command.make(
+const newApp = Command.make(
   "new",
   {
     directory: Argument.string("directory").pipe(
@@ -114,7 +144,7 @@ const newProject = Command.make(
     const path = yield* Path.Path;
     const terminal = yield* Terminal.Terminal;
     const currentDirectory = path.resolve(".");
-    const result = yield* createProject({ currentDirectory, directory, git, install }).pipe(
+    const result = yield* createApp({ currentDirectory, directory, git, install }).pipe(
       Effect.mapError((error) =>
         CliError.UserError.make({ cause: error, userMessage: error.message }),
       ),
@@ -124,7 +154,7 @@ const newProject = Command.make(
     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`,
+      `Created ${result.appName} in ${result.directory}.\n\nNext steps:\n${changeDirectory}${installCommand}  npx ignotum dev\n`,
     );
   }),
 ).pipe(
@@ -142,14 +172,16 @@ const newProject = Command.make(
 );
 
 const ignotum = Command.make("ignotum").pipe(
-  Command.withSubcommands([newProject, install, codegen, dev]),
+  Command.withSubcommands([newApp, install, codegen, dev, deploy]),
 );
 
 export const main = (): void => {
   ignotum.pipe(
     Command.run({ version: packageJson.version }),
     // @effect-diagnostics-next-line strictEffectProvide:off
-    Effect.provide(NodeServices.layer),
+    Effect.provide(
+      Layer.mergeAll(NodeServices.layer, NodeHttpClient.layerUndici, IdGenerator.layer),
+    ),
     NodeRuntime.runMain,
   );
 };