ignotum 0.0.13 → 0.0.15

package/src/cli/build/client.ts

@@ -1,119 +0,0 @@
-import { Array, Effect, FileSystem, Path, String } from "effect";
-import tailwindcss from "@tailwindcss/vite";
-import { ClientManifest, clientShellPath } from "@ignotum/contracts/deployment";
-import { artifactReference, encodeCanonical, sha256, utf8Bytes } from "@ignotum/deployment";
-
-import { resolveClientBuildConfig, validateClientFiles } from "../client-config.js";
-import { loadClientEntryTitle } from "../client-entry.js";
-import { clientEntryId, ignotumClientPlugin, renderClientDocument } from "../client-plugin.js";
-import { moduleBoundariesPlugin } from "../module-boundaries.js";
-import { InvalidBuildOutput, runViteBuild } from "./artifact.js";
-import { copyPublicFiles } from "./public.js";
-
-export interface ClientBuildResult {
-  readonly assets: number;
-  readonly manifestPath: string;
-  readonly shellPath: string;
-}
-
-export const buildClient = Effect.fn("Deploy.buildClient")(function* (
-  appDirectory: string,
-  outputDirectory: string,
-) {
-  const fileSystem = yield* FileSystem.FileSystem;
-  const path = yield* Path.Path;
-  const clientFiles = yield* validateClientFiles(appDirectory);
-  const clientDirectory = clientFiles.clientDirectory;
-  const title = yield* loadClientEntryTitle(clientFiles.entryPath);
-  const clientConfig = yield* resolveClientBuildConfig(false);
-  const boundaries = yield* moduleBoundariesPlugin("Client", appDirectory);
-
-  yield* fileSystem.makeDirectory(outputDirectory, { recursive: true });
-
-  const output = yield* runViteBuild("client", {
-    appType: "spa",
-    build: {
-      assetsDir: "assets",
-      emptyOutDir: true,
-      outDir: outputDirectory,
-      rolldownOptions: {
-        input: clientEntryId,
-        output: {
-          assetFileNames: (asset) =>
-            asset.names.some((name) => name.endsWith(".css"))
-              ? "assets/styles-[hash][extname]"
-              : "assets/[name]-[hash][extname]",
-          chunkFileNames: "assets/chunks/[name]-[hash].js",
-          entryFileNames: "assets/main-[hash].js",
-        },
-      },
-      sourcemap: false,
-    },
-    configFile: false,
-    logLevel: "warn",
-    mode: "production",
-    oxc: {
-      jsx: {
-        importSource: "ignotum/client",
-        runtime: "automatic",
-      },
-    },
-    plugins: [
-      boundaries,
-      ignotumClientPlugin({ development: false, icon: undefined, loadTitle: undefined }),
-      tailwindcss(),
-    ],
-    publicDir: false,
-    resolve: {
-      alias: clientConfig.aliases,
-      conditions: [...clientConfig.conditions],
-      dedupe: ["preact"],
-      tsconfigPaths: true,
-    },
-    root: clientDirectory,
-  });
-  const entry = Array.findFirst(output, (item) => item.type === "chunk" && item.isEntry);
-  const entryFile = yield* Effect.fromOption(entry, () =>
-    InvalidBuildOutput.make({ message: "The client build did not emit an entry chunk." }),
-  ).pipe(Effect.map((item) => item.fileName));
-  const styles = Array.sort(String.Order)(
-    Array.map(
-      Array.filter(output, (item) => item.type === "asset" && item.fileName.endsWith(".css")),
-      (item) => item.fileName,
-    ),
-  );
-  let icon: string | undefined;
-  if (clientFiles.iconPath !== undefined) {
-    const bytes = yield* fileSystem.readFile(clientFiles.iconPath);
-    const digest = yield* sha256(bytes);
-    const fileName = `icon-${digest.slice(0, 16)}.svg`;
-    const assetsDirectory = path.join(outputDirectory, "assets");
-    yield* fileSystem.makeDirectory(assetsDirectory, { recursive: true });
-    yield* fileSystem.writeFile(path.join(assetsDirectory, fileName), bytes);
-    icon = `/_ignotum/assets/${fileName}`;
-  }
-  const shellPath = path.join(outputDirectory, "shell.html");
-  const document = renderClientDocument({
-    icon,
-    scripts: [{ source: `_ignotum/${entryFile}`, type: "External" }],
-    styles: styles.map((style) => `_ignotum/${style}`),
-    title,
-  });
-
-  const shellBytes = utf8Bytes(document);
-  yield* fileSystem.writeFile(shellPath, shellBytes);
-  const publicBuild = yield* copyPublicFiles(appDirectory, outputDirectory);
-  const manifest = {
-    formatVersion: 1,
-    shell: yield* artifactReference(clientShellPath, shellBytes),
-    routes: publicBuild.routes,
-  } satisfies ClientManifest;
-  const manifestPath = path.join(outputDirectory, "manifest.json");
-  yield* fileSystem.writeFileString(manifestPath, `${encodeCanonical(ClientManifest, manifest)}\n`);
-
-  return {
-    assets: output.length + (icon === undefined ? 0 : 1) + publicBuild.files,
-    manifestPath,
-    shellPath,
-  } satisfies ClientBuildResult;
-});

