gruber 0.2.0 → 0.4.0

package/core/http.test.js

@@ -1,8 +1,8 @@
-import { assertInstanceOf, assertEquals } from "./test-deps.js";
+import { assertInstanceOf, assertEquals, describe, it } from "./test-deps.js";
 import { defineRoute, HTTPError } from "./http.js";
 
-Deno.test("defineRoute", async (t) => {
-	await t.step("sets the method", () => {
+describe("defineRoute", () => {
+	it("sets the method", () => {
 		const result = defineRoute({
 			method: "GET",
 			pathname: "/",
@@ -11,7 +11,7 @@ Deno.test("defineRoute", async (t) => {
 		assertEquals(result.method, "GET");
 	});
 
-	await t.step("creates a URLPattern", () => {
+	it("creates a URLPattern", () => {
 		const result = defineRoute({
 			method: "GET",
 			pathname: "/hello/:name",
@@ -22,47 +22,69 @@ Deno.test("defineRoute", async (t) => {
 	});
 });
 
-Deno.test("HTTPError", async (t) => {
-	await t.step("constructor", () => {
-		const result = new HTTPError(418, "I'm a teapot");
-		assertEquals(result.status, 418);
-		assertEquals(result.statusText, "I'm a teapot");
-		assertEquals(result.name, "HTTPError");
+describe("HTTPError", () => {
+	describe("constructor", () => {
+		it("creates the error", () => {
+			const result = new HTTPError(418, "I'm a teapot");
+			assertEquals(result.status, 418);
+			assertEquals(result.statusText, "I'm a teapot");
+			assertEquals(result.name, "HTTPError");
+		});
 	});
 
-	await t.step("toResponse", () => {
-		const result = new HTTPError(200, "OK").toResponse();
-		assertEquals(result.status, 200);
-		assertEquals(result.statusText, "OK");
-	});
+	describe("toResponse", () => {
+		it("creates the error", () => {
+			const result = new HTTPError(200, "OK").toResponse();
+			assertEquals(result.status, 200);
+			assertEquals(result.statusText, "OK");
+		});
+		it("sets headers", () => {
+			const error = new HTTPError(200, "OK", null, {
+				"X-HOTEL-BAR": "Hotel Bar?",
+			});
 
-	await t.step("badRequest", () => {
-		const result = HTTPError.badRequest("body");
-		assertEquals(result.status, 400);
-		assertEquals(result.statusText, "Bad Request");
+			const result = error.toResponse();
+			assertEquals(result.headers.get("X-HOTEL-BAR"), "Hotel Bar?");
+		});
 	});
 
-	await t.step("unauthorized", () => {
-		const result = HTTPError.unauthorized();
-		assertEquals(result.status, 401);
-		assertEquals(result.statusText, "Unauthorized");
+	describe("badRequest", () => {
+		it("creates the error", () => {
+			const result = HTTPError.badRequest("body");
+			assertEquals(result.status, 400);
+			assertEquals(result.statusText, "Bad Request");
+		});
 	});
 
-	await t.step("notFound", () => {
-		const result = HTTPError.notFound();
-		assertEquals(result.status, 404);
-		assertEquals(result.statusText, "Not Found");
+	describe("unauthorized", () => {
+		it("creates the error", () => {
+			const result = HTTPError.unauthorized();
+			assertEquals(result.status, 401);
+			assertEquals(result.statusText, "Unauthorized");
+		});
 	});
 
-	await t.step("internalServerError", () => {
-		const result = HTTPError.internalServerError();
-		assertEquals(result.status, 500);
-		assertEquals(result.statusText, "Internal Server Error");
+	describe("notFound", () => {
+		it("creates the error", () => {
+			const result = HTTPError.notFound();
+			assertEquals(result.status, 404);
+			assertEquals(result.statusText, "Not Found");
+		});
 	});
 
-	await t.step("notImplemented", () => {
-		const result = HTTPError.notImplemented();
-		assertEquals(result.status, 501);
-		assertEquals(result.statusText, "Not Implemented");
+	describe("internalServerError", () => {
+		it("creates the error", () => {
+			const result = HTTPError.internalServerError();
+			assertEquals(result.status, 500);
+			assertEquals(result.statusText, "Internal Server Error");
+		});
+
+		describe("notImplemented", () => {
+			it("creates the error", () => {
+				const result = HTTPError.notImplemented();
+				assertEquals(result.status, 501);
+				assertEquals(result.statusText, "Not Implemented");
+			});
+		});
 	});
 });

package/{types/core → core}/migrator.d.ts

@@ -53,4 +53,3 @@ export type MigratorOptions<T> = {
     getRecords: () => Promise<MigrationRecord[]>;
     execute: (def: MigrationDefinition<T>, direction: "up" | "down") => void | Promise<void>;
 };
-//# sourceMappingURL=migrator.d.ts.map

package/core/migrator.test.d.ts

@@ -0,0 +1 @@
+export {};

package/{types/core → core}/mod.d.ts

@@ -3,5 +3,5 @@ export * from "./fetch-router.js";
 export * from "./http.js";
 export * from "./migrator.js";
 export * from "./postgres.js";
+export * from "./structures.js";
 export * from "./utilities.js";
-//# sourceMappingURL=mod.d.ts.map

package/core/mod.js

@@ -3,4 +3,5 @@ export * from "./fetch-router.js";
 export * from "./http.js";
 export * from "./migrator.js";
 export * from "./postgres.js";
+export * from "./structures.js";
 export * from "./utilities.js";

package/{types/core → core}/postgres.d.ts

@@ -40,4 +40,3 @@ export type MigrationDefinition = import("./migrator.js").MigrationDefinition;
 export type PostgresMigratorOptions = {
     sql: Sql;
 };
-//# sourceMappingURL=postgres.d.ts.map

package/core/structures.d.ts

@@ -0,0 +1,91 @@
+export class StructError extends Error {
+    /**
+     * @param {unknown} error
+     * @param {StructContext} context
+     * @returns {StructError}
+     */
+    static chain(error: unknown, context?: StructContext): StructError;
+    /**
+     * @param {string} message
+     * @param {string[]} path
+     * @param {StructError[]} children
+     */
+    constructor(message: string, path?: string[], children?: StructError[]);
+    path: string[];
+    children: StructError[];
+    getOneLiner(): string;
+    toFriendlyString(): string;
+    /** @returns {Iterator<StructError>} */
+    [Symbol.iterator](): Iterator<StructError>;
+}
+/**
+ * @typedef {Record<string,unknown>} Schema
+ */
+/**
+ * @template T
+ * @typedef {(input?: unknown, context?: StructContext) => T} StructExec
+ */
+/**
+ * @template T
+ * @typedef {T extends Structure<infer U> ? U : never} Infer
+ */
+/**
+ * @template T
+ */
+export class Structure<T> {
+    /**
+     * @param {string} [fallback]
+     * @returns {Structure<string>}
+     */
+    static string(fallback?: string): Structure<string>;
+    /**
+     * @param {number} [fallback]
+     * @returns {Structure<number>}
+     */
+    static number(fallback?: number): Structure<number>;
+    /**
+     * @param {boolean} fallback
+     * @returns {Structure<boolean>}
+     */
+    static boolean(fallback: boolean): Structure<boolean>;
+    /**
+     * @param {string | URL} [fallback]
+     * @returns {Structure<URL>}
+     */
+    static url(fallback?: string | URL): Structure<URL>;
+    /**
+     * @template {Record<string, Structure<any>>} U
+     * @param {U} fields
+     * @returns {Structure<{ [K in keyof U]: Infer<U[K]> }>}
+     */
+    static object<U extends Record<string, Structure<any>>>(fields: U): Structure<{ [K in keyof U]: Infer<U[K]>; }>;
+    /**
+     * **UNSTABLE** use at your own risk
+     *
+     * @template {Structure<any>} U
+     * @param {U} struct
+     * @returns {Structure<Array<Infer<U>>>}
+     */
+    static array<U_1 extends Structure<any>>(struct: U_1): Structure<Infer<U_1>[]>;
+    /**
+     * @param {Schema} schema
+     * @param {StructExec<T>} process
+     */
+    constructor(schema: Schema, process: StructExec<T>);
+    schema: Schema;
+    process: StructExec<T>;
+    getSchema(): {
+        $schema: string;
+    };
+}
+export type StructContext = {
+    path: string[];
+};
+export type StructOptions<Type, Schema> = {
+    type: 'object' | 'string' | 'url';
+    schema: Schema;
+    fn: (value: unknown, ctx: StructContext) => Type;
+};
+export type Schema = Record<string, unknown>;
+export type StructExec<T> = (input?: unknown, context?: StructContext) => T;
+export type Infer<T> = T extends Structure<infer U> ? U : never;

package/core/structures.js

@@ -0,0 +1,260 @@
+/** @typedef {{ path: string[] }} StructContext */
+
+/**
+ * @template Type
+ * @template Schema
+ * @typedef {object} StructOptions
+ * @property {'object' | 'string' | 'url'} type
+ * @property {Schema} schema
+ * @property {(value: unknown, ctx: StructContext) => Type} fn
+ */
+
+const DEFAULT_CONTEXT = { path: [] };
+
+export class StructError extends Error {
+	/**
+	 * @param {string} message
+	 * @param {string[]} path
+	 * @param {StructError[]} children
+	 */
+	constructor(message, path = [], children = []) {
+		super(message);
+		this.path = path;
+		this.children = children;
+		this.name = "StructError";
+		Error.captureStackTrace(this, StructError);
+	}
+
+	/**
+	 * @param {unknown} error
+	 * @param {StructContext} context
+	 * @returns {StructError}
+	 */
+	static chain(error, context = DEFAULT_CONTEXT) {
+		let chained;
+		if (error instanceof StructError) {
+			return error;
+		} else if (error instanceof Error) {
+			chained = new StructError(error.message, context.path);
+		} else {
+			chained = new StructError("Unknown error", context.path);
+		}
+		Error.captureStackTrace(chained, StructError.chain);
+		return chained;
+	}
+
+	getOneLiner() {
+		return (this.path.join(".") || ".") + " — " + this.message;
+	}
+
+	/** @returns {Iterator<StructError>} */
+	*[Symbol.iterator]() {
+		if (this.children.length === 0) {
+			yield this;
+		} else {
+			for (const child of this.children) {
+				yield* child;
+			}
+		}
+	}
+
+	toFriendlyString() {
+		const messages = [];
+		for (const child of this) {
+			messages.push("  " + child.getOneLiner());
+		}
+
+		return [
+			this.message,
+			...messages.toSorted((a, b) => a.localeCompare(b)),
+		].join("\n");
+	}
+}
+
+/**
+ * @typedef {Record<string,unknown>} Schema
+ */
+
+/**
+ * @template T
+ * @typedef {(input?: unknown, context?: StructContext) => T} StructExec
+ */
+
+/**
+ * @template T
+ * @typedef {T extends Structure<infer U> ? U : never} Infer
+ */
+
+/**
+ * @template T
+ */
+export class Structure {
+	/**
+	 * @param {Schema} schema
+	 * @param {StructExec<T>} process
+	 */
+	constructor(schema, process) {
+		this.schema = schema;
+		this.process = process;
+	}
+
+	getSchema() {
+		return {
+			$schema: "https://json-schema.org/draft/2020-12/schema",
+			...this.schema,
+		};
+	}
+
+	/**
+	 * @param {string} [fallback]
+	 * @returns {Structure<string>}
+	 */
+	static string(fallback = undefined) {
+		const schema = { type: "string" };
+		if (fallback !== undefined) schema.default = fallback;
+
+		return new Structure(schema, (input = fallback, context = undefined) => {
+			if (input === undefined) {
+				throw new StructError("Missing value", context?.path);
+			}
+			if (typeof input !== "string") {
+				throw new StructError("Expected a string", context?.path);
+			}
+			return input;
+		});
+	}
+
+	/**
+	 * @param {number} [fallback]
+	 * @returns {Structure<number>}
+	 */
+	static number(fallback) {
+		const schema = { type: "number" };
+		if (fallback !== undefined) schema.default = fallback;
+
+		return new Structure(schema, (input = fallback, context = undefined) => {
+			if (input === undefined) {
+				throw new StructError("Missing value", context?.path);
+			}
+			// if (typeof input === "string") {
+			// 	const parsed = Number.parseFloat(input);
+			// 	if (!Number.isNaN(parsed)) return parsed;
+			// }
+			if (typeof input !== "number") {
+				throw new StructError("Expected a number", context?.path);
+			}
+			return input;
+		});
+	}
+
+	/**
+	 * @param {boolean} fallback
+	 * @returns {Structure<boolean>}
+	 */
+	static boolean(fallback) {
+		const schema = { type: "boolean" };
+		if (fallback !== undefined) schema.default = fallback;
+
+		return new Structure(schema, (input, context) => {
+			if (input === undefined) return fallback;
+			if (typeof input !== "boolean") {
+				throw new StructError("Not a boolean", context?.path);
+			}
+			return input;
+		});
+	}
+
+	/**
+	 * @param {string | URL} [fallback]
+	 * @returns {Structure<URL>}
+	 */
+	static url(fallback) {
+		const schema = { type: "string", format: "uri" };
+		if (fallback !== undefined) schema.default = fallback.toString();
+
+		// ~ make sure the fallback is valid ~
+		const url = fallback ? new URL(fallback) : undefined;
+		return new Structure(schema, (input = url, context = undefined) => {
+			if (input === undefined) {
+				throw new StructError("Missing value", context?.path);
+			}
+			if (input instanceof URL) return input;
+			if (typeof input !== "string") {
+				throw new StructError("Not a string or URL", context?.path);
+			}
+			return new URL(input);
+		});
+	}
+
+	/**
+	 * @template {Record<string, Structure<any>>} U
+	 * @param {U} fields
+	 * @returns {Structure<{ [K in keyof U]: Infer<U[K]> }>}
+	 */
+	static object(fields) {
+		const schema = {
+			type: "object",
+			properties: {},
+			default: {},
+			additionalProperties: false,
+		};
+		for (const [key, struct] of Object.entries(fields)) {
+			schema.properties[key] = struct.schema;
+		}
+		return new Structure(schema, (input = {}, context = undefined) => {
+			const path = context?.path ?? [];
+			if (input && typeof input !== "object") {
+				throw new StructError("Expected an object", path);
+			}
+			const output = {};
+			const errors = [];
+			for (const key in fields) {
+				const ctx = { path: [...path, key] };
+				try {
+					output[key] = fields[key].process(input[key], ctx);
+				} catch (error) {
+					errors.push(StructError.chain(error, ctx));
+				}
+			}
+			if (errors.length > 0) {
+				throw new StructError("Object does not match schema", path, errors);
+			}
+			return output;
+		});
+	}
+
+	/**
+	 * **UNSTABLE** use at your own risk
+	 *
+	 * @template {Structure<any>} U
+	 * @param {U} struct
+	 * @returns {Structure<Array<Infer<U>>>}
+	 */
+	static array(struct) {
+		const schema = {
+			type: "array",
+			items: struct.schema,
+			default: [],
+		};
+		return new Structure(schema, (input = [], context = undefined) => {
+			const path = context?.path ?? [];
+			if (!Array.isArray(input)) {
+				throw new StructError("Expected an array", path);
+			}
+			const output = [];
+			const errors = [];
+			for (let i = 0; i < input.length; i++) {
+				const ctx = { path: [...path, `${i}`] };
+				try {
+					output.push(struct.process(input[i], ctx));
+				} catch (error) {
+					errors.push(StructError.chain(error, ctx));
+				}
+			}
+			if (errors.length > 0) {
+				throw new StructError("Array item does not match schema", path, errors);
+			}
+			return output;
+		});
+	}
+}

package/core/structures.test.d.ts

@@ -0,0 +1 @@
+export {};