tspace-mysql 1.5.0 → 1.5.2

package/build/lib/core/Schema.d.ts

@@ -0,0 +1,137 @@
+import { Builder } from "./Builder";
+declare class Schema extends Builder {
+    table: (table: string, schemas: Record<string, any>) => Promise<void>;
+    createTable: (table: string, schemas: Record<string, any>) => string;
+    /**
+    *
+    * The 'Sync' method is used to check for create or update table or columns with your schema in your model.
+    *
+    * The schema can define with method 'useSchema'
+    * @param    {string} pathFolders directory to models
+    * @property {boolean} options.force - forec always check all columns if not exists will be created
+    * @property {boolean} options.log   - show log execution with sql statements
+    * @property {boolean} options.foreign - check when has a foreign keys will be created
+    * @property {boolean} options.changed - check when column is changed attribute will be change attribute
+    * @return {Promise<void>}
+    * @example
+    *
+    * - node_modules
+    * - app
+    *   - Models
+    *     - User.ts
+    *     - Post.ts
+    *
+    *  // file User.ts
+    *  class User extends Model {
+    *      constructor(){
+    *          super()
+    *          this.hasMany({ name : 'posts' , model : Post })
+    *          this.useSchema ({
+    *               id          : new Blueprint().int().notNull().primary().autoIncrement(),
+    *               uuid        : new Blueprint().varchar(50).null(),
+    *               email       : new Blueprint().int().notNull().unique(),
+    *               name        : new Blueprint().varchar(255).null(),
+    *               created_at  : new Blueprint().timestamp().null(),
+    *               updated_at  : new Blueprint().timestamp().null(),
+    *               deleted_at  : new Blueprint().timestamp().null()
+    *           })
+    *       }
+    *   }
+    *
+    *   // file Post.ts
+    *   class Post extends Model {
+    *      constructor(){
+    *          super()
+    *          this.hasMany({ name : 'comments' , model : Comment })
+    *          this.belongsTo({ name : 'user' , model : User })
+    *          this.useSchema ({
+    *               id          : new Blueprint().int().notNull().primary().autoIncrement(),
+    *               uuid        : new Blueprint().varchar(50).null(),
+    *               user_id     : new Blueprint().int().notNull().foreign({ references : 'id' , on : User , onDelete : 'CASCADE' , onUpdate : 'CASCADE' }),
+    *               title       : new Blueprint().varchar(255).null(),
+    *               created_at  : new Blueprint().timestamp().null(),
+    *               updated_at  : new Blueprint().timestamp().null(),
+    *               deleted_at  : new Blueprint().timestamp().null()
+    *           })
+    *       }
+    *   }
+    *
+    *
+    *  await new Schema().sync(`app/Models` , { force : true , log = true, foreign = true , changed = true })
+    */
+    sync(pathFolders: string, { force, log, foreign, changed }?: {
+        force?: boolean | undefined;
+        log?: boolean | undefined;
+        foreign?: boolean | undefined;
+        changed?: boolean | undefined;
+    }): Promise<void>;
+    /**
+     *
+     * The 'Sync' method is used to check for create or update table or columns with your schema in your model.
+     *
+     * The schema can define with method 'useSchema'
+     * @param    {string} pathFolders directory to models
+     * @type     {object}  options
+     * @property {boolean} options.force - forec always check all columns if not exists will be created
+     * @property {boolean} options.log   - show log execution with sql statements
+     * @property {boolean} options.foreign - check when has a foreign keys will be created
+     * @property {boolean} options.changed - check when column is changed attribute will be change attribute
+     * @return {Promise<void>}
+     * @example
+     *
+     * - node_modules
+     * - app
+     *   - Models
+     *     - User.ts
+     *     - Post.ts
+     *
+     *  // file User.ts
+     *  class User extends Model {
+     *      constructor(){
+     *          super()
+     *          this.hasMany({ name : 'posts' , model : Post })
+     *          this.useSchema ({
+     *               id          : new Blueprint().int().notNull().primary().autoIncrement(),
+     *               uuid        : new Blueprint().varchar(50).null(),
+     *               email       : new Blueprint().int().notNull().unique(),
+     *               name        : new Blueprint().varchar(255).null(),
+     *               created_at  : new Blueprint().timestamp().null(),
+     *               updated_at  : new Blueprint().timestamp().null(),
+     *               deleted_at  : new Blueprint().timestamp().null()
+     *           })
+     *       }
+     *   }
+     *
+     *   // file Post.ts
+     *   class Post extends Model {
+     *      constructor(){
+     *          super()
+     *          this.hasMany({ name : 'comments' , model : Comment })
+     *          this.belongsTo({ name : 'user' , model : User })
+     *          this.useSchema ({
+     *               id          : new Blueprint().int().notNull().primary().autoIncrement(),
+     *               uuid        : new Blueprint().varchar(50).null(),
+     *               user_id     : new Blueprint().int().notNull().foreign({ references : 'id' , on : User , onDelete : 'CASCADE' , onUpdate : 'CASCADE' }),
+     *               title       : new Blueprint().varchar(255).null(),
+     *               created_at  : new Blueprint().timestamp().null(),
+     *               updated_at  : new Blueprint().timestamp().null(),
+     *               deleted_at  : new Blueprint().timestamp().null()
+     *           })
+     *       }
+     *   }
+     *
+     *
+     *  await Schema.sync(`app/Models` , { force : true })
+     */
+    static sync(pathFolders: string, { force, log, foreign, changed }?: {
+        force?: boolean | undefined;
+        log?: boolean | undefined;
+        foreign?: boolean | undefined;
+        changed?: boolean | undefined;
+    }): Promise<void>;
+    private _import;
+    private _syncExecute;
+    private _syncForeignKey;
+}
+export { Schema };
+export default Schema;

