@liase/core 1.0.0

package/dist/lib/networkRequestsCache.d.ts

@@ -0,0 +1,23 @@
+import type { OptionsInit as GotOptionsInit } from "got-scraping";
+import type { QueryOptions } from "../schemas/queryOptions.js";
+type CacheableRequest = {
+    url: string;
+    method: string;
+    headers: Record<string, string>;
+    body: string;
+    headerGeneratorOptions: GotOptionsInit["headerGeneratorOptions"];
+};
+type CachedResponse = {
+    body: string;
+    statusCode: number;
+    headers: Record<string, string>;
+    cachedOn: Date;
+    request: {
+        headers: Record<string, string>;
+    };
+};
+export declare function getCachedResponse(req: CacheableRequest): Promise<CachedResponse | undefined>;
+export declare function cacheResponse(req: CacheableRequest, res: Omit<CachedResponse, "cachedOn">): Promise<void>;
+export declare function addCachingFetchWrapper(originalFetch: typeof fetch, cacheNetworkRequests: QueryOptions["cacheNetworkRequests"]): typeof fetch;
+export {};
+//# sourceMappingURL=networkRequestsCache.d.ts.map

package/dist/lib/networkRequestsCache.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"networkRequestsCache.d.ts","sourceRoot":"","sources":["../../src/lib/networkRequestsCache.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,WAAW,IAAI,cAAc,EAAE,MAAM,cAAc,CAAC;AAElE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,4BAA4B,CAAC;AAK/D,KAAK,gBAAgB,GAAG;IACtB,GAAG,EAAE,MAAM,CAAC;IACZ,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAChC,IAAI,EAAE,MAAM,CAAC;IAIb,sBAAsB,EAAE,cAAc,CAAC,wBAAwB,CAAC,CAAC;CAClE,CAAC;AAEF,KAAK,cAAc,GAAG;IACpB,IAAI,EAAE,MAAM,CAAC;IACb,UAAU,EAAE,MAAM,CAAC;IACnB,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAChC,QAAQ,EAAE,IAAI,CAAC;IACf,OAAO,EAAE;QACP,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;KACjC,CAAC;CACH,CAAC;AAEF,wBAAsB,iBAAiB,CACrC,GAAG,EAAE,gBAAgB,GACpB,OAAO,CAAC,cAAc,GAAG,SAAS,CAAC,CAoBrC;AAED,wBAAsB,aAAa,CACjC,GAAG,EAAE,gBAAgB,EACrB,GAAG,EAAE,IAAI,CAAC,cAAc,EAAE,UAAU,CAAC,iBAQtC;AASD,wBAAgB,sBAAsB,CACpC,aAAa,EAAE,OAAO,KAAK,EAC3B,oBAAoB,EAAE,YAAY,CAAC,sBAAsB,CAAC,GACzD,OAAO,KAAK,CAkDd"}

package/dist/lib/networkRequestsCache.js

@@ -0,0 +1,81 @@
+import cacache from "cacache";
+import stringify from "json-stable-stringify";
+import { headersToNormalisedBasicObject, parseFetchArgs } from "./fetch.js";
+const cacheDir = "/tmp/liase/network-requests-cache/custom";
+export async function getCachedResponse(req) {
+    const key = getCacheKeyFromReq(req);
+    try {
+        const { data } = await cacache.get(cacheDir, key);
+        const cachedValue = JSON.parse(data.toString());
+        return {
+            ...cachedValue,
+            cachedOn: new Date(cachedValue.cachedOn),
+        };
+    }
+    catch (error) {
+        if (typeof error === "object" &&
+            error &&
+            "code" in error &&
+            error.code === "ENOENT") {
+            return undefined;
+        }
+        throw error;
+    }
+}
+export async function cacheResponse(req, res) {
+    const key = getCacheKeyFromReq(req);
+    const value = {
+        ...res,
+        cachedOn: Date.now(),
+    };
+    await cacache.put(cacheDir, key, JSON.stringify(value));
+}
+function getCacheKeyFromReq(req) {
+    return (stringify([req.url, req.method, Object.entries(req.headers), req.body]) ||
+        "");
+}
+export function addCachingFetchWrapper(originalFetch, cacheNetworkRequests) {
+    return async (input, init) => {
+        if (cacheNetworkRequests === "auto") {
+            throw Error(`The "auto" value for the cacheNetworkRequests option is not yet supported. Sorry!`);
+        }
+        const { url, body, headers, method } = parseFetchArgs(input, init);
+        const cacheableRequest = {
+            url: url.href,
+            body: await body,
+            headers,
+            method,
+            headerGeneratorOptions: undefined,
+        };
+        let res;
+        if (cacheNetworkRequests === "always") {
+            res = await getCachedResponse(cacheableRequest);
+            if (res) {
+                return new Response(res.body, {
+                    headers: res.headers,
+                    status: res.statusCode,
+                    statusText: `Cached on: ${res.cachedOn.getTime()}`,
+                });
+            }
+        }
+        else {
+            cacheNetworkRequests;
+        }
+        res = await originalFetch(input, init);
+        if (cacheNetworkRequests === "always") {
+            const clonedRes = res.clone();
+            await cacheResponse(cacheableRequest, {
+                statusCode: clonedRes.status,
+                body: await clonedRes.text(),
+                headers: headersToNormalisedBasicObject(clonedRes.headers),
+                request: {
+                    headers,
+                },
+            });
+        }
+        else {
+            cacheNetworkRequests;
+        }
+        return res;
+    };
+}

