@weapnl/js-junction 0.0.1

package/docker-compose.yml

@@ -0,0 +1,14 @@
+services:
+  dev:
+    image: registry.weap.nl:5005/docker/npmnginx:8.1
+    volumes:
+      - ./:/var/www
+      - ../Shared:/var/shared
+    command: "tail -f /dev/null"
+
+  build:
+    image: registry.weap.nl:5005/docker/npmnginx:8.1
+    volumes:
+      - ./:/var/www
+      - ../Shared:/var/shared
+    command: "npm run prod"

package/index.d.ts

@@ -0,0 +1,150 @@
+import { AxiosResponse } from 'axios';
+
+interface JsonMap {
+    [key: string]: any;
+}
+
+// Definieer de class en zijn methoden
+declare class Api {
+    constructor();
+
+    host(host: string): this;
+    suffix(suffix: string): this;
+    readonly baseUrl: string;
+
+    request(uri: string): Request;
+    cancelRequests(): this;
+    batch(requests: Request[]): Batch;
+
+    setBearer(token: string): void;
+    resetBearer(): void;
+    setCsrf(token: string): void;
+    resetCsrf(): void;
+
+    setHeader(key: string, value: string): void;
+    removeHeader(key: string): void;
+
+    onSuccess(callback?: (data: any) => void): this;
+    onError(callback?: (response: AxiosResponse) => void): this;
+    onValidationError(callback?: (validation: any) => void): this;
+    onUnauthorized(callback?: (response: AxiosResponse) => void): this;
+    onForbidden(callback?: (response: AxiosResponse) => void): this;
+
+    responseInterceptors(
+        onSuccess?: (response: AxiosResponse) => void,
+        onError?: (error: any) => void
+    ): this;
+}
+
+interface Response {
+    data: any;
+    statusCode: number;
+    validation?: {
+        message: string;
+        errors: object;
+    };
+}
+
+declare class Mixins {
+    count(relations: any[]): this;
+    limit(amount: number): this;
+    order(input: string | any[], direction?: string): this;
+    with(relations: any[]): this;
+    scope(name: string, ...params: any[]): this;
+    scopes(...params: any[]): this;
+    search(value: any, columns?: any[]): this;
+    where(column: string, operator: string, value: any): this;
+    wheres(...params: any[]): this;
+    whereIn(column: string, values: any[]): this;
+    whereIns(...params: any[]): this;
+    pluck(fields: any[]): this;
+
+    appends(appends: string | string[]): this;
+    hiddenFields(hiddenFields: string | string[]): this;
+
+    action(name: string, id?: number): this;
+
+    pagination(page: number, perPage?: number, findPageForId?: number | null): this;
+}
+
+declare class Request extends Mixins {
+    constructor();
+    readonly response: Response;
+    setUrl(url: string): this;
+    cancel(): this;
+    get(): Promise<this>;
+    post(data?: object): Promise<this>;
+    put(data?: object): Promise<this>;
+    delete(): Promise<this>;
+    storeFiles(files?: object, data?: object): Promise<this>;
+    readonly bodyParameters: object;
+    onSuccess<T = any>(callback?: (result: T, data: any) => void): this;
+    onError(callback?: (response: Response) => void): this;
+    onValidationError(callback?: (validation: object) => void): this;
+    onUnauthorized(callback?: (response: Response) => void): this;
+    onForbidden(callback?: (response: Response) => void): this;
+    triggerResponseEvents(response: Response, successResponse?: any): Promise<void>;
+    customParameters(parameters?: any[]): this;
+}
+
+export class Model extends Request {
+    constructor(defaults?: JsonMap);
+
+    static fromJson(json: JsonMap): Model;
+
+    toJson(): JsonMap;
+
+    fill(values?: JsonMap): this;
+
+    static accessors(): JsonMap;
+
+    static attributes(): JsonMap;
+
+    static counts(): JsonMap;
+
+    static relations(): JsonMap;
+
+    static readonly endpoint: string;
+
+    readonly _identifier: number | string;
+
+    index(): Promise<Model[]>;
+
+    show(identifier?: number | string): Promise<Model | null>;
+
+    store(extraData?: JsonMap): Promise<Model>;
+
+    update(extraData?: JsonMap): Promise<Model>;
+
+    destroy(): Promise<boolean>;
+
+    save(extraData?: JsonMap): Promise<Model>;
+
+    clone(): Model;
+
+    _queryString(identifier?: number | string): string;
+}
+
+declare class Batch {
+    constructor(requests: any[]);
+
+    readonly successful: boolean;
+    readonly successfulRequests: any[];
+    readonly failedRequests: any[];
+
+    get(): Promise<any[]>;
+    post(): Promise<any[]>;
+    put(): Promise<any[]>;
+    delete(): Promise<any[]>;
+    index(): Promise<any[]>;
+    show(): Promise<any[]>;
+    store(): Promise<any[]>;
+    update(): Promise<any[]>;
+    destroy(): Promise<any[]>;
+    save(): Promise<any[]>;
+    storeFiles(): Promise<any[]>;
+
+    execute(method: string): Promise<any[]>;
+}
+
+export default Api;

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "@weapnl/js-junction",
+  "version": "0.0.1",
+  "description": "This project allows you to easily consume API's built with Junction.",
+  "main": "./src/index.js",
+  "scripts": {
+    "dev": "webpack --mode development",
+    "watch": "webpack --mode development --watch",
+    "prod": "webpack"
+  },
+  "author": "Robin",
+  "license": "ISC",
+  "devDependencies": {
+    "@babel/core": "^7.12.13",
+    "@babel/preset-env": "^7.12.13",
+    "babel-core": "^6.26.3",
+    "babel-loader": "^8.2.2",
+    "babel-polyfill": "^6.26.0",
+    "webpack": "^5.77.0",
+    "webpack-cli": "^4.9.0"
+  },
+  "dependencies": {
+    "axios": "^1.3.0",
+    "lodash": "^4.17.20"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/weapnl/js-junction.git"
+  },
+  "bugs": {
+    "url": "https://github.com/weapnl/js-junction/issues"
+  },
+  "homepage": "https://github.com/weapnl/js-junction#readme"
+}

