gruber 0.2.0 → 0.4.0

package/core/configuration.test.js

@@ -1,10 +1,8 @@
 import { Configuration } from "./configuration.js";
-import { assertEquals, assertThrows } from "./test-deps.js";
-import { superstruct } from "./test-deps.js";
+import { assertEquals, assertThrows, describe, it } from "./test-deps.js";
 
 /** @type {import("./configuration.js").ConfigurationOptions} */
 const bareOptions = {
-	superstruct,
 	readTextFile() {},
 	getEnvironmentVariable(_key) {},
 	getCommandArgument(_key) {},
@@ -12,11 +10,10 @@ const bareOptions = {
 	parse(_value) {},
 };
 
-Deno.test("Configuration", async ({ step }) => {
-	await step("constructor", async ({ step }) => {
-		await step("validates options", () => {
+describe("Configuration", () => {
+	describe("constructor", () => {
+		it("validates options", () => {
 			new Configuration({
-				superstruct,
 				readTextFile() {},
 				getEnvironmentVariable(_key) {},
 				getCommandArgument(_key) {},
@@ -26,76 +23,205 @@ Deno.test("Configuration", async ({ step }) => {
 		});
 	});
 
-	await step("object", async ({ step }) => {
+	describe("object", () => {
 		const config = new Configuration(bareOptions);
 
-		await step("stores spec", () => {
-			const result = config.object({});
+		it("stores the options", () => {
+			const result = config.object({ key: "value" });
+
 			assertEquals(result[Configuration.spec].type, "object");
-			assertEquals(result[Configuration.spec].value, {});
+			assertEquals(result[Configuration.spec].options, { key: "value" });
+		});
+		it("describes itself", () => {
+			const spec = config.object({
+				fullName: config.string({ variable: "FULL_NAME", fallback: "Geoff T" }),
+				age: config.number({ flag: "--age", fallback: 42 }),
+			});
+			//
+			const result = spec[Configuration.spec].describe(
+				"person",
+				(options, name) => ({ name, ...options }),
+			);
+
+			assertEquals(result, {
+				fallback: { fullName: "Geoff T", age: 42 },
+				fields: [
+					{
+						name: "person.fullName",
+						type: "string",
+						variable: "FULL_NAME",
+						fallback: "Geoff T",
+					},
+					{
+						name: "person.age",
+						type: "number",
+						flag: "--age",
+						fallback: 42,
+					},
+				],
+			});
 		});
 	});
 
-	await step("string", async ({ step }) => {
+	describe("string", () => {
 		const config = new Configuration(bareOptions);
 
-		await step("requires a fallback", () => {
+		it("requires a fallback", () => {
 			assertThrows(() => config.string({}), TypeError);
 		});
-
-		await step("uses the fallback", () => {
+		it("uses the fallback", () => {
 			const struct = config.string({ fallback: "Geoff Testington" });
-			const result = superstruct.create(undefined, struct);
+			const result = struct.process(undefined);
 			assertEquals(result, "Geoff Testington");
 		});
-
-		await step("stores spec", () => {
+		it("stores the options", () => {
 			const result = config.string({
 				variable: "SOME_VAR",
+				flag: "--some-flag",
 				fallback: "value",
 			});
 			assertEquals(result[Configuration.spec].type, "string");
-			assertEquals(result[Configuration.spec].value, {
+			assertEquals(result[Configuration.spec].options, {
+				variable: "SOME_VAR",
+				flag: "--some-flag",
+				fallback: "value",
+			});
+		});
+		it("describes itself", () => {
+			const spec = config.string({
 				variable: "SOME_VAR",
+				flag: "--some-flag",
+				fallback: "value",
+			});
+			const result = spec[Configuration.spec].describe("fullName");
+			assertEquals(result, {
 				fallback: "value",
+				fields: [
+					{
+						name: "fullName",
+						type: "string",
+						variable: "SOME_VAR",
+						flag: "--some-flag",
+						fallback: "value",
+					},
+				],
 			});
 		});
 	});
 
-	await step("url", async ({ step }) => {
+	describe("number", () => {
 		const config = new Configuration(bareOptions);
 
-		await step("requires a fallback", () => {
-			assertThrows(() => config.url({}), TypeError);
+		it("requires a fallback", () => {
+			assertThrows(() => config.number({}), TypeError);
+		});
+		it("uses the fallback", () => {
+			const struct = config.number({ fallback: 42 });
+			const result = struct.process(undefined);
+			assertEquals(result, 42);
+		});
+		it("stores the options", () => {
+			const result = config.number({
+				variable: "SOME_VAR",
+				flag: "--some-flag",
+				fallback: 42,
+			});
+			assertEquals(result[Configuration.spec].type, "number");
+			assertEquals(result[Configuration.spec].options, {
+				variable: "SOME_VAR",
+				flag: "--some-flag",
+				fallback: 42,
+			});
 		});
+		it("parses strings", () => {
+			const vars = { SOME_VAR: "12.34" };
+			const config = new Configuration({
+				...bareOptions,
+				getEnvironmentVariable: (key) => vars[key],
+			});
 
-		await step("converts to URL", () => {
-			const struct = config.url({ fallback: "" });
-			const result = superstruct.create("https://example.com", struct);
-			assertEquals(result, new URL("https://example.com"));
+			const result = config.number({
+				variable: "SOME_VAR",
+				fallback: 42,
+			});
+
+			assertEquals(result.process(undefined), 12.34);
 		});
+	});
 
-		await step("uses the fallback", () => {
-			const struct = config.url({ fallback: "https://example.com" });
-			const result = superstruct.create(undefined, struct);
-			assertEquals(result, new URL("https://example.com"));
+	describe("boolean", () => {
+		const config = new Configuration(bareOptions);
+
+		it("requires a fallback", () => {
+			assertThrows(() => config.boolean({}), TypeError);
+		});
+		it("uses the fallback", () => {
+			const struct = config.boolean({ fallback: false });
+			const result = struct.process(undefined);
+			assertEquals(result, false);
+		});
+		it("stores the options", () => {
+			const result = config.boolean({
+				variable: "SOME_VAR",
+				flag: "--some-flag",
+				fallback: false,
+			});
+			assertEquals(result[Configuration.spec].type, "boolean");
+			assertEquals(result[Configuration.spec].options, {
+				variable: "SOME_VAR",
+				flag: "--some-flag",
+				fallback: false,
+			});
+		});
+		it("parses strings", () => {
+			const vars = { SOME_VAR: "true" };
+			const config = new Configuration({
+				...bareOptions,
+				getEnvironmentVariable: (key) => vars[key],
+			});
+
+			const result = config.boolean({
+				variable: "SOME_VAR",
+				fallback: false,
+			});
+
+			assertEquals(result.process(undefined), true);
 		});
+	});
 
-		await step("stores spec", () => {
+	describe("url", () => {
+		const config = new Configuration(bareOptions);
+
+		it("requires a fallback", () => {
+			assertThrows(() => config.url({}), TypeError);
+		});
+		it("converts to URL", () => {
+			const struct = config.url({ fallback: "https://fallback.example.com" });
+			const result = struct.process("https://example.com");
+			assertEquals(result, new URL("https://example.com"));
+		});
+		it("uses the fallback", () => {
+			const struct = config.url({ fallback: "https://fallback.example.com" });
+			const result = struct.process(undefined);
+			assertEquals(result, new URL("https://fallback.example.com"));
+		});
+		it("stores the options", () => {
 			const result = config.url({
 				variable: "SOME_VAR",
+				flag: "--some-flag",
 				fallback: "https://example.com",
 			});
 			assertEquals(result[Configuration.spec].type, "url");
-			assertEquals(result[Configuration.spec].value, {
+			assertEquals(result[Configuration.spec].options, {
 				variable: "SOME_VAR",
-				fallback: "https://example.com",
+				flag: "--some-flag",
+				fallback: new URL("https://example.com"),
 			});
 		});
 	});
 
-	await step("_getValue", async ({ step }) => {
-		await step("uses arguments", () => {
+	describe("_getValue", () => {
+		it("uses arguments", () => {
 			const args = { "--option": "value-from-arg" };
 			const config = new Configuration({
 				...bareOptions,
@@ -104,10 +230,12 @@ Deno.test("Configuration", async ({ step }) => {
 			const result = config._getValue({
 				flag: "--option",
 			});
-			assertEquals(result, "value-from-arg");
+			assertEquals(result, {
+				source: "argument",
+				value: "value-from-arg",
+			});
 		});
-
-		await step("uses environment variables", () => {
+		it("uses environment variables", () => {
 			const env = { MY_VAR: "value-from-env" };
 			const config = new Configuration({
 				...bareOptions,
@@ -116,17 +244,78 @@ Deno.test("Configuration", async ({ step }) => {
 			const result = config._getValue({
 				variable: "MY_VAR",
 			});
-			assertEquals(result, "value-from-env");
+			assertEquals(result, {
+				source: "variable",
+				value: "value-from-env",
+			});
 		});
-
-		await step("uses the fallback", () => {
+		it("uses the fallback", () => {
 			const config = new Configuration(bareOptions);
 			const result = config._getValue({ fallback: "value-from-fallback" });
-			assertEquals(result, "value-from-fallback");
+			assertEquals(result, {
+				source: "fallback",
+				value: "value-from-fallback",
+			});
+		});
+	});
+
+	describe("_parseFloat", () => {
+		it("parses strings", () => {
+			const config = new Configuration(bareOptions);
+			assertEquals(
+				config._parseFloat({ source: "argument", value: "12.34" }),
+				12.34,
+				"should parse the float from the result",
+			);
+		});
+		it("passes numbers through", () => {
+			const config = new Configuration(bareOptions);
+			assertEquals(
+				config._parseFloat({ source: "fallback", value: 98.76 }),
+				98.76,
+				"should preserve number literals",
+			);
+		});
+	});
+
+	describe("_parseBoolean", () => {
+		it("parses strings", () => {
+			const config = new Configuration(bareOptions);
+			assertEquals(
+				config._parseBoolean({ source: "argument", value: "1" }),
+				true,
+			);
+			assertEquals(
+				config._parseBoolean({ source: "argument", value: "true" }),
+				true,
+			);
+			assertEquals(
+				config._parseBoolean({ source: "argument", value: "0" }),
+				false,
+			);
+			assertEquals(
+				config._parseBoolean({ source: "argument", value: "false" }),
+				false,
+			);
+		});
+		it("passes booleans through", () => {
+			const config = new Configuration(bareOptions);
+			assertEquals(
+				config._parseBoolean({ source: "fallback", value: true }),
+				true,
+				"should preserve boolean literals",
+			);
+		});
+		it("allows empty-string for arguments", () => {
+			const config = new Configuration(bareOptions);
+			assertEquals(
+				config._parseBoolean({ source: "argument", value: "" }),
+				true,
+			);
 		});
 	});
 
-	await step("load", async ({ step }) => {
+	describe("load", () => {
 		const files = {
 			"config.json":
 				'{"env":"production","meta":{"version":"1.2.3"},"selfUrl":"https://example.com"}',
@@ -146,7 +335,7 @@ Deno.test("Configuration", async ({ step }) => {
 			selfUrl: config.url({ fallback: "http://localhost" }),
 		});
 
-		await step("loads config", async () => {
+		it("loads config", async () => {
 			const result = await config.load("config.json", spec);
 			assertEquals(result, {
 				env: "production",
@@ -155,7 +344,7 @@ Deno.test("Configuration", async ({ step }) => {
 			});
 		});
 
-		await step("uses the fallback", async () => {
+		it("uses the fallback", async () => {
 			const result = await config.load("missing-config.json", spec);
 			assertEquals(result, {
 				env: "development",
@@ -165,10 +354,10 @@ Deno.test("Configuration", async ({ step }) => {
 		});
 	});
 
-	await step("describeSpecification", async ({ step }) => {
-		await step("processes strings", () => {
+	describe("describe", () => {
+		it("processes strings", () => {
 			const config = new Configuration(bareOptions);
-			const result = config.describeSpecification(
+			const result = config.describe(
 				config.string({
 					fallback: "test-app",
 					variable: "APP_NAME",
@@ -188,9 +377,9 @@ Deno.test("Configuration", async ({ step }) => {
 			]);
 		});
 
-		await step("processes urls", () => {
+		it("processes urls", () => {
 			const config = new Configuration(bareOptions);
-			const result = config.describeSpecification(
+			const result = config.describe(
 				config.url({
 					fallback: "https://example.com",
 					variable: "SELF_URL",
@@ -203,16 +392,16 @@ Deno.test("Configuration", async ({ step }) => {
 				{
 					name: "selfUrl",
 					type: "url",
-					fallback: "https://example.com",
+					fallback: new URL("https://example.com"),
 					variable: "SELF_URL",
 					flag: "--self-url",
 				},
 			]);
 		});
 
-		await step("processes objects", () => {
+		it("processes objects", () => {
 			const config = new Configuration(bareOptions);
-			const result = config.describeSpecification(
+			const result = config.describe(
 				config.object({
 					name: config.string({
 						fallback: "testing-app",

package/{types/core → core}/fetch-router.d.ts

@@ -49,4 +49,3 @@ export type FetchRouterOptions = {
     routes?: import("./types.ts").RouteDefinition<any>[];
     errorHandler?: RouteErrorHandler;
 };
-//# sourceMappingURL=fetch-router.d.ts.map

package/core/fetch-router.test.d.ts

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

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

@@ -26,23 +26,42 @@
  */
 export function defineRoute<T extends string>(init: import("./types.ts").RouteOptions<T>): import("./types.ts").RouteDefinition<T>;
 export class HTTPError extends Error {
-    /** https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/400 */
-    static badRequest(): HTTPError;
-    /** https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/401 */
-    static unauthorized(): HTTPError;
-    /** https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/404 */
-    static notFound(): HTTPError;
-    /** https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/500 */
-    static internalServerError(): HTTPError;
-    /** https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/501 */
-    static notImplemented(): HTTPError;
+    /**
+     * https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/400
+     * @param {BodyInit} [body]
+     */
+    static badRequest(body?: BodyInit): HTTPError;
+    /**
+     * https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/401
+     * @param {BodyInit} [body]
+     */
+    static unauthorized(body?: BodyInit): HTTPError;
+    /**
+     * https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/404
+     * @param {BodyInit} [body]
+     */
+    static notFound(body?: BodyInit): HTTPError;
+    /**
+     * https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/500
+     * @param {BodyInit} [body]
+     */
+    static internalServerError(body?: BodyInit): HTTPError;
+    /**
+     * https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/501
+     * @param {BodyInit} [body]
+     */
+    static notImplemented(body?: BodyInit): HTTPError;
     /**
      * @param {number} status
      * @param {string} statusText
+     * @param {BodyInit|null|undefined} [body=null]
+     * @param {HeadersInit} [headers=undefined]
      */
-    constructor(status?: number, statusText?: string);
+    constructor(status?: number, statusText?: string, body?: BodyInit | null | undefined, headers?: HeadersInit);
     /** @type {number} */ status: number;
     /** @type {string}*/ statusText: string;
+    body: BodyInit;
+    headers: Headers;
     toResponse(): Response;
 }
 export type HTTPMethod = import("./types.ts").HTTPMethod;
@@ -52,4 +71,3 @@ export type RouteContext<T> = import("./types.ts").RouteContext<T>;
 export type RouteHandler<T> = import("./types.ts").RouteHandler<T>;
 export type RouteOptions<T extends string> = import("./types.ts").RouteOptions<T>;
 export type RouteDefinition<T = any> = import("./types.ts").RouteDefinition<T>;
-//# sourceMappingURL=http.d.ts.map

package/core/http.js

@@ -41,29 +41,44 @@ export function defineRoute(init) {
 // NOTE: add more error codes as needed
 // NOTE: design an API for setting the body on static errors
 export class HTTPError extends Error {
-	/** https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/400 */
-	static badRequest() {
-		return new HTTPError(400, "Bad Request");
+	/**
+	 * https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/400
+	 * @param {BodyInit} [body]
+	 */
+	static badRequest(body = undefined) {
+		return new HTTPError(400, "Bad Request", body);
 	}
 
-	/** https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/401 */
-	static unauthorized() {
-		return new HTTPError(401, "Unauthorized");
+	/**
+	 * https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/401
+	 * @param {BodyInit} [body]
+	 */
+	static unauthorized(body = undefined) {
+		return new HTTPError(401, "Unauthorized", body);
 	}
 
-	/** https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/404 */
-	static notFound() {
-		return new HTTPError(404, "Not Found");
+	/**
+	 * https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/404
+	 * @param {BodyInit} [body]
+	 */
+	static notFound(body = undefined) {
+		return new HTTPError(404, "Not Found", body);
 	}
 
-	/** https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/500 */
-	static internalServerError() {
-		return new HTTPError(500, "Internal Server Error");
+	/**
+	 * https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/500
+	 * @param {BodyInit} [body]
+	 */
+	static internalServerError(body = undefined) {
+		return new HTTPError(500, "Internal Server Error", body);
 	}
 
-	/** https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/501 */
-	static notImplemented() {
-		return new HTTPError(501, "Not Implemented");
+	/**
+	 * https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/501
+	 * @param {BodyInit} [body]
+	 */
+	static notImplemented(body = undefined) {
+		return new HTTPError(501, "Not Implemented", body);
 	}
 
 	/** @type {number} */ status;
@@ -72,19 +87,29 @@ export class HTTPError extends Error {
 	/**
 	 * @param {number} status
 	 * @param {string} statusText
+	 * @param {BodyInit|null|undefined} [body=null]
+	 * @param {HeadersInit} [headers=undefined]
 	 */
-	constructor(status = 200, statusText = "OK") {
+	constructor(
+		status = 200,
+		statusText = "OK",
+		body = null,
+		headers = undefined,
+	) {
 		super(statusText);
 		this.status = status;
 		this.statusText = statusText;
+		this.body = body;
 		this.name = "HTTPError";
+		this.headers = new Headers(headers);
 		Error.captureStackTrace(this, HTTPError);
 	}
 
 	toResponse() {
-		return new Response(null, {
+		return new Response(this.body, {
 			status: this.status,
 			statusText: this.statusText,
+			headers: this.headers,
 		});
 	}
 }

package/core/http.test.d.ts

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