package/dist/lib/networkRequestsHistory.d.ts

@@ -0,0 +1,21 @@
+export type NetworkRequestsHistoryItem = {
+    constructorPath: (string | number)[];
+    request: {
+        url: URL;
+        method: string;
+        headers: Record<string, string>;
+        body?: string | Promise<string>;
+    };
+    response: {
+        headers: Record<string, string>;
+        body: string | Promise<string>;
+        statusCode: number;
+        cached: boolean;
+        cachedOn: Date | null;
+    };
+};
+export declare function exportNetworkRequestsHistory({ networkRequestsHistory, }: {
+    networkRequestsHistory: NetworkRequestsHistoryItem[];
+}): Promise<void>;
+export declare function exportNetworkRequestsHistoryIfRelevantError(error: unknown): Promise<void>;
+//# sourceMappingURL=networkRequestsHistory.d.ts.map

package/dist/lib/networkRequestsHistory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"networkRequestsHistory.d.ts","sourceRoot":"","sources":["../../src/lib/networkRequestsHistory.ts"],"names":[],"mappings":"AASA,MAAM,MAAM,0BAA0B,GAAG;IACvC,eAAe,EAAE,CAAC,MAAM,GAAG,MAAM,CAAC,EAAE,CAAC;IACrC,OAAO,EAAE;QACP,GAAG,EAAE,GAAG,CAAC;QACT,MAAM,EAAE,MAAM,CAAC;QACf,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;QAChC,IAAI,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;KACjC,CAAC;IACF,QAAQ,EAAE;QACR,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;QAChC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;QAC/B,UAAU,EAAE,MAAM,CAAC;QACnB,MAAM,EAAE,OAAO,CAAC;QAChB,QAAQ,EAAE,IAAI,GAAG,IAAI,CAAC;KACvB,CAAC;CACH,CAAC;AAEF,wBAAsB,4BAA4B,CAAC,EACjD,sBAAsB,GACvB,EAAE;IACD,sBAAsB,EAAE,0BAA0B,EAAE,CAAC;CACtD,iBA+FA;AAED,wBAAsB,2CAA2C,CAC/D,KAAK,EAAE,OAAO,iBAgCf"}

package/dist/lib/networkRequestsHistory.js

