jcc-express-mvc 1.2.5 → 1.2.6

package/dist/Database/src/BaseEntity.js

@@ -0,0 +1,208 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseEntity = void 0;
+const connection_1 = require("./db/connection");
+const QueryInstance_1 = require("./QueryInstance");
+const Cast_1 = require("./Cast");
+class BaseEntity extends connection_1.Database {
+    constructor() {
+        super(...arguments);
+        this.attributes = {};
+        this._select = "*";
+        this._tableName = "";
+        this._where = [];
+        this._joins = [];
+        this._distinct = false;
+        this._insertData = {
+            keys: [],
+            values: [],
+        };
+        this._updateData = {}; //{ keys: Array<any>; values: Array<any> };
+        this._relationships = [];
+        this.fillable = [];
+        this.guard = [];
+        this.hidden = [];
+        this._max = "";
+        this._min = "";
+        this._sum = "";
+        this._avg = "";
+        this.sqlQuery = "";
+    }
+    /**
+     * Resets all query builder state variables to their default values.
+     */
+    _resetQuery() {
+        this._select = "*";
+        this._tableName = "";
+        this._where = [];
+        this._joins = [];
+        this._orderBy = "";
+        this._limit = "";
+        this._offset = "";
+        this._groupBy = "";
+        this._having = "";
+        this._distinct = false;
+        this._insertData = { keys: [], values: [] };
+        this._updateData = {};
+        this._delete = false;
+        this._count = false;
+        this._relationships = [];
+        this._max = "";
+        this._min = "";
+        this._sum = "";
+        this._avg = "";
+        return;
+    }
+    /**
+     * Constructs and returns the SQL query based on the current query builder state.
+     *
+     * @returns {string} The generated SQL query.
+     */
+    compileToSql() {
+        if (this._count) {
+            this.sqlQuery += this.buildCount();
+        }
+        else if (this._sum) {
+            this.sqlQuery += this.buildSum();
+        }
+        else if (this._avg) {
+            this.sqlQuery += this.buildAvg();
+        }
+        else if (this._max) {
+            this.sqlQuery += this.buildMax();
+        }
+        else if (this._min) {
+            this.sqlQuery += this.buildMin();
+        }
+        else if (Object.values(this._insertData.keys).length > 1) {
+            this.sqlQuery += this.buidInsert();
+        }
+        else if (Object.values(this._updateData).length > 1) {
+            this.sqlQuery += this.buildUpdate();
+        }
+        else if (this._delete) {
+            this.sqlQuery += this.buildDelete();
+        }
+        else {
+            this.sqlQuery += this.buildselect();
+        }
+        if (this._joins.length > 0) {
+            this.sqlQuery += this.buildJoin();
+        }
+        if (this._where.length > 0) {
+            this.sqlQuery += this.buildWhere();
+        }
+        if (this._groupBy) {
+            this.sqlQuery += this.buildGroup();
+        }
+        if (this._having) {
+            this.sqlQuery += this.buildHaving();
+        }
+        if (this._orderBy) {
+            this.sqlQuery += this.buildOrderBy();
+        }
+        if (this._limit) {
+            this.sqlQuery += this.buildLimit();
+        }
+        if (this._offset) {
+            this.sqlQuery += this.buildOffset();
+        }
+    }
+    buidInsert() {
+        return `INSERT INTO ${this._tableName} (${this._insertData.keys.join(",")}) VALUES (${this._insertData.values.join(", ")})`;
+    }
+    buildUpdate() {
+        let updateString = Object.keys(this._updateData)
+            .map((key) => `${key}='${this._updateData[key]}'`)
+            .join(", ");
+        return `UPDATE ${this._tableName} SET ${updateString}`;
+    }
+    buildJoin() {
+        return this._joins
+            .map((join) => {
+            ` ${join.type} JOIN ${join.table} ON ${join.firstColumn} ${join.operator} ${join.secondColumn}`;
+        })
+            .join();
+    }
+    // private buildSelect(): string {}
+    buildOffset() {
+        return ` OFFSET ${this._offset}`;
+    }
+    buildselect() {
+        return `SELECT ${this._distinct ? "DISTINCT " : ""}${this._select} FROM ${this._tableName}`;
+    }
+    buildDelete() {
+        return `DELETE FROM ${this._tableName}`;
+    }
+    buildWhere() {
+        return (" WHERE " +
+            this._where
+                .map((condition, index) => {
+                const connector = index > 0 && condition.connector
+                    ? ` ${condition.connector} `
+                    : index > 0
+                        ? " AND "
+                        : "";
+                return `${connector}${condition.column} ${condition.operator} '${condition.value}'`;
+            })
+                .join(""));
+    }
+    buildCount() {
+        return `SELECT COUNT(*) as count FROM ${this._tableName}`;
+    }
+    buildMin() {
+        return `SELECT MIN(${this._min}) FROM ${this._tableName}`;
+    }
+    buildMax() {
+        return `SELECT MAX(${this._max}) FROM ${this._tableName} `;
+    }
+    buildAvg() {
+        return `SELECT MAX(${this._avg}) FROM ${this._tableName} `;
+    }
+    buildSum() {
+        return `SELECT SUM(${this._sum}) FROM ${this._tableName} `;
+    }
+    buildHaving() {
+        return ` HAVING ${this._having}`;
+    }
+    buildGroup() {
+        return ` GROUP BY ${this._groupBy}`;
+    }
+    buildOrderBy() {
+        return ` ORDER BY ${this._orderBy}`;
+    }
+    buildLimit() {
+        return ` LIMIT ${this._limit}`;
+    }
+    getCompileSqlCode() {
+        this.compileToSql();
+        // this._resetQuery();
+        let sql = this.sqlQuery;
+        this.sqlQuery = "";
+        return sql;
+    }
+    setGuard(values) {
+        this.guard = values;
+    }
+    setFillable(values) {
+        this.fillable = values;
+    }
+    setHidden(values) {
+        this.hidden = values;
+    }
+    setCasts(values) {
+        this.casts = values;
+    }
+    removeHiddenValues(item) {
+        const keysSet = new Set(this.hidden);
+        const newItem = { ...item };
+        for (const key of keysSet) {
+            delete newItem[key];
+        }
+        return newItem;
+    }
+    newInstance(results) {
+        return results.map((result) => new QueryInstance_1.QueryInstance(Cast_1.Cast.getCastType(this.casts || {}, this.removeHiddenValues(result))));
+    }
+}
+exports.BaseEntity = BaseEntity;

