@weapnl/js-junction 0.0.1

package/src/builder/properties/relations.js

@@ -0,0 +1,124 @@
+import Caster from '../caster';
+
+/**
+ * @implements {Property}
+ */
+export default class Relations {
+    /**
+     * @param {Model} model Instance of the model.
+     */
+    constructor (model) {
+        this.model = model;
+
+        _.each(model.constructor.relations(), (options, key) => {
+            this.set(key, _.has(options, 'default') ? options.default : null);
+        });
+    }
+
+    /**
+     * @param {Object} json.
+     */
+    fromJson (json) {
+        _.each(this.model.constructor.relations(), (options, key) => {
+            let value = _.get(json, options.jsonKey ?? _.snakeCase(key), _.get(json, _.camelCase(key)));
+
+            value = value
+                ? Relations._getCastedFromJsonValue(value, options)
+                : value;
+
+            this.set(key, value);
+        });
+    }
+
+    /**
+     * @return {Object} The attributes casted to a json object.
+     */
+    toJson () {
+        const json = {};
+
+        _.each(this.model.constructor.relations(), (options, key) => {
+            let jsonValue = this.get(key);
+
+            jsonValue = Relations._getCastedToJsonValue(jsonValue, options);
+
+            _.set(json, options.jsonKey ?? _.snakeCase(key), jsonValue);
+        });
+
+        return json;
+    }
+
+    /**
+     * @param {string} relation
+     *
+     * @returns {*} The value of the relation.
+     */
+    get (relation) {
+        return _.get(this.model, relation);
+    }
+
+    /**
+     * @param  {string|Object} relation
+     * @param  {*} value
+     *
+     * @returns {Relations}
+     */
+    set (relation, value = null) {
+        if (_.isObject(relation)) {
+            _.each(this.model.constructor.relations(), (options, key) => {
+                if (! _.has(relation, key)) return;
+
+                this.set(key, relation[key]);
+            });
+
+            return this;
+        }
+
+        this.model[relation] = value;
+
+        return this;
+    }
+
+    /**
+     * @private
+     *
+     * @param {*} value
+     * @param {Object} options
+     *
+     * @returns {*} The casted value.
+     */
+    static _getCastedFromJsonValue (value, options) {
+        if (_.has(options, 'type')) {
+            const cast = options.type;
+
+            if (_.isArray(value)) {
+                return _.map(value, (val) => Caster.fromJson(cast, val));
+            } else {
+                return Caster.fromJson(cast, value);
+            }
+        }
+
+        return value;
+    }
+
+    /**
+     * @private
+     *
+     * @param {*} value
+     * @param {Object} options
+     *
+     * @returns {*} The casted value.
+     */
+    static _getCastedToJsonValue (value, options) {
+        if (_.has(options, 'type')) {
+            const cast = options.type;
+
+            if (_.isArray(value)) {
+                return _.map(value, (val) => Caster.toJson(cast, val));
+            } else {
+                return Caster.toJson(cast, value);
+            }
+        }
+
+        return value;
+    }
+}

package/src/connection.js

@@ -0,0 +1,83 @@
+import Response from './response';
+import axios from 'axios';
+
+export default class Connection {
+    constructor () {
+        this._abortController = null;
+
+        this._config = {};
+
+        this.running = false;
+        this.canceled = false;
+        this.failed = false;
+    }
+
+    cancel () {
+        if (! this._abortController) return this;
+
+        this._abortController.abort();
+
+        this.canceled = true;
+    }
+
+    setConfig (config) {
+        this._config = config;
+    }
+
+    async get (query, params) {
+        return this._execute(query, 'get', params);
+    }
+
+    async post (query, data) {
+        return this._execute(query, 'post', data);
+    }
+
+    async put (query, params) {
+        return this._execute(query, 'put', params);
+    }
+
+    async delete (query) {
+        return this._execute(query, 'delete');
+    }
+
+    async _execute (url, method, data) {
+        this.running = true;
+
+        if (! _.startsWith(url, '/')) {
+            url = `/${url}`;
+        }
+
+        const config = {
+            url: api.baseUrl + url,
+            method,
+            ...({
+                [method === 'get' ? 'params' : 'data']: data,
+            }),
+            signal: (this._abortController = new AbortController()).signal,
+        };
+
+        const request = axios(Object.assign(config, this._config));
+        const response = new Response();
+
+        await request
+            .then((axiosResponse) => {
+                response.set(axiosResponse.status, axiosResponse);
+            })
+            .catch((error) => {
+                this.failed = true;
+
+                let statusCode = 0;
+
+                if (error.response) {
+                    statusCode = error.response.status;
+                }
+
+                response.set(statusCode, error);
+            })
+            .finally(() => {
+                this.running = false;
+            });
+
+        return response;
+    }
+}

package/src/filters/count.js