package/build/lib/{tspace → core}/Schema.js

@@ -77,23 +77,100 @@ class Schema extends Builder_1.Builder {
                     `${key} ${type} ${attributes === null || attributes === void 0 ? void 0 : attributes.join(' ')}`
                 ];
             }
-            const sql = [
+            return [
                 `${this.$constants('CREATE_TABLE_NOT_EXISTS')}`,
-                `${table} (${columns === null || columns === void 0 ? void 0 : columns.join(', ')})`,
+                `${table} (${columns.join(', ')})`,
                 `${this.$constants('ENGINE')}`
             ].join(' ');
-            return sql;
         };
     }
+    /**
+    *
+    * The 'Sync' method is used to check for create or update table or columns with your schema in your model.
+    *
+    * The schema can define with method 'useSchema'
+    * @param    {string} pathFolders directory to models
+    * @property {boolean} options.force - forec always check all columns if not exists will be created
+    * @property {boolean} options.log   - show log execution with sql statements
+    * @property {boolean} options.foreign - check when has a foreign keys will be created
+    * @property {boolean} options.changed - check when column is changed attribute will be change attribute
+    * @return {Promise<void>}
+    * @example
+    *
+    * - node_modules
+    * - app
+    *   - Models
+    *     - User.ts
+    *     - Post.ts
+    *
+    *  // file User.ts
+    *  class User extends Model {
+    *      constructor(){
+    *          super()
+    *          this.hasMany({ name : 'posts' , model : Post })
+    *          this.useSchema ({
+    *               id          : new Blueprint().int().notNull().primary().autoIncrement(),
+    *               uuid        : new Blueprint().varchar(50).null(),
+    *               email       : new Blueprint().int().notNull().unique(),
+    *               name        : new Blueprint().varchar(255).null(),
+    *               created_at  : new Blueprint().timestamp().null(),
+    *               updated_at  : new Blueprint().timestamp().null(),
+    *               deleted_at  : new Blueprint().timestamp().null()
+    *           })
+    *       }
+    *   }
+    *
+    *   // file Post.ts
+    *   class Post extends Model {
+    *      constructor(){
+    *          super()
+    *          this.hasMany({ name : 'comments' , model : Comment })
+    *          this.belongsTo({ name : 'user' , model : User })
+    *          this.useSchema ({
+    *               id          : new Blueprint().int().notNull().primary().autoIncrement(),
+    *               uuid        : new Blueprint().varchar(50).null(),
+    *               user_id     : new Blueprint().int().notNull().foreign({ references : 'id' , on : User , onDelete : 'CASCADE' , onUpdate : 'CASCADE' }),
+    *               title       : new Blueprint().varchar(255).null(),
+    *               created_at  : new Blueprint().timestamp().null(),
+    *               updated_at  : new Blueprint().timestamp().null(),
+    *               deleted_at  : new Blueprint().timestamp().null()
+    *           })
+    *       }
+    *   }
+    *
+    *
+    *  await new Schema().sync(`app/Models` , { force : true , log = true, foreign = true , changed = true })
+    */
+    sync(pathFolders_1) {
+        return __awaiter(this, arguments, void 0, function* (pathFolders, { force = false, log = false, foreign = false, changed = false } = {}) {
+            const directories = fs_1.default.readdirSync(pathFolders, { withFileTypes: true });
+            const files = (yield Promise.all(directories.map((directory) => {
+                const newDir = path_1.default.resolve(String(pathFolders), directory.name);
+                if (directory.isDirectory() && directory.name.toLocaleLowerCase().includes('migrations'))
+                    return null;
+                return directory.isDirectory() ? Schema.sync(newDir, { force, log, changed }) : newDir;
+            })));
+            const pathModels = [].concat(...files).filter(d => d != null || d === '');
+            yield new Promise(r => setTimeout(r, 1200));
+            const models = yield Promise.all(pathModels.map((pathModel) => this._import(pathModel)).filter(d => d != null));
+            if (!models.length)
+                return;
+            yield this._syncExecute({ models, force, log, foreign, changed });
+            return;
+        });
+    }
     /**
      *
      * The 'Sync' method is used to check for create or update table or columns with your schema in your model.
      *
      * The schema can define with method 'useSchema'
-     * @param {string} pathFolders directory to models
+     * @param    {string} pathFolders directory to models
+     * @type     {object}  options
      * @property {boolean} options.force - forec always check all columns if not exists will be created
      * @property {boolean} options.log   - show log execution with sql statements
-     * @property {boolean} options.delay - wait for execution
+     * @property {boolean} options.foreign - check when has a foreign keys will be created
+     * @property {boolean} options.changed - check when column is changed attribute will be change attribute
+     * @return {Promise<void>}
      * @example
      *
      * - node_modules
@@ -128,7 +205,7 @@ class Schema extends Builder_1.Builder {
      *          this.useSchema ({
      *               id          : new Blueprint().int().notNull().primary().autoIncrement(),
      *               uuid        : new Blueprint().varchar(50).null(),
-     *               user_id     : new Blueprint().int().notNull().foreign({ references : 'id' , on : User , onDelete : 'CASCADE' , onUpdate : 'CASCADE' }),,
+     *               user_id     : new Blueprint().int().notNull().foreign({ references : 'id' , on : User , onDelete : 'CASCADE' , onUpdate : 'CASCADE' }),
      *               title       : new Blueprint().varchar(255).null(),
      *               created_at  : new Blueprint().timestamp().null(),
      *               updated_at  : new Blueprint().timestamp().null(),
@@ -137,27 +214,15 @@ class Schema extends Builder_1.Builder {
      *       }
      *   }
      *
+     *
      *  await Schema.sync(`app/Models` , { force : true })
      */