@@ -0,0 +1,119 @@
+import crypto from "node:crypto";
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import chalk from "chalk";
+import mimeTypes from "mime-types";
+import { ActionContext } from "../ActionContext.js";
+import { timeSince } from "./time.js";
+export async function exportNetworkRequestsHistory({ networkRequestsHistory, }) {
+    if (!networkRequestsHistory.length) {
+        return;
+    }
+    const tmpDir = path.join(os.tmpdir(), "liase-exports", Date.now().toString());
+    try {
+        await fs.access(tmpDir);
+    }
+    catch (error) {
+        await fs.mkdir(tmpDir, { recursive: true });
+    }
+    const constructorPathCount = {};
+    for (const networkRequestsHistoryItem of networkRequestsHistory) {
+        const constructorPath = networkRequestsHistoryItem.constructorPath.join(".");
+        if (!constructorPathCount[constructorPath]) {
+            constructorPathCount[constructorPath] = 1;
+        }
+        else {
+            constructorPathCount[constructorPath]++;
+        }
+        const mimeType = networkRequestsHistoryItem.response.headers["content-type"];
+        const ext = mimeTypes.extension(mimeType ?? "") || "txt";
+        const constructorPathStr = networkRequestsHistoryItem.constructorPath
+            .map((value) => (typeof value === "number" ? `[${value}]` : value))
+            .join(".");
+        const count = constructorPathCount[constructorPath];
+        const urlPart = networkRequestsHistoryItem.request.url.href
+            .replaceAll(/(?:^\w+:\/\/|\/+$)/g, "")
+            .replaceAll("/", ".");
+        const makeBasename = (url) => `${[constructorPathStr, count, url].join("_")}.${ext}`;
+        // Most OSes enforce a 255-character limit on filenames. URLs (especially
+        // those with long query strings) can easily exceed this, so we truncate the
+        // URL portion and append a short hash to keep the name unique.
+        const MAX_BASENAME_LENGTH = 242; // 255 minus len(".metadata.txt")
+        let basename = makeBasename(urlPart);
+        if (basename.length > MAX_BASENAME_LENGTH) {
+            const hash = crypto
+                .createHash("sha256")
+                .update(urlPart)
+                .digest("hex")
+                .slice(0, 12);
+            const prefix = `${[constructorPathStr, count].join("_")}_`;
+            const suffix = `_${hash}.${ext}`;
+            const availableForUrl = MAX_BASENAME_LENGTH - prefix.length - suffix.length;
+            const truncatedUrl = availableForUrl > 0 ? urlPart.slice(0, availableForUrl) : "";
+            basename = `${prefix}${truncatedUrl}${suffix}`;
+        }
+        const filename = path.join(tmpDir, basename);
+        let body;
+        if (ext === "json") {
+            body = JSON.stringify(JSON.parse(await networkRequestsHistoryItem.response.body), null, 2);
+        }
+        else {
+            body = await networkRequestsHistoryItem.response.body;
+        }
+        await fs.writeFile(filename, body);
+        await fs.writeFile(`${filename}.metadata.txt`, [
+            `Request URL: ${networkRequestsHistoryItem.request.url.href}`,
+            "",
+            `Request method: ${networkRequestsHistoryItem.request.method}`,
+            "",
+            "Request headers:",
+            Object.entries(networkRequestsHistoryItem.request.headers)
+                .map(([key, value]) => `  ${key}: ${value}`)
+                .join("\n"),
+            "",
+            `Response cached: ${networkRequestsHistoryItem.response.cachedOn
+                ? `Yes (${timeSince(networkRequestsHistoryItem.response.cachedOn)})`
+                : "No"}`,
+            "",
+            "Response headers:",
+            Object.entries(networkRequestsHistoryItem.response.headers)
+                .map(([key, value]) => `  ${key}: ${value}`)
+                .join("\n"),
+            "",
+            `Status code: ${networkRequestsHistoryItem.response.statusCode}`,
+        ].join("\n"));
+    }
+    console.info(chalk.bold("To assist with debugging all requests made with loadUrl have been exported to:"), tmpDir);
+}
+export async function exportNetworkRequestsHistoryIfRelevantError(error) {
+    if (!(error instanceof Error)) {
+        return;
+    }
+    let networkRequestsHistory;
+    if ("actionContext" in error &&
+        error.actionContext instanceof ActionContext) {
+        // Most likely error is an instance of ConstructorExecutionError
+        networkRequestsHistory = error.actionContext.networkRequestsHistory;
+    }
+    else if ("context" in error && error.context instanceof ActionContext) {
+        // Most likely error is an instance of ZodFriendlyError thrown when parsing the result.
+        const rootActionContext = error.context;
+        const allActionContexts = [
+            rootActionContext,
+            ...rootActionContext.descendants,
+        ];
+        const networkRequestsHistorySet = new Set();
+        for (const actionContext of allActionContexts) {
+            for (const networkRequestsHistoryItem of actionContext.networkRequestsHistory) {
+                networkRequestsHistorySet.add(networkRequestsHistoryItem);
+            }
+        }
+        networkRequestsHistory = [...networkRequestsHistorySet];
+    }
+    if (networkRequestsHistory) {
+        await exportNetworkRequestsHistory({
+            networkRequestsHistory,
+        });
+    }
+}