package/src/cli/build/public.ts

@@ -1,186 +0,0 @@
-import {
-  ArtifactPath,
-  ClientPath,
-  clientPublicFileExtensions,
-  deploymentArtifactLimits,
-  type ClientRoute,
-} from "@ignotum/contracts/deployment";
-import { artifactReference } from "@ignotum/deployment";
-import { Effect, FileSystem, Option, Path, Schema } from "effect";
-
-export class InvalidPublicFile extends Schema.TaggedError<InvalidPublicFile>()(
-  "InvalidPublicFile",
-  {
-    message: Schema.String,
-    path: Schema.String,
-  },
-) {}
-
-export interface PublicBuildResult {
-  readonly files: number;
-  readonly routes: ReadonlyArray<ClientRoute>;
-}
-
-interface PublicFile {
-  readonly bytes: Uint8Array;
-  readonly destination: string;
-  readonly route: ClientRoute;
-  readonly source: string;
-}
-
-const pathSegmentPattern = /^[A-Za-z0-9._~-]+$/;
-
-const startsWith = (bytes: Uint8Array, signature: ReadonlyArray<number>, offset = 0): boolean =>
-  signature.every((byte, index) => bytes[offset + index] === byte);
-
-const asciiAt = (bytes: Uint8Array, value: string, offset = 0): boolean =>
-  startsWith(
-    bytes,
-    globalThis.Array.from(value, (character) => character.charCodeAt(0)),
-    offset,
-  );
-
-const hasValidSignature = (extension: string, bytes: Uint8Array): boolean => {
-  switch (extension) {
-    case ".avif": {
-      if (!asciiAt(bytes, "ftyp", 4)) return false;
-      const headerLength = Math.min(bytes.length, 64);
-      for (let offset = 8; offset + 4 <= headerLength; offset += 4) {
-        if (asciiAt(bytes, "avif", offset) || asciiAt(bytes, "avis", offset)) return true;
-      }
-      return false;
-    }
-    case ".gif":
-      return asciiAt(bytes, "GIF87a") || asciiAt(bytes, "GIF89a");
-    case ".ico":
-      return startsWith(bytes, [0x00, 0x00, 0x01, 0x00]);
-    case ".jpeg":
-    case ".jpg":
-      return startsWith(bytes, [0xff, 0xd8, 0xff]);
-    case ".pdf":
-      return asciiAt(bytes, "%PDF-");
-    case ".png":
-      return startsWith(bytes, [0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a]);
-    case ".webp":
-      return asciiAt(bytes, "RIFF") && asciiAt(bytes, "WEBP", 8);
-    default:
-      return false;
-  }
-};
-
-const invalid = (path: string, message: string) => InvalidPublicFile.make({ message, path });
-
-export const copyPublicFiles = Effect.fn("Deploy.copyPublicFiles")(function* (
-  appDirectory: string,
-  outputDirectory: string,
-) {
-  const fileSystem = yield* FileSystem.FileSystem;
-  const path = yield* Path.Path;
-  const publicDirectory = path.join(appDirectory, "public");
-  if (!(yield* fileSystem.exists(publicDirectory))) {
-    return { files: 0, routes: [] } satisfies PublicBuildResult;
-  }
-
-  if (Option.isSome(yield* Effect.option(fileSystem.readLink(publicDirectory)))) {
-    return yield* invalid(
-      publicDirectory,
-      "The top-level public directory cannot be a symbolic link.",
-    );
-  }
-  const publicInfo = yield* fileSystem.stat(publicDirectory);
-  if (publicInfo.type !== "Directory") {
-    return yield* invalid(publicDirectory, "The top-level public path must be a directory.");
-  }
-
-  const entries = (yield* fileSystem.readDirectory(publicDirectory, {
-    recursive: true,
-  })).toSorted();
-  const publicFiles = yield* Effect.forEach(entries, (entry) =>
-    Effect.gen(function* () {
-      const relativePath = entry.replaceAll("\\", "/");
-      const source = path.join(publicDirectory, entry);
-      if (Option.isSome(yield* Effect.option(fileSystem.readLink(source)))) {
-        return yield* invalid(source, "Public entries cannot be symbolic links.");
-      }
-      const info = yield* fileSystem.stat(source);
-      if (info.type === "Directory") return undefined;
-      if (info.type !== "File") {
-        return yield* invalid(source, "Public entries must be regular files or directories.");
-      }
-
-      const segments = relativePath.split("/");
-      if (segments.some((segment) => !pathSegmentPattern.test(segment))) {
-        return yield* invalid(
-          source,
-          "Public file paths may only contain letters, numbers, dots, underscores, tildes, hyphens, and directory separators.",
-        );
-      }
-      if (segments[0] === "_ignotum") {
-        return yield* invalid(source, "The /_ignotum namespace is reserved by the platform.");
-      }
-
-      const extension = path.extname(relativePath).toLowerCase();
-      if (!clientPublicFileExtensions.some((allowedExtension) => allowedExtension === extension)) {
-        return yield* invalid(
-          source,
-          `Unsupported public file type '${extension || "(none)"}'. Allowed types: ${clientPublicFileExtensions.join(", ")}.`,
-        );
-      }
-      if (info.size > BigInt(deploymentArtifactLimits.fileBytes)) {
-        return yield* invalid(
-          source,
-          `Public files cannot exceed ${deploymentArtifactLimits.fileBytes} bytes.`,
-        );
-      }
-
-      const bytes = yield* fileSystem.readFile(source);
-      if (!hasValidSignature(extension, bytes)) {
-        return yield* invalid(
-          source,
-          `The contents do not match the '${extension}' file extension.`,
-        );
-      }
-
-      const pathname = `/${relativePath}`;
-      return {
-        bytes,
-        destination: path.join(outputDirectory, "routes", entry),
-        route: {
-          pathname: ClientPath.make(pathname),
-          artifact: yield* artifactReference(
-            ArtifactPath.make(`client/routes/${relativePath}`),
-            bytes,
-          ),
-        },
-        source,
-      } satisfies PublicFile;
-    }),
-  );
-  const files = publicFiles.filter((file): file is PublicFile => file !== undefined);
-
-  yield* Effect.forEach(files, (file) =>
-    Effect.gen(function* () {
-      if (yield* fileSystem.exists(file.destination)) {
-        return yield* invalid(
-          file.source,
-          `Public route '${file.route.pathname}' overlaps generated client output.`,
-        );
-      }
-    }),
-  );
-
-  yield* Effect.forEach(
-    files,
-    (file) =>
-      Effect.gen(function* () {
-        yield* fileSystem.makeDirectory(path.dirname(file.destination), { recursive: true });
-        yield* fileSystem.writeFile(file.destination, file.bytes);
-      }),
-    { discard: true },
-  );
-
-  return {
-    files: files.length,
-    routes: files.map((file) => file.route),
-  } satisfies PublicBuildResult;
-});