-    static sync(pathFolders, { force = false, log = false, foreign = false, delay = 1500 } = {}) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const directories = fs_1.default.readdirSync(pathFolders, { withFileTypes: true });
-            const files = (yield Promise.all(directories.map((directory) => {
-                const newDir = path_1.default.resolve(String(pathFolders), directory.name);
-                if (directory.isDirectory() && directory.name.toLocaleLowerCase().includes('migrations'))
-                    return null;
-                return directory.isDirectory() ? Schema.sync(newDir, { force, log, delay }) : newDir;
-            })));
-            const pathModels = [].concat(...files).filter(d => d != null || d === '');
-            yield new Promise(r => setTimeout(r, delay));
-            const models = yield Promise.all(pathModels.map((pathModel) => Schema._import(pathModel)).filter(d => d != null));
-            if (!models.length)
-                return;
-            yield Schema._syncExecute({ models, force, log, foreign });
-            return;
+    static sync(pathFolders_1) {
+        return __awaiter(this, arguments, void 0, function* (pathFolders, { force = false, log = false, foreign = false, changed = false } = {}) {
+            return new this().sync(pathFolders, { force, log, foreign, changed });
         });
     }
-    static _import(pathModel) {
+    _import(pathModel) {
         return __awaiter(this, void 0, void 0, function* () {
             try {
                 const loadModel = yield Promise.resolve(`${pathModel}`).then(s => __importStar(require(s))).catch(_ => { });
@@ -170,10 +235,10 @@ class Schema extends Builder_1.Builder {
             }
         });
     }
-    static _syncExecute({ models, force, log, foreign }) {
-        var _a, _b, _c, _d;
-        return __awaiter(this, void 0, void 0, function* () {
-            const checkTables = yield new Builder_1.Builder().query('SHOW TABLES');
+    _syncExecute(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ models, force, log, foreign, changed }) {
+            var _b, _c, _d, _e, _f, _g, _h, _j;
+            const checkTables = yield this.query(this.$constants('SHOW_TABLES'));
             const existsTables = checkTables.map((c) => Object.values(c)[0]);
             for (const model of models) {
                 if (model == null)
@@ -183,8 +248,11 @@ class Schema extends Builder_1.Builder {
                     continue;
                 const checkTableIsExists = existsTables.some((table) => table === model.getTableName());
                 if (!checkTableIsExists) {
-                    const sql = new Schema().createTable(`\`${model.getTableName()}\``, schemaModel);
-                    yield new Builder_1.Builder().debug(log).query(sql);
+                    const sql = this.createTable(`\`${model.getTableName()}\``, schemaModel);
+                    yield model.debug(log).query(sql);
+                    const beforeCreatingTheTable = model['$state'].get('BEFORE_CREATING_TABLE');
+                    if (beforeCreatingTheTable != null)
+                        yield beforeCreatingTheTable();
                     yield this._syncForeignKey({
                         schemaModel,
                         model,
@@ -204,6 +272,29 @@ class Schema extends Builder_1.Builder {
                 const schemaTable = yield model.getSchema();
                 const schemaTableKeys = schemaTable.map((k) => k.Field);
                 const schemaModelKeys = Object.keys(schemaModel);
+                const wasChangedColumns = changed ? Object.entries(schemaModel).map(([key, value]) => {
+                    const find = schemaTable.find(t => t.Field === key);
+                    if (find == null)
+                        return null;
+                    const compare = String(find.Type).toLocaleLowerCase() !== String(value.type).toLocaleLowerCase();
+                    return compare ? key : null;
+                }).filter(d => d != null) : [];
+                if (wasChangedColumns.length) {
+                    for (const column of wasChangedColumns) {
+                        if (column == null)
+                            continue;
+                        const type = (_c = (_b = schemaModel[column]) === null || _b === void 0 ? void 0 : _b.type) !== null && _c !== void 0 ? _c : null;
+                        const attributes = (_e = (_d = schemaModel[column]) === null || _d === void 0 ? void 0 : _d.attributes) !== null && _e !== void 0 ? _e : null;
+                        const sql = [
+                            this.$constants('ALTER_TABLE'),
+                            `\`${model.getTableName()}\``,
+                            this.$constants('CHANGE'),
+                            `\`${column}\``,
+                            `\`${column}\` ${type} ${attributes.join(' ')}`,
+                        ].join(' ');
+                        yield this.debug(log).query(sql);
+                    }
+                }
                 const missingColumns = schemaModelKeys.filter(schemaModelKey => !schemaTableKeys.includes(schemaModelKey));
                 if (!missingColumns.length)
                     continue;
@@ -211,19 +302,19 @@ class Schema extends Builder_1.Builder {
                 for (const column of missingColumns) {
                     const indexWithColumn = entries.findIndex(([key]) => key === column);
                     const findAfterIndex = indexWithColumn ? entries[indexWithColumn - 1][0] : null;
-                    const type = (_b = (_a = schemaModel[column]) === null || _a === void 0 ? void 0 : _a.type) !== null && _b !== void 0 ? _b : null;
-                    const attributes = (_d = (_c = schemaModel[column]) === null || _c === void 0 ? void 0 : _c.attributes) !== null && _d !== void 0 ? _d : null;
+                    const type = (_g = (_f = schemaModel[column]) === null || _f === void 0 ? void 0 : _f.type) !== null && _g !== void 0 ? _g : null;
+                    const attributes = (_j = (_h = schemaModel[column]) === null || _h === void 0 ? void 0 : _h.attributes) !== null && _j !== void 0 ? _j : null;
                     if (findAfterIndex == null || type == null || attributes == null)
                         continue;
                     const sql = [
-                        'ALTER TABLE',
+                        this.$constants('ALTER_TABLE'),
                         `\`${model.getTableName()}\``,
-                        'ADD',
+                        this.$constants('ADD'),
                         `\`${column}\` ${type} ${attributes.join(' ')}`,
-                        'AFTER',
+                        this.$constants('AFTER'),
                         `\`${findAfterIndex}\``
                     ].join(' ');
-                    yield new Builder_1.Builder().debug(log).query(sql);
+                    yield this.debug(log).query(sql);
                 }
                 yield this._syncForeignKey({
                     schemaModel,
@@ -234,37 +325,41 @@ class Schema extends Builder_1.Builder {
             return;
         });
     }
-    static _syncForeignKey({ schemaModel, model, log }) {
-        var _a;
-        return __awaiter(this, void 0, void 0, function* () {
+    _syncForeignKey(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ schemaModel, model, log }) {
+            var _b;
             for (const key in schemaModel) {
-                if (((_a = schemaModel[key]) === null || _a === void 0 ? void 0 : _a.foreignKey) == null)
+                if (((_b = schemaModel[key]) === null || _b === void 0 ? void 0 : _b.foreignKey) == null)
                     continue;
                 const foreign = schemaModel[key].foreignKey;
-                const table = typeof foreign.on === "string" ? foreign.on : foreign.on.getTableName();
+                if (foreign.on == null)
+                    continue;
+                const onReference = typeof foreign.on === "string" ? foreign.on : new foreign.on;
+                const table = typeof onReference === "string" ? onReference : onReference.getTableName();
+                const constraintName = `\`${model.getTableName()}(${key})_${table}(${foreign.references})\``;
                 const sql = [
-                    "ALTER TABLE",
+                    this.$constants("ALTER_TABLE"),
                     `\`${model.getTableName()}\``,
-                    "ADD CONSTRAINT",
-                    `\`${model.getTableName()}(${key})_${table}(${foreign.references})\``,
-                    `FOREIGN KEY(\`${key}\`)`,
-                    `REFERENCES \`${table}\`(\`${foreign.references}\`)`,
-                    `ON DELETE ${foreign.onDelete} ON UPDATE ${foreign.onUpdate}`
+                    this.$constants('ADD_CONSTRAINT'),
+                    `${constraintName}`,
+                    `${this.$constants('FOREIGN_KEY')}(\`${key}\`)`,
+                    `${this.$constants('REFERENCES')} \`${table}\`(\`${foreign.references}\`)`,
+                    `${this.$constants('ON_DELETE')} ${foreign.onDelete} ${this.$constants('ON_UPDATE')} ${foreign.onUpdate}`
                 ].join(' ');
                 try {
-                    yield new Builder_1.Builder().debug(log).query(sql);
+                    yield this.debug(log).query(sql);
                 }
                 catch (e) {
-                    if (typeof foreign.on === "string")
+                    if (typeof onReference === "string")
                         continue;
                     if (String(e.message).includes("Duplicate foreign key constraint"))
                         continue;
-                    const schemaModelOn = yield foreign.on.getSchemaModel();
+                    const schemaModelOn = yield onReference.getSchemaModel();
                     if (!schemaModelOn)
                         continue;
-                    const tableSql = new Schema().createTable(`\`${table}\``, schemaModelOn);
-                    yield new Builder_1.Builder().debug(log).query(tableSql).catch(e => console.log(e));
-                    yield new Builder_1.Builder().debug(log).query(sql).catch(e => console.log(e));
+                    const tableSql = this.createTable(`\`${table}\``, schemaModelOn);
+                    yield this.debug(log).query(tableSql).catch(e => console.log(e));
+                    yield this.debug(log).query(sql).catch(e => console.log(e));
                     continue;
                 }
             }

package/build/lib/core/Type.d.ts

@@ -0,0 +1,6 @@
+export type SchemaType<TSchema, TSpecific = any> = {
+    [K in keyof TSchema]: K extends keyof TSpecific ? TSpecific[K] : any;
+};
+export type RelationType<T> = {
+    [K in keyof T]: T[K];
+};

package/build/lib/core/Type.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/build/lib/{tspace → core}/index.d.ts

@@ -5,10 +5,11 @@ import Blueprint from './Blueprint';
 import Pool from '../connection';
 export { DB };
 export { Model };
-export { Schema };
 export { Blueprint };
 export { Pool };
 export * from './Decorator';
+export * from './Schema';
+export * from './Type';
 declare const _default: {
     DB: typeof DB;
     Model: typeof Model;

package/build/lib/{tspace → core}/index.js

@@ -17,18 +17,19 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Pool = exports.Blueprint = exports.Schema = exports.Model = exports.DB = void 0;
+exports.Pool = exports.Blueprint = exports.Model = exports.DB = void 0;
 const DB_1 = __importDefault(require("./DB"));
 exports.DB = DB_1.default;
 const Model_1 = __importDefault(require("./Model"));
 exports.Model = Model_1.default;
 const Schema_1 = __importDefault(require("./Schema"));
-exports.Schema = Schema_1.default;
 const Blueprint_1 = __importDefault(require("./Blueprint"));
 exports.Blueprint = Blueprint_1.default;
 const connection_1 = __importDefault(require("../connection"));
 exports.Pool = connection_1.default;
 __exportStar(require("./Decorator"), exports);
+__exportStar(require("./Schema"), exports);
+__exportStar(require("./Type"), exports);
 exports.default = {
     DB: DB_1.default,
     Model: Model_1.default,

package/build/lib/index.d.ts

@@ -3,6 +3,6 @@
   *
   * @module tspace-mysql
   */
-import * as tspace from './tspace';
-export * from './tspace';
+import * as tspace from './core';
+export * from './core';
 export default tspace;

package/build/lib/index.js

@@ -31,6 +31,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
   *
   * @module tspace-mysql
   */
-const tspace = __importStar(require("./tspace"));
-__exportStar(require("./tspace"), exports);
+const tspace = __importStar(require("./core"));
+__exportStar(require("./core"), exports);
 exports.default = tspace;

package/build/lib/utils/index.d.ts

@@ -7,6 +7,7 @@ declare const utils: {
     timestamp: (dateString?: string) => string;
     date: () => string;
     escape: (str: any) => any;
+    escapeActions: (str: any) => any;
     escapeXSS: (str: any) => any;
     isSubQuery: (subQuery: string) => boolean;
     generateUUID: () => string;

package/build/lib/utils/index.js

@@ -47,14 +47,25 @@ const date = () => {
 const escape = (str) => {
     if (typeof str !== 'string')
         return str;
-    return str.replace(/[\0\b\t\n\r\x1a\'\\]/g, '');
+    if (str.includes('$RAW:'))
+        return str;
+    return str.replace(/[\0\b\t\n\r\x1a\'\\]/g, "\\'");
+};
+const escapeActions = (str) => {
+    if (typeof str !== 'string')
+        return str;
+    return str.replace(/[\0\b\r\x1a\'\\]/g, "\\'");
 };
 const escapeXSS = (str) => {
     if (typeof str !== 'string')
         return str;
     return str
-        .replace(/<script\b[^<]*(?:(?!<\/script>)<[^<]*)*<\/script>/gi, '')
-        .replace(/on\w+="[^"]+"/g, '');
+        .replace(/[;\\]/gi, '')
+        .replace(/on\w+="[^"]+"/gi, '')
+        .replace(/\s+(onerror|onload)\s*=/gi, '')
+        .replace(/\s+alert*/gi, '')
+        .replace(/\([^)]*\) *=>/g, '')
+        .replace(/<script\b[^<]*(?:(?!<\/script>)<[^<]*)*<\/script>/gi, '');
 };
 const isSubQuery = (subQuery) => {
     const checkIsSubQuery = (/\bSELECT\s+(?!\*)/i.test(subQuery));
@@ -140,11 +151,9 @@ const camelCase = (data) => {
     }
 };
 const consoleDebug = (debug) => {
-    if (debug == null)
-        return;
-    if (typeof debug !== "string")
+    if (typeof debug !== "string" || debug == null)
         return;
-    console.log(`\n\x1b[33m${debug === null || debug === void 0 ? void 0 : debug.replace(/(\r\n|\n|\r|\t)/gm, "").trim()};\x1b[0m`);
+    console.log(`\n\x1b[34mQUERY:\x1b[0m \x1b[33m${debug === null || debug === void 0 ? void 0 : debug.replace(/(\r\n|\n|\r|\t)/gm, "").trim()};\x1b[0m`);
 };
 const randomString = (length = 100) => {
     let str = '';
@@ -204,6 +213,7 @@ const utils = {
     timestamp,
     date,
     escape,
+    escapeActions,
     escapeXSS,
     isSubQuery,
     generateUUID,

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "tspace-mysql",
-  "version": "1.5.0",
-  "description": "mysql query builder object relational mapping",
+  "version": "1.5.2",
+  "description": "mysql query builder object relational mapping (ORM)",
   "main": "build/lib/index.js",
   "types": "build/lib/index.d.ts",
   "files": [
@@ -15,8 +15,8 @@
     "url": "https://github.com/thanathip41/tspace-mysql.git"
   },
   "keywords": [
-    "tspace-mysql",
     "tspace",
+    "tspace-mysql",
     "mysql",
     "orm",
     "relations",
@@ -31,7 +31,8 @@
     "cli",
     "migrate",
     "backup",
-    "blueprint"
+    "blueprint",
+    "type safety"
   ],
   "author": "Thanathip (https://github.com/thanathip41)",
   "license": "MIT",
@@ -54,6 +55,7 @@
   "devDependencies": {
     "@types/chai": "^4.3.11",
     "@types/chai-json-schema": "^1.4.9",
+    "@types/debug": "^4.1.12",
     "@types/mocha": "^10.0.6",
     "@types/mysql": "^2.15.19",
     "@types/pluralize": "^0.0.29",