package/dist/lib/time.d.ts

@@ -0,0 +1,2 @@
+export declare function timeSince(date: Date): string;
+//# sourceMappingURL=time.d.ts.map

package/dist/lib/time.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"time.d.ts","sourceRoot":"","sources":["../../src/lib/time.ts"],"names":[],"mappings":"AAKA,wBAAgB,SAAS,CAAC,IAAI,EAAE,IAAI,UA4BnC"}

package/dist/lib/time.js

@@ -0,0 +1,31 @@
+const timePeriodFormatter = new Intl.RelativeTimeFormat("en", {
+    localeMatcher: "best fit",
+    numeric: "auto",
+});
+export function timeSince(date) {
+    if (Number.isNaN(date.getTime())) {
+        throw Error("Invalid date");
+    }
+    const seconds = Math.floor((date.getTime() - Date.now()) / 1000);
+    let interval = seconds / 31536000;
+    if (interval < -1) {
+        return timePeriodFormatter.format(Math.trunc(interval), "year");
+    }
+    interval = seconds / 2592000;
+    if (interval < -1) {
+        return timePeriodFormatter.format(Math.trunc(interval), "month");
+    }
+    interval = seconds / 86400;
+    if (interval < -1) {
+        return timePeriodFormatter.format(Math.trunc(interval), "day");
+    }
+    interval = seconds / 3600;
+    if (interval < -1) {
+        return timePeriodFormatter.format(Math.trunc(interval), "hours");
+    }
+    interval = seconds / 60;
+    if (interval < -1) {
+        return timePeriodFormatter.format(Math.trunc(interval), "minutes");
+    }
+    return timePeriodFormatter.format(Math.trunc(interval), "seconds");
+}

package/dist/lib/utils.d.ts

@@ -0,0 +1,46 @@
+import type { ActionContext } from "../ActionContext.js";
+export declare function createCounter(): () => number;
+export declare function getRandomIntOfScale(scale?: number): number;
+export declare function getRandomIntInRange(min?: number, max?: number): number;
+export declare const getUniqueId: () => string;
+export declare function mergeInUnsetProperties(a: object, b: object): {};
+export declare const formatObjectPath: (path: (string | number)[]) => string;
+export declare const formatObjectPathAsTree: (path: (string | number)[], options: {
+    lineIndent?: number;
+    overallIndent?: number;
+    lastNodeExtraInfo?: string;
+}) => string;
+declare const returnType: (v: unknown) => "string" | "number" | "bigint" | "boolean" | "symbol" | "undefined" | "object" | "function";
+type TypeOfTypes = ReturnType<typeof returnType>;
+export declare const capitaliseType: (type: TypeOfTypes | "array" | "set" | "date") => string;
+type ConstructorExecutionErrorOptions = {
+    cause?: Error;
+    log: string[];
+    message?: string;
+    actionContext: ActionContext;
+};
+export declare class ConstructorExecutionError extends Error {
+    errorOccurredAtPath: (string | number)[];
+    log: string[];
+    actionContext: ActionContext;
+    constructor({ message, cause, actionContext, log, }: ConstructorExecutionErrorOptions);
+    getFormattedErrorInfo(): string;
+}
+type ValueType = "string" | "number" | "bigint" | "boolean" | "symbol" | "undefined" | "object" | "function" | "array";
+export declare const getType: (value: unknown) => ValueType;
+export declare function hasNoDuplicates(array: unknown[]): boolean;
+export declare function getDuplicates<T>(array: T[]): T[];
+export declare function getOrdinal(number: number): string;
+export declare function getPromiseWithResolvers<Expected = unknown>(): {
+    promise: Promise<Expected>;
+    resolve: (value: Expected) => void;
+    reject: (reason?: any) => void;
+};
+export type ObjectEntry<BaseType> = [keyof BaseType, BaseType[keyof BaseType]];
+export declare function waitForAllPropertiesToResolve<ObjectWithPromises>(object: {
+    [key in keyof ObjectWithPromises]: ObjectWithPromises[key];
+}): Promise<{
+    [key in keyof ObjectWithPromises]: Awaited<ObjectWithPromises[key]>;
+}>;
+export {};
+//# sourceMappingURL=utils.d.ts.map

