counterfact 2.5.1 → 2.7.0

package/dist/server/counterfact-types/open-api-response.ts

@@ -0,0 +1,22 @@
+import type { MediaType } from "./media-type.js";
+import type { OpenApiContent } from "./open-api-content.js";
+
+/**
+ * Describes a single HTTP response as modelled in an OpenAPI document.
+ * Contains the allowed content types, optional named examples, and the
+ * required/optional response headers for that response.
+ */
+export interface OpenApiResponse {
+  content: { [key: MediaType]: OpenApiContent };
+  examples?: { [key: string]: unknown };
+  headers: { [key: string]: { schema: unknown } };
+  requiredHeaders: string;
+}
+
+/**
+ * A map of HTTP status codes (or `"default"`) to their corresponding
+ * `OpenApiResponse` definitions for a given operation.
+ */
+export interface OpenApiResponses {
+  [key: string]: OpenApiResponse;
+}

package/dist/server/counterfact-types/random-function.ts

@@ -0,0 +1,9 @@
+import type { COUNTERFACT_RESPONSE } from "./counterfact-response.js";
+import type { MaybePromise } from "./maybe-promise.js";
+
+/**
+ * The type of the `.random()` method on the response builder.
+ * When called, it randomly selects one of the available content-type examples
+ * and returns a completed `COUNTERFACT_RESPONSE`.
+ */
+export type RandomFunction = () => MaybePromise<COUNTERFACT_RESPONSE>;

package/dist/server/counterfact-types/response-builder-factory.ts

@@ -0,0 +1,16 @@
+import type { GenericResponseBuilder } from "./generic-response-builder.js";
+import type { OpenApiResponses } from "./open-api-response.js";
+
+/**
+ * Maps each HTTP status code (or `"default"`) in an OpenAPI operation's
+ * response definitions to the corresponding `GenericResponseBuilder`.
+ * This is the type of the `response` property in a generated route handler's
+ * argument object, allowing handlers to call e.g. `response[200].json(body)`.
+ */
+export type ResponseBuilderFactory<
+  Responses extends OpenApiResponses = OpenApiResponses,
+> = {
+  [StatusCode in keyof Responses]: GenericResponseBuilder<
+    Responses[StatusCode]
+  >;
+} & { [key: string]: GenericResponseBuilder<Responses["default"]> };

package/dist/server/counterfact-types/response-builder.ts

@@ -0,0 +1,31 @@
+import type { CookieOptions } from "./cookie-options.js";
+import type { MaybePromise } from "./maybe-promise.js";
+
+/**
+ * A loosely-typed, chainable response builder used in non-generated contexts
+ * (e.g. middleware or wide/catch-all route handlers) where the exact response
+ * shape is not statically known. For generated route handlers, prefer the
+ * strongly-typed `GenericResponseBuilder`.
+ */
+export interface ResponseBuilder {
+  [status: number | `${number} ${string}`]: ResponseBuilder;
+  binary: (body: Uint8Array | string) => ResponseBuilder;
+  content?: { body: unknown; type: string }[];
+  cookie: (
+    name: string,
+    value: string,
+    options?: CookieOptions,
+  ) => ResponseBuilder;
+  empty: () => ResponseBuilder;
+  example: (name: string) => ResponseBuilder;
+  header: (name: string, value: string) => ResponseBuilder;
+  headers: { [name: string]: string | string[] };
+  html: (body: unknown) => ResponseBuilder;
+  json: (body: unknown) => ResponseBuilder;
+  match: (contentType: string, body: unknown) => ResponseBuilder;
+  random: () => MaybePromise<ResponseBuilder>;
+  randomLegacy: () => MaybePromise<ResponseBuilder>;
+  status?: number;
+  text: (body: unknown) => ResponseBuilder;
+  xml: (body: unknown) => ResponseBuilder;
+}

package/dist/server/counterfact-types/wide-operation-argument.ts

@@ -0,0 +1,17 @@
+import type { WideResponseBuilder } from "./wide-response-builder.js";
+
+/**
+ * The loosely-typed argument object passed to wide (catch-all) route handlers.
+ * Unlike the generated operation argument types, all fields are typed as
+ * `unknown` or broad index signatures. Use this when writing handlers that
+ * should accept any request without compile-time schema enforcement.
+ */
+export interface WideOperationArgument {
+  body: unknown;
+  context: unknown;
+  headers: { [key: string]: string };
+  path: { [key: string]: string };
+  proxy: (url: string) => { proxyUrl: string };
+  query: { [key: string]: string };
+  response: { [key: number]: WideResponseBuilder };
+}

