tspace-mysql 1.4.6 → 1.4.7

package/dist/lib/tspace/Schema.js

@@ -37,7 +37,6 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Schema = void 0;
 const Builder_1 = require("./Builder");
-const Model_1 = require("./Model");
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
 class Schema extends Builder_1.Builder {
@@ -60,7 +59,7 @@ class Schema extends Builder_1.Builder {
                     `${table} (${columns === null || columns === void 0 ? void 0 : columns.join(',')})`,
                     `ENGINE=INNODB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8`
                 ].join(' ');
-                yield this.rawQuery(sql);
+                yield this.query(sql);
                 console.log(`Migrats : '${table}' created successfully`);
                 return;
             }
@@ -88,9 +87,11 @@ class Schema extends Builder_1.Builder {
     }
     /**
      *
-     * Sync will check for create or update table or columns with useSchema in your model.
+     * 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 to always check columns is exists
+     * @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
      * @example
@@ -127,7 +128,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(),
+     *               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(),
@@ -138,65 +139,138 @@ class Schema extends Builder_1.Builder {
      *
      *  await Schema.sync(`app/Models` , { force : true })
      */
-    static sync(pathFolders, { force = false, log = false, delay = 3000 } = {}) {
+    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 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 promises = pathModels.map((pathModel) => Schema._syncExecute({ pathModel, force, log }));
-            yield Promise.all(promises);
+            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 _syncExecute({ pathModel, force, log }) {
+    static _import(pathModel) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const loadModel = yield Promise.resolve(`${pathModel}`).then(s => __importStar(require(s))).catch(_ => { });
+                const model = new loadModel.default();
+                return model;
+            }
+            catch (err) {
+                console.log(`Check your 'Model' from path : '${pathModel}' is not instance of Model`);
+                return null;
+            }
+        });
+    }
+    static _syncExecute({ models, force, log, foreign }) {
         var _a, _b, _c, _d;
         return __awaiter(this, void 0, void 0, function* () {
-            const loadModel = yield Promise.resolve(`${pathModel}`).then(s => __importStar(require(s)));
-            if (!loadModel.hasOwnProperty('default') && !(loadModel instanceof Model_1.Model))
-                return;
-            const model = new loadModel.default();
-            const schemaModel = yield model.getSchemaModel();
-            if (!schemaModel)
-                return;
-            const checkTableIsExists = Boolean((yield new Builder_1.Builder().rawQuery(`SHOW TABLES LIKE '${model.getTableName()}';`)).length);
-            if (!checkTableIsExists) {
-                const sql = new Schema().createTable(model.getTableName(), schemaModel);
-                yield new Builder_1.Builder().debug(log).rawQuery(sql);
-                return;
+            const checkTables = yield new Builder_1.Builder().query('SHOW TABLES');
+            const existsTables = checkTables.map((c) => Object.values(c)[0]);
+            // console.log(checkTables)
+            for (const model of models) {
+                if (model == null)
+                    continue;
+                const schemaModel = model.getSchemaModel();
+                if (!schemaModel)
+                    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);
+                    yield this._syncForeignKey({
+                        schemaModel,
+                        model,
+                        log
+                    });
+                    continue;
+                }
+                if (foreign) {
+                    yield this._syncForeignKey({
+                        schemaModel,
+                        model,
+                        log
+                    });
+                }
+                if (!force)
+                    continue;
+                const schemaTable = yield model.getSchema();
+                const schemaTableKeys = schemaTable.map((k) => k.Field);
+                const schemaModelKeys = Object.keys(schemaModel);
+                const missingColumns = schemaModelKeys.filter(schemaModelKey => !schemaTableKeys.includes(schemaModelKey));
+                if (!missingColumns.length)
+                    continue;
+                const entries = Object.entries(schemaModel);
+                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;
+                    if (findAfterIndex == null || type == null || attributes == null)
+                        continue;
+                    const sql = [
+                        'ALTER TABLE',
+                        `\`${model.getTableName()}\``,
+                        'ADD',
+                        `\`${column}\` ${type} ${attributes.join(' ')}`,
+                        'AFTER',
+                        `\`${findAfterIndex}\``
+                    ].join(' ');
+                    yield new Builder_1.Builder().debug(log).query(sql);
+                }
+                yield this._syncForeignKey({
+                    schemaModel,
+                    model,
+                    log
+                });
             }
-            if (!force)
-                return;
-            const schemaTable = yield model.getSchema();
-            const schemaTableKeys = schemaTable.map((k) => k.Field);
-            const schemaModelKeys = Object.keys(schemaModel);
-            const missingColumns = schemaModelKeys.filter(schemaModelKey => !schemaTableKeys.includes(schemaModelKey));
-            if (!missingColumns.length)
-                return;
-            const entries = Object.entries(schemaModel);
-            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;
-                if (findAfterIndex == null || type == null || attributes == null)
+            return;
+        });
+    }
+    static _syncForeignKey({ schemaModel, model, log }) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            for (const key in schemaModel) {
+                if (((_a = schemaModel[key]) === null || _a === void 0 ? void 0 : _a.foreignKey) == null)
                     continue;
+                const foreign = schemaModel[key].foreignKey;
+                const table = typeof foreign.on === "string" ? foreign.on : foreign.on.getTableName();
                 const sql = [
-                    'ALTER TABLE',
+                    "ALTER TABLE",
                     `\`${model.getTableName()}\``,
-                    'ADD',
-                    `\`${column}\` ${type} ${attributes.join(' ')}`,
-                    'AFTER',
-                    `\`${findAfterIndex}\``
+                    "ADD CONSTRAINT",
+                    `\`${model.getTableName()}(${key})_${table}(${foreign.references})\``,
+                    `FOREIGN KEY(\`${key}\`)`,
+                    `REFERENCES \`${table}\`(\`${foreign.references}\`)`,
+                    `ON DELETE ${foreign.onDelete} ON UPDATE ${foreign.onUpdate}`
                 ].join(' ');
-                yield new Builder_1.Builder().debug(log).rawQuery(sql);
+                try {
+                    yield new Builder_1.Builder().debug(log).query(sql);
+                }
+                catch (e) {
+                    if (typeof foreign.on === "string") {
+                        console.log(e);
+                        continue;
+                    }
+                    if (String(e.message).includes("Duplicate foreign key constraint"))
+                        continue;
+                    const schemaModelOn = yield foreign.on.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));
+                    continue;
+                }
             }
-            return;
         });
     }
 }

package/dist/lib/tspace/StateHandler.js

@@ -39,6 +39,10 @@ class StateHandler {
         this.STATE.currentState.set('WHERE', '');
         this.STATE.currentState.set('LIMIT', '');
         this.STATE.currentState.set('OFFSET', '');
+        this.STATE.currentState.set('SELECT', []);
+        this.STATE.currentState.set('GROUP_BY', '');
+        this.STATE.currentState.set('HAVING', '');
+        this.STATE.currentState.set('JOIN', '');
         this.STATE.currentState.set('SAVE', '');
         return;
     }

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

@@ -1,13 +1,16 @@
 declare const utils: {
+    typeOf: (data: any) => string;
+    isDate: (data: any) => boolean;
     consoleDebug: (debug?: string) => void;
     faker: (value: string) => string | number | boolean;
     columnRelation: (name: string) => string;
-    timestamp: () => string;
+    timestamp: (dateString?: string) => string;
     date: () => string;
     escape: (str: any) => any;
     isSubQuery: (subQuery: string) => boolean;
     generateUUID: () => string;
     covertBooleanToNumber: (data: any) => any;
+    covertDataToDateIfDate: (data: Record<string, any>) => void;
     snakeCase: (data: any) => any;
     camelCase: (data: any) => any;
     randomString: (length?: number) => string;

package/dist/lib/utils/index.js

@@ -10,8 +10,14 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.utils = void 0;
-const timestamp = () => {
-    const d = new Date();
+const typeOf = (data) => Object.prototype.toString.apply(data).slice(8, -1).toLocaleLowerCase();
+const isDate = (data) => {
+    if (typeOf(data) === 'date')
+        return true;
+    return false;
+};
+const timestamp = (dateString) => {
+    const d = dateString == null ? new Date() : new Date(dateString);
     const year = d.getFullYear();
     const month = `0${(d.getMonth() + 1)}`.slice(-2);
     const date = `0${(d.getDate())}`.slice(-2);
@@ -75,6 +81,15 @@ const covertBooleanToNumber = (data) => {
         return +data;
     return data;
 };
+const covertDataToDateIfDate = (data) => {
+    for (const key in data) {
+        const d = data[key];
+        if (!isDate(d))
+            continue;
+        data[key] = timestamp(d);
+    }
+    return;
+};
 const snakeCase = (data) => {
     try {
         if (typeof (data) !== "object")
@@ -120,7 +135,9 @@ const camelCase = (data) => {
 const consoleDebug = (debug) => {
     if (debug == null)
         return;
-    console.log(`\n\x1b[33m${debug.replace(/(\r\n|\n|\r|\t)/gm, "").trim()};\x1b[0m`);
+    if (typeof debug !== "string")
+        return;
+    console.log(`\n\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 = '';
@@ -152,6 +169,12 @@ const faker = (value) => {
         return Number((Math.random() * 100).toFixed(2));
     if (!value.search('double'))
         return Number((Math.random() * 100).toFixed(2));
+    if (!value.search('json')) {
+        return JSON.stringify({
+            id: Number(Math.floor(Math.random() * 1000)),
+            name: randomString(50)
+        });
+    }
     if (!value.search('varchar')) {
         const regex = /\d+/g;
         const limit = Number((_b = (_a = value === null || value === void 0 ? void 0 : value.match(regex)) === null || _a === void 0 ? void 0 : _a.pop()) !== null && _b !== void 0 ? _b : 255);
@@ -165,6 +188,8 @@ const hookHandle = (hooks, result) => __awaiter(void 0, void 0, void 0, function
     return;
 });
 const utils = {
+    typeOf,
+    isDate,
     consoleDebug,
     faker,
     columnRelation,
@@ -174,6 +199,7 @@ const utils = {
     isSubQuery,
     generateUUID,
     covertBooleanToNumber,
+    covertDataToDateIfDate,
     snakeCase,
     camelCase,
     randomString,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tspace-mysql",
-  "version": "1.4.6",
+  "version": "1.4.7",
   "description": "mysql query builder object relational mapping",
   "main": "dist/lib/index.js",
   "types": "dist/lib/index.d.ts",