package/dist/lib/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../src/lib/utils.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAEzD,wBAAgB,aAAa,iBAM5B;AAKD,wBAAgB,mBAAmB,CAAC,KAAK,SAAI,UAI5C;AAGD,wBAAgB,mBAAmB,CAAC,GAAG,SAAI,EAAE,GAAG,SAAU,UAIzD;AAED,eAAO,MAAM,WAAW,cAGpB,CAAC;AAGL,wBAAgB,sBAAsB,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,MAE1D;AAED,eAAO,MAAM,gBAAgB,GAAI,MAAM,CAAC,MAAM,GAAG,MAAM,CAAC,EAAE,WAK3C,CAAC;AAEhB,eAAO,MAAM,sBAAsB,GACjC,MAAM,CAAC,MAAM,GAAG,MAAM,CAAC,EAAE,EACzB,SAAS;IACP,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,iBAAiB,CAAC,EAAE,MAAM,CAAC;CAC5B,WA0CF,CAAC;AAKF,QAAA,MAAM,UAAU,GAAI,GAAG,OAAO,gGAAa,CAAC;AAC5C,KAAK,WAAW,GAAG,UAAU,CAAC,OAAO,UAAU,CAAC,CAAC;AAEjD,eAAO,MAAM,cAAc,GACzB,MAAM,WAAW,GAAG,OAAO,GAAG,KAAK,GAAG,MAAM,KAC3C,MAoBF,CAAC;AAEF,KAAK,gCAAgC,GAAG;IACtC,KAAK,CAAC,EAAE,KAAK,CAAC;IACd,GAAG,EAAE,MAAM,EAAE,CAAC;IACd,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,aAAa,EAAE,aAAa,CAAC;CAC9B,CAAC;AACF,qBAAa,yBAA0B,SAAQ,KAAK;IAClD,mBAAmB,sBAAC;IACpB,GAAG,WAAC;IACJ,aAAa,gBAAC;gBAEF,EACV,OAAO,EACP,KAAK,EACL,aAAa,EACb,GAAG,GACJ,EAAE,gCAAgC;IAoBnC,qBAAqB;CAqBtB;AAED,KAAK,SAAS,GACV,QAAQ,GACR,QAAQ,GACR,QAAQ,GACR,SAAS,GACT,QAAQ,GACR,WAAW,GACX,QAAQ,GACR,UAAU,GACV,OAAO,CAAC;AAEZ,eAAO,MAAM,OAAO,GAAI,OAAO,OAAO,KAAG,SAKxC,CAAC;AAEF,wBAAgB,eAAe,CAAC,KAAK,EAAE,OAAO,EAAE,GAAG,OAAO,CAEzD;AAED,wBAAgB,aAAa,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,GAAG,CAAC,EAAE,CAUhD;AAED,wBAAgB,UAAU,CAAC,MAAM,EAAE,MAAM,UAgBxC;AAED,wBAAgB,uBAAuB,CAAC,QAAQ,GAAG,OAAO;;qBACnC,QAAQ,KAAK,IAAI;sBAEhB,GAAG,KAAK,IAAI;EAcnC;AAED,MAAM,MAAM,WAAW,CAAC,QAAQ,IAAI,CAAC,MAAM,QAAQ,EAAE,QAAQ,CAAC,MAAM,QAAQ,CAAC,CAAC,CAAC;AAG/E,wBAAsB,6BAA6B,CAAC,kBAAkB,EACpE,MAAM,EAAE;KACL,GAAG,IAAI,MAAM,kBAAkB,GAAG,kBAAkB,CAAC,GAAG,CAAC;CAC3D,GACA,OAAO,CAAC;KACR,GAAG,IAAI,MAAM,kBAAkB,GAAG,OAAO,CAAC,kBAAkB,CAAC,GAAG,CAAC,CAAC;CACpE,CAAC,CAqBD"}

package/dist/lib/utils.js

