tspace-mysql 1.1.2 → 1.1.4

package/dist/lib/tspace/Blueprint.js

@@ -31,42 +31,39 @@ var Blueprint = /** @class */ (function () {
         this.type = '';
         this.attrbuites = [];
     }
-    Blueprint.prototype._addAssignType = function (type) {
-        if (this.type)
-            return this;
-        this.type = type;
-        return this;
-    };
-    Blueprint.prototype._addAssignAttrbuite = function (attrbuite) {
-        this.attrbuites = __spreadArray(__spreadArray([], __read(this.attrbuites), false), [attrbuite], false);
-        return this;
-    };
+    /**
+     * Assign type 'int' in table
+     * @return {this} this
+     */
     Blueprint.prototype.int = function () {
         this._addAssignType('INT');
         return this;
     };
     /**
-     * Assign type
-     * @param {number}
+     * Assign type 'TINYINT' in table
+     * @param {number} number
+     * @return {this} this
      */
-    Blueprint.prototype.tinyInt = function (n) {
-        if (n === void 0) { n = 1; }
-        this._addAssignType("TINYINT(".concat(n, ")"));
+    Blueprint.prototype.tinyInt = function (number) {
+        if (number === void 0) { number = 1; }
+        this._addAssignType("TINYINT(".concat(number, ")"));
         return this;
     };
     /**
-     * Assign type
-     * @param {number}
+     * Assign type 'BIGINT' in table
+     * @param {number} number [number = 10]
+     * @return {this} this
      */
-    Blueprint.prototype.bigInt = function (n) {
-        if (n === void 0) { n = 10; }
-        this._addAssignType("BIGINT(".concat(n, ")"));
+    Blueprint.prototype.bigInt = function (number) {
+        if (number === void 0) { number = 10; }
+        this._addAssignType("BIGINT(".concat(number, ")"));
         return this;
     };
     /**
-     * Assign type
+     * Assign type 'DOUBLE' in table
      * @param {number} length  between 1-255
      * @param {number} decimal  0.000...n
+     * @return {this} this
      */
     Blueprint.prototype.double = function (length, decimal) {
         if (length === void 0) { length = 0; }
@@ -79,9 +76,10 @@ var Blueprint = /** @class */ (function () {
         return this;
     };
     /**
-     * Assign type
+     * Assign type 'FLOAT' in table
      * @param {number} length  between 1-255
      * @param {number} decimal 0.000...n
+     * @return {this} this
      */
     Blueprint.prototype.float = function (length, decimal) {
         if (length === void 0) { length = 0; }
@@ -94,44 +92,66 @@ var Blueprint = /** @class */ (function () {
         return this;
     };
     /**
-     * Assign type
-     * @param {number} length string between 1-255
+     * Assign type 'VARCHAR' in table
+     * @param {number} length  [length = 100] length of string
+     * @return {this} this
      */
-    Blueprint.prototype.varchar = function (n) {
-        if (n === void 0) { n = 100; }
-        if (n > 255)
-            n = 255;
-        this._addAssignType("VARCHAR(".concat(n, ")"));
+    Blueprint.prototype.varchar = function (length) {
+        if (length === void 0) { length = 100; }
+        if (length > 255)
+            length = 255;
+        this._addAssignType("VARCHAR(".concat(length, ")"));
         return this;
     };
     /**
-     * Assign type
-     * @param {number} length string between 1-255
+     * Assign type 'CHAR' in table
+     * @param {number} length [length = 1] length of string
+     * @return {this} this
      */
-    Blueprint.prototype.char = function (n) {
-        if (n === void 0) { n = 1; }
-        this._addAssignType("CHAR(".concat(n, ")"));
+    Blueprint.prototype.char = function (length) {
+        if (length === void 0) { length = 1; }
+        this._addAssignType("CHAR(".concat(length, ")"));
         return this;
     };
+    /**
+     * Assign type 'LONGTEXT' in table
+     * @return {this} this
+     */
     Blueprint.prototype.longText = function () {
         this._addAssignType("LONGTEXT");
         return this;
     };
+    /**
+     * Assign type 'MEDIUMTEXT' in table
+     * @param {number} length [length = 1] length of string
+     * @return {this} this
+     */
     Blueprint.prototype.mediumText = function () {
         this._addAssignType("MEDIUMTEXT");
         return this;
     };
+    /**
+     * Assign type 'TINYTEXT' in table
+     * @param {number} length [length = 1] length of string
+     * @return {this} this
+     */
     Blueprint.prototype.tinyText = function () {
         this._addAssignType("TINYTEXT");
         return this;
     };
+    /**
+     * Assign type 'TEXT' in table
+     * @param {number} length [length = 1] length of string
+     * @return {this} this
+     */
     Blueprint.prototype.text = function () {
         this._addAssignType("TEXT");
         return this;
     };
     /**
-     * Assign type
-     * @param {...string} enum n1, n2, n3, ...n
+     * Assign type 'ENUM'
+     * @param {...string} enums n1, n2, n3, ...n
+     * @return {this} this
      */
     Blueprint.prototype.enum = function () {
         var enums = [];
@@ -141,54 +161,105 @@ var Blueprint = /** @class */ (function () {
         this._addAssignType("ENUM('".concat(enums, "')"));
         return this;
     };
+    /**
+     * Assign type 'DATE' in table
+     * @return {this} this
+     */
     Blueprint.prototype.date = function () {
         this._addAssignType("DATE");
         return this;
     };
+    /**
+     * Assign type 'DATETIME' in table
+     * @return {this} this
+     */
     Blueprint.prototype.dateTime = function () {
         this._addAssignType("DATETIME");
         return this;
     };
+    /**
+     * Assign type 'TIMESTAMP' in table
+     * @return {this} this
+     */
     Blueprint.prototype.timestamp = function () {
         this._addAssignType("TIMESTAMP");
         return this;
     };
+    /**
+     * Assign type 'UNSIGNED' in table
+     * @return {this} this
+     */
     Blueprint.prototype.unsigned = function () {
         this._addAssignAttrbuite("UNSIGNED");
         return this;
     };
+    /**
+     * Assign type 'UNIQUE' in table
+     * @return {this} this
+     */
     Blueprint.prototype.unique = function () {
         this._addAssignAttrbuite("UNIQUE");
         return this;
     };
+    /**
+     * Assign type 'NULL' in table
+     * @return {this} this
+     */
     Blueprint.prototype.null = function () {
         this._addAssignAttrbuite("NULL");
         return this;
     };
+    /**
+     * Assign type 'NOT NULL' in table
+     * @return {this} this
+     */
     Blueprint.prototype.notNull = function () {
         this._addAssignAttrbuite("NOT NULL");
         return this;
     };
+    /**
+     * Assign type 'PRIMARY KEY' in table
+     * @return {this} this
+     */
     Blueprint.prototype.primary = function () {
         this._addAssignAttrbuite("PRIMARY KEY");
         return this;
     };
     /**
-     * Assign attrbuites
-     * @param {string | number} default value
+     * Assign attrbuites 'default' in table
+     * @param {string | number} n  default value
+     * @return {this} this
      */
     Blueprint.prototype.default = function (n) {
         this._addAssignAttrbuite("DEFAULT '".concat(n, "'"));
         return this;
     };
-    Blueprint.prototype.defaultTimestamp = function () {
+    /**
+     * Assign attrbuites 'default currentTimestamp' in table
+     * @return {this} this
+     */
+    Blueprint.prototype.currentTimestamp = function () {
         this._addAssignAttrbuite("DEFAULT CURRENT_TIMESTAMP");
         return this;
     };
+    /**
+     * Assign attrbuites 'autoIncrement' in table
+     * @return {this} this
+     */
     Blueprint.prototype.autoIncrement = function () {
         this._addAssignAttrbuite("AUTO_INCREMENT");
         return this;
     };
+    Blueprint.prototype._addAssignType = function (type) {
+        if (this.type)
+            return this;
+        this.type = type;
+        return this;
+    };
+    Blueprint.prototype._addAssignAttrbuite = function (attrbuite) {
+        this.attrbuites = __spreadArray(__spreadArray([], __read(this.attrbuites), false), [attrbuite], false);
+        return this;
+    };
     return Blueprint;
 }());
 exports.Blueprint = Blueprint;

package/dist/lib/tspace/DB.d.ts

@@ -1,6 +1,6 @@
 import { AbstractDB } from './AbstractDB';
+import { ConnectionTransaction } from '../connection';
 declare class DB extends AbstractDB {
-    [x: string]: any;
     constructor(table?: string);
     /**
      * Assign table name
@@ -9,10 +9,60 @@ declare class DB extends AbstractDB {
      */
     table(table: string): this;
     /**
-     * transaction query rollback & commit
-     * @return {promise<any>}
+     * cases query
+     * @param {array} cases array
+     * @return {string} string
      */
-    beginTransaction(): Promise<any>;
+    caseUpdate(cases: any[]): string;
+    /**
+     * generate UUID
+     * @return {string} string
+     */
+    generateUUID(): string;
+    /**
+     * Get a connection
+     * @return {ConnectionTransaction}
+     * @type     {object} connection
+     * @property {function} connection.query - execute query sql then release connection to pool
+     * @property {function} connection.startTransaction - start transaction of query
+     * @property {function} connection.commit - commit transaction of query
+     * @property {function} connection.rollback - rollback transaction of query
+     */
+    beginTransaction(): Promise<ConnectionTransaction>;
+    /**
+     * Assign table name
+     * @static
+     * @param {string} table table name
+     * @return {DB} DB
+     */
+    static table(table: string): DB;
+    /**
+     * select by cases
+     * @static
+     * @param {array} cases array object
+     * @return {this}
+     */
+    static caseUpdate(cases: {
+        when: string;
+        then: string;
+    }[]): string;
+    /**
+    * generate UUID
+    * @static
+    * @return {string} string
+    */
+    static generateUUID(): string;
+    /**
+     * Get a connection
+     * @static
+     * @return {ConnectionTransaction}
+     * @type     {object} connection
+     * @property {function} connection.query - execute query sql then release connection to pool
+     * @property {function} connection.startTransaction - start transaction of query
+     * @property {function} connection.commit - commit transaction of query
+     * @property {function} connection.rollback - rollback transaction of query
+     */
+    static beginTransaction(): Promise<ConnectionTransaction>;
     private _initialDB;
     private _setupDB;
 }

package/dist/lib/tspace/DB.js

@@ -72,6 +72,31 @@ var __values = (this && this.__values) || function(o) {
     };
     throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
 };
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DB = void 0;
 var AbstractDB_1 = require("./AbstractDB");
@@ -97,64 +122,149 @@ var DB = /** @class */ (function (_super) {
         return this;
     };
     /**
-     * transaction query rollback & commit
-     * @return {promise<any>}
+     * cases query
+     * @param {array} cases array
+     * @return {string} string
+     */
+    DB.prototype.caseUpdate = function (cases) {
+        var e_1, _a;
+        var query = [];
+        try {
+            for (var cases_1 = __values(cases), cases_1_1 = cases_1.next(); !cases_1_1.done; cases_1_1 = cases_1.next()) {
+                var c = cases_1_1.value;
+                if (c.when == null)
+                    throw new Error("can't find when condition");
+                if (c.then == null)
+                    throw new Error("can't find then condition");
+                query = __spreadArray(__spreadArray([], __read(query), false), [
+                    "".concat(this.$constants('WHEN'), " ").concat(c.when, " ").concat(this.$constants('THEN'), " ").concat(c.then)
+                ], false);
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (cases_1_1 && !cases_1_1.done && (_a = cases_1.return)) _a.call(cases_1);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+        return [
+            this.$constants('RAW'),
+            this.$constants('CASE'),
+            query.join(' '),
+            this.$constants('END')
+        ].join(' ');
+    };
+    /**
+     * generate UUID
+     * @return {string} string
+     */
+    DB.prototype.generateUUID = function () {
+        return this.$utils.generateUUID();
+    };
+    /**
+     * Get a connection
+     * @return {ConnectionTransaction}
+     * @type     {object} connection
+     * @property {function} connection.query - execute query sql then release connection to pool
+     * @property {function} connection.startTransaction - start transaction of query
+     * @property {function} connection.commit - commit transaction of query
+     * @property {function} connection.rollback - rollback transaction of query
      */
     DB.prototype.beginTransaction = function () {
         return __awaiter(this, void 0, void 0, function () {
-            var transaction;
-            var _this = this;
+            var pool;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.$pool.load()];
+                    case 1:
+                        pool = _a.sent();
+                        return [4 /*yield*/, pool.connection()];
+                    case 2: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    /**
+     * Assign table name
+     * @static
+     * @param {string} table table name
+     * @return {DB} DB
+     */
+    DB.table = function (table) {
+        var self = new this();
+        self.$db.set('SELECT', "".concat(self.$constants('SELECT'), " *"));
+        self.$db.set('TABLE_NAME', "`".concat(table, "`"));
+        self.$db.set('FROM', "".concat(self.$constants('FROM')));
+        return self;
+    };
+    /**
+     * select by cases
+     * @static
+     * @param {array} cases array object
+     * @return {this}
+     */
+    DB.caseUpdate = function (cases) {
+        var e_2, _a;
+        var self = new this();
+        var query = [];
+        try {
+            for (var cases_2 = __values(cases), cases_2_1 = cases_2.next(); !cases_2_1.done; cases_2_1 = cases_2.next()) {
+                var c = cases_2_1.value;
+                if (c.when == null)
+                    throw new Error("can't find when condition");
+                if (c.then == null)
+                    throw new Error("can't find then condition");
+                query = __spreadArray(__spreadArray([], __read(query), false), [
+                    "".concat(self.$constants('WHEN'), " ").concat(c.when, " ").concat(self.$constants('THEN'), " ").concat(c.then)
+                ], false);
+            }
+        }
+        catch (e_2_1) { e_2 = { error: e_2_1 }; }
+        finally {
+            try {
+                if (cases_2_1 && !cases_2_1.done && (_a = cases_2.return)) _a.call(cases_2);
+            }
+            finally { if (e_2) throw e_2.error; }
+        }
+        return [
+            self.$constants('RAW'),
+            self.$constants('CASE'),
+            query.join(' '),
+            self.$constants('END'),
+        ].join(' ');
+    };
+    /**
+    * generate UUID
+    * @static
+    * @return {string} string
+    */
+    DB.generateUUID = function () {
+        return new this().$utils.generateUUID();
+    };
+    /**
+     * Get a connection
+     * @static
+     * @return {ConnectionTransaction}
+     * @type     {object} connection
+     * @property {function} connection.query - execute query sql then release connection to pool
+     * @property {function} connection.startTransaction - start transaction of query
+     * @property {function} connection.commit - commit transaction of query
+     * @property {function} connection.rollback - rollback transaction of query
+     */
+    DB.beginTransaction = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var self, pool;
             return __generator(this, function (_a) {
-                transaction = {
-                    rollback: function () { return __awaiter(_this, void 0, void 0, function () {
-                        var transaction, _a, _b, query, e_1_1;
-                        var e_1, _c;
-                        return __generator(this, function (_d) {
-                            switch (_d.label) {
-                                case 0:
-                                    transaction = this.$db.get('TRANSACTION');
-                                    if (!(transaction === null || transaction === void 0 ? void 0 : transaction.query.length))
-                                        return [2 /*return*/, false];
-                                    _d.label = 1;
-                                case 1:
-                                    _d.trys.push([1, 6, 7, 8]);
-                                    _a = __values(transaction.query), _b = _a.next();
-                                    _d.label = 2;
-                                case 2:
-                                    if (!!_b.done) return [3 /*break*/, 5];
-                                    query = _b.value;
-                                    if (query.id === '' || query.table === '' || query.id == null || query.table == null) {
-                                        return [2 /*return*/, false];
-                                    }
-                                    return [4 /*yield*/, new DB()
-                                            .table(query.table)
-                                            .where('id', query.id)
-                                            .delete()];
-                                case 3:
-                                    _d.sent();
-                                    _d.label = 4;
-                                case 4:
-                                    _b = _a.next();
-                                    return [3 /*break*/, 2];
-                                case 5: return [3 /*break*/, 8];
-                                case 6:
-                                    e_1_1 = _d.sent();
-                                    e_1 = { error: e_1_1 };
-                                    return [3 /*break*/, 8];
-                                case 7:
-                                    try {
-                                        if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
-                                    }
-                                    finally { if (e_1) throw e_1.error; }
-                                    return [7 /*endfinally*/];
-                                case 8: return [2 /*return*/, true];
-                            }
-                        });
-                    }); },
-                    query: []
-                };
-                this.$db.set('TRANSACTION', transaction);
-                return [2 /*return*/, transaction];
+                switch (_a.label) {
+                    case 0:
+                        self = new this();
+                        return [4 /*yield*/, self.$pool.load()];
+                    case 1:
+                        pool = _a.sent();
+                        return [4 /*yield*/, pool.connection()];
+                    case 2: return [2 /*return*/, _a.sent()];
+                }
             });
         });
     };
@@ -177,6 +287,10 @@ var DB = /** @class */ (function (_super) {
                     throw new Error("can't set this [".concat(key, "]"));
                 db.set(key, value);
                 return;
+            },
+            clone: function (data) {
+                db = new Map(Object.entries(__assign({}, data)));
+                return;
             }
         };
     };