@luminix/support 0.0.1-beta.0

package/src/Contracts/EventSource.ts

@@ -0,0 +1,46 @@
+import { createNanoEvents, Unsubscribe } from 'nanoevents';
+
+export type Event<TData = any, TSource extends EventSource = EventSource> = TData & {
+    source: TSource;
+};
+
+export type EventMap = {
+    [key: string]: (event: Event) => void
+};
+
+
+
+export default class EventSource<TEvents extends EventMap = EventMap>
+{
+    private emitter;
+
+    constructor()
+    {
+        this.emitter = createNanoEvents<TEvents>();
+    }
+
+    on<E extends keyof TEvents>(event: E, callback: TEvents[E]): Unsubscribe
+    {
+        return this.emitter.on(event, callback);
+    }
+
+    once<E extends keyof TEvents>(event: E, callback: TEvents[E]): void
+    {
+        const off = this.emitter.on(event, ((e: Parameters<TEvents[E]>[0]) => {
+            off();
+            callback(e);
+        }) as any);
+    }
+
+    emit<E extends keyof TEvents>(event: E, ...data: Parameters<TEvents[E]>): void
+    {
+        this.emitter.emit(event, ...data);
+    }
+
+    static foo() {
+
+        return 'bar';
+    }
+}
+
+

package/src/Exceptions/ReducerOverrideException.ts

@@ -0,0 +1,8 @@
+
+export default class ReducerOverrideException extends Error {
+    [Symbol.toStringTag] = 'ReducerOverrideException';
+
+    constructor(name: string, target: unknown) {
+        super(`[Luminix] Cannot create reducer '${name}' on '${target}' as it is a reserved property`);
+    }
+}

package/src/Http/Client.ts

@@ -0,0 +1,139 @@
+
+import { AxiosRequestConfig } from 'axios';
+import * as Obj from '../Obj';
+import Request from './Request';
+
+
+export type RequestOptions = Omit<AxiosRequestConfig, 'url' | 'method'>;
+
+
+export default class Client {
+
+    constructor(
+        protected options: AxiosRequestConfig = {}
+    ) {}
+
+    private parseData(data?: object) {
+        if (Obj.get(this.options, 'headers[Content-Type]', 'application/json') === 'application/x-www-form-urlencoded' && data) {
+            return Obj.toFormData(data || {});
+        }
+
+        return data;
+    }
+
+    baseUrl(baseUrl: string): this {
+        Obj.set(this.options, 'baseURL', baseUrl);
+
+        return this;
+    }
+
+    asForm(): this {
+        Obj.set(this.options, 'headers[Content-Type]', 'application/x-www-form-urlencoded');
+
+        return this;
+    }
+
+    accept(type: string): this {
+        Obj.set(this.options, 'headers[Accept]', type);
+
+        return this;
+    }
+
+    acceptJson(): this {
+        return this.accept('application/json');
+    }
+
+    withHeaders(headers: Record<string, string>): this {
+        Obj.set(this.options, 'headers', Obj.merge(this.options.headers, headers));
+
+        return this;
+    }
+
+    replaceHeaders(headers: Record<string, string>): this {
+        Obj.set(this.options, 'headers', headers);
+
+        return this;
+    }
+
+    withOptions(options: RequestOptions): this {
+        this.options = Obj.merge(this.options, options);
+
+        return this;
+    }
+
+    replaceOptions(options: RequestOptions): this {
+        this.options = options;
+
+        return this;
+    }
+
+    withQueryParameters(params: string | object): this {
+        Obj.set(this.options, 'params', Obj.merge(this.options.params, params));
+
+        return this;
+    }
+
+    replaceQueryParameters(params: string | object): this {
+        Obj.set(this.options, 'params', params);
+
+        return this;
+    }
+
+    withBasicAuth(username: string, password: string): this {
+        Obj.set(this.options, 'headers.Authorization', `Basic ${btoa(`${username}:${password}`)}`);
+
+        return this;
+    }
+
+    withToken(token: string): this {
+        Obj.set(this.options, 'headers.Authorization', `Bearer ${token}`);
+
+        return this;
+    }
+
+    get<TResponse = any>(url: string, query?: string | object) {
+        return new Request<TResponse>({
+            ...this.options,
+            params: query ?? this.options.params,
+            url,
+        });
+    }
+
+    post<TResponse = any, TData = any>(url: string, data?: TData) {
+        return new Request<TResponse, TData>({
+            ...this.options,
+            method: 'post',
+            url,
+            data: this.parseData(data ?? this.options.data),
+        });
+    }
+
+    put<TResponse = any, TData = any>(url: string, data?: TData) {
+        return new Request<TResponse, TData>({
+            ...this.options,
+            method: 'put',
+            url,
+            data: this.parseData(data ?? this.options.data),
+        });
+    }
+
+    patch<TResponse = any, TData = any>(url: string, data?: TData) {
+        return new Request<TResponse, TData>({
+            ...this.options,
+            method: 'patch',
+            url,
+            data: this.parseData(data ?? this.options.data),
+        });
+    }
+
+    delete<TResponse = any>(url: string, query?: string | object) {
+        return new Request<TResponse>({
+            ...this.options,
+            method: 'delete',
+            params: query ?? this.options.params,
+            url,
+        });
+    }
+
+};
+

