@h3ravel/http 0.1.0

package/src/Request.ts

@@ -0,0 +1,59 @@
+import { getQuery, getRouterParams, readBody, type H3Event } from 'h3'
+import { DotNestedKeys, DotNestedValue, safeDot } from '@h3ravel/support'
+
+export class Request {
+    private readonly event: H3Event
+
+    constructor(event: H3Event) {
+        this.event = event
+    }
+
+    /**
+     * Get all input data (query + body).
+     */
+    async all<T = Record<string, unknown>> (): Promise<T> {
+        let data = {
+            ...getRouterParams(this.event),
+            ...getQuery(this.event),
+        } as T
+
+        if (this.event.req.method === 'POST') {
+            data = Object.assign({}, data, Object.fromEntries((await this.event.req.formData()).entries()))
+        } else if (this.event.req.method === 'PUT') {
+            data = <never>Object.fromEntries(Object.entries(<never>await readBody(this.event)))
+        }
+
+        return data
+    }
+
+    /**
+     * Get a single input field from query or body.
+     */
+    async input<T = unknown> (key: string, defaultValue?: T): Promise<T> {
+        const data = await this.all<Record<string, T>>()
+        return (data[key] ?? defaultValue) as T
+    }
+
+    /**
+     * Get route parameters.
+     */
+    params<T = Record<string, string>> (): T {
+        return getRouterParams(this.event) as T
+    }
+
+    /**
+     * Get query parameters.
+     */
+    query<T = Record<string, string>> (): T {
+        return getQuery(this.event) as T
+    }
+
+    /**
+     * Get the base event
+     */
+    getEvent (): H3Event
+    getEvent<K extends DotNestedKeys<H3Event>> (key: K): DotNestedValue<H3Event, K>
+    getEvent<K extends DotNestedKeys<H3Event>> (key?: K): any {
+        return safeDot(this.event, key)
+    }
+}

package/src/Resources/ApiResource.ts

@@ -0,0 +1,39 @@
+import { JsonResource, Resource } from "./JsonResource";
+
+import { H3Event } from "h3";
+
+export function ApiResource (
+    instance: JsonResource
+) {
+    return new Proxy(instance, {
+        get (target, prop, receiver) {
+            const value = Reflect.get(target, prop, receiver);
+            if (typeof value === 'function') {
+                // Intercept json, additional, and send methods
+                if (prop === 'json' || prop === 'additional') {
+                    return (...args: any[]) => {
+                        const result = value.apply(target, args);
+                        // Schedule checkSend after json or additional
+                        setImmediate(() => target['checkSend']());
+                        return result;
+                    };
+                } else if (prop === 'send') {
+                    return (...args: any[]) => {
+                        // Prevent checkSend from firing
+                        target['shouldSend'] = false;
+
+                        return value.apply(target, args);
+                    };
+                }
+            }
+            return value;
+        },
+    });
+}
+
+export default function BaseResource<R extends Resource> (
+    evt: H3Event,
+    rsc: R
+) {
+    return ApiResource(new JsonResource<R>(evt, rsc))
+}

package/src/Resources/JsonResource.ts

