@fedify/cli 2.0.0-pr.474.1879 → 2.0.0-pr.479.1900

package/src/init/action/patch.ts

@@ -1,7 +1,7 @@
-import { apply, entries, forEach, pipe, pipeLazy, tap } from "@fxts/core";
+import { always, apply, entries, map, pipe, pipeLazy, tap } from "@fxts/core";
 import { toMerged } from "es-toolkit";
 import { readFile } from "node:fs/promises";
-import { formatJson, merge, set } from "../../utils.ts";
+import { formatJson, merge, replaceAll, set } from "../../utils.ts";
 import { createFile, throwUnlessNotExists } from "../lib.ts";
 import type { InitCommandData } from "../types.ts";
 import {
@@ -23,7 +23,8 @@ import { joinDir, stringifyEnvs } from "./utils.ts";
  * Handles both dry-run mode (recommending files) and actual file creation.
  * Orchestrates the entire file generation and writing process.
  *
- * @param data - The initialization command data containing project configuration
+ * @param data - The initialization command data containing project
+ *               configuration
  * @returns A processed data object with files and JSONs ready for creation
  */
 export const patchFiles = (data: InitCommandData) =>
@@ -44,8 +45,9 @@ export const recommendPatchFiles = (data: InitCommandData) =>
 
 /**
  * Generates text-based files (TypeScript, environment files) for the project.
- * Creates federation configuration, logging setup, environment variables, and framework-specific files
- * by processing templates and combining them with project-specific data.
+ * Creates federation configuration, logging setup, environment variables, and
+ * framework-specific files by processing templates and combining them with
+ * project-specific data.
  *
  * @param data - The initialization command data
  * @returns A record of file paths to their string content
@@ -64,8 +66,9 @@ const getFiles = <
 
 /**
  * Generates JSON configuration files based on the package manager type.
- * Creates different sets of configuration files for Deno vs Node.js/Bun environments,
- * including compiler configs, package manifests, and development tool configurations.
+ * Creates different sets of configuration files for Deno vs other environments,
+ * including compiler configs, package manifests, and development
+ * tool configurations.
  *
  * @param data - The initialization command data
  * @returns A record of file paths to their JSON object content
@@ -80,7 +83,9 @@ const getJsons = <
       [devToolConfigs["vscExtDeno"].path]: devToolConfigs["vscExtDeno"].data,
     }
     : {
-      "tsconfig.json": loadTsConfig(data).data,
+      ...(data.initializer.compilerOptions
+        ? { "tsconfig.json": loadTsConfig(data).data }
+        : {}),
       "package.json": loadPackageJson(data).data,
       [devToolConfigs["biome"].path]: devToolConfigs["biome"].data,
       [devToolConfigs["vscSet"].path]: devToolConfigs["vscSet"].data,
@@ -88,9 +93,10 @@ const getJsons = <
     };
 
 /**
- * Handles dry-run mode by recommending files to be created without actually creating them.
- * Displays what files would be created and shows their content for user review.
- * This allows users to preview the initialization process before committing to it.
+ * Handles dry-run mode by recommending files to be created without actually
+ * creating them.
+ * Displays what files would be created and shows their content for user review,
+ * so users can preview the initialization process before committing to it.
  *
  * @param data - The initialization command data with files and JSONs prepared
  * @returns The processed data with recommendations displayed
@@ -106,7 +112,7 @@ const recommendFiles = (data: InitCommandWithFiles) =>
   );
 
 /**
- * Actually creates files on the filesystem during normal (non-dry-run) execution.
+ * Actually creates files on the filesystem during normal execution.
  * Merges text files and JSON files together and writes them to disk.
  * This performs the actual file system operations to initialize the project.
  *
@@ -126,8 +132,8 @@ interface InitCommandWithFiles extends InitCommandData {
 }
 
 /**
- * Higher-order function that processes all files with a given processing function.
- * Takes a processing function (either display or create) and applies it to all files
+ * Processes all files with a given processing function.
+ * Takes a processor (either display or create) and applies it to all files
  * in the target directory, handling path resolution and content patching.
  *
  * @param process - Function to process each file (either display or create)
@@ -140,19 +146,20 @@ const processAllFiles = (
   pipe(
     files,
     entries,
-    forEach(
+    map(
       pipeLazy(
         joinDir(dir),
         apply(patchContent),
         apply(process),
       ),
     ),
+    Array.fromAsync,
   );
 
 /**
- * Patches file content by either merging JSON objects or appending text content.
- * Handles existing files by reading their current content and intelligently combining
- * it with new content based on the content type (JSON vs text).
+ * Patches file content by either merging JSON or appending text content.
+ * Handles existing files by reading their current content and intelligently
+ * combining it with new content based on the content type (JSON vs text).
  *
  * @param path - The file path to patch
  * @param content - The new content (either string or object)
@@ -173,13 +180,32 @@ async function patchContent(
  * Merges new JSON data with existing JSON content and formats the result.
  * Parses existing JSON content (if any) and deep merges it with new data,
  * then formats the result for consistent output.
+ * Supports JSONC (JSON with Comments) by removing comments before parsing.
  *
  * @param prev - The previous JSON content as string
  * @param data - The new data object to merge
  * @returns Formatted JSON string with merged content
  */
 const mergeJson = (prev: string, data: object): string =>
-  pipe(prev ? JSON.parse(prev) : {}, merge(data), formatJson);
+  pipe(
+    prev ? JSON.parse(removeJsonComments(prev)) : {},
+    merge(data),
+    formatJson,
+  );
+
+/**
+ * Removes single-line (//) and multi-line (/* *\/) comments from JSON string.
+ * This allows parsing JSONC (JSON with Comments) files.
+ *
+ * @param jsonString - The JSON string potentially containing comments
+ * @returns JSON string with comments removed
+ */
+const removeJsonComments = (jsonString: string): string =>
+  pipe(
+    jsonString,
+    replaceAll(/\/\/.*$/gm, ""),
+    replaceAll(/\/\*[\s\S]*?\*\//g, ""),
+  );
 
 /**
  * Appends new text content to existing text content line by line.
@@ -202,11 +228,6 @@ const appendText = (prev: string, data: string) =>
  * @returns The file content as string, or empty string if file doesn't exist
  * @throws Error if file access fails for reasons other than file not existing
  */
-async function readFileIfExists(path: string): Promise<string> {
-  try {
-    return await readFile(path, "utf8");
-  } catch (e) {
-    throwUnlessNotExists(e);
-    return "";
-  }
-}
+const readFileIfExists = (path: string): Promise<string> =>
+  readFile(path, "utf8")
+    .catch(pipeLazy(tap(throwUnlessNotExists), always("")));

package/src/init/action/precommand.ts

@@ -1,4 +1,4 @@
-import { exit, runSubCommand } from "../../utils.ts";
+import { CommandError, exit, runSubCommand } from "../../utils.ts";
 import type { InitCommandData } from "../types.ts";
 
 /**
@@ -15,7 +15,14 @@ const runPrecommand = ({
     cwd: dir,
     stdio: "inherit",
   }).catch((e) => {
-    console.error("Failed to run the precommand:", e);
+    if (e instanceof CommandError) {
+      console.error("Failed to run the precommand.");
+      console.error("Command:", e.commandLine);
+      if (e.stderr) console.error("Error:", e.stderr);
+      if (e.stdout) console.error("Output:", e.stdout);
+    } else {
+      console.error("Failed to run the precommand:", e);
+    }
     exit(1);
   });
 

package/src/init/action/set.ts

@@ -11,7 +11,6 @@ import type {
   KvStoreDescription,
   MessageQueue,
   MessageQueueDescription,
-  PackageManager,
 } from "../types.ts";
 import webFrameworks from "../webframeworks.ts";
 
@@ -45,20 +44,8 @@ const setProjectName = set(
 );
 
 const setInitializer = set("initializer", <
-  T extends {
-    webFramework: keyof typeof webFrameworks;
-    projectName: string;
-    packageManager: PackageManager;
-  },
->({
-  webFramework,
-  projectName,
-  packageManager,
-}: T) =>
-  webFrameworks[webFramework].init(
-    projectName,
-    packageManager,
-  ));
+  T extends InitCommandOptions & { projectName: string },
+>(data: T) => webFrameworks[data.webFramework].init(data));
 
 const setKv = set("kv", <
   T extends { kvStore: KvStore },

package/src/init/action/templates.ts

@@ -81,6 +81,7 @@ export const getAlias = (imports: Record<string, string>) =>
     join(", "),
   );
 
+const ENV_REG_EXP = /process\.env\.(\w+)/g;
 /**
  * Converts Node.js environment variable access to Deno-compatible syntax when needed.
  * Transforms `process.env.VAR_NAME` to `Deno.env.get("VAR_NAME")` for Deno projects.
@@ -90,6 +91,6 @@ export const getAlias = (imports: Record<string, string>) =>
  * @returns The converted object string with appropriate environment variable access syntax
  */
 export const convertEnv = (obj: string, pm: PackageManager) =>
-  pm === "deno" && /process\.env\.(\w+)/.test(obj)
-    ? obj.replaceAll(/process\.env\.(\w+)/, (_, g1) => `Deno.env.get("${g1}")`)
+  pm === "deno" && ENV_REG_EXP.test(obj)
+    ? obj.replaceAll(ENV_REG_EXP, (_, g1) => `Deno.env.get("${g1}")`)
     : obj;

package/src/init/action/utils.ts

@@ -6,7 +6,7 @@ export const isDry = ({ dryRun }: InitCommandData) => dryRun;
 export const hasCommand = (data: InitCommandData) => !!data.initializer.command;
 
 export const isDeno = (
-  { packageManager }: InitCommandData,
+  { packageManager }: Pick<InitCommandData, "packageManager">,
 ) => packageManager === "deno";
 
 export const joinDir =

package/src/init/ask/kv.ts

@@ -1,6 +1,8 @@
+import { pipe, tap, throwError, unless, when } from "@fxts/core/index.js";
 import { select } from "@inquirer/prompts";
+import { printErrorMessage } from "../../utils.ts";
 import { KV_STORE } from "../const.ts";
-import { kvStores } from "../lib.ts";
+import { isTest, kvStores } from "../lib.ts";
 import type { KvStore, PackageManager } from "../types.ts";
 
 /**
@@ -11,29 +13,70 @@ import type { KvStore, PackageManager } from "../types.ts";
  * @returns A promise resolving to options with a guaranteed kvStore
  */
 const fillKvStore: //
-  <T extends { kvStore?: KvStore; packageManager: PackageManager }>(
-    options: T,
-  ) => Promise<T & { kvStore: KvStore }> = async (options) => //
-  ({
-    ...options,
-    kvStore: options.kvStore ?? await askKvStore(options.packageManager),
-  });
+  <
+    T extends {
+      kvStore?: KvStore;
+      packageManager: PackageManager;
+      testMode: boolean;
+    },
+  >(options: T) => Promise<KvDefined<T>> //
+ = (options) =>
+  pipe(
+    options,
+    when(isKvStoreEmpty, askKvStore) as <
+      T extends { kvStore?: KvStore; packageManager: PackageManager },
+    >(options: T) => KvDefined<T>,
+    unless(
+      isKvSupportsPm,
+      (opt: KvDefined<typeof options>) =>
+        pipe(
+          opt,
+          when(isTest, throwError(unmatchedWhileTesting)),
+          tap(noticeUnmatched),
+          fillKvStore,
+        ),
+    ),
+  ) as Promise<KvDefined<typeof options>>;
 
 export default fillKvStore;
 
-const askKvStore = (pm: PackageManager) =>
-  select<KvStore>({
+type KvDefined<T> = Omit<T, "kvStore"> & { kvStore: KvStore };
+
+const isKvStoreEmpty = <T extends { kvStore?: KvStore }>(
+  options: T,
+): options is T & { kvStore: undefined } => !options.kvStore;
+
+const askKvStore = async <
+  T extends { packageManager: PackageManager },
+>(data: T): Promise<Omit<T, "kvStore"> & { kvStore: KvStore }> => ({
+  ...data,
+  kvStore: await select<KvStore>({
     message: "Choose the key-value store to use",
-    choices: KV_STORE.map(choiceKvStore(pm)),
-  });
-
-const choiceKvStore = (pm: PackageManager) => (value: KvStore) => ({
-  name: isKvSupportsPm(value, pm)
-    ? value
-    : `${value} (not supported with ${pm})`,
-  value,
-  disabled: !isKvSupportsPm(value, pm),
+    choices: KV_STORE.map(choiceKvStore(data.packageManager)),
+  }),
+});
+
+const unmatchedWhileTesting = <
+  T extends { kvStore: KvStore; packageManager: PackageManager },
+>({ kvStore: kv, packageManager: pm }: T) =>
+  new Error(
+    `Key-value store '${kv}' is not compatible with package manager '${pm}'`,
+  );
+
+const noticeUnmatched = <
+  T extends { kvStore: KvStore; packageManager: PackageManager },
+>({ kvStore: kv, packageManager: pm }: T) =>
+  printErrorMessage`Error: Key-value store '${kv}' is not compatible with package manager '${pm}'`;
+
+const choiceKvStore = (pm: PackageManager) => (kv: KvStore) => ({
+  name: isKvSupportsPm({ kvStore: kv, packageManager: pm })
+    ? kv
+    : `${kv} (not supported with ${pm})`,
+  value: kv,
+  disabled: !isKvSupportsPm({ kvStore: kv, packageManager: pm }),
 });
 
-const isKvSupportsPm = (kv: KvStore, pm: PackageManager) =>
-  kvStores[kv].packageManagers.includes(pm);
+const isKvSupportsPm = <
+  T extends { kvStore: KvStore; packageManager: PackageManager },
+>({ kvStore, packageManager }: T) =>
+  kvStores[kvStore].packageManagers.includes(packageManager);

package/src/init/ask/mq.ts

@@ -1,6 +1,8 @@
+import { pipe, tap, throwError, unless, when } from "@fxts/core/index.js";
 import { select } from "@inquirer/prompts";
+import { printErrorMessage } from "../../utils.ts";
 import { MESSAGE_QUEUE } from "../const.ts";
-import { messageQueues } from "../lib.ts";
+import { isTest, messageQueues } from "../lib.ts";
 import type { MessageQueue, PackageManager } from "../types.ts";
 
 /**
@@ -11,27 +13,74 @@ import type { MessageQueue, PackageManager } from "../types.ts";
  * @returns A promise resolving to options with a guaranteed messageQueue
  */
 const fillMessageQueue: //
-  <T extends { messageQueue?: MessageQueue; packageManager: PackageManager }> //
-  (options: T) => Promise<T & { messageQueue: MessageQueue }> = //
-  async (options) => ({
-    ...options,
-    messageQueue: options.messageQueue ??
-      await askMessageQueue(options.packageManager),
-  });
+  <
+    T extends {
+      messageQueue?: MessageQueue;
+      packageManager: PackageManager;
+      testMode: boolean;
+    },
+  >(options: T) => Promise<MqDefined<T>> //
+ = (options) =>
+  pipe(
+    options,
+    when(isMessageQueueEmpty, askMessageQueue) as <
+      T extends { messageQueue?: MessageQueue; packageManager: PackageManager },
+    >(options: T) => MqDefined<T>,
+    unless(
+      isMqSupportsPm,
+      (opt: MqDefined<typeof options>) =>
+        pipe(
+          opt,
+          when(isTest, throwError(unmatchedWhileTesting)),
+          tap(noticeUnmatched),
+          fillMessageQueue,
+        ),
+    ),
+  ) as Promise<MqDefined<typeof options>>;
 
 export default fillMessageQueue;
 
-const askMessageQueue = (pm: PackageManager) =>
-  select<MessageQueue>({
+type MqDefined<T> = Omit<T, "messageQueue"> & { messageQueue: MessageQueue };
+
+const isMessageQueueEmpty = <T extends { messageQueue?: MessageQueue }>(
+  options: T,
+): options is T & { messageQueue: undefined } => !options.messageQueue;
+
+const askMessageQueue = async <
+  T extends { packageManager: PackageManager },
+>(
+  data: T,
+): Promise<Omit<T, "messageQueue"> & { messageQueue: MessageQueue }> => ({
+  ...data,
+  messageQueue: await select<MessageQueue>({
     message: "Choose the message queue to use",
-    choices: MESSAGE_QUEUE.map(choiceMessageQueue(pm)),
-  });
-const choiceMessageQueue = (pm: PackageManager) => (value: MessageQueue) => ({
-  name: isMqSupportsPm(value, pm)
-    ? value
-    : `${value} (not supported with ${pm})`,
-  value,
-  disabled: !isMqSupportsPm(value, pm),
+    choices: MESSAGE_QUEUE.map(choiceMessageQueue(data.packageManager)),
+  }),
 });
-const isMqSupportsPm = (mq: MessageQueue, pm: PackageManager) =>
-  messageQueues[mq].packageManagers.includes(pm);
+
+const unmatchedWhileTesting = <
+  T extends { messageQueue: MessageQueue; packageManager: PackageManager },
+>({ messageQueue: mq, packageManager: pm }: T) =>
+  new Error(
+    `Message queue '${mq}' is not compatible with package manager '${pm}'`,
+  );
+
+const noticeUnmatched = <
+  T extends { messageQueue: MessageQueue; packageManager: PackageManager },
+>({ messageQueue: mq, packageManager: pm }: T) => {
+  printErrorMessage`Error: Message queue '${mq}' is not compatible with package manager '${pm}'`;
+};
+
+const choiceMessageQueue =
+  (packageManager: PackageManager) => (messageQueue: MessageQueue) => ({
+    name: isMqSupportsPm({ messageQueue, packageManager })
+      ? messageQueue
+      : `${messageQueue} (not supported with ${packageManager})`,
+    value: messageQueue,
+    disabled: !isMqSupportsPm({ messageQueue, packageManager }),
+  });
+
+const isMqSupportsPm = <
+  T extends { messageQueue: MessageQueue; packageManager: PackageManager },
+>({ messageQueue, packageManager }: T) =>
+  messageQueues[messageQueue].packageManagers.includes(packageManager);

package/src/init/command.ts

@@ -5,19 +5,20 @@ import {
   constant,
   type InferValue,
   message,
+  multiple,
   object,
   option,
   optional,
   optionNames,
 } from "@optique/core";
 import { path } from "@optique/run";
+import { debugOption } from "../globals.ts";
 import {
   KV_STORE,
   MESSAGE_QUEUE,
   PACKAGE_MANAGER,
   WEB_FRAMEWORK,
 } from "./const.ts";
-import { debugOption } from "../globals.ts";
 
 const webFramework = optional(option(
   "-w",
@@ -53,6 +54,12 @@ const messageQueue = optional(option(
     description: message`The message queue to use for background tasks.`,
   },
 ));
+const testMode = option(
+  "--test-mode",
+  {
+    description: message`The test mode to use for testing purposes.`,
+  },
+);
 
 export const initCommand = command(
   "init",
@@ -70,6 +77,7 @@ export const initCommand = command(
       description: message`Perform a trial run with no changes made.`,
     }),
     debugOption,
+    testMode,
   }),
   {
     brief: message`Initialize a new Fedify project directory.`,
@@ -86,3 +94,33 @@ Unless you specify all options (${optionNames(["-w", "--web-framework"])}, ${
 );
 
 export type InitCommand = InferValue<typeof initCommand>;
+
+export const testInitCommand = command(
+  "test-init",
+  object("Initialization options", {
+    command: constant("test-init"),
+    webFramework: multiple(webFramework),
+    packageManager: multiple(packageManager),
+    kvStore: multiple(kvStore),
+    messageQueue: multiple(messageQueue),
+    hydRun: option("-h", "--hyd-run", {
+      description: message`Test with files creations and installations.`,
+    }),
+    dryRun: option("-d", "--dry-run", {
+      description: message`Log outputs without creating files.`,
+    }),
+    debugOption,
+  }),
+  {
+    brief: message`Test an initializing command .`,
+    description: message`Test an initializing command on temporary directories.
+
+Unless you specify all options (${optionNames(["-w", "--web-framework"])}, ${
+      optionNames(["-p", "--package-manager"])
+    }, ${optionNames(["-k", "--kv-store"])}, and ${
+      optionNames(["-m", "--message-queue"])
+    }), it will test all combinations of the options.`,
+  },
+);
+
+export type TestInitCommand = InferValue<typeof testInitCommand>;

package/src/init/lib.ts

@@ -10,13 +10,15 @@ import {
   when,
 } from "@fxts/core";
 import { getLogger } from "@logtape/logtape";
-import { dirname, join as joinPath } from "node:path";
+import type { Message } from "@optique/core";
+import { commandLine, message } from "@optique/core/message";
 import { toMerged } from "es-toolkit";
 import { readFileSync } from "node:fs";
 import { mkdir, readdir, writeFile } from "node:fs/promises";
+import { dirname, join as joinPath } from "node:path";
 import process from "node:process";
 import metadata from "../../deno.json" with { type: "json" };
-import { colors, isNotFoundError, runSubCommand } from "../utils.ts";
+import { isNotFoundError, runSubCommand } from "../utils.ts";
 import kv from "./json/kv.json" with { type: "json" };
 import mq from "./json/mq.json" with { type: "json" };
 import pm from "./json/pm.json" with { type: "json" };
@@ -108,31 +110,21 @@ export const readTemplate: (templatePath: string) => string = (
 
 export const getInstruction: (
   packageManager: PackageManager,
-) => string = (pm) => `
+  port: number,
+) => Message = (pm, port) =>
+  message`
 To start the server, run the following command:
 
-  ${getDevCommand(pm)}
+  ${commandLine(getDevCommand(pm))}
 
 Then, try look up an actor from your server:
 
-  ${
-  colors.bold(colors.green(
-    "fedify lookup http://localhost:8000/users/john",
-  ))
-}
+  ${commandLine(`fedify lookup http://localhost:${port}/users/john`)}
 
 `;
 
-const getDevCommand = (pm: PackageManager) =>
-  colors.bold(
-    colors.green(
-      pm === "deno"
-        ? "deno task dev"
-        : pm === "bun"
-        ? "bun dev"
-        : `${pm} run dev`,
-    ),
-  );
+export const getDevCommand = (pm: PackageManager) =>
+  pm === "deno" ? "deno task dev" : pm === "bun" ? "bun dev" : `${pm} run dev`;
 
 async function isCommandAvailable(
   { checkCommand, outputPattern }: {
@@ -181,20 +173,23 @@ export const isDirectoryEmpty = async (
   }
 };
 
+/**
+ * Converts a package manager to its corresponding runtime.
+ * @param pm - The package manager (deno, bun, npm, yarn, pnpm)
+ * @returns The runtime name (deno, bun, or node)
+ */
+export const packageManagerToRuntime = (
+  pm: PackageManager,
+): "deno" | "bun" | "node" =>
+  pm === "deno" ? "deno" : pm === "bun" ? "bun" : "node";
+
 export const getNextInitCommand = (
   pm: PackageManager,
-): string[] => [
-  ...createNextAppCommand(pm),
-  ".",
-  "--ts",
-  "--app",
-  "--biome",
-  "--skip-install",
-];
+): string[] => [...createNextAppCommand(pm), ".", "--yes"];
 
 const createNextAppCommand = (pm: PackageManager): string[] =>
   pm === "deno"
-    ? ["deno", "run", "-A", "npm:create-next-app@latest"]
+    ? ["deno", "-Ar", "npm:create-next-app@latest"]
     : pm === "bun"
     ? ["bun", "create", "next-app"]
     : pm === "npm"
@@ -208,6 +203,10 @@ export const getNitroInitCommand = (
   pm === "deno" ? "npm:giget@latest" : "giget@latest",
   "nitro",
   ".",
+  "&&",
+  "rm",
+  "nitro.config.ts", // Remove default nitro config file
+  // This file will be created from template
 ];
 
 const createNitroAppCommand = (pm: PackageManager): string[] =>
@@ -218,3 +217,7 @@ const createNitroAppCommand = (pm: PackageManager): string[] =>
     : pm === "npm"
     ? ["npx"]
     : [pm, "dlx"];
+
+export const isTest: <
+  T extends { testMode: boolean },
+>({ testMode }: T) => boolean = ({ testMode }) => testMode;

package/src/init/mod.ts

@@ -1,2 +1,3 @@
 export { default as runInit } from "./action/mod.ts";
-export { initCommand } from "./command.ts";
+export { initCommand, testInitCommand } from "./command.ts";
+export { default as runTestInit } from "./test/action.ts";

package/src/init/templates/nitro/.env.test.tpl

@@ -0,0 +1 @@
+HOST=127.0.0.1

package/src/init/templates/nitro/nitro.config.ts.tpl

@@ -1,5 +1,14 @@
-// https://nitro.unjs.io/config
+import { defineNitroConfig } from "nitropack/config"
+
+// https://nitro.build/config
 export default defineNitroConfig({
+  errorHandler: "~/error",
+  esbuild: {
+    options: {
+      target: "esnext",
+    },
+  },
+  compatibilityDate: "latest",
   srcDir: "server",
-  errorHandler: "~/error"
-});
+  imports: false
+});