package/src/api.js

@@ -0,0 +1,226 @@
+import Request from './request';
+import Batch from './batch';
+import axios from 'axios';
+
+export default class Api {
+    constructor () {
+        this.setHeader('X-Requested-With', 'XMLHttpRequest');
+
+        this._requests = [];
+
+        this.host('/').suffix('');
+
+        this._onSuccess = () => {};
+        this._onError = () => {};
+        this._onValidationError = () => {};
+        this._onUnauthorized = () => {};
+        this._onForbidden = () => {};
+    }
+
+    /**
+     * @param {string} host
+     *
+     * @returns {this} The current instance.
+     */
+    host (host) {
+        this._host = host;
+
+        return this;
+    }
+
+    /**
+     * @param {string} suffix
+     *
+     * @returns {this} The current instance.
+     */
+    suffix (suffix) {
+        if (! _.startsWith(suffix, '/') && suffix) {
+            suffix = `/${suffix}`;
+        }
+
+        this._suffix = suffix;
+
+        return this;
+    }
+
+    /**
+     * @returns {string} Url containing the host and suffix.
+     */
+    get baseUrl () {
+        let url = '';
+
+        if (this._host) url += this._host;
+        if (this._suffix) url += this._suffix;
+
+        return url;
+    }
+
+    /**
+     * @param {string} uri
+     *
+     * @returns {Request} The created request.
+     */
+    request (uri) {
+        if (! uri) throw new Error(`Request url is empty.`);
+
+        if (! _.startsWith(uri, '/')) {
+            uri = `/${uri}`;
+        }
+
+        const request = new Request();
+
+        request.setUrl(uri)
+            .onSuccess(this._onSuccess)
+            .onError(this._onError)
+            .onValidationError(this._onValidationError)
+            .onUnauthorized(this._onUnauthorized)
+            .onForbidden(this._onForbidden);
+
+        this._requests.push(request);
+
+        return request;
+    }
+
+    /**
+     * @returns {this} The current instance.
+     */
+    cancelRequests () {
+        this._requests.forEach((request) => {
+            request.cancel();
+        });
+
+        this._requests = [];
+
+        return this;
+    }
+
+    /**
+     * @param {array} requests
+     * @returns Batch
+     */
+    batch (requests) {
+        return new Batch(requests);
+    }
+
+    /**
+     * @param {string} token
+     */
+    setBearer (token) {
+        this.setHeader('Authorization', 'Bearer ' + token);
+    }
+
+    resetBearer () {
+        this.removeHeader('Authorization');
+    }
+
+    /**
+     * @param {string} token
+     */
+    setCsrf (token) {
+        this.setHeader('X-CSRF-TOKEN', token);
+    }
+
+    resetCsrf () {
+        this.removeHeader('X-CSRF-TOKEN');
+    }
+
+    /**
+     * @param {string} key
+     * @param {string} value
+     */
+    setHeader (key, value) {
+        axios.defaults.headers.common[key] = value;
+    }
+
+    /**
+     * @param {string} key
+     */
+    removeHeader (key) {
+        delete axios.defaults.headers.common[key];
+    }
+
+    /**
+     * Set the default 'onSuccess'. Can be overridden in the Request class.
+     *
+     * @param {function(Response.data)} callback
+     *
+     * @returns {this} The current instance.
+     */
+    onSuccess (callback = () => {}) {
+        this._onSuccess = callback;
+
+        return this;
+    }
+
+    /**
+     * Set the default 'onError'. Can be overridden in the Request class.
+     *
+     * @param {function(Response)} callback
+     *
+     * @returns {this} The current instance.
+     */
+    onError (callback = () => {}) {
+        this._onError = callback;
+
+        return this;
+    }
+
+    /**
+     * Set the default 'onValidationError'. Can be overridden in the Request class.
+     *
+     * @param {function(Response.validation)} callback
+     *
+     * @returns {this} The current instance.
+     */
+    onValidationError (callback = () => {}) {
+        this._onValidationError = callback;
+
+        return this;
+    }
+
+    /**
+     * Set the default 'onUnauthorized'. Can be overridden in the Request class.
+     *
+     * @param {function(Response)} callback
+     *
+     * @returns {this} The current instance.
+     */
+    onUnauthorized (callback = () => {}) {
+        this._onUnauthorized = callback;
+
+        return this;
+    }
+
+    /**
+     * Set the default 'onForbidden'. Can be overridden in the Request class.
+     *
+     * @param {function(Response)} callback
+     *
+     * @returns {this} The current instance.
+     */
+    onForbidden (callback = () => {}) {
+        this._onForbidden = callback;
+
+        return this;
+    }
+
+    /**
+     * @param {function(Response)} onSuccess
+     * @param {function(Error)} onError
+     *
+     * @returns {this}
+     */
+    responseInterceptors (onSuccess = () => {}, onError = () => {}) {
+        axios.interceptors.response.use((response) => {
+            onSuccess(response);
+
+            return response;
+        }, (error) => {
+            onError(error);
+
+            return Promise.reject(error);
+        });
+
+        return this;
+    }
+}