package/dist/server/counterfact-types/wide-response-builder.ts

@@ -0,0 +1,26 @@
+import type { CookieOptions } from "./cookie-options.js";
+import type { MaybePromise } from "./maybe-promise.js";
+
+/**
+ * A loosely-typed response builder used in wide (catch-all) route handlers
+ * where the response shape is not known at compile time. Unlike the generated
+ * `GenericResponseBuilder`, this interface accepts `unknown` for all body
+ * arguments and does not enforce content-type constraints.
+ */
+export interface WideResponseBuilder {
+  binary: (body: Uint8Array | string) => WideResponseBuilder;
+  empty: () => WideResponseBuilder;
+  example: (name: string) => WideResponseBuilder;
+  cookie: (
+    name: string,
+    value: string,
+    options?: CookieOptions,
+  ) => WideResponseBuilder;
+  header: (body: unknown) => WideResponseBuilder;
+  html: (body: unknown) => WideResponseBuilder;
+  json: (body: unknown) => WideResponseBuilder;
+  match: (contentType: string, body: unknown) => WideResponseBuilder;
+  random: () => MaybePromise<WideResponseBuilder>;
+  text: (body: unknown) => WideResponseBuilder;
+  xml: (body: unknown) => WideResponseBuilder;
+}

package/dist/server/create-koa-app.js

@@ -1,11 +1,9 @@
-import { pathToFileURL } from "node:url";
 import createDebug from "debug";
 import Koa from "koa";
 import bodyParser from "koa-bodyparser";
 import { koaSwagger } from "koa2-swagger-ui";
 import { adminApiMiddleware } from "./admin-api-middleware.js";
 import { openapiMiddleware } from "./openapi-middleware.js";