@@ -0,0 +1,27 @@
+import Filter from './filter';
+
+export default class Count extends Filter {
+    constructor () {
+        super();
+
+        this._relations = [];
+    }
+
+    filled () {
+        return this._relations.length > 0;
+    }
+
+    add (relations) {
+        this._relations.push(...relations);
+    }
+
+    toObject () {
+        const data = {};
+
+        if (this.filled()) {
+            data.count = this._relations;
+        }
+
+        return data;
+    }
+}

package/src/filters/filter.js

@@ -0,0 +1,9 @@
+export default class Filter {
+    filled () {
+        return !! this.toObject();
+    }
+
+    toObject () {
+        return null;
+    }
+}

package/src/filters/filters.js

@@ -0,0 +1,33 @@
+import Limit from './limit';
+import Order from './order';
+import Relations from './relations';
+import Scopes from './scopes';
+import Search from './search';
+import Wheres from './wheres';
+import WhereIn from './whereIn';
+import Count from './count';
+import Pluck from './pluck';
+
+export default class Filters {
+    constructor () {
+        this.count = new Count();
+        this.limit = new Limit();
+        this.order = new Order();
+        this.relations = new Relations();
+        this.scopes = new Scopes();
+        this.search = new Search();
+        this.wheres = new Wheres();
+        this.whereIn = new WhereIn();
+        this.pluck = new Pluck();
+    }
+
+    toObject () {
+        const items = [];
+
+        for (let i = 0, filters = ['count', 'limit', 'order', 'relations', 'scopes', 'search', 'wheres', 'whereIn', 'pluck']; i < filters.length; i++) {
+            if (this[filters[i]].filled()) items.push(this[filters[i]].toObject());
+        }
+
+        return _.merge(...items);
+    }
+}

package/src/filters/limit.js

@@ -0,0 +1,27 @@
+import Filter from './filter';
+
+export default class Limit extends Filter {
+    constructor () {
+        super();
+
+        this._amount = null;
+    }
+
+    filled () {
+        return !! this._amount;
+    }
+
+    amount (amount) {
+        this._amount = amount;
+    }
+
+    toObject () {
+        const data = {};
+
+        if (this.filled()) {
+            data.limit = this._amount;
+        }
+
+        return data;
+    }
+}

package/src/filters/order.js

@@ -0,0 +1,30 @@
+import Filter from './filter';
+
+export default class Order extends Filter {
+    constructor () {
+        super();
+
+        this._orders = [];
+    }
+
+    filled () {
+        return this._orders.length > 0;
+    }
+
+    add (column, direction) {
+        this._orders.push({
+            column,
+            direction,
+        });
+    }
+
+    toObject () {
+        const data = {};
+
+        if (this.filled()) {
+            data.orders = this._orders;
+        }
+
+        return data;
+    }
+}

package/src/filters/pluck.js

@@ -0,0 +1,28 @@
+import Filter from './filter';
+import Format from '../utilities/format';
+
+export default class Pluck extends Filter {
+    constructor () {
+        super();
+
+        this._fields = [];
+    }
+
+    filled () {
+        return this._fields.length > 0;
+    }
+
+    add (fields) {
+        this._fields.push(..._.map(fields, Format.snakeCase));
+    }
+
+    toObject () {
+        const data = {};
+
+        if (this.filled()) {
+            data.pluck = this._fields;
+        }
+
+        return data;
+    }
+}

package/src/filters/relations.js

@@ -0,0 +1,27 @@
+import Filter from './filter';
+
+export default class Relations extends Filter {
+    constructor () {
+        super();
+
+        this._relations = [];
+    }
+
+    filled () {
+        return this._relations.length > 0;
+    }
+
+    add (relations) {
+        this._relations.push(...relations);
+    }
+
+    toObject () {
+        const data = {};
+
+        if (this.filled()) {
+            data.with = this._relations;
+        }
+
+        return data;
+    }
+}

package/src/filters/scopes.js

@@ -0,0 +1,30 @@
+import Filter from './filter';
+
+export default class Relations extends Filter {
+    constructor () {
+        super();
+
+        this._scopes = [];
+    }
+
+    filled () {
+        return this._scopes.length > 0;
+    }
+
+    add (name, params) {
+        this._scopes.push({
+            name,
+            params,
+        });
+    }
+
+    toObject () {
+        const data = {};
+
+        if (this.filled()) {
+            data.scopes = this._scopes;
+        }
+
+        return data;
+    }
+}

package/src/filters/search.js

@@ -0,0 +1,34 @@
+import Filter from './filter';
+import Format from '../utilities/format';
+
+export default class Search extends Filter {
+    constructor () {
+        super();
+
+        this._value = null;
+        this._columns = null;
+    }
+
+    filled () {
+        return this._value;
+    }
+
+    value (value) {
+        this._value = value;
+    }
+
+    columns (columns) {
+        this._columns = _.map(columns, Format.snakeCase);
+    }
+
+    toObject () {
+        const data = {};
+
+        if (this.filled()) {
+            data.search_value = this._value;
+            data.search_columns = this._columns;
+        }
+
+        return data;
+    }
+}

package/src/filters/whereIn.js