package/src/batch.js

@@ -0,0 +1,39 @@
+export default class Batch {
+    constructor (requests) {
+        this._requests = requests;
+    }
+
+    get successful () {
+        return _.isEmpty(this.failedRequests);
+    }
+
+    get successfulRequests () {
+        return _.filter(this._requests, ['response.failed', false]);
+    }
+
+    get failedRequests () {
+        return _.filter(this._requests, ['response.failed', true]);
+    }
+
+    async get () { return this.execute('get'); }
+    async post () { return this.execute('post'); }
+    async put () { return this.execute('put'); }
+    async delete () { return this.execute('delete'); }
+    async index () { return this.execute('index'); }
+    async show () { return this.execute('show'); }
+    async store () { return this.execute('store'); }
+    async update () { return this.execute('update'); }
+    async destroy () { return this.execute('destroy'); }
+    async save () { return this.execute('save'); }
+    async storeFiles () { return this.execute('storeFiles'); }
+
+    /**
+     * @param {string} method The methods used to execute the requests. Should be `index`, `show`, `store`, `update` or `delete`.
+     * @returns {array} List of results if all requests were successful.
+     */
+    async execute (method) {
+        return await Promise.all(_.map(this._requests, (request) => {
+            return request[method]();
+        }));
+    }
+}

package/src/builder/caster.js

@@ -0,0 +1,67 @@
+import Model from './model';
+
+export default class Caster {
+    /**
+     * Get the casted value from a json value.
+     *
+     * @param {Object} cast
+     * @param {any} value
+     *
+     * @returns {any}
+     */
+    static fromJson (cast, value) {
+        if (cast.prototype instanceof Model) {
+            return this._castValue(value, (json) => cast.fromJson(json));
+        }
+
+        if (cast === Array) {
+            return this._castValue(value, (json) => Array.from(json));
+        }
+
+        if (cast === Object) {
+            return this._castValue(value, (json) => Object.assign({}, json));
+        }
+
+        return this._castValue(value, _.flow(cast));
+    }
+
+    /**
+     * Get the casted value of a property so it's safe to send with json.
+     *
+     * @param {Object} cast
+     * @param {any} value
+     *
+     * @returns {any}
+     */
+    static toJson (cast, value) {
+        if (_.isNil(value)) {
+            return null;
+        }
+
+        if (cast.prototype instanceof Model) {
+            return this._castValue(value, (model) => model.toJson());
+        }
+
+        if (cast === Array) {
+            return this._castValue(value, (value) => Array.from(value));
+        }
+
+        return this._castValue(value, _.flow(cast));
+    }
+
+    /**
+     * Cast the value with the given cast method.
+     *
+     * @param {Function} cast
+     * @param {any} value
+     *
+     * @returns {any}
+     */
+    static _castValue (value, cast) {
+        if (_.isNil(value)) {
+            return null;
+        }
+
+        return cast(value);
+    }
+}