@riddance/host 0.0.1

package/host/registry.js

@@ -0,0 +1,61 @@
+const handlers = {};
+function addHandler(type, handler) {
+    ;
+    (handlers[type] ??= []).push(handler);
+}
+export function getHandlers(type) {
+    return (handlers[type] ?? []);
+}
+let httpHostRegistry;
+function setHttpHost(host) {
+    httpHostRegistry = host;
+}
+let metadata;
+export function setMeta(packageName, fileName, revision, config) {
+    metadata = {
+        packageName,
+        fileName,
+        revision,
+        config,
+    };
+}
+function getMetadata() {
+    return metadata;
+}
+function pathToRegExp(path) {
+    return new RegExp(('^' +
+        path.replace(/[/\\^$+?.()|[\]{}]/gu, '\\$&').replaceAll('*', '[^/\\?]+') +
+        '(\\?.*)?$').replace('[^/\\?]+[^/\\?]+(\\?.*)?$', ''), 'u');
+}
+function combineConfig(base, override) {
+    if (base === undefined) {
+        return override;
+    }
+    else if (override === undefined) {
+        return base;
+    }
+    return { ...base, ...override };
+}
+function httpHost(meta, cfg, method, path, entry) {
+    addHandler('http', {
+        meta,
+        config: combineConfig(meta?.config, cfg),
+        method,
+        pathPattern: path,
+        pathRegExp: pathToRegExp(path),
+        entry,
+    });
+}
+setHttpHost(httpHost);
+export function registerHttpHandler(method, path, configOrHandler, fn) {
+    if (typeof configOrHandler === 'function') {
+        httpHostRegistry(getMetadata(), undefined, method, path, configOrHandler);
+    }
+    else {
+        if (!fn) {
+            throw new Error('Please provide a handler function.');
+        }
+        httpHostRegistry(getMetadata(), configOrHandler, method, path, fn);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/http.d.ts

@@ -0,0 +1,39 @@
+/// <reference types="node" resolution-mode="require"/>
+import type { UrlWithParsedQuery } from 'node:url';
+import { Context, HandlerConfiguration, Json } from './context.js';
+export * from './context.js';
+export interface ResponseHeaders {
+    [key: string]: string;
+}
+export interface FullResult {
+    headers?: ResponseHeaders;
+    status?: number;
+    body?: unknown;
+}
+export declare type Result = void | string | FullResult;
+export interface HttpRequest {
+    readonly rawUrl: string;
+    readonly url: Readonly<UrlWithParsedQuery> & {
+        pathStepAt: (index: number) => string;
+    };
+    readonly headers: Readonly<ResponseHeaders>;
+    readonly body?: Json | string;
+}
+export interface HttpHandlerConfiguration extends HandlerConfiguration {
+    /**
+     * A string identifying which domains can access the endpoint cross-origin.
+     * @default undefined
+     */
+    readonly cors?: string;
+}
+export declare type Handler = (context: Context, request: HttpRequest) => Promise<Result> | Result;
+export declare function get(path: string, fn: Handler): void;
+export declare function get(path: string, config: HttpHandlerConfiguration, fn: Handler): void;
+export declare function post(path: string, fn: Handler): void;
+export declare function post(path: string, config: HttpHandlerConfiguration, fn: Handler): void;
+export declare function put(path: string, fn: Handler): void;
+export declare function put(path: string, config: HttpHandlerConfiguration, fn: Handler): void;
+export declare function patch(path: string, fn: Handler): void;
+export declare function patch(path: string, config: HttpHandlerConfiguration, fn: Handler): void;
+export declare function del(path: string, fn: Handler): void;
+export declare function del(path: string, config: HttpHandlerConfiguration, fn: Handler): void;

package/http.js

@@ -0,0 +1,18 @@
+import { registerHttpHandler } from './host/registry.js';
+export * from './context.js';
+export function get(path, configOrHandler, fn) {
+    registerHttpHandler('GET', path, configOrHandler, fn);
+}
+export function post(path, configOrHandler, fn) {
+    registerHttpHandler('POST', path, configOrHandler, fn);
+}
+export function put(path, configOrHandler, fn) {
+    registerHttpHandler('PUT', path, configOrHandler, fn);
+}
+export function patch(path, configOrHandler, fn) {
+    registerHttpHandler('PATCH', path, configOrHandler, fn);
+}
+export function del(path, configOrHandler, fn) {
+    registerHttpHandler('DELETE', path, configOrHandler, fn);
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaHR0cC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbImh0dHAudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBRUEsT0FBTyxFQUFFLG1CQUFtQixFQUFFLE1BQU0sb0JBQW9CLENBQUE7QUFFeEQsY0FBYyxjQUFjLENBQUE7QUFpQzVCLE1BQU0sVUFBVSxHQUFHLENBQ2YsSUFBWSxFQUNaLGVBQW1ELEVBQ25ELEVBQVk7SUFFWixtQkFBbUIsQ0FBQyxLQUFLLEVBQUUsSUFBSSxFQUFFLGVBQWUsRUFBRSxFQUFFLENBQUMsQ0FBQTtBQUN6RCxDQUFDO0FBR0QsTUFBTSxVQUFVLElBQUksQ0FDaEIsSUFBWSxFQUNaLGVBQW1ELEVBQ25ELEVBQVk7SUFFWixtQkFBbUIsQ0FBQyxNQUFNLEVBQUUsSUFBSSxFQUFFLGVBQWUsRUFBRSxFQUFFLENBQUMsQ0FBQTtBQUMxRCxDQUFDO0FBR0QsTUFBTSxVQUFVLEdBQUcsQ0FDZixJQUFZLEVBQ1osZUFBbUQsRUFDbkQsRUFBWTtJQUVaLG1CQUFtQixDQUFDLEtBQUssRUFBRSxJQUFJLEVBQUUsZUFBZSxFQUFFLEVBQUUsQ0FBQyxDQUFBO0FBQ3pELENBQUM7QUFHRCxNQUFNLFVBQVUsS0FBSyxDQUNqQixJQUFZLEVBQ1osZUFBbUQsRUFDbkQsRUFBWTtJQUVaLG1CQUFtQixDQUFDLE9BQU8sRUFBRSxJQUFJLEVBQUUsZUFBZSxFQUFFLEVBQUUsQ0FBQyxDQUFBO0FBQzNELENBQUM7QUFHRCxNQUFNLFVBQVUsR0FBRyxDQUNmLElBQVksRUFDWixlQUFtRCxFQUNuRCxFQUFZO0lBRVosbUJBQW1CLENBQUMsUUFBUSxFQUFFLElBQUksRUFBRSxlQUFlLEVBQUUsRUFBRSxDQUFDLENBQUE7QUFDNUQsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB0eXBlIHsgVXJsV2l0aFBhcnNlZFF1ZXJ5IH0gZnJvbSAnbm9kZTp1cmwnXHJcbmltcG9ydCB7IENvbnRleHQsIEhhbmRsZXJDb25maWd1cmF0aW9uLCBKc29uIH0gZnJvbSAnLi9jb250ZXh0LmpzJ1xyXG5pbXBvcnQgeyByZWdpc3Rlckh0dHBIYW5kbGVyIH0gZnJvbSAnLi9ob3N0L3JlZ2lzdHJ5LmpzJ1xyXG5cclxuZXhwb3J0ICogZnJvbSAnLi9jb250ZXh0LmpzJ1xyXG5cclxuZXhwb3J0IGludGVyZmFjZSBSZXNwb25zZUhlYWRlcnMge1xyXG4gICAgW2tleTogc3RyaW5nXTogc3RyaW5nXHJcbn1cclxuXHJcbmV4cG9ydCBpbnRlcmZhY2UgRnVsbFJlc3VsdCB7XHJcbiAgICBoZWFkZXJzPzogUmVzcG9uc2VIZWFkZXJzXHJcbiAgICBzdGF0dXM/OiBudW1iZXJcclxuICAgIGJvZHk/OiB1bmtub3duXHJcbn1cclxuXHJcbmV4cG9ydCB0eXBlIFJlc3VsdCA9IHZvaWQgfCBzdHJpbmcgfCBGdWxsUmVzdWx0XHJcblxyXG5leHBvcnQgaW50ZXJmYWNlIEh0dHBSZXF1ZXN0IHtcclxuICAgIHJlYWRvbmx5IHJhd1VybDogc3RyaW5nXHJcbiAgICByZWFkb25seSB1cmw6IFJlYWRvbmx5PFVybFdpdGhQYXJzZWRRdWVyeT4gJiB7IHBhdGhTdGVwQXQ6IChpbmRleDogbnVtYmVyKSA9PiBzdHJpbmcgfVxyXG4gICAgcmVhZG9ubHkgaGVhZGVyczogUmVhZG9ubHk8UmVzcG9uc2VIZWFkZXJzPlxyXG4gICAgcmVhZG9ubHkgYm9keT86IEpzb24gfCBzdHJpbmdcclxufVxyXG5cclxuZXhwb3J0IGludGVyZmFjZSBIdHRwSGFuZGxlckNvbmZpZ3VyYXRpb24gZXh0ZW5kcyBIYW5kbGVyQ29uZmlndXJhdGlvbiB7XHJcbiAgICAvKipcclxuICAgICAqIEEgc3RyaW5nIGlkZW50aWZ5aW5nIHdoaWNoIGRvbWFpbnMgY2FuIGFjY2VzcyB0aGUgZW5kcG9pbnQgY3Jvc3Mtb3JpZ2luLlxyXG4gICAgICogQGRlZmF1bHQgdW5kZWZpbmVkXHJcbiAgICAgKi9cclxuICAgIHJlYWRvbmx5IGNvcnM/OiBzdHJpbmdcclxufVxyXG5cclxuZXhwb3J0IHR5cGUgSGFuZGxlciA9IChjb250ZXh0OiBDb250ZXh0LCByZXF1ZXN0OiBIdHRwUmVxdWVzdCkgPT4gUHJvbWlzZTxSZXN1bHQ+IHwgUmVzdWx0XHJcblxyXG5leHBvcnQgZnVuY3Rpb24gZ2V0KHBhdGg6IHN0cmluZywgZm46IEhhbmRsZXIpOiB2b2lkXHJcbmV4cG9ydCBmdW5jdGlvbiBnZXQocGF0aDogc3RyaW5nLCBjb25maWc6IEh0dHBIYW5kbGVyQ29uZmlndXJhdGlvbiwgZm46IEhhbmRsZXIpOiB2b2lkXHJcbmV4cG9ydCBmdW5jdGlvbiBnZXQoXHJcbiAgICBwYXRoOiBzdHJpbmcsXHJcbiAgICBjb25maWdPckhhbmRsZXI6IEh0dHBIYW5kbGVyQ29uZmlndXJhdGlvbiB8IEhhbmRsZXIsXHJcbiAgICBmbj86IEhhbmRsZXIsXHJcbik6IHZvaWQge1xyXG4gICAgcmVnaXN0ZXJIdHRwSGFuZGxlcignR0VUJywgcGF0aCwgY29uZmlnT3JIYW5kbGVyLCBmbilcclxufVxyXG5leHBvcnQgZnVuY3Rpb24gcG9zdChwYXRoOiBzdHJpbmcsIGZuOiBIYW5kbGVyKTogdm9pZFxyXG5leHBvcnQgZnVuY3Rpb24gcG9zdChwYXRoOiBzdHJpbmcsIGNvbmZpZzogSHR0cEhhbmRsZXJDb25maWd1cmF0aW9uLCBmbjogSGFuZGxlcik6IHZvaWRcclxuZXhwb3J0IGZ1bmN0aW9uIHBvc3QoXHJcbiAgICBwYXRoOiBzdHJpbmcsXHJcbiAgICBjb25maWdPckhhbmRsZXI6IEh0dHBIYW5kbGVyQ29uZmlndXJhdGlvbiB8IEhhbmRsZXIsXHJcbiAgICBmbj86IEhhbmRsZXIsXHJcbik6IHZvaWQge1xyXG4gICAgcmVnaXN0ZXJIdHRwSGFuZGxlcignUE9TVCcsIHBhdGgsIGNvbmZpZ09ySGFuZGxlciwgZm4pXHJcbn1cclxuZXhwb3J0IGZ1bmN0aW9uIHB1dChwYXRoOiBzdHJpbmcsIGZuOiBIYW5kbGVyKTogdm9pZFxyXG5leHBvcnQgZnVuY3Rpb24gcHV0KHBhdGg6IHN0cmluZywgY29uZmlnOiBIdHRwSGFuZGxlckNvbmZpZ3VyYXRpb24sIGZuOiBIYW5kbGVyKTogdm9pZFxyXG5leHBvcnQgZnVuY3Rpb24gcHV0KFxyXG4gICAgcGF0aDogc3RyaW5nLFxyXG4gICAgY29uZmlnT3JIYW5kbGVyOiBIdHRwSGFuZGxlckNvbmZpZ3VyYXRpb24gfCBIYW5kbGVyLFxyXG4gICAgZm4/OiBIYW5kbGVyLFxyXG4pOiB2b2lkIHtcclxuICAgIHJlZ2lzdGVySHR0cEhhbmRsZXIoJ1BVVCcsIHBhdGgsIGNvbmZpZ09ySGFuZGxlciwgZm4pXHJcbn1cclxuZXhwb3J0IGZ1bmN0aW9uIHBhdGNoKHBhdGg6IHN0cmluZywgZm46IEhhbmRsZXIpOiB2b2lkXHJcbmV4cG9ydCBmdW5jdGlvbiBwYXRjaChwYXRoOiBzdHJpbmcsIGNvbmZpZzogSHR0cEhhbmRsZXJDb25maWd1cmF0aW9uLCBmbjogSGFuZGxlcik6IHZvaWRcclxuZXhwb3J0IGZ1bmN0aW9uIHBhdGNoKFxyXG4gICAgcGF0aDogc3RyaW5nLFxyXG4gICAgY29uZmlnT3JIYW5kbGVyOiBIdHRwSGFuZGxlckNvbmZpZ3VyYXRpb24gfCBIYW5kbGVyLFxyXG4gICAgZm4/OiBIYW5kbGVyLFxyXG4pOiB2b2lkIHtcclxuICAgIHJlZ2lzdGVySHR0cEhhbmRsZXIoJ1BBVENIJywgcGF0aCwgY29uZmlnT3JIYW5kbGVyLCBmbilcclxufVxyXG5leHBvcnQgZnVuY3Rpb24gZGVsKHBhdGg6IHN0cmluZywgZm46IEhhbmRsZXIpOiB2b2lkXHJcbmV4cG9ydCBmdW5jdGlvbiBkZWwocGF0aDogc3RyaW5nLCBjb25maWc6IEh0dHBIYW5kbGVyQ29uZmlndXJhdGlvbiwgZm46IEhhbmRsZXIpOiB2b2lkXHJcbmV4cG9ydCBmdW5jdGlvbiBkZWwoXHJcbiAgICBwYXRoOiBzdHJpbmcsXHJcbiAgICBjb25maWdPckhhbmRsZXI6IEh0dHBIYW5kbGVyQ29uZmlndXJhdGlvbiB8IEhhbmRsZXIsXHJcbiAgICBmbj86IEhhbmRsZXIsXHJcbik6IHZvaWQge1xyXG4gICAgcmVnaXN0ZXJIdHRwSGFuZGxlcignREVMRVRFJywgcGF0aCwgY29uZmlnT3JIYW5kbGVyLCBmbilcclxufVxyXG4iXX0=

package/package.json

@@ -0,0 +1,38 @@
+{
+    "name": "@riddance/host",
+    "version": "0.0.1",
+    "type": "module",
+    "license": "MIT",
+    "engines": {
+        "node": ">=16"
+    },
+    "keywords": [
+        "riddance",
+        "serverless",
+        "environment",
+        "devenv",
+        "opinionated"
+    ],
+    "files": [
+        "*.js",
+        "*.d.ts",
+        "host/*.js",
+        "host/*.d.ts"
+    ],
+    "exports": {
+        "./lib/context": "./context.js",
+        "./lib/http": "./http.js",
+        "./registry": "./host/registry.js",
+        "./reflect": "./host/reflect.js",
+        "./logging": "./host/logging.js",
+        "./context": "./host/context.js",
+        "./http": "./host/http.js"
+    },
+    "devDependencies": {
+        "@riddance/env": "0.0.1"
+    },
+    "scripts": {
+        "prepare": "tsc",
+        "watch": "watch"
+    }
+}