@@ -0,0 +1,31 @@
+import Filter from './filter';
+import Format from '../utilities/format';
+
+export default class Relations extends Filter {
+    constructor () {
+        super();
+
+        this._whereIns = [];
+    }
+
+    filled () {
+        return this._whereIns.length > 0;
+    }
+
+    add (column, values) {
+        this._whereIns.push({
+            column: Format.snakeCase(column),
+            values,
+        });
+    }
+
+    toObject () {
+        const data = {};
+
+        if (this.filled()) {
+            data.where_in = this._whereIns;
+        }
+
+        return data;
+    }
+}

package/src/filters/wheres.js

@@ -0,0 +1,32 @@
+import Filter from './filter';
+import Format from '../utilities/format';
+
+export default class Wheres extends Filter {
+    constructor () {
+        super();
+
+        this._wheres = [];
+    }
+
+    filled () {
+        return this._wheres.length > 0;
+    }
+
+    add (column, operator, value) {
+        this._wheres.push({
+            column: Format.snakeCase(column),
+            operator,
+            value,
+        });
+    }
+
+    toObject () {
+        const data = {};
+
+        if (this.filled()) {
+            data.wheres = this._wheres;
+        }
+
+        return data;
+    }
+}

package/src/index.js

@@ -0,0 +1,12 @@
+import _ from 'lodash';
+import Api from './api';
+import Model from './builder/model';
+
+window._ = _;
+
+const api = new Api();
+window.api = api;
+
+export { Model };
+
+export default api;

package/src/mixins/actionMixin.js

@@ -0,0 +1,20 @@
+/**
+ * @mixin actionMixin
+ */
+const actionMixin = {
+    /**
+     * @param {string} name
+     * @param {int} [id]
+     * @returns {this}
+     */
+    action (name, id) {
+        id ??= this._identifier;
+
+        this._action.name(name);
+        this._action.id(id);
+
+        return this;
+    },
+};
+
+export default actionMixin;

package/src/mixins/filterMixin.js

@@ -0,0 +1,104 @@
+/**
+ * @mixin filterMixin
+ */
+const filterMixin = {
+    count (relations) {
+        if (! Array.isArray(relations)) relations = [relations];
+
+        this._filters.count.add(relations);
+
+        return this;
+    },
+
+    limit (amount) {
+        this._filters.limit.amount(amount);
+
+        return this;
+    },
+
+    order (input, direction = 'asc') {
+        // If a single column name (string) is specified
+        if (typeof input === 'string') {
+            this._filters.order.add(_.snakeCase(input), direction);
+        }
+
+        // If there is an array input
+        else if (Array.isArray(input)) {
+            input.forEach(item => {
+                // If the item is a string (single column name)
+                if (typeof item === 'string') {
+                    this._filters.order.add(_.snakeCase(input), 'asc');
+                }
+
+                // If the item is an array ([column name, direction])
+                else if (Array.isArray(item)) {
+                    const [column, direction = 'asc'] = item; // default value for dir is 'asc' if not specified
+
+                    this._filters.order.add(_.snakeCase(column), direction);
+                }
+            });
+        }
+
+        return this;
+    },
+
+    with (relations) {
+        if (! Array.isArray(relations)) relations = [relations];
+
+        this._filters.relations.add(relations);
+
+        return this;
+    },
+
+    scope (name, ...params) {
+        this._filters.scopes.add(name, params);
+
+        return this;
+    },
+
+    search (value, columns = []) {
+        if (! Array.isArray(columns)) columns = [columns];
+
+        this._filters.search.value(value);
+        this._filters.search.columns(columns);
+
+        return this;
+    },
+
+    where (column, operator, value) {
+        if (arguments.length === 2) {
+            value = operator;
+            operator = '=';
+        }
+
+        this._filters.wheres.add(column, operator, value);
+
+        return this;
+    },
+
+    wheres (...params) {
+        return this.where(...params);
+    },
+
+    whereIn (column, values) {
+        if (! Array.isArray(values)) values = [values];
+
+        this._filters.whereIn.add(column, values);
+
+        return this;
+    },
+
+    whereIns (...params) {
+        return this.whereIn(...params);
+    },
+
+    pluck (fields) {
+        if (! Array.isArray(fields)) fields = [fields];
+
+        this._filters.pluck.add(fields);
+
+        return this;
+    },
+};
+
+export default filterMixin;

package/src/mixins/modifierMixin.js

@@ -0,0 +1,22 @@
+/**
+ * @mixin modifierMixin
+ */
+const modifierMixin = {
+    appends (appends) {
+        if (! Array.isArray(appends)) appends = [appends];
+
+        this._modifiers.appends.add(appends);
+
+        return this;
+    },
+
+    hiddenFields (hiddenFields) {
+        if (! Array.isArray(hiddenFields)) hiddenFields = [hiddenFields];
+
+        this._modifiers.hiddenFields.add(hiddenFields);
+
+        return this;
+    },
+};
+
+export default modifierMixin;