jcc-express-mvc 1.2.6 → 1.2.8

package/Command-Line/command.js

@@ -1,134 +0,0 @@
-const path = require("path");
-const fs = require("fs");
-const appRootPath = require("app-root-path");
-const createController = require("./files/Controller");
-const createModel = require("./files/Models");
-const resourceController = require("./files/ResourcesController");
-const createRequest = require("./files/Request");
-const createMigration = require("./files/Migration");
-const colors = require("colors"); // Module for adding color to console output
-const { formatDate } = require("./utils");
-
-const rootPath = appRootPath.path;
-
-class Command {
-  // Method to add a web controller
-  addWeb(controllerName, modelName = false) {
-    try {
-      let webControllerPath = path.resolve(`${rootPath}/app/Http/Controllers`); // Resolve path to web controllers directory
-      if (fs.existsSync(`${webControllerPath}/${controllerName}.ts`)) {
-        // Check if controller file already exists
-        return console.log(`${controllerName} already exist`.yellow); // Log a warning if controller already exists
-      }
-      if (modelName && typeof modelName === "string") {
-        // If model name is provided, create a resource controller
-        fs.writeFileSync(
-          `${webControllerPath}/${controllerName}.ts`,
-          resourceController(controllerName, modelName),
-        );
-        return console.log(`${controllerName} added successfully`.green); // Log success message
-      }
-      fs.writeFileSync(
-        `${webControllerPath}/${controllerName}.ts`,
-        createController(controllerName), // Create a basic controller file
-      );
-
-      return console.log(`${controllerName} added successfully`.green); // Log success message
-    } catch (err) {
-      console.log(`${controllerName} admin controller not added`.red); // Log error if controller addition fails
-    }
-  }
-
-  // Method to add an API controller
-  addApi(controllerName, modelName = false) {
-    try {
-      let apiPath = path.resolve(`${rootPath}/app/Http/ApiControllers`); // Resolve path to API controllers directory
-      if (fs.existsSync(`${apiPath}/${controllerName}.ts`)) {
-        // Check if API controller file already exists
-        return console.log(
-          `${controllerName} api controller already exist`.yellow,
-        ); // Log a warning if API controller already exists
-      }
-      if (modelName && typeof modelName === "string") {
-        // If model name is provided, create a resource controller
-        fs.writeFileSync(
-          `${apiPath}/${controllerName}.ts`,
-          resourceController(controllerName, modelName),
-        );
-        return console.log(`${controllerName} added successfully`.green); // Log success message
-      }
-      fs.writeFileSync(
-        `${apiPath}/${controllerName}.ts`,
-        createController(controllerName), // Create a basic controller file
-      );
-      return console.log(`${controllerName} added successfully`.green); // Log success message
-    } catch (err) {
-      console.log(err.message);
-      console.log(`${controllerName} api controller not added`.red); // Log error if controller addition fails
-    }
-  }
-
-  // Method to add a model
-  addModel(modelName) {
-    try {
-      let modelPath = path.resolve(`${rootPath}/app/Models`); // Resolve path to models directory
-      if (fs.existsSync(`${modelPath}/${modelName}.ts`)) {
-        // Check if model file already exists
-        return console.log(`${modelName} model already exist`.yellow); // Log a warning if model already exists
-      }
-      fs.writeFileSync(`${modelPath}/${modelName}.ts`, createModel(modelName)); // Create a model file
-      return console.log(`${modelName} model added successfully`.green); // Log success message
-    } catch (err) {
-      return console.log(`${modelName} model not added`.red); // Log error if model addition fails
-    }
-  }
-
-  // Method to add a request file
-  addRequest(requestName) {
-    try {
-      let requestPath = path.resolve(`${rootPath}/app/Http/Requests`); // Resolve path to request files directory
-      if (fs.existsSync(`${requestPath}/${requestName}.ts`)) {
-        // Check if request file already exists
-        return console.log(`${requestName} already exist`.yellow); // Log a warning if request file already exists
-      }
-
-      fs.writeFileSync(
-        `${requestPath}/${requestName}.ts`,
-        createRequest(requestName), // Create a request file
-      );
-      return console.log(`${requestName} added successfully`.green); // Log success message
-    } catch (err) {
-      return console.log(`${requestName} request not added`.red, { err }); // Log error if request addition fails
-    }
-  }
-
-  // Method to add a request file
-  addMigration(migrationName) {
-    try {
-      const tableName = migrationName.replace(/(create_|_table)/g, "");
-
-      let migrationPath = path.resolve(`${rootPath}/database/migrations`);
-      // Resolve path to request files directory
-      const fullName = `${formatDate()}_${migrationName}`;
-      if (fs.existsSync(`${migrationPath}/${fullName}.ts`)) {
-        // Check if request file already exists
-        return console.log(`${tableName} already exist`.yellow); // Log a warning if request file already exists
-      }
-
-      fs.writeFileSync(
-        `${migrationPath}/${fullName}.ts`,
-        createMigration(tableName), // Create a request file
-      );
-      return console.log(`${fullName} added successfully`.green); // Log success message
-    } catch (err) {
-      return console.log(`${fullName} request not added`.red, { err }); // Log error if request addition fails
-    }
-  }
-
-  // Method to handle a command not found
-  notFound() {
-    return console.log(`Command not found`.bgRed); // Log a message indicating the command was not found
-  }
-}
-
-module.exports = new Command(); // Export an instance of the Command class