@@ -0,0 +1,208 @@
+import chalk from "chalk";
+export function createCounter() {
+    let counter = -1;
+    return () => {
+        counter = counter === Number.MAX_SAFE_INTEGER ? 0 : counter + 1;
+        return counter;
+    };
+}
+// Now that getUniqueId uses a counter to ensure there are no id clashes due to having the same timestamp,
+// we don't really need to use a random int but I had fun writing these functions and don't want to get rid
+// of them. So until there's a reason to I'm not going to.
+export function getRandomIntOfScale(scale = 6) {
+    const min = 10 ** (scale - 1);
+    const max = 10 ** scale - 1;
+    return getRandomIntInRange(min, max);
+}
+// Both min and max are inclusive
+export function getRandomIntInRange(min = 0, max = 999_999) {
+    return Math.floor(Math.random() * (Math.floor(max) - Math.ceil(min) + 1) + Math.ceil(min));
+}
+export const getUniqueId = (() => {
+    const counter = createCounter();
+    return () => `${Date.now()}-${counter()}-${getRandomIntOfScale(6)}`;
+})();
+// Used to increase readability in some places
+export function mergeInUnsetProperties(a, b) {
+    return { ...b, ...a };
+}
+export const formatObjectPath = (path) => `$${path
+    .map((segment) => typeof segment === "number" ? `[${segment}]` : `.${segment}`)
+    .join("")}`;
+export const formatObjectPathAsTree = (path, options) => {
+    const lineIndent = options.lineIndent ?? 2;
+    const overallIndent = options.overallIndent ?? 0;
+    const lastNodeExtraInfo = options.lastNodeExtraInfo ?? "";
+    if (lineIndent < 2) {
+        throw Error("Line indent can not be less than 2");
+    }
+    let formattedTree = path
+        .reduce((segments, segment) => {
+        if (typeof segment === "number") {
+            const formattedSegment = `[${segment}]`;
+            if (segments.length) {
+                segments[segments.length - 1] += formattedSegment;
+            }
+            else {
+                segments.push(formattedSegment);
+            }
+        }
+        else {
+            segments.push(segment);
+        }
+        return segments;
+    }, [])
+        // If segment is a number then wrap square brackets around it to signal that
+        .map((segment) => typeof segment === "number" ? `[${segment}]` : `${segment}`)
+        .map((segment) => chalk.bold(segment))
+        // Add arrow between segments
+        // Indent each segment by lineIndent more than the last + add arrow between segments
+        .map((segment, index) => (index ? " ".repeat(index * lineIndent - 2) + chalk.dim("↳ ") : "") +
+        segment)
+        .join("\n");
+    if (lastNodeExtraInfo) {
+        formattedTree = `${formattedTree} - ${lastNodeExtraInfo.replace(/\n/, `\n${" ".repeat((path.length - 1) * lineIndent)}`)}`;
+    }
+    return formattedTree
+        .split("\n")
+        .map((line) => " ".repeat(overallIndent) + line)
+        .join("\n");
+};
+const capitalisedFirstLetter = (string) => string[0].toUpperCase() + string.substring(1);
+const returnType = (v) => typeof v;
+export const capitaliseType = (type) => {
+    let result;
+    switch (type) {
+        case "string":
+        case "number":
+        case "boolean":
+        case "symbol":
+        case "undefined":
+        case "object":
+        case "function":
+        case "array":
+        case "set":
+        case "date":
+            result = capitalisedFirstLetter(type);
+            break;
+        case "bigint":
+            result = "BigInt";
+            break;
+    }
+    return result;
+};
+export class ConstructorExecutionError extends Error {
+    errorOccurredAtPath;
+    log;
+    actionContext;
+    constructor({ message, cause, actionContext, log, }) {
+        super(message ?? cause?.message ?? "Error when executing constructor");
+        if (cause) {
+            this.stack = cause.stack;
+        }
+        // Use class name as the name of the error
+        ConstructorExecutionError.prototype.name = this.constructor.name;
+        this.errorOccurredAtPath = actionContext.path;
+        this.log = log;
+        this.actionContext = actionContext;
+        this.message = this.getFormattedErrorInfo();
+        // Explicitly set the prototype to maintain the correct prototype chain is
+        // required for "instanceOf" to work as expected
+        Object.setPrototypeOf(this, ConstructorExecutionError.prototype);
+    }
+    getFormattedErrorInfo() {
+        const stack = this.cause instanceof Error
+            ? this.cause.stack?.replace(`${this.cause.toString()}\n`, "")
+            : this.stack;
+        const lastConstructorProp = this.errorOccurredAtPath[this.errorOccurredAtPath.length - 1];
+        const errorLocation = stack
+            ?.split("\n")
+            .find((line) => line.startsWith(`    at ${lastConstructorProp}`))
+            ?.match(/\((.*)\)/)?.[1];
+        return [
+            "Failed to render the following response constructor property",
+            formatObjectPathAsTree(this.errorOccurredAtPath, {
+                lineIndent: 3,
+                overallIndent: 2,
+                lastNodeExtraInfo: `${chalk.bold(this.message)}\n(${chalk.blue(errorLocation)})`,
+            }),
+            "",
+        ].join("\n");
+    }
+}
+export const getType = (value) => {
+    if (Array.isArray(value)) {
+        return "array";
+    }
+    return typeof value;
+};
+export function hasNoDuplicates(array) {
+    return new Set(array).size === array.length;
+}
+export function getDuplicates(array) {
+    const duplicates = new Set();
+    for (let i = 0; i < array.length; i++) {
+        for (let j = i + 1; j < array.length; j++) {
+            if (array[i] === array[j]) {
+                duplicates.add(array[i]);
+            }
+        }
+    }
+    return [...duplicates];
+}
+export function getOrdinal(number) {
+    let suffix;
+    switch (number % 10) {
+        case 1:
+            suffix = "st";
+            break;
+        case 2:
+            suffix = "nd";
+            break;
+        case 3:
+            suffix = "rd";
+            break;
+        default:
+            suffix = "th";
+    }
+    return `${number}${suffix}`;
+}
+export function getPromiseWithResolvers() {
+    let resolve;
+    // biome-ignore lint/suspicious/noExplicitAny: reject reason is intentionally untyped
+    let reject;
+    const promise = new Promise((...resolvers) => {
+        resolve = resolvers[0];
+        reject = resolvers[1];
+    });
+    // @ts-expect-error The point of this is to make sure the resolvers are defined
+    if (typeof resolve === "undefined" || typeof reject === "undefined") {
+        throw Error("Resolvers not set yet");
+    }
+    return {
+        promise,
+        resolve,
+        reject,
+    };
+}
+// Takes an object and if any property values are promises it will wait until they're resolved.
+export async function waitForAllPropertiesToResolve(object) {
+    // So that we can use Promise.all() to resolve every prop in object we first convert
+    // object to an array of entries, then we swap each entry with a promise that resolves
+    // to the entry. That way we can can use Promise.all() on it to get us back to an array
+    // of entries (but now with any promises resolved), then use Object.fromEntry() to
+    // re-assemble the entries back into an object.
+    const entriesAsPromises = Object.entries(object).map((entry) => {
+        const [entryKey, entryValue] = entry;
+        if (entryValue instanceof Promise) {
+            return entryValue.then((resolvedEntryValue) => [
+                entryKey,
+                resolvedEntryValue,
+            ]);
+        }
+        // biome-ignore lint/suspicious/noExplicitAny: entry tuple cast needed for Promise.all compatibility
+        return new Promise((resolve) => resolve(entry));
+    });
+    const entriesResolved = await Promise.all(entriesAsPromises);
+    return Object.fromEntries(entriesResolved);
+}