package/dist/Database/src/BaseModel.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseModel = void 0;
+const QueryBuilder_1 = require("./QueryBuilder");
+const utils_1 = require("./utils");
+class BaseModel extends QueryBuilder_1.QueryBuilder {
+    /**
+     * Defines a hasMany relationship between the current model and another model.
+     *
+     * @param {string} relatedModel - The name of the related model.
+     * @param {string} foreingKey - The foreign key in the related model (defaults to id).
+     * @param {string} localKey - The local key in the current model (defaults to 'id').
+     * @returns {Function} A function that retrieves the related data based on the relationship.
+     */
+    hasMany(relatedModel, foreingKey, localKey = "id") {
+        return async (query = {}) => {
+            const result = (0, utils_1.extractFirst)(query);
+            const value = result[localKey];
+            return {
+                results: this.select().table(relatedModel).where(foreingKey, value),
+                type: "hasMany",
+            };
+        };
+    }
+    /**
+     * Defines a belongsTo relationship between the current model and another model.
+     *
+     * @param {string} relatedModel - The name of the related model.
+     * @param {string} foreingKey - The foreign key in the related model (defaults to id).
+     * @param {string} localKey - The local key in the current model (defaults to 'id').
+     * @returns {Function} A function that retrieves the related data based on the relationship.
+     */
+    belongsTo(relatedModel, foreingKey, localKey = "id") {
+        return async (query = {}) => {
+            const result = (0, utils_1.extractFirst)(query);
+            const value = result[foreingKey];
+            return {
+                results: this.select().table(relatedModel).where(localKey, value),
+                type: "belongsTo",
+            };
+        };
+    }
+}
+exports.BaseModel = BaseModel;

package/dist/Database/src/Builder.js