package/Command-Line/utils.js

@@ -1,11 +0,0 @@
-exports.formatDate = () => {
-  const date = new Date();
-  const year = date.getFullYear();
-  const month = String(date.getMonth() + 1).padStart(2, "0");
-  const day = String(date.getDate()).padStart(2, "0");
-  const hours = String(date.getHours()).padStart(2, "0");
-  const minutes = String(date.getMinutes()).padStart(2, "0");
-  const seconds = String(date.getSeconds()).padStart(2, "0");
-
-  return `${year}_${month}_${day}_${hours}_${minutes}_${seconds}`;
-};

package/Database/src/BaseEntity.ts

@@ -1,247 +0,0 @@
-import { objType } from "./type";
-import { Database } from "./db/connection";
-import { QueryInstance } from "./QueryInstance";
-import { Cast } from "./Cast";
-
-export class BaseEntity extends Database {
-  protected attributes: objType = {};
-  protected _select: string | Array<string> = "*";
-  protected _tableName: string = "";
-  protected _where: Array<any> = [];
-  protected _joins: Array<any> = [];
-  protected _orderBy?: string;
-  protected _limit?: string | number;
-  protected _offset?: string | number;
-  protected _groupBy?: string;
-  protected _having?: string;
-  protected _distinct: boolean = false;
-  protected _insertData: { keys: Array<any>; values: Array<any> } = {
-    keys: [],
-    values: [],
-  };
-  protected _updateData: objType = {}; //{ keys: Array<any>; values: Array<any> };
-  protected _delete?: boolean;
-  protected _count?: boolean;
-  protected _relationships: Array<any> = [];
-  protected fillable: Array<string> = [];
-  protected guard: Array<string> = [];
-  protected hidden: Array<string> = [];
-  protected casts?: object;
-  protected _max: string = "";
-  protected _min: string = "";
-  protected _sum: string = "";
-  protected _avg: string = "";
-  protected sqlQuery: string = "";
-
-  /**
-   * Resets all query builder state variables to their default values.
-   */
-  public _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.
-   */
-  private compileToSql(): void {
-    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();
-    }
-  }
-
-  private buidInsert(): string {
-    return `INSERT INTO ${this._tableName} (${this._insertData.keys.join(
-      ",",
-    )}) VALUES (${this._insertData.values.join(", ")})`;
-  }
-
-  private buildUpdate(): string {
-    let updateString = Object.keys(this._updateData)
-      .map((key: string) => `${key}='${this._updateData[key]}'`)
-      .join(", ");
-    return `UPDATE ${this._tableName} SET ${updateString}`;
-  }
-
-  private buildJoin(): string {
-    return this._joins
-      .map((join) => {
-        ` ${join.type} JOIN ${join.table} ON ${join.firstColumn} ${join.operator} ${join.secondColumn}`;
-      })
-      .join();
-  }
-  // private buildSelect(): string {}
-
-  private buildOffset(): string {
-    return ` OFFSET ${this._offset}`;
-  }
-
-  private buildselect(): string {
-    return `SELECT ${this._distinct ? "DISTINCT " : ""}${this._select} FROM ${
-      this._tableName
-    }`;
-  }
-
-  private buildDelete(): string {
-    return `DELETE FROM ${this._tableName}`;
-  }
-
-  private buildWhere(): string {
-    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("")
-    );
-  }
-
-  private buildCount(): string {
-    return `SELECT COUNT(*) as count FROM ${this._tableName}`;
-  }
-
-  private buildMin(): string {
-    return `SELECT MIN(${this._min}) FROM ${this._tableName}`;
-  }
-
-  private buildMax(): string {
-    return `SELECT MAX(${this._max}) FROM ${this._tableName} `;
-  }
-
-  private buildAvg(): string {
-    return `SELECT MAX(${this._avg}) FROM ${this._tableName} `;
-  }
-
-  private buildSum(): string {
-    return `SELECT SUM(${this._sum}) FROM ${this._tableName} `;
-  }
-
-  private buildHaving(): string {
-    return ` HAVING ${this._having}`;
-  }
-
-  private buildGroup(): string {
-    return ` GROUP BY ${this._groupBy}`;
-  }
-
-  private buildOrderBy(): string {
-    return ` ORDER BY ${this._orderBy}`;
-  }
-
-  private buildLimit(): string {
-    return ` LIMIT ${this._limit}`;
-  }
-
-  protected getCompileSqlCode(): string {
-    this.compileToSql();
-    // this._resetQuery();
-    let sql = this.sqlQuery;
-    this.sqlQuery = "";
-    return sql;
-  }
-
-  public setGuard(values: Array<string>): void {
-    this.guard = values;
-  }
-
-  public setFillable(values: Array<string>): void {
-    this.fillable = values;
-  }
-
-  public setHidden(values: Array<string>): void {
-    this.hidden = values;
-  }
-
-  public setCasts(values: objType): void {
-    this.casts = values;
-  }
-
-  private removeHiddenValues(item: any): objType {
-    const keysSet = new Set(this.hidden);
-    const newItem = { ...item };
-    for (const key of keysSet) {
-      delete newItem[key as keyof typeof item];
-    }
-    return newItem;
-  }
-
-  protected newInstance<T>(results: objType): QueryInstance<T> {
-    return results.map(
-      (result: T) =>
-        new QueryInstance<T>(
-          Cast.getCastType(this.casts || {}, this.removeHiddenValues(result)),
-        ),
-    );
-  }
-}

package/Database/src/BaseModel.ts

@@ -1,51 +0,0 @@
-import { objType } from "./type";
-import { QueryBuilder } from "./QueryBuilder";
-import { extractFirst } from "./utils";
-
-export class BaseModel extends 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.
-   */
-  protected hasMany(
-    relatedModel: string,
-    foreingKey: string,
-    localKey: string = "id",
-  ): any {
-    return async (query: objType | Array<objType> = {}) => {
-      const result = 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.
-   */
-  protected belongsTo(
-    relatedModel: string,
-    foreingKey: string,
-    localKey: string = "id",
-  ): any {
-    return async (query: objType | Array<objType> = {}) => {
-      const result = extractFirst(query);
-      const value = result[foreingKey];
-      return {
-        results: this.select().table(relatedModel).where(localKey, value),
-        type: "belongsTo",
-      };
-    };
-  }
-}