package/dist/lib/zod.d.ts

@@ -0,0 +1,35 @@
+import type { z } from "zod";
+export declare function zodParseOrThrow<Output, Def extends z.ZodTypeDef, Input>(zodSchema: z.ZodType<Output, Def, Input>, input: any, options?: {
+    errorMessage?: string;
+    context?: unknown;
+}): Output;
+type ValueType = "string" | "number" | "bigint" | "boolean" | "symbol" | "undefined" | "object" | "function" | "array";
+export declare const getType: (value: unknown) => ValueType;
+type FriendlyZodErrorOptions = {
+    message?: string;
+    inputData?: unknown;
+    context?: unknown;
+};
+type FriendlyZodErrorIssue = {
+    zodIssue: z.ZodIssue;
+    depth: number;
+    formattedMessage: string;
+};
+type FriendlyZodErrorIssuesTree = {
+    issues: FriendlyZodErrorIssue[];
+    children: Record<string | number, FriendlyZodErrorIssuesTree>;
+};
+export declare class FriendlyZodError extends Error {
+    #private;
+    zodError: z.ZodError;
+    context: unknown;
+    constructor(error: z.ZodError, { message, inputData, context }?: FriendlyZodErrorOptions);
+    formatZodIssue(issue: z.ZodIssue, includePath?: boolean): string;
+    formatZodErrorIssues(error?: z.ZodError, depth?: number, includePath?: boolean): FriendlyZodErrorIssue[];
+    formatZodErrorIssuesAsDotPoints(error?: z.ZodError, depth?: number, indentSize?: number): string;
+    formatZodErrorIssuesAsTree(error?: z.ZodError): FriendlyZodErrorIssuesTree;
+    formatZodErrorIssuesAsTreeString(error?: z.ZodError, depth?: number, indentSize?: number): string;
+    get formattedErrorInfo(): string;
+}
+export {};
+//# sourceMappingURL=zod.d.ts.map