@@ -0,0 +1,201 @@
+import { EventHandlerRequest, H3Event } from "h3";
+
+export interface Resource {
+    [key: string]: any;
+    pagination?: {
+        from?: number | undefined;
+        to?: number | undefined;
+        perPage?: number | undefined;
+        total?: number | undefined;
+    } | undefined;
+}
+
+type BodyResource = Resource & {
+    data: Omit<Resource, 'pagination'>,
+    meta?: {
+        pagination?: Resource['pagination']
+    } | undefined;
+}
+
+/**
+ * Class to render API resource
+ */
+export class JsonResource<R extends Resource = any> {
+    /**
+     * The request instance
+     */
+    request: H3Event<EventHandlerRequest>['req'];
+    /**
+     * The response instance
+     */
+    response: H3Event['res'];
+    /**
+     * The data to send to the client
+     */
+    resource: R;
+    /**
+     * The final response data object
+     */
+    body: BodyResource = {
+        data: {},
+    };
+    /**
+     * Flag to track if response should be sent automatically
+     */
+    private shouldSend: boolean = false;
+    /**
+     * Flag to track if response has been sent
+     */
+
+    private responseSent: boolean = false;
+
+    /**
+     * Declare that this includes R's properties
+     */
+    [key: string]: any;
+
+    /**
+     * @param req The request instance
+     * @param res The response instance
+     * @param rsc The data to send to the client
+     */
+    constructor(private event: H3Event, rsc: R) {
+        this.request = event.req;
+        this.response = event.res;
+        this.resource = rsc;
+
+        // Copy all properties from rsc to this, avoiding conflicts
+        for (const key of Object.keys(rsc)) {
+            if (!(key in this)) {
+                Object.defineProperty(this, key, {
+                    enumerable: true,
+                    configurable: true,
+                    get: () => this.resource[key],
+                    set: (value) => {
+                        (<any>this.resource)[key] = value;
+                    },
+                });
+            }
+        }
+    }
+
+    /**
+     * Return the data in the expected format
+     * 
+     * @returns 
+     */
+    data (): Resource {
+        return this.resource
+    }
+
+    /**
+     * Build the response object
+     * @returns this
+     */
+    json () {
+        // Indicate response should be sent automatically
+        this.shouldSend = true;
+
+        // Set default status code
+        this.response.status = 200;
+
+        // Prepare body
+        const resource = this.data()
+        let data: Resource = Array.isArray(resource) ? [...resource] : { ...resource };
+
+        if (typeof data.data !== 'undefined') {
+            data = data.data
+        }
+
+        if (!Array.isArray(resource)) {
+            delete data.pagination;
+        }
+
+        this.body = {
+            data,
+        };
+
+        // Set the pagination from the data() resource, if available
+        if (!Array.isArray(resource) && resource.pagination) {
+            const meta: BodyResource['meta'] = this.body.meta ?? {}
+            meta.pagination = resource.pagination;
+            this.body.meta = meta;
+        }
+
+        // If pagination is not available on the resource, then check and set it
+        // if it's available on the base resource.
+        if (this.resource.pagination && !this.body.meta?.pagination) {
+            const meta: BodyResource['meta'] = this.body.meta ?? {}
+            meta.pagination = this.resource.pagination;
+            this.body.meta = meta;
+        }
+
+        return this;
+    }
+
+    /**
+     * Add context data to the response object
+     * @param data Context data
+     * @returns this
+     */
+    additional<X extends { [key: string]: any }> (data: X) {
+
+        // Allow automatic send after additional
+        this.shouldSend = true;
+
+        // Merge data with body
+        delete data.data;
+        delete data.pagination;
+
+        this.body = {
+            ...this.body,
+            ...data,
+        };
+
+        return this;
+    }
+
+    /**
+     * Send the output to the client
+     * @returns this
+     */
+    send () {
+        this.shouldSend = false; // Prevent automatic send
+        if (!this.responseSent) {
+            this.#send();
+        }
+        return this;
+    }
+
+    /**
+     * Set the status code for this response
+     * @param code Status code
+     * @returns this
+     */
+    status (code: number) {
+        this.response.status = code;
+        return this;
+    }
+
+    /**
+     * Private method to send the response
+     */
+    #send () {
+        if (!this.responseSent) {
+            this.event.context.
+                this.response.json(this.body);
+
+            // Mark response as sent
+            this.responseSent = true;
+        }
+    }
+
+    /**
+     * Check if send should be triggered automatically
+     */
+    private checkSend () {
+        if (this.shouldSend && !this.responseSent) {
+            this.#send();
+        }
+    }
+}

package/src/Response.ts

@@ -0,0 +1,80 @@
+import { DotNestedKeys, DotNestedValue, safeDot } from '@h3ravel/support'
+import { html, redirect, } from 'h3'
+
+import type { H3Event } from 'h3'
+
+export class Response {
+    private readonly event: H3Event
+    private statusCode: number = 200
+    private headers: Record<string, string> = {}
+
+    constructor(event: H3Event) {
+        this.event = event
+    }
+
+    /**
+     * Set HTTP status code.
+     */
+    setStatusCode (code: number): this {
+        this.statusCode = code
+        this.event.res.status = code
+        return this
+    }
+
+    /**
+     * Set a header.
+     */
+    setHeader (name: string, value: string): this {
+        this.headers[name] = value
+        return this
+    }
+
+    html (content: string): string {
+        this.applyHeaders()
+        return html(this.event, content)
+    }
+
+    /**
+     * Send a JSON response.
+     */
+    json<T = unknown> (data: T): T {
+        this.setHeader("content-type", "application/json; charset=utf-8")
+        this.applyHeaders()
+        return data
+    }
+
+    /**
+     * Send plain text.
+     */
+    text (data: string): string {
+        this.setHeader("content-type", "text/plain; charset=utf-8")
+        this.applyHeaders()
+        return data;
+    }
+
+    /**
+     * Redirect to another URL.
+     */
+    redirect (url: string, status = 302): string {
+        this.setStatusCode(status)
+        return redirect(this.event, url, this.statusCode)
+    }
+
+    /**
+     * Apply headers before sending response.
+     */
+    private applyHeaders (): void {
+        Object.entries(this.headers).forEach(([key, value]) => {
+            this.event.res.headers.set(key, value)
+        })
+    }
+
+    /**
+     * Get the base event
+     */
+    getEvent (): H3Event
+    getEvent<K extends DotNestedKeys<H3Event>> (key: K): DotNestedValue<H3Event, K>
+    getEvent<K extends DotNestedKeys<H3Event>> (key?: K): any {
+        return safeDot(this.event, key)
+    }
+}

package/src/index.ts

@@ -0,0 +1,13 @@
+/**
+ * @file Automatically generated by barrelsby.
+ */
+
+export * from './Middleware';
+export * from './Request';
+export * from './Response';
+export * from './Contracts/ControllerContracts';
+export * from './Contracts/HttpContract';
+export * from './Middleware/LogRequests';
+export * from './Providers/HttpServiceProvider';
+export * from './Resources/ApiResource';
+export * from './Resources/JsonResource';

package/tsconfig.json

@@ -0,0 +1,8 @@
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "outDir": "dist"
+  },
+  "include": ["src"],
+  "exclude": ["dist", "node_modules"]
+}

package/vite.config.ts

@@ -0,0 +1,9 @@
+import { defineConfig } from 'tsup'
+
+export default defineConfig({
+    entry: ['src/index.ts'],
+    format: ['esm', 'cjs'],
+    dts: true,
+    sourcemap: true,
+    clean: true
+})