-import { pageMiddleware } from "./page-middleware.js";
 const debug = createDebug("counterfact:server:create-koa-app");
 export function createKoaApp(registry, koaMiddleware, config, contextRegistry) {
     const app = new Koa();
@@ -21,30 +19,13 @@ export function createKoaApp(registry, koaMiddleware, config, contextRegistry) {
     }
     debug("basePath: %s", config.basePath);
     debug("routes", registry.routes);
-    app.use(pageMiddleware("/counterfact/", "index", {
-        basePath: config.basePath,
-        methods: ["get", "post", "put", "delete", "patch"],
-        openApiHref: config.openApiPath.includes("://")
-            ? config.openApiPath
-            : pathToFileURL(config.openApiPath).href,
-        openApiPath: config.openApiPath,
-        get routes() {
-            return registry.routes;
-        },
-    }));
     app.use(async (ctx, next) => {
         if (ctx.URL.pathname === "/counterfact") {
-            ctx.redirect("/counterfact/");
+            ctx.redirect("/counterfact/swagger");
             return;
         }
         await next();
     });
-    app.use(pageMiddleware("/counterfact/rapidoc", "rapi-doc", {
-        basePath: config.basePath,
-        get routes() {
-            return registry.routes;
-        },
-    }));
     app.use(bodyParser());
     app.use(async (ctx, next) => {
         await next();

package/dist/server/determine-module-kind.js

@@ -6,7 +6,7 @@ export async function determineModuleKind(modulePath) {
     if (modulePath.endsWith(".cjs")) {
         return "commonjs";
     }
-    if (modulePath.endsWith(".mjs")) {
+    if (modulePath.endsWith(".mjs") || modulePath.endsWith(".ts")) {
         return "module";
     }
     if (modulePath === path.parse(modulePath).root) {

package/dist/server/dispatcher.js

@@ -2,6 +2,8 @@ import { mediaTypes } from "@hapi/accept";
 import createDebugger from "debug";
 import fetch, { Headers } from "node-fetch";
 import { createResponseBuilder } from "./response-builder.js";
+import { validateRequest } from "./request-validator.js";
+import { validateResponse } from "./response-validator.js";
 import { Tools } from "./tools.js";
 const debug = createDebugger("counterfact:server:dispatcher");
 function parseCookies(cookieHeader) {
@@ -17,7 +19,8 @@ function parseCookies(cookieHeader) {
             try {
                 cookies[key] = decodeURIComponent(value);
             }
-            catch {
+            catch (error) {
+                debug("could not decode cookie value for key %s: %o", key, error);
                 cookies[key] = value;
             }
         }
@@ -39,12 +42,12 @@ export class Dispatcher {
     }
     parameterTypes(parameters) {
         const types = {
-            body: {},
-            cookie: {},
-            formData: {},
-            header: {},
-            path: {},
-            query: {},
+            body: new Map(),
+            cookie: new Map(),
+            formData: new Map(),
+            header: new Map(),
+            path: new Map(),
+            query: new Map(),
         };
         if (!parameters) {
             return types;
@@ -52,8 +55,7 @@ export class Dispatcher {
         for (const parameter of parameters) {
             const type = parameter?.type;
             if (type !== undefined) {
-                types[parameter.in][parameter.name] =
-                    type === "integer" ? "number" : type;
+                types[parameter.in].set(parameter.name, type === "integer" ? "number" : type);
             }
         }
         return types;
@@ -130,14 +132,14 @@ export class Dispatcher {
         }
         return false;
     }
-    async request({ auth, body, headers = {}, method, path, query, req, }) {
+    async request({ auth, body, headers = {}, method, path, query, rawBody, req, }) {
         debug(`request: ${method} ${path}`);
         debug(`headers: ${JSON.stringify(headers)}`);
         debug(`body: ${JSON.stringify(body)}`);
         // If the incoming path includes the base path, remove it
         if (this.openApiDocument?.basePath !== undefined &&
             path.toLowerCase().startsWith(this.openApiDocument.basePath.toLowerCase())) {
-            path = path.replace(new RegExp(this.openApiDocument.basePath, "iu"), "");
+            path = path.slice(this.openApiDocument.basePath.length);
         }
         const { matchedPath } = this.registry.handler(path, method);
         if (!this.registry.exists(method, path) &&
@@ -150,6 +152,16 @@ export class Dispatcher {
             };
         }
         const operation = this.operationForPathAndMethod(matchedPath, method);
+        if (this.config?.validateRequests !== false) {
+            const validation = validateRequest(operation, { body, headers, query });
+            if (!validation.valid) {
+                return {
+                    body: `Request validation failed:\n${validation.errors.join("\n")}`,
+                    contentType: "text/plain",
+                    status: 400,
+                };
+            }
+        }
         const continuousDistribution = (min, max) => {
             return min + Math.random() * (max - min);
         };
@@ -166,12 +178,9 @@ export class Dispatcher {
             cookie: parseCookies(headers.cookie ?? headers.Cookie ?? ""),
             headers,
             proxy: async (url) => {
-                if (body !== undefined && headers.contentType !== "application/json") {
-                    throw new Error(`$.proxy() is currently limited to application/json requests. You tried to proxy to ${url} with a Content-Type of ${headers.contentType ?? "[unknown]"}. Please open an issue at https://github.com/pmcelhaney/counterfact/issues and prod me to fix this limitation.`);
-                }
                 delete headers.host;
                 const fetchResponse = await this.fetch(`${url}${req.path ?? ""}`, {
-                    body: body === undefined ? undefined : JSON.stringify(body),
+                    body: body === undefined ? undefined : rawBody,
                     headers: new Headers(headers),
                     method,
                 });
@@ -202,6 +211,21 @@ export class Dispatcher {
                 status: 406,
             };
         }
+        if (this.config?.validateResponses !== false) {
+            const validation = validateResponse(operation, normalizedResponse);
+            if (!validation.valid) {
+                return {
+                    ...normalizedResponse,
+                    appendedHeaders: [
+                        ...(normalizedResponse.appendedHeaders ?? []),
+                        ...validation.errors.map((error) => [
+                            "response-type-error",
+                            error,
+                        ]),
+                    ],
+                };
+            }
+        }
         return normalizedResponse;
     }
 }

package/dist/server/file-discovery.js

@@ -0,0 +1,34 @@
+import { existsSync } from "node:fs";
+import fs from "node:fs/promises";
+import nodePath from "node:path";
+import { escapePathForWindows } from "../util/windows-escape.js";
+const JS_EXTENSIONS = new Set(["cjs", "cts", "js", "mjs", "mts", "ts"]);
+export class FileDiscovery {
+    basePath;
+    constructor(basePath) {
+        this.basePath = basePath.replaceAll("\\", "/");
+    }
+    async findFiles(directory = "") {
+        const fullDir = nodePath
+            .join(this.basePath, directory)
+            .replaceAll("\\", "/");
+        if (!existsSync(fullDir)) {
+            throw new Error(`Directory does not exist ${fullDir}`);
+        }
+        const entries = await fs.readdir(fullDir, { withFileTypes: true });
+        const results = await Promise.all(entries.map(async (entry) => {
+            if (entry.isDirectory()) {
+                return this.findFiles(nodePath.join(directory, entry.name).replaceAll("\\", "/"));
+            }
+            const extension = entry.name.split(".").at(-1);
+            if (!JS_EXTENSIONS.has(extension ?? "")) {
+                return [];
+            }
+            const fullPath = nodePath
+                .join(this.basePath, directory, entry.name)
+                .replaceAll("\\", "/");
+            return [escapePathForWindows(fullPath)];
+        }));
+        return results.flat();
+    }
+}

package/dist/server/json-to-xml.js

@@ -50,5 +50,5 @@ export function jsonToXml(json, schema, keyName = "root") {
     if (typeof json === "object" && json !== null) {
         return objectToXml(json, schema, name);
     }
-    return `<${name}>${String(json)}</${name}>`;
+    return `<${name}>${xmlEscape(String(json))}</${name}>`;
 }

package/dist/server/koa-middleware.js

@@ -49,7 +49,7 @@ export function koaMiddleware(dispatcher, config, proxy = koaProxy) {
             return await next();
         }
         const auth = getAuthObject(ctx);
-        const { body, headers, query } = ctx.request;
+        const { body, headers, query, rawBody } = ctx.request;
         const path = ctx.request.path.slice(routePrefix.length);
         const method = ctx.request.method;
         if (isProxyEnabledForPath(path, config) && proxyUrl) {
@@ -69,6 +69,7 @@ export function koaMiddleware(dispatcher, config, proxy = koaProxy) {
             path,
             /* @ts-expect-error the value of a querystring item can be an array and we don't have a solution for that yet */
             query,
+            rawBody: method === "HEAD" || method === "GET" ? undefined : rawBody,
             req: { path: "", ...ctx.req },
         });
         ctx.body = response.body;
@@ -88,6 +89,11 @@ export function koaMiddleware(dispatcher, config, proxy = koaProxy) {
                 }
             }
         }
+        if (response.appendedHeaders) {
+            for (const [key, value] of response.appendedHeaders) {
+                ctx.res.appendHeader(key, value);
+            }
+        }
         ctx.status = response.status ?? HTTP_STATUS_CODE_OK;
         return undefined;
     };

package/dist/server/load-openapi-document.js

@@ -0,0 +1,13 @@
+import { dereference } from "@apidevtools/json-schema-ref-parser";
+import createDebug from "debug";
+const debug = createDebug("counterfact:server:load-openapi-document");
+export async function loadOpenApiDocument(source) {
+    try {
+        return (await dereference(source));
+    }
+    catch (error) {
+        debug("could not load OpenAPI document from %s: %o", source, error);
+        const details = error instanceof Error ? error.message : String(error);
+        throw new Error(`Could not load the OpenAPI spec from "${source}".\n${details}`, { cause: error });
+    }
+}

package/dist/server/middleware-detector.js

@@ -0,0 +1,8 @@
+export function isContextModule(module) {
+    return "Context" in module && typeof module.Context === "function";
+}
+export function isMiddlewareModule(module) {
+    return ("middleware" in module &&
+        typeof Object.getOwnPropertyDescriptor(module, "middleware")?.value ===
+            "function");
+}

package/dist/server/module-dependency-graph.js

@@ -1,12 +1,15 @@
 import { dirname, resolve } from "node:path";
+import createDebug from "debug";
 import precinct from "precinct";
+const debug = createDebug("counterfact:server:module-dependency-graph");
 export class ModuleDependencyGraph {
     dependents = new Map();
     loadDependencies(path) {
         try {
             return precinct.paperwork(path);
         }
-        catch {
+        catch (error) {
+            debug("could not load dependencies for %s: %o", path, error);
             return [];
         }
     }

package/dist/server/module-loader.js

@@ -1,5 +1,4 @@
 import { once } from "node:events";
-import { existsSync } from "node:fs";
 import fs from "node:fs/promises";
 import nodePath, { basename, dirname } from "node:path";
 import { watch } from "chokidar";
@@ -7,33 +6,34 @@ import createDebug from "debug";
 import { CHOKIDAR_OPTIONS } from "./constants.js";
 import { ContextRegistry } from "./context-registry.js";
 import { determineModuleKind } from "./determine-module-kind.js";
+import { FileDiscovery } from "./file-discovery.js";
+import { isContextModule, isMiddlewareModule, } from "./middleware-detector.js";
 import { ModuleDependencyGraph } from "./module-dependency-graph.js";
 import { uncachedImport } from "./uncached-import.js";
+import { unescapePathForWindows } from "../util/windows-escape.js";
 const { uncachedRequire } = await import("./uncached-require.cjs");
 const debug = createDebug("counterfact:server:module-loader");
-import { escapePathForWindows, unescapePathForWindows, } from "../util/windows-escape.js";
-function isContextModule(module) {
-    return "Context" in module && typeof module.Context === "function";
-}
-function isMiddlewareModule(module) {
-    return ("middleware" in module &&
-        typeof Object.getOwnPropertyDescriptor(module, "middleware")?.value ===
-            "function");
-}
 export class ModuleLoader extends EventTarget {
     basePath;
     registry;
     watcher;
+    scenariosWatcher;
     contextRegistry;
+    scenariosPath;
+    scenarioRegistry;
     dependencyGraph = new ModuleDependencyGraph();
+    fileDiscovery;
     uncachedImport = async function (moduleName) {
         throw new Error(`uncachedImport not set up; importing ${moduleName}`);
     };
-    constructor(basePath, registry, contextRegistry = new ContextRegistry()) {
+    constructor(basePath, registry, contextRegistry = new ContextRegistry(), scenariosPath, scenarioRegistry) {
         super();
         this.basePath = basePath.replaceAll("\\", "/");
         this.registry = registry;
         this.contextRegistry = contextRegistry;
+        this.scenariosPath = scenariosPath?.replaceAll("\\", "/");
+        this.scenarioRegistry = scenarioRegistry;
+        this.fileDiscovery = new FileDiscovery(this.basePath);
     }
     async watch() {
         this.watcher = watch(this.basePath, CHOKIDAR_OPTIONS).on("all", (eventName, pathNameOriginal) => {
@@ -42,7 +42,7 @@ export class ModuleLoader extends EventTarget {
                 return;
             const pathName = pathNameOriginal.replaceAll("\\", "/");
             if (pathName.includes("$.context") && eventName === "add") {
-                process.stdout.write(`\n\n!!! The file at ${pathName} needs a minor update.\n    See https://github.com/pmcelhaney/counterfact/blob/main/docs/context-change.md\n\n\n`);
+                process.stdout.write(`\n\n!!! The file at ${pathName} needs a minor update.\n    See https://github.com/pmcelhaney/counterfact/blob/main/docs/faq.md\n\n\n`);
                 return;
             }
             if (!["add", "change", "unlink"].includes(eventName)) {
@@ -55,6 +55,9 @@ export class ModuleLoader extends EventTarget {
             if (eventName === "unlink") {
                 this.registry.remove(url);
                 this.dispatchEvent(new Event("remove"));
+                if (this.isContextFile(pathName)) {
+                    this.contextRegistry.remove(unescapePathForWindows(parts.dir).replaceAll("\\", "/") || "/");
+                }
                 return;
             }
             const dependencies = this.dependencyGraph.dependentsOf(pathName);
@@ -64,32 +67,78 @@ export class ModuleLoader extends EventTarget {
             }
         });
         await once(this.watcher, "ready");
+        if (this.scenariosPath && this.scenarioRegistry) {
+            const JS_EXTENSIONS = ["js", "mjs", "cjs", "ts", "mts", "cts"];
+            const scenariosPath = this.scenariosPath;
+            this.scenariosWatcher = watch(scenariosPath, CHOKIDAR_OPTIONS).on("all", (eventName, pathNameOriginal) => {
+                if (!JS_EXTENSIONS.some((ext) => pathNameOriginal.endsWith(`.${ext}`)))
+                    return;
+                if (!["add", "change", "unlink"].includes(eventName))
+                    return;
+                const pathName = pathNameOriginal.replaceAll("\\", "/");
+                if (eventName === "unlink") {
+                    const fileKey = this.scenarioFileKey(pathName);
+                    this.scenarioRegistry?.remove(fileKey);
+                    return;
+                }
+                void this.loadScenarioFile(pathName);
+            });
+            await once(this.scenariosWatcher, "ready");
+        }
     }
     async stopWatching() {
         await this.watcher?.close();
+        await this.scenariosWatcher?.close();
+    }
+    isContextFile(pathName) {
+        return basename(pathName).startsWith("_.context.");
     }
     async load(directory = "") {
-        if (!existsSync(nodePath.join(this.basePath, directory).replaceAll("\\", "/"))) {
-            throw new Error(`Directory does not exist ${this.basePath}`);
+        const files = await this.fileDiscovery.findFiles(directory);
+        await Promise.all(files.map((file) => this.loadEndpoint(file)));
+        await this.loadScenarios();
+    }
+    shouldLoadScenarioFile(pathName) {
+        return !pathName.endsWith(".d.ts") && !pathName.endsWith(".map");
+    }
+    async loadScenarios() {
+        if (!this.scenariosPath || !this.scenarioRegistry)
+            return;
+        try {
+            const fileDiscovery = new FileDiscovery(this.scenariosPath);
+            const files = await fileDiscovery.findFiles();
+            const loadableFiles = files.filter((file) => this.shouldLoadScenarioFile(file));
+            await Promise.all(loadableFiles.map((file) => this.loadScenarioFile(file)));
         }
-        const files = await fs.readdir(nodePath.join(this.basePath, directory).replaceAll("\\", "/"), {
-            withFileTypes: true,
-        });
-        const imports = files.flatMap(async (file) => {
-            const extension = file.name.split(".").at(-1);
-            if (file.isDirectory()) {
-                await this.load(nodePath.join(directory, file.name).replaceAll("\\", "/"));
-                return;
-            }
-            if (!["cjs", "cts", "js", "mjs", "mts", "ts"].includes(extension ?? "")) {
-                return;
+        catch {
+            // Scenarios directory does not exist yet — that's fine.
+        }
+    }
+    scenarioFileKey(pathName) {
+        const normalizedScenariosPath = (this.scenariosPath ?? "").replaceAll("\\", "/");
+        const directory = dirname(pathName.slice(normalizedScenariosPath.length)).replaceAll("\\", "/");
+        const name = nodePath.parse(basename(pathName)).name;
+        const url = unescapePathForWindows(`/${nodePath.join(directory, name)}`
+            .replaceAll("\\", "/")
+            .replaceAll(/\/+/gu, "/"));
+        return url.slice(1); // strip leading "/"
+    }
+    async loadScenarioFile(pathName) {
+        if (!this.scenariosPath || !this.scenarioRegistry)
+            return;
+        const fileKey = this.scenarioFileKey(pathName);
+        try {
+            const doImport = (await determineModuleKind(pathName)) === "commonjs"
+                ? uncachedRequire
+                : uncachedImport;
+            const module = await doImport(pathName);
+            if (module) {
+                this.scenarioRegistry.add(fileKey, module);
             }
-            const fullPath = nodePath
-                .join(this.basePath, directory, file.name)
-                .replaceAll("\\", "/");
-            await this.loadEndpoint(escapePathForWindows(fullPath));
-        });
-        await Promise.all(imports);
+        }
+        catch (error) {
+            process.stdout.write(`\nError loading scenario ${pathName}:\n${String(error)}\n`);
+        }
     }
     async loadEndpoint(pathName) {
         debug("importing module: %s", pathName);
@@ -137,8 +186,7 @@ export class ModuleLoader extends EventTarget {
                 return;
             }
             this.dispatchEvent(new Event("add"));
-            if (basename(pathName).startsWith("_.context.") &&
-                isContextModule(endpoint)) {
+            if (this.isContextFile(pathName) && isContextModule(endpoint)) {
                 const loadContext = (path) => this.contextRegistry.find(path);
                 const contextDir = nodePath.dirname(unescapePathForWindows(pathName));
                 const readJson = async (relativePath) => {