package/dist/lib/zod.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"zod.d.ts","sourceRoot":"","sources":["../../src/lib/zod.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAO7B,wBAAgB,eAAe,CAAC,MAAM,EAAE,GAAG,SAAS,CAAC,CAAC,UAAU,EAAE,KAAK,EACrE,SAAS,EAAE,CAAC,CAAC,OAAO,CAAC,MAAM,EAAE,GAAG,EAAE,KAAK,CAAC,EAExC,KAAK,EAAE,GAAG,EACV,OAAO,GAAE;IAAE,YAAY,CAAC,EAAE,MAAM,CAAC;IAAC,OAAO,CAAC,EAAE,OAAO,CAAA;CAAO,GACzD,MAAM,CAiBR;AAED,KAAK,SAAS,GACV,QAAQ,GACR,QAAQ,GACR,QAAQ,GACR,SAAS,GACT,QAAQ,GACR,WAAW,GACX,QAAQ,GACR,UAAU,GACV,OAAO,CAAC;AAEZ,eAAO,MAAM,OAAO,GAAI,OAAO,OAAO,KAAG,SAKxC,CAAC;AA0CF,KAAK,uBAAuB,GAAG;IAC7B,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB,CAAC;AAEF,KAAK,qBAAqB,GAAG;IAC3B,QAAQ,EAAE,CAAC,CAAC,QAAQ,CAAC;IACrB,KAAK,EAAE,MAAM,CAAC;IACd,gBAAgB,EAAE,MAAM,CAAC;CAC1B,CAAC;AACF,KAAK,0BAA0B,GAAG;IAChC,MAAM,EAAE,qBAAqB,EAAE,CAAC;IAChC,QAAQ,EAAE,MAAM,CAAC,MAAM,GAAG,MAAM,EAAE,0BAA0B,CAAC,CAAC;CAC/D,CAAC;AACF,qBAAa,gBAAiB,SAAQ,KAAK;;IAEzC,QAAQ,EAAE,CAAC,CAAC,QAAQ,CAAC;IACrB,OAAO,EAAE,OAAO,CAAC;gBAGf,KAAK,EAAE,CAAC,CAAC,QAAQ,EACjB,EAAE,OAAO,EAAE,SAAS,EAAE,OAAO,EAAE,GAAE,uBAA4B;IAqB/D,cAAc,CAAC,KAAK,EAAE,CAAC,CAAC,QAAQ,EAAE,WAAW,UAAO,GAAG,MAAM;IAyF7D,oBAAoB,CAClB,KAAK,GAAE,CAAC,CAAC,QAAwB,EACjC,KAAK,SAAI,EACT,WAAW,UAAO,GACjB,qBAAqB,EAAE;IAsD1B,+BAA+B,CAC7B,KAAK,GAAE,CAAC,CAAC,QAAwB,EACjC,KAAK,SAAI,EACT,UAAU,SAAI,GACb,MAAM;IAST,0BAA0B,CACxB,KAAK,GAAE,CAAC,CAAC,QAAwB,GAChC,0BAA0B;IAqC7B,gCAAgC,CAC9B,KAAK,GAAE,CAAC,CAAC,QAAwB,EACjC,KAAK,SAAI,EACT,UAAU,SAAI,GACb,MAAM;IAgCT,IAAI,kBAAkB,IAAI,MAAM,CAY/B;CACF"}