package/src/cli/client-entry.ts

@@ -1,152 +0,0 @@
-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,136 +0,0 @@
-import type { Plugin } from "vite";
-
-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';
-
-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>${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>
-${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>`;
-
-export const renderClientEntry = (
-  development: boolean,
-): string => `${development ? 'import "preact/debug"\n' : ""}import { render } from "preact"
-import { jsx } from "preact/jsx-runtime"
-
-import "${clientStylesId}"
-import application from "/index.tsx"
-
-const root = document.getElementById("app")
-
-if (root === null) {
-  throw new Error("Ignotum mount element is missing.")
-}
-
-document.title = application.title
-render(jsx(application.component, {}), root)
-`;
-
-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) => {
-    server.middlewares.use((request, response, next) => {
-      const acceptsHtml = request.headers.accept?.includes("text/html") === true;
-      const isNavigation = request.method === "GET" || request.method === "HEAD";
-
-      if (!acceptsHtml || !isNavigation) {
-        next();
-        return;
-      }
-
-      const requestUrl = request.originalUrl ?? request.url ?? "/";
-
-      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");
-          response.end(request.method === "HEAD" ? undefined : html);
-        })
-        .catch(next);
-    });
-  },
-
-  load: (id) => loadClientModule(id, options.development),
-
-  resolveId: resolveClientModule,
-});

package/src/client/app.ts

@@ -1,15 +0,0 @@
-import type { ComponentType } from "preact";
-
-export interface AppDefinition<Component extends ComponentType<{}> = ComponentType<{}>> {
-  readonly component: Component;
-  readonly title: string;
-}
-
-export const app = <Component extends ComponentType<{}>>(
-  definition: AppDefinition<Component>,
-): AppDefinition<Component> => {
-  if (definition.title.trim().length === 0) {
-    throw new Error("The app title must contain a non-whitespace character.");
-  }
-  return definition;
-};