@@ -0,0 +1,430 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Builder = void 0;
+const RelationBuilder_1 = require("./RelationBuilder");
+const utils_1 = require("./utils");
+class Builder extends RelationBuilder_1.RelationBuilder {
+    constructor() {
+        super(...arguments);
+        this.guard = [];
+    }
+    /**
+     * Specifies the columns to select in a query.
+     *
+     * @param {...string} columns - The columns to select.
+     * @returns {this} The instance of the model, allowing for method chaining.
+     */
+    select(...columns) {
+        this._select = columns.length > 0 ? columns.join(", ") : "*";
+        return this;
+    }
+    /**
+     * Marks the query to return distinct results.
+     *
+     * @returns {this} The instance of the model, allowing for method chaining.
+     */
+    distinct() {
+        this._distinct = true;
+        return this;
+    }
+    /**
+     * Specifies the offset for starting the query results.
+     *
+     * @param {number} count - The number of rows to skip before starting to return rows.
+     * @returns {this} The instance of the model, allowing for method chaining.
+     */
+    offset(value) {
+        this._offset = value;
+        return this;
+    }
+    /**
+     * Specifies the table to query from.
+     *
+     * @param {string} tableName - The name of the table to query from.
+     * @returns {this} The instance of the model, allowing for method chaining.
+     */
+    from(tableName) {
+        this._tableName = (0, utils_1.pluralize)(tableName);
+        return this;
+    }
+    /**
+     * Adds a WHERE clause to the query.
+     *
+     * @param {string} column - The column to apply the condition on.
+     * @param {string} operator - The operator to use for the condition (e.g., '=', '>', '<').
+     * @param {any} value - The value to compare the column against.
+     * @returns {this} The instance of the model, allowing for method chaining.
+     */
+    where(column, operator, value) {
+        if (!value) {
+            value = operator;
+            operator = "=";
+        }
+        this._where.push({ column, operator, value });
+        return this;
+    }
+    /**
+     * Inserts data into the database and retrieves the inserted record.
+     *
+     * @param {Object} data - The data to insert into the database.
+     * @returns {Promise<any>} The inserted record.
+     */
+    async insert(data, fillable, guard) {
+        try {
+            const tableName = this._tableName || this.constructor.name;
+            this.setFillable(fillable);
+            this.setGuard(guard);
+            const { keys, values } = (0, utils_1.transformData)(data, fillable, guard);
+            this._insertData = { keys, values };
+            const result = await this.runQuery(this.getCompileSqlCode());
+            this._resetQuery();
+            return this.select()
+                .table(tableName)
+                .where("id", result.insertId)
+                .first();
+        }
+        catch (error) {
+            throw new Error(error?.message);
+        }
+    }
+    /**
+     * Adds an OR WHERE clause to the query.
+     *
+     * @param {string} column - The column to apply the condition on.
+     * @param {string} operator - The operator to use for the condition (e.g., '=', '>', '<').
+     * @param {any} value - The value to compare the column against.
+     * @returns {this} The instance of the model, allowing for method chaining.
+     */
+    orWhere(column, operator, value) {
+        if (arguments.length === 2) {
+            value = operator;
+            operator = "=";
+        }
+        this._where.push({ column, operator, value, connector: "OR" });
+        return this;
+    }
+    /**
+     * Specifies the column and direction for ordering the query results.
+     *
+     * @param {string} column - The column to order by.
+     * @param {string} [direction="asc"] - The direction of ordering ("asc" for ascending, "desc" for descending).
+     * @returns {this} The instance of the model, allowing for method chaining.
+     */
+    orderBy(column, direction = "asc") {
+        this._orderBy = `${column} ${direction.toUpperCase()}`;
+        return this;
+    }
+    /**
+     * Limits the number of results returned by the query.
+     *
+     * @param {number} count - The maximum number of results to return.
+     * @returns {this} The instance of the model, allowing for method chaining.
+     */
+    limit(count) {
+        this._limit = count;
+        return this;
+    }
+    /**
+     * Limits the number of results returned by the query.
+     *
+     * @param {number} count - The maximum number of results to return.
+     * @returns {this} The instance of the model, allowing for method chaining.
+     */
+    take(count) {
+        this._limit = count;
+        return this;
+    }
+    /**
+     * Specifies the columns to group the query results by.
+     *
+     * @param {...string} columns - The columns to group by.
+     * @returns {this} The instance of the model, allowing for method chaining.
+     */
+    groupBy(...columns) {
+        this._groupBy = columns.join(", ");
+        return this;
+    }
+    /**
+     * Adds a HAVING clause to the query.
+     *
+     * @param {string} column - The column to apply the condition on.
+     * @param {string} operator - The operator to use for the condition (e.g., '=', '>', '<').
+     * @param {any} value - The value to compare the column against.
+     * @returns {this} The instance of the model, allowing for method chaining.
+     */
+    having(column, operator, value) {
+        this._having = `${column} ${operator} '${value}'`;
+        return this;
+    }
+    /**
+     * Adds a JOIN clause to the query.
+     *
+     * @param {string} table - The name of the table to join.
+     * @param {string} firstColumn - The column from the current table to join on.
+     * @param {string} operator - The operator to use for the join condition (e.g., '=', '>', '<').
+     * @param {string} secondColumn - The column from the joined table to join on.
+     * @returns {this} The instance of the model, allowing for method chaining.
+     */
+    join(type, table, firstColumn, operator, secondColumn) {
+        this._joins.push({
+            type,
+            table,
+            firstColumn,
+            operator,
+            secondColumn,
+        });
+        return this;
+    }
+    /**
+     * Adds an INNER JOIN clause to the query.
+     *
+     * @param {string} table - The name of the table to join.
+     * @param {string} firstColumn - The column from the current table to join on.
+     * @param {string} operator - The operator to use for the join condition (e.g., '=', '>', '<').
+     * @param {string} secondColumn - The column from the joined table to join on.
+     * @returns {this} The instance of the model, allowing for method chaining.
+     */
+    innerJoin(table, firstColumn, operator, secondColumn) {
+        this.join("INNER", table, firstColumn, operator, secondColumn);
+        return this;
+    }
+    /**
+     * Adds a LEFT JOIN clause to the query.
+     *
+     * @param {string} table - The name of the table to join.
+     * @param {string} firstColumn - The column from the current table to join on.
+     * @param {string} operator - The operator to use for the join condition (e.g., '=', '>', '<').
+     * @param {string} secondColumn - The column from the joined table to join on.
+     * @returns {this} The instance of the model, allowing for method chaining.
+     */
+    leftJoin(table, firstColumn, operator, secondColumn) {
+        this.join("LEFT", table, firstColumn, operator, secondColumn);
+        return this;
+    }
+    /**
+     * Adds a RIGHT JOIN clause to the query.
+     *
+     * @param {string} table - The name of the table to join.
+     * @param {string} firstColumn - The column from the current table to join on.
+     * @param {string} operator - The operator to use for the join condition (e.g., '=', '>', '<').
+     * @param {string} secondColumn - The column from the joined table to join on.
+     * @returns {this} The instance of the model, allowing for method chaining.
+     */
+    rightJoin(table, firstColumn, operator, secondColumn) {
+        this.join("RIGHT", table, firstColumn, operator, secondColumn);
+        return this;
+    }
+    /**
+     * Sets the data to update for the query.
+     *
+     * @param {Object} data - The data to update.
+     * @returns {Promise<any>} The instance of the model, allowing for method chaining.
+     */
+    async update(data = {}, fillable = [], guard = []) {
+        try {
+            const id = data["id"];
+            delete data["id"];
+            this.setFillable(fillable);
+            this.setGuard(guard);
+            this.where("id", id);
+            const tableName = this._tableName || this.constructor.name;
+            this._updateData = data;
+            // Object.keys(this.casts).length > 0 ? new Cast(this.casts, data) : data;
+            await this.runQuery(this.getCompileSqlCode());
+            return this.select().from(tableName).where("id", id).first();
+        }
+        catch (error) {
+            throw new Error(`${this.getCompileSqlCode()} \n ${error.message}`);
+        }
+    }
+    /**
+     * Fetch the first record from the database table.
+     * The table name is derived from the current class name or the previously set table name.
+     * @returns {Object} The first record if found, otherwise an empty object.
+     */
+    async first() {
+        try {
+            const tableName = this._tableName || this.constructor.name;
+            let query = this.table(tableName);
+            if (!this._limit) {
+                query.limit(1);
+            }
+            if (!this._orderBy) {
+                query.orderBy("id");
+            }
+            return (0, utils_1.extractFirst)(await query.get());
+        }
+        catch (error) {
+            throw new Error(error.message);
+        }
+    }
+    /**
+     * Executes the constructed query, loads specified relations, and resets the query builder state.
+     *
+     * @returns {Promise<Array>} A Promise that resolves with the fetched results including loaded relations.
+     */
+    async get() {
+        try {
+            const results = await this.runQuery(this.getCompileSqlCode());
+            this.addAttributes(results);
+            for (const relation of this._relationships) {
+                await this.loadRelations(this._tableName, relation, results);
+            }
+            this._resetQuery();
+            return this.newInstance(results);
+        }
+        catch (error) {
+            console.log(error.message);
+            throw new Error(this.getCompileSqlCode());
+        }
+    }
+    addGuard(columns) {
+        this.guard = columns;
+    }
+    addFillable(columns) {
+        this.fillable = columns;
+    }
+    addHidden(columns) {
+        this.hidden = columns;
+    }
+    // public addHidden(columns: Array<string>) {
+    //   this.hidden = columns;
+    // }
+    latest(column = "created_at") {
+        this.orderBy(column, "desc");
+        return this;
+    }
+    table(table) {
+        this.from(table);
+        return this;
+    }
+    /**
+     * Adds the specified relationships to the model.
+     *
+     * @param {...string} relations - The names of the relationships to add.
+     * @returns {this} The instance of the model, allowing for method chaining.
+     */
+    with(...relations) {
+        this._relationships?.push(...relations);
+        return this;
+    }
+    /**
+     * Iterates over each record, applies a callback function to each record, and collects the results in an array.
+     *
+     * @param {Function} callback - The function to be applied to each record. The function should accept a record as an argument and return a value.
+     * @returns {Promise<Array>} A promise that resolves to an array of results from applying the callback function to each record.
+     */
+    async each(callback) {
+        const results = await this.get(); //(this.getCompileSqlCode())) || [];
+        for (let result of results) {
+            callback(result);
+        }
+    }
+    /**
+     * Iterates over map record returned by the query, applies a callback function to map record, and collects the results in an array.
+     *
+     * @param {Function} callback - The function to be applied to map record. The function should accept a record as an argument and return a value.
+     * @returns {Promise<Array>} A promise that resolves to an array of results from applying the callback function to each record.
+     */
+    async map(callback) {
+        const data = [];
+        const results = (await this.get()) || []; //(await this.runQuery(this.getCompileSqlCode())) || [];
+        for (let result of results) {
+            if (callback(result)) {
+                data.push(callback(result));
+            }
+        }
+        return data;
+    }
+    /**
+     * Retrieves the value of a specified field from the first record that matches the current query conditions.
+     *
+     * @param {string} field - The field name whose value is to be retrieved.
+     * @returns {Promise<any>} A promise that resolves to the value of the specified field, or null if no records are found.
+     */
+    async value(field) {
+        const result = await this.get(); //await this.runQuery(this.getCompileSqlCode());
+        const record = (0, utils_1.extractFirst)(result);
+        return record[field] || null;
+    }
+    /**
+     * Checks if any records exist that match the current query conditions.
+     *
+     * @returns {Promise<boolean>} A promise that resolves to true if records exist, false otherwise.
+     */
+    async exists() {
+        const result = await this.get();
+        return Array.isArray(result) && result.length >= 1;
+    }
+    /**
+     * Checks if no records exist that match the current query conditions.
+     *
+     * @returns {Promise<boolean>} A promise that resolves to true if no records exist, false otherwise.
+     */
+    async doesntExist() {
+        const result = await this.get(); //QueryBuilder.runQuery(QueryBuilder.getFinalQuery());
+        return !Array.isArray(result) || result.length < 1;
+    }
+    /**
+     * Executes a count query based on the current query builder state.
+     *
+     * @returns {Promise<number>} A Promise that resolves with the count of records.
+     */
+    async count() {
+        try {
+            this._count = true;
+            const record = await this.get();
+            return (0, utils_1.countValue)((0, utils_1.extractFirst)(record));
+        }
+        catch (error) {
+            throw new Error(error.message);
+        }
+    }
+    /**
+     * Executes a max query based on the current query builder state.
+     *
+     * @returns {Promise<number>} A Promise that resolves with the max of records.
+     */
+    async max(column) {
+        this._max = column;
+        const record = await this.get();
+        return (0, utils_1.countValue)((0, utils_1.extractFirst)(record));
+        return 0;
+    }
+    /**
+     * Executes a min query based on the current query builder state.
+     *
+     * @returns {Promise<number>} A Promise that resolves with the min of records.
+     */
+    async min(column) {
+        this._min = column;
+        const record = await this.get();
+        return (0, utils_1.countValue)((0, utils_1.extractFirst)(record));
+        return 0;
+    }
+    /**
+     * Executes a sum of a specify column query based on the current query builder state.
+     *
+     * @returns {Promise<number>} A Promise that resolves with the min of records.
+     */
+    async sum(column) {
+        this._sum = column;
+        const record = await this.get();
+        return (0, utils_1.countValue)((0, utils_1.extractFirst)(record));
+    }
+    /**
+     * Executes a average query based on the current query builder state.
+     *
+     * @returns {Promise<number>} A Promise that resolves with the sum of records.
+     */
+    async avg(column) {
+        this._avg = column;
+        const record = await this.get();
+        return (0, utils_1.countValue)((0, utils_1.extractFirst)(record));
+    }
+    addAttributes(record) {
+        return (this.attributes = { ...(0, utils_1.extractFirst)(record[record.length - 1]) });
+    }
+}
+exports.Builder = Builder;
+Builder.query = new Builder();