package/src/Http/Request.ts

@@ -0,0 +1,45 @@
+import axios, { AxiosRequestConfig, isAxiosError } from "axios";
+import Response from "./Response";
+
+export default class Request<TResponse = any, TData = any> implements Promise<Response<TResponse, TData>> {
+
+    private promise: Promise<Response<TResponse, TData>>;
+    private response?: Response<TResponse, TData>;
+
+    constructor(options: AxiosRequestConfig) {
+        this.promise = new Promise<Response<TResponse, TData>>((resolve, reject) => {
+            axios(options)
+                .then((response) => {
+                    this.response = new Response(response);
+                    resolve(this.response);
+                })
+                .catch((error) => {
+                    if (isAxiosError(error) && error.response) {
+                        this.response = new Response(error.response, error);
+                        resolve(this.response);
+                    } else {
+                        reject(error);
+                    }
+                });
+        });
+    }
+
+    [Symbol.toStringTag]: string = 'Request';
+
+    then<TResult1 = Response<TResponse, TData>, TResult2 = never>(
+        onfulfilled?: ((value: Response<TResponse, TData>) => TResult1 | PromiseLike<TResult1>) | null | undefined,
+        onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined
+    ): Promise<TResult1 | TResult2> {
+        return this.promise.then(onfulfilled, onrejected);
+    }
+
+    catch<TResult = never>(
+        onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | null | undefined
+    ): Promise<Response<TResponse, TData> | TResult> {
+        return this.promise.catch(onrejected);
+    }
+
+    finally(onfinally?: (() => void) | null | undefined): Promise<Response<TResponse, TData>> {
+        return this.promise.finally(onfinally);
+    }
+}

package/src/Http/Response.ts

@@ -0,0 +1,170 @@
+
+import { AxiosResponse } from 'axios';
+import * as Obj from '../Obj';
+
+export default class Response<TResponse = any, TData = any> {
+
+    constructor(
+        private response: AxiosResponse<TResponse, TData>,
+        private error?: Error
+    ) {
+
+    }
+
+    body(): string {
+        return typeof this.response.data === 'object'
+            ? JSON.stringify(this.response.data)
+            : String(this.response.data);
+    }
+
+    json(): TResponse;
+    json<K extends keyof TResponse>(key: K): TResponse[K];
+    json(key: string, defaultValue?: any): any;
+    json(key?: string, defaultValue?: any): any {
+
+        if (key) {
+            return Obj.get(this.response.data, key, defaultValue);
+        }
+
+        return this.response.data;
+    }
+    // collect(key?: string): Collection {}
+    status(): number {
+        return Number(this.response.status);
+    }
+
+    successful(): boolean {
+        return this.status() >= 200 && this.status() < 300;
+    }
+
+    redirect(): boolean {
+        return this.status() >= 300 && this.status() < 400;
+    }
+
+    clientError(): boolean {
+        return this.status() >= 400 && this.status() < 500;
+    }
+
+    serverError(): boolean {
+        return this.status() >= 500;
+    }
+
+    failed(): boolean {
+        return this.clientError() || this.serverError();
+    }
+
+    header(header: string): string {
+        return this.response.headers[header];
+    }
+
+    headers(): Record<string, string> {
+        return this.response.headers as Record<string, string>;
+    }
+
+    ok(): boolean {
+        return this.status() === 200;
+    }
+
+    created(): boolean {
+        return this.status() === 201;
+    }
+
+    accepted(): boolean {
+        return this.status() === 202;
+    }
+
+    noContent(): boolean {
+        return this.status() === 204;
+    }
+
+    movedPermanently(): boolean {
+        return this.status() === 301;
+    }
+
+    found(): boolean {
+        return this.status() === 302;
+    }
+
+    badRequest(): boolean {
+        return this.status() === 400;
+    }
+
+    unauthorized(): boolean {
+        return this.status() === 401;
+    }
+
+    paymentRequired(): boolean {
+        return this.status() === 402;
+    }
+
+    forbidden(): boolean {
+        return this.status() === 403;
+    }
+
+    notFound(): boolean {
+        return this.status() === 404;
+    }
+
+    requestTimeout(): boolean {
+        return this.status() === 408;
+    }
+
+    conflict(): boolean {
+        return this.status() === 409;
+    }
+
+    unprocessableEntity(): boolean {
+        return this.status() === 422;
+    }
+
+    tooManyRequests(): boolean {
+        return this.status() === 429;
+    }
+
+    throw(): this {
+        if (this.failed()) {
+            throw this.error || new Error(this.body());
+        }
+
+        return this;
+    }
+
+    throwIf(condition: boolean | ((response: Response) => boolean)): this {
+        if (typeof condition === 'function') {
+            return condition(this) ? this.throw() : this;
+        } 
+        return condition ? this.throw() : this;
+    }
+
+    throwUnless(condition: boolean | ((response: Response) => boolean)): this {
+        if (typeof condition === 'function') {
+            return condition(this) ? this : this.throw();
+        }
+        return condition ? this : this.throw();
+    }
+
+    throwIfStatus(statusCode: number | ((status: number, response: Response) => boolean)): this {
+        if (typeof statusCode === 'function' && statusCode(this.status(), this)) {
+            return this.throw();
+        } 
+        return this.status() === statusCode ? this.throw() : this;
+    }
+
+    throwUnlessStatus(statusCode: number | ((status: number, response: Response) => boolean)): this {
+        if (typeof statusCode === 'function' && !statusCode(this.status(), this)) {
+            return this.throw();
+        }
+        return this.status() === statusCode ? this : this.throw();
+    }
+
+    throwIfClientError(): this {
+        return this.clientError() ? this.throw() : this;
+    }
+
+    throwIfServerError(): this {
+        return this.serverError() ? this.throw() : this;
+    }
+    
+
+};
+

package/src/Http/index.ts

@@ -0,0 +1,90 @@
+import Client, { RequestOptions } from "./Client";
+import Response from "./Response";
+import Request from "./Request";
+import Macroable from "../Mixins/Macroable";
+
+class HttpStatic {
+
+    get Client() {
+        return Client;
+    }
+
+    get Response() {
+        return Response;
+    }
+
+    get Request() {
+        return Request;
+    }
+
+    getClient(): Client {
+        return new Client();
+    }
+
+    baseUrl(baseUrl: string): Client {
+        return this.getClient().baseUrl(baseUrl);
+    }
+
+    asForm(): Client {
+        return this.getClient().asForm();
+    }
+
+    accept(type: string): Client {
+        return this.getClient().accept(type);
+    }
+
+    acceptJson(): Client {
+        return this.getClient().acceptJson();
+    }
+
+    withHeaders(headers: Record<string, string>): Client {
+        return this.getClient().withHeaders(headers);
+    }
+
+    withOptions(options: RequestOptions): Client {
+        return this.getClient().withOptions(options);
+    }
+
+
+    withQueryParameters(params: string | object): Client {
+        return this.getClient().withQueryParameters(params);
+    }
+
+    withBasicAuth(username: string, password: string): Client {
+        return this.getClient().withBasicAuth(username, password);
+    }
+
+    withToken(token: string): Client {
+        return this.getClient().withToken(token);
+    }
+
+    get<TResponse = any>(url: string, query?: string | object) {
+        return this.getClient().get<TResponse>(url, query);
+    }
+
+
+    post<TResponse = any, TData = any>(url: string, data?: TData) {
+        return this.getClient().post<TResponse, TData>(url, data);
+    }
+
+
+    put<TResponse = any, TData = any>(url: string, data?: TData) {
+        return this.getClient().put<TResponse, TData>(url, data);
+    }
+
+
+    patch<TResponse = any, TData = any>(url: string, data?: TData) {
+        return this.getClient().patch<TResponse, TData>(url, data);
+    }
+
+
+    delete<TResponse = any>(url: string, query?: string | object) {
+        return this.getClient().delete<TResponse>(url, query);
+    }
+
+}
+
+const Http = new (Macroable(HttpStatic))();
+
+export default Http;
+

package/src/Js.ts

@@ -0,0 +1,5 @@
+
+
+export type Constructor<T = {}> = new (...args: any[]) => T;
+
+export type TypeOf = 'string' | 'number' | 'boolean' | 'object' | 'undefined' | 'function' | 'symbol' | 'bigint';

package/src/Mixins/Macroable.ts

@@ -0,0 +1,81 @@
+
+import { Constructor } from "../Js";
+
+export type MacroMethodMap = Record<string, (...args: any[]) => any>;
+
+export type MacroableInterface<TMacros extends MacroMethodMap> = {
+    /**
+     * 
+     * Register a custom macro
+     * 
+     * @param name 
+     * @param macro 
+     */
+    macro<K extends keyof TMacros>(name: K, macro: TMacros[K]): void;
+
+    /**
+     * 
+     * Checks if a macro is registered
+     * 
+     * @param name
+     */
+    hasMacro(name: string): boolean;
+
+    /**
+     * 
+     * Flushes the existing macros.
+     * 
+     */
+    flushMacros(): void;
+};
+
+export type MacroableOf<TBase extends Constructor, TMacros extends MacroMethodMap> = Omit<TBase, 'new'> & {
+    new (...args: ConstructorParameters<TBase>): InstanceType<TBase> & TMacros & MacroableInterface<TMacros>; /* & {
+        [key: string]: (...args: any[]) => any;
+    };*/
+};
+
+export default function Macroable<TMacros extends MacroMethodMap, TBase extends Constructor>(
+    Base: TBase
+): MacroableOf<TBase, TMacros>
+{
+    return class MacroableBase extends Base {
+
+        _macros: TMacros = {} as TMacros;
+
+        constructor(...args: any[]) {
+            super(...args);
+
+            return new Proxy(this, {
+                get(target, prop, receiver) {
+                    if (Reflect.has(target, prop)) {
+                        return Reflect.get(target, prop, receiver);
+                    }
+
+                    if (typeof prop === 'string' && target.hasMacro(prop)) {
+                        return target._macros[prop].bind(target);
+                    }
+
+                    return Reflect.get(target, prop, receiver);
+                },
+            });
+        }
+
+        macro<K extends keyof TMacros>(name: K, macro: TMacros[K]): void {
+            if (typeof macro !== 'function') {
+                throw new TypeError('Macro must be a function');
+            }
+
+            this._macros[name] = macro;
+        }
+
+        hasMacro(name: string): boolean {
+            return name in this._macros && typeof this._macros[name] === 'function';
+        }
+
+        flushMacros(): void {
+            this._macros = {} as TMacros;
+        }
+
+    } as any;
+}