@benclmnt/postmock 0.0.1

package/dist/src/discover.d.ts

@@ -0,0 +1,16 @@
+export interface Discovered {
+    url: URL;
+    module: unknown;
+}
+/** `.ts` when Node runs the sources, `.js` in the built package: discovered files share it. */
+export declare const MODULE_EXTENSION: string;
+/**
+ * Imports modules found on disk, sorted by path, so parallel tracks add files without editing a
+ * shared list (docs/11 §5). Names starting with `.` are skipped (macOS `._*` files).
+ * Without `file`: each module file in `dir` (`MODULE_EXTENSION`), tests excluded.
+ * With `file`: `<subdir>/<file><MODULE_EXTENSION>` for each subdirectory; a subdirectory without it
+ * throws.
+ */
+export declare function importAll(dir: URL, file?: string): Promise<Discovered[]>;
+/** The default export of a discovered module, which must be a function. */
+export declare function defaultFunction<F extends (...args: never[]) => unknown>(found: Discovered): F;

package/dist/src/discover.js

@@ -0,0 +1,49 @@
+var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExtension) || function (path, preserveJsx) {
+    if (typeof path === "string" && /^\.\.?\//.test(path)) {
+        return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {
+            return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : (d + ext + "." + cm.toLowerCase() + "js");
+        });
+    }
+    return path;
+};
+import { existsSync, readdirSync } from "node:fs";
+import { extname } from "node:path";
+import { fileURLToPath } from "node:url";
+/** `.ts` when Node runs the sources, `.js` in the built package: discovered files share it. */
+export const MODULE_EXTENSION = extname(fileURLToPath(import.meta.url));
+const visible = (name) => !name.startsWith(".");
+/**
+ * Imports modules found on disk, sorted by path, so parallel tracks add files without editing a
+ * shared list (docs/11 §5). Names starting with `.` are skipped (macOS `._*` files).
+ * Without `file`: each module file in `dir` (`MODULE_EXTENSION`), tests excluded.
+ * With `file`: `<subdir>/<file><MODULE_EXTENSION>` for each subdirectory; a subdirectory without it
+ * throws.
+ */
+export async function importAll(dir, file) {
+    const ext = MODULE_EXTENSION;
+    const entries = readdirSync(dir, { withFileTypes: true }).filter((e) => visible(e.name));
+    const urls = file === undefined
+        ? entries
+            .filter((e) => e.isFile() && e.name.endsWith(ext) && !e.name.endsWith(`.test${ext}`))
+            .map((e) => new URL(e.name, dir))
+        : entries
+            .filter((e) => e.isDirectory())
+            .map((e) => {
+            const url = new URL(`${e.name}/${file}${ext}`, dir);
+            if (!existsSync(url))
+                throw new Error(`${new URL(`${e.name}/`, dir).pathname}: ${e.name} has no ${file}${ext}`);
+            return url;
+        });
+    urls.sort((a, b) => (a.href < b.href ? -1 : 1));
+    const found = [];
+    for (const url of urls)
+        found.push({ url, module: await import(__rewriteRelativeImportExtension(url.href)) });
+    return found;
+}
+/** The default export of a discovered module, which must be a function. */
+export function defaultFunction(found) {
+    const value = found.module.default;
+    if (typeof value !== "function")
+        throw new Error(`${found.url.pathname} has no default export function`);
+    return value;
+}

package/dist/src/errors.d.ts

@@ -0,0 +1,49 @@
+export declare const ERROR_FAMILIES: readonly ["auth", "global", "sending", "templates", "servers", "messages", "inboundRules", "streams", "suppressions", "senders", "smtpTokens", "stats", "dataRemovals", "webhooks"];
+export type ErrorFamily = (typeof ERROR_FAMILIES)[number];
+/** HTTP statuses a code uses. 200 means the code only appears inside a 200 body item. */
+type Statuses = readonly [number, ...number[]];
+type Row = readonly [
+    code: number,
+    family: ErrorFamily,
+    statuses: Statuses,
+    wording: "message" | "summary",
+    text: string
+];
+export declare const ERROR_TABLE: readonly Row[];
+export type ErrorBody = {
+    ErrorCode: number;
+    Message: string;
+};
+/** A Postmark error response. The HTTP app turns it into the envelope (docs/02 §4.1). */
+export declare class ApiError extends Error {
+    readonly status: number;
+    readonly body: ErrorBody & Record<string, unknown>;
+    constructor(status: number, body: ErrorBody & Record<string, unknown>);
+}
+export type ErrorOptions = {
+    /** Required for a code listed under more than one family (614, 1226). */
+    family?: ErrorFamily;
+} & ({
+    /** Exact wire text, used as given. Required for a `summary` row. */
+    message: string;
+    params?: never;
+} | {
+    message?: never;
+    /** Values for `{name}` placeholders in a `message` row. */
+    params?: Record<string, string>;
+});
+/** Whether the docs/02 §4.4 row of `code` is a summary that needs an exact message. */
+export declare const isSummaryRow: (code: number, family?: ErrorFamily) => boolean;
+/** `{ErrorCode, Message}` for a response body or a batch item. */
+export declare function errorBody(code: number, options?: ErrorOptions): ErrorBody;
+/** An HTTP error for `code`. `status` is required when the code uses several statuses. */
+export declare function apiError(code: number, options?: ErrorOptions & {
+    status?: number;
+    extra?: Record<string, unknown>;
+}): ApiError;
+/**
+ * The HTTP error for a body `errorBody` built earlier, such as a send rejection. The code may sit
+ * under several families; every row of it must use the same single status.
+ */
+export declare function apiErrorOf(body: ErrorBody): ApiError;
+export {};