tspace-mysql 1.1.2 → 1.1.3

package/dist/lib/tspace/Blueprint.js

@@ -1,195 +1,226 @@
 "use strict";
-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.Blueprint = void 0;
-var Blueprint = /** @class */ (function () {
-    function Blueprint() {
-        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;
-    };
-    Blueprint.prototype.int = function () {
+class Blueprint {
+    type = '';
+    attrbuites = [];
+    /**
+     * Assign type 'int' in table
+     * @return {this} this
+     */
+    int() {
         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, ")"));
+    tinyInt(number = 1) {
+        this._addAssignType(`TINYINT(${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, ")"));
+    bigInt(number = 10) {
+        this._addAssignType(`BIGINT(${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; }
-        if (decimal === void 0) { decimal = 0; }
+    double(length = 0, decimal = 0) {
         if (!length || !decimal) {
-            this._addAssignType("DOUBLE");
+            this._addAssignType(`DOUBLE`);
             return this;
         }
-        this._addAssignType("DOUBLE(".concat(length, ",").concat(decimal, ")"));
+        this._addAssignType(`DOUBLE(${length},${decimal})`);
         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; }
-        if (decimal === void 0) { decimal = 0; }
+    float(length = 0, decimal = 0) {
         if (!length || !decimal) {
-            this._addAssignType("FLOAT");
+            this._addAssignType(`FLOAT`);
             return this;
         }
-        this._addAssignType("FLOAT(".concat(length, ",").concat(decimal, ")"));
+        this._addAssignType(`FLOAT(${length},${decimal})`);
         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, ")"));
+    varchar(length = 100) {
+        if (length > 255)
+            length = 255;
+        this._addAssignType(`VARCHAR(${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, ")"));
+    char(length = 1) {
+        this._addAssignType(`CHAR(${length})`);
         return this;
-    };
-    Blueprint.prototype.longText = function () {
-        this._addAssignType("LONGTEXT");
+    }
+    /**
+     * Assign type 'LONGTEXT' in table
+     * @return {this} this
+     */
+    longText() {
+        this._addAssignType(`LONGTEXT`);
         return this;
-    };
-    Blueprint.prototype.mediumText = function () {
-        this._addAssignType("MEDIUMTEXT");
+    }
+    /**
+     * Assign type 'MEDIUMTEXT' in table
+     * @param {number} length [length = 1] length of string
+     * @return {this} this
+     */
+    mediumText() {
+        this._addAssignType(`MEDIUMTEXT`);
         return this;
-    };
-    Blueprint.prototype.tinyText = function () {
-        this._addAssignType("TINYTEXT");
+    }
+    /**
+     * Assign type 'TINYTEXT' in table
+     * @param {number} length [length = 1] length of string
+     * @return {this} this
+     */
+    tinyText() {
+        this._addAssignType(`TINYTEXT`);
         return this;
-    };
-    Blueprint.prototype.text = function () {
-        this._addAssignType("TEXT");
+    }
+    /**
+     * Assign type 'TEXT' in table
+     * @param {number} length [length = 1] length of string
+     * @return {this} this
+     */
+    text() {
+        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 = [];
-        for (var _i = 0; _i < arguments.length; _i++) {
-            enums[_i] = arguments[_i];
-        }
-        this._addAssignType("ENUM('".concat(enums, "')"));
+    enum(...enums) {
+        this._addAssignType(`ENUM('${enums}')`);
+        return this;
+    }
+    /**
+     * Assign type 'DATE' in table
+     * @return {this} this
+     */
+    date() {
+        this._addAssignType(`DATE`);
         return this;
-    };
-    Blueprint.prototype.date = function () {
-        this._addAssignType("DATE");
+    }
+    /**
+     * Assign type 'DATETIME' in table
+     * @return {this} this
+     */
+    dateTime() {
+        this._addAssignType(`DATETIME`);
         return this;
-    };
-    Blueprint.prototype.dateTime = function () {
-        this._addAssignType("DATETIME");
+    }
+    /**
+     * Assign type 'TIMESTAMP' in table
+     * @return {this} this
+     */
+    timestamp() {
+        this._addAssignType(`TIMESTAMP`);
         return this;
-    };
-    Blueprint.prototype.timestamp = function () {
-        this._addAssignType("TIMESTAMP");
+    }
+    /**
+     * Assign type 'UNSIGNED' in table
+     * @return {this} this
+     */
+    unsigned() {
+        this._addAssignAttrbuite(`UNSIGNED`);
         return this;
-    };
-    Blueprint.prototype.unsigned = function () {
-        this._addAssignAttrbuite("UNSIGNED");
+    }
+    /**
+     * Assign type 'UNIQUE' in table
+     * @return {this} this
+     */
+    unique() {
+        this._addAssignAttrbuite(`UNIQUE`);
         return this;
-    };
-    Blueprint.prototype.unique = function () {
-        this._addAssignAttrbuite("UNIQUE");
+    }
+    /**
+     * Assign type 'NULL' in table
+     * @return {this} this
+     */
+    null() {
+        this._addAssignAttrbuite(`NULL`);
         return this;
-    };
-    Blueprint.prototype.null = function () {
-        this._addAssignAttrbuite("NULL");
+    }
+    /**
+     * Assign type 'NOT NULL' in table
+     * @return {this} this
+     */
+    notNull() {
+        this._addAssignAttrbuite(`NOT NULL`);
         return this;
-    };
-    Blueprint.prototype.notNull = function () {
-        this._addAssignAttrbuite("NOT NULL");
+    }
+    /**
+     * Assign type 'PRIMARY KEY' in table
+     * @return {this} this
+     */
+    primary() {
+        this._addAssignAttrbuite(`PRIMARY KEY`);
         return this;
-    };
-    Blueprint.prototype.primary = function () {
-        this._addAssignAttrbuite("PRIMARY KEY");
+    }
+    /**
+     * Assign attrbuites 'default' in table
+     * @param {string | number} n  default value
+     * @return {this} this
+     */
+    default(n) {
+        this._addAssignAttrbuite(`DEFAULT '${n}'`);
         return this;
-    };
+    }
     /**
-     * Assign attrbuites
-     * @param {string | number} default value
+     * Assign attrbuites 'default currentTimestamp' in table
+     * @return {this} this
      */
-    Blueprint.prototype.default = function (n) {
-        this._addAssignAttrbuite("DEFAULT '".concat(n, "'"));
+    currentTimestamp() {
+        this._addAssignAttrbuite(`DEFAULT CURRENT_TIMESTAMP`);
         return this;
-    };
-    Blueprint.prototype.defaultTimestamp = function () {
-        this._addAssignAttrbuite("DEFAULT CURRENT_TIMESTAMP");
+    }
+    /**
+     * Assign attrbuites 'autoIncrement' in table
+     * @return {this} this
+     */
+    autoIncrement() {
+        this._addAssignAttrbuite(`AUTO_INCREMENT`);
+        return this;
+    }
+    _addAssignType(type) {
+        if (this.type)
+            return this;
+        this.type = type;
         return this;
-    };
-    Blueprint.prototype.autoIncrement = function () {
-        this._addAssignAttrbuite("AUTO_INCREMENT");
+    }
+    _addAssignAttrbuite(attrbuite) {
+        this.attrbuites = [...this.attrbuites, attrbuite];
         return this;
-    };
-    return Blueprint;
-}());
+    }
+}
 exports.Blueprint = Blueprint;
 exports.default = 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,33 @@ declare class DB extends AbstractDB {
      */
     table(table: string): this;
     /**
-     * transaction query rollback & commit
-     * @return {promise<any>}
+    * 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;
+    /**
+     * 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
      */
-    beginTransaction(): Promise<any>;
+    static beginTransaction(): Promise<ConnectionTransaction>;
     private _initialDB;
     private _setupDB;
 }

package/dist/lib/tspace/DB.js

@@ -1,186 +1,94 @@
 "use strict";
-var __extends = (this && this.__extends) || (function () {
-    var extendStatics = function (d, b) {
-        extendStatics = Object.setPrototypeOf ||
-            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
-            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
-        return extendStatics(d, b);
-    };
-    return function (d, b) {
-        if (typeof b !== "function" && b !== null)
-            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
-        extendStatics(d, b);
-        function __() { this.constructor = d; }
-        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
-    };
-})();
-var __assign = (this && this.__assign) || function () {
-    __assign = Object.assign || function(t) {
-        for (var s, i = 1, n = arguments.length; i < n; i++) {
-            s = arguments[i];
-            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
-                t[p] = s[p];
-        }
-        return t;
-    };
-    return __assign.apply(this, arguments);
-};
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __generator = (this && this.__generator) || function (thisArg, body) {
-    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
-    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
-    function verb(n) { return function (v) { return step([n, v]); }; }
-    function step(op) {
-        if (f) throw new TypeError("Generator is already executing.");
-        while (_) try {
-            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
-            if (y = 0, t) op = [op[0] & 2, t.value];
-            switch (op[0]) {
-                case 0: case 1: t = op; break;
-                case 4: _.label++; return { value: op[1], done: false };
-                case 5: _.label++; y = op[1]; op = [0]; continue;
-                case 7: op = _.ops.pop(); _.trys.pop(); continue;
-                default:
-                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
-                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
-                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
-                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
-                    if (t[2]) _.ops.pop();
-                    _.trys.pop(); continue;
-            }
-            op = body.call(thisArg, _);
-        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
-        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
-    }
-};
-var __values = (this && this.__values) || function(o) {
-    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
-    if (m) return m.call(o);
-    if (o && typeof o.length === "number") return {
-        next: function () {
-            if (o && i >= o.length) o = void 0;
-            return { value: o && o[i++], done: !o };
-        }
-    };
-    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DB = void 0;
-var AbstractDB_1 = require("./AbstractDB");
-var ProxyHandler_1 = require("./ProxyHandler");
-var DB = /** @class */ (function (_super) {
-    __extends(DB, _super);
-    function DB(table) {
-        var _this = _super.call(this) || this;
-        _this._initialDB();
+const AbstractDB_1 = require("./AbstractDB");
+const ProxyHandler_1 = require("./ProxyHandler");
+class DB extends AbstractDB_1.AbstractDB {
+    constructor(table) {
+        super();
+        this._initialDB();
         if (table)
-            _this.table(table);
-        return new Proxy(_this, ProxyHandler_1.proxyHandler);
+            this.table(table);
+        return new Proxy(this, ProxyHandler_1.proxyHandler);
     }
     /**
      * Assign table name
      * @param {string} table table name
      * @return {this} this
      */
-    DB.prototype.table = function (table) {
-        this.$db.set('SELECT', "".concat(this.$constants('SELECT'), " *"));
-        this.$db.set('TABLE_NAME', "`".concat(table, "`"));
-        this.$db.set('FROM', "".concat(this.$constants('FROM')));
+    table(table) {
+        this.$db.set('SELECT', `${this.$constants('SELECT')} *`);
+        this.$db.set('TABLE_NAME', `\`${table}\``);
+        this.$db.set('FROM', `${this.$constants('FROM')}`);
         return this;
-    };
+    }
+    /**
+    * 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
+    */
+    async beginTransaction() {
+        const pool = await this.$pool.load();
+        return await pool.connection();
+    }
     /**
-     * transaction query rollback & commit
-     * @return {promise<any>}
+     * Assign table name
+     * @static
+     * @param {string} table table name
+     * @return {DB} DB
      */
-    DB.prototype.beginTransaction = function () {
-        return __awaiter(this, void 0, void 0, function () {
-            var transaction;
-            var _this = this;
-            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];
-            });
-        });
-    };
-    DB.prototype._initialDB = function () {
+    static table(table) {
+        const self = new this();
+        self.$db.set('SELECT', `${self.$constants('SELECT')} *`);
+        self.$db.set('TABLE_NAME', `\`${table}\``);
+        self.$db.set('FROM', `${self.$constants('FROM')}`);
+        return self;
+    }
+    /**
+     * 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 async beginTransaction() {
+        const self = new this();
+        const pool = await self.$pool.load();
+        return await pool.connection();
+    }
+    _initialDB() {
         this.$db = this._setupDB();
         return this;
-    };
-    DB.prototype._setupDB = function () {
-        var db = new Map(Object.entries(__assign({}, this.$constants('DB'))));
+    }
+    _setupDB() {
+        let db = new Map(Object.entries({ ...this.$constants('DB') }));
         return {
-            get: function (key) {
+            get: (key) => {
                 if (key == null)
                     return db;
                 if (!db.has(key))
-                    throw new Error("can't get this [".concat(key, "]"));
+                    throw new Error(`can't get this [${key}]`);
                 return db.get(key);
             },
-            set: function (key, value) {
+            set: (key, value) => {
                 if (!db.has(key))
-                    throw new Error("can't set this [".concat(key, "]"));
+                    throw new Error(`can't set this [${key}]`);
                 db.set(key, value);
                 return;
+            },
+            clone: (data) => {
+                db = new Map(Object.entries({ ...data }));
+                return;
             }
         };
-    };
-    return DB;
-}(AbstractDB_1.AbstractDB));
+    }
+}
 exports.DB = DB;
 exports.default = DB;