tspace-mysql 1.1.8 → 1.2.0

package/dist/lib/connection/index.js

@@ -6,31 +6,19 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Pool = exports.PoolConnection = void 0;
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
-const env_1 = __importDefault(require("../config/env"));
+const options_1 = __importDefault(require("./options"));
 const mysql2_1 = require("mysql2");
 class PoolConnection {
-    OPTIONS = this._loadOptions();
     /**
      *
      * @Init a options connection pool
      */
     constructor(options) {
+        this.OPTIONS = this._loadOptions();
         if (options) {
-            this.OPTIONS = new Map(Object.entries({
-                ...Object.fromEntries(this.OPTIONS),
-                ...JSON.parse(JSON.stringify(options))
-            }));
+            this.OPTIONS = new Map(Object.entries(Object.assign(Object.assign({}, Object.fromEntries(this.OPTIONS)), JSON.parse(JSON.stringify(options)))));
         }
     }
-    /**
-     *
-     * Set a options connection pool
-     * @return {this} this
-     */
-    options(options) {
-        this.OPTIONS = new Map(Object.entries(options));
-        return this;
-    }
     /**
      *
      * Get a connection to database
@@ -40,17 +28,17 @@ class PoolConnection {
      */
     connection() {
         const pool = (0, mysql2_1.createPool)(Object.fromEntries(this.OPTIONS));
-        const conn = pool.getConnection((err, _) => {
-            if (!err)
-                return;
-            const message = this._messageError.bind(this);
-            if (!env_1.default.CONNECTION_ERROR)
-                return;
-            process.nextTick(() => {
-                console.log(message());
-                return process.exit();
+        if (options_1.default.CONNECTION_ERROR) {
+            pool.getConnection((err, _) => {
+                if (err == null || !err)
+                    return;
+                const message = this._messageError.bind(this);
+                process.nextTick(() => {
+                    console.log(message());
+                    return process.exit();
+                });
             });
-        });
+        }
         return {
             query: (sql) => {
                 return new Promise((resolve, reject) => {
@@ -91,23 +79,41 @@ class PoolConnection {
     }
     _defaultOptions() {
         return new Map(Object.entries({
-            connectionLimit: Number(env_1.default.CONNECTION_LIMIT),
-            dateStrings: Boolean(env_1.default.DATE_STRINGS),
-            connectTimeout: Number(env_1.default.TIMEOUT),
-            waitForConnections: true,
-            queueLimit: Number(env_1.default.QUEUE_LIMIT),
-            charset: 'utf8mb4',
-            host: String(env_1.default.HOST),
-            port: Number.isNaN(Number(env_1.default.PORT))
+            connectionLimit: Number(options_1.default.CONNECTION_LIMIT),
+            dateStrings: Boolean(options_1.default.DATE_STRINGS),
+            connectTimeout: Number(options_1.default.TIMEOUT),
+            waitForConnections: Boolean(options_1.default.WAIT_FOR_CONNECTIONS),
+            queueLimit: Number(options_1.default.QUEUE_LIMIT),
+            charset: String(options_1.default.CHARSET),
+            host: String(options_1.default.HOST),
+            port: Number.isNaN(Number(options_1.default.PORT))
                 ? 3306
-                : Number(env_1.default.PORT),
-            database: String(env_1.default.DATABASE),
-            user: String(env_1.default.USERNAME),
-            password: String(env_1.default.PASSWORD) === '' ? '' : String(env_1.default.PASSWORD)
+                : Number(options_1.default.PORT),
+            database: String(options_1.default.DATABASE),
+            user: String(options_1.default.USERNAME),
+            password: String(options_1.default.PASSWORD) !== ''
+                ? String(options_1.default.PASSWORD)
+                : ''
         }));
     }
     _loadOptions() {
         try {
+            /**
+             *
+             * @Json connection
+             *
+                "host"                  : "",
+                "port"                  : "",
+                "database"              : "",
+                "user"                  : "",
+                "password"              : "",
+                "connectionLimit"       : "",
+                "dateStrings"           : "",
+                "connectTimeout"        : "",
+                "waitForConnections"    : "",
+                "queueLimit"            : "",
+                "charset"               : ""
+             */
             const jsonPath = path_1.default.join(path_1.default.resolve(), 'tspace-mysql.json');
             const jsonOptionsExists = fs_1.default.existsSync(jsonPath);
             if (!jsonOptionsExists)
@@ -135,6 +141,13 @@ class PoolConnection {
     }
 }
 exports.PoolConnection = PoolConnection;
+/**
+ *
+ * Connection to database when service is started
+ * @return {Connection} Connection
+ * @property {Function} Connection.query
+ * @property {Function} Connection.connection
+ */
 const pool = new PoolConnection().connection();
 exports.Pool = pool;
 exports.default = pool;

package/dist/lib/connection/options.d.ts

@@ -0,0 +1,4 @@
+declare const _default: Readonly<{
+    [x: string]: any;
+}>;
+export default _default;

package/dist/lib/{config/env.js → connection/options.js}

@@ -7,14 +7,15 @@ const dotenv_1 = __importDefault(require("dotenv"));
 const path_1 = __importDefault(require("path"));
 const fs_1 = __importDefault(require("fs"));
 const environment = () => {
-    const NODE_ENV = process.env?.NODE_ENV;
-    const envWithoutEnviroment = path_1.default.join(path_1.default.resolve(), '.env');
+    var _a;
+    const NODE_ENV = (_a = process.env) === null || _a === void 0 ? void 0 : _a.NODE_ENV;
+    const env = path_1.default.join(path_1.default.resolve(), '.env');
     const envWithEnviroment = path_1.default.join(path_1.default.resolve(), `.env.${NODE_ENV}`);
     if (NODE_ENV == null)
-        return envWithoutEnviroment;
+        return env;
     if (fs_1.default.existsSync(envWithEnviroment))
         return envWithEnviroment;
-    return envWithoutEnviroment;
+    return env;
 };
 dotenv_1.default.config({ path: environment() });
 const env = {
@@ -23,10 +24,12 @@ const env = {
     USERNAME: process.env.DB_USERNAME || process.env.TSPACE_USERNAME,
     PASSWORD: process.env.DB_PASSWORD || process.env.TSPACE_PASSWORD || '',
     DATABASE: process.env.DB_DATABASE || process.env.TSPACE_DATABASE,
-    CONNECTION_LIMIT: process.env.DB_CONNECTION_LIMIT || process.env.TSPACE_CONNECTION_LIMIT || 10,
-    CONNECTION_ERROR: process.env.DB_CONNECTION_ERROR || process.env.TSPACE_CONNECTION_ERROR || true,
+    CONNECTION_LIMIT: process.env.DB_CONNECTION_LIMIT || process.env.TSPACE_CONNECTION_LIMIT || 151,
     QUEUE_LIMIT: process.env.DB_QUEUE_LIMIT || process.env.TSPACE_QUEUE_LIMIT || 25,
     TIMEOUT: process.env.DB_TIMEOUT || process.env.TSPACE_TIMEOUT || 1000 * 30,
+    CHARSET: process.env.DB_CHARSET || process.env.TSPACE_CHARSET || 'utf8mb4',
+    CONNECTION_ERROR: process.env.DB_CONNECTION_ERROR || process.env.TSPACE_CONNECTION_ERROR || true,
+    WAIT_FOR_CONNECTIONS: process.env.DB_WAIT_FOR_CONNECTIONS || process.env.TSPACE_WAIT_FOR_CONNECTIONS || true,
     DATE_STRINGS: process.env.DB_DATE_STRINGS || process.env.TSPACE_DATE_STRINGS || true
 };
 for (const [key, value] of Object.entries(env)) {
@@ -36,4 +39,4 @@ for (const [key, value] of Object.entries(env)) {
         env[key] = JSON.parse(value.toLowerCase());
     }
 }
-exports.default = Object.freeze({ ...env });
+exports.default = Object.freeze(Object.assign({}, env));

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

@@ -1,8 +1,8 @@
 declare const CONSTANTS: {
-    [x: string]: string | Object;
+    [key: string]: string | Object;
 };
 export { CONSTANTS };
 declare const _default: Readonly<{
-    [x: string]: string | Object;
+    [key: string]: string | Object;
 }>;
 export default _default;

package/dist/lib/constants/index.js

@@ -4,6 +4,7 @@ exports.CONSTANTS = void 0;
 const CONSTANTS = {
     ID: 'ID',
     SHOW: 'SHOW',
+    SHOW_TABLES: 'SHOW TABLES',
     FIELDS: 'FIELDS',
     COLUMNS: 'COLUMNS',
     WHERE: 'WHERE',
@@ -14,9 +15,9 @@ const CONSTANTS = {
     OR: 'OR',
     LIKE: 'LIKE',
     SELECT: 'SELECT',
+    SELECTED: '*',
     DISTINCT: 'DISTINCT',
     FROM: 'FROM',
-    STAR: 'STAR',
     OFFSET: 'OFFSET',
     GROUP_BY: 'GROUP BY',
     GROUP_CONCAT: 'GROUP_CONCAT',
@@ -102,7 +103,8 @@ const CONSTANTS = {
         DEBUG: false,
         UUID: false,
         PAGE: 1,
-        PER_PAGE: 1
+        PER_PAGE: 1,
+        HOOK: []
     },
     MODEL: {
         PRIMARY_KEY: 'id',
@@ -125,11 +127,6 @@ const CONSTANTS = {
         HAVING: '',
         TABLE_NAME: '',
         UUID_FORMAT: 'uuid',
-        TIMESTAMP: false,
-        TIMESTAMP_FORMAT: {
-            CREATED_AT: 'created_at',
-            UPDATED_AT: 'updated_at'
-        },
         HIDDEN: [],
         DEBUG: false,
         UUID: false,
@@ -137,9 +134,6 @@ const CONSTANTS = {
         SOFT_DELETE_FORMAT: 'deleted_at',
         SOFT_DELETE_RELATIONS: false,
         RELATION: [],
-        WITH: [],
-        WITH_EXISTS: false,
-        WITH_EXISTS_NOT_ID: [],
         PAGE: 1,
         PER_PAGE: 1,
         REGISTRY: {},
@@ -147,7 +141,16 @@ const CONSTANTS = {
         PATTERN: 'snake_case',
         DISTINCT: '',
         PLUCK: '',
-        SAVE: ''
+        SAVE: '',
+        HOOK: [],
+        WITH: [],
+        WITH_EXISTS: false,
+        WITH_EXISTS_NOT_ID: [],
+        TIMESTAMP: false,
+        TIMESTAMP_FORMAT: {
+            CREATED_AT: 'created_at',
+            UPDATED_AT: 'updated_at'
+        },
     }
 };
 exports.CONSTANTS = CONSTANTS;

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

@@ -1,4 +1,5 @@
 import Database from './Database';
+import { Connection, ConnectionOptions } from './Interface';
 declare abstract class AbstractDB extends Database {
     abstract table(tableName: string): void;
     abstract beginTransaction(): Promise<any>;
@@ -11,6 +12,7 @@ declare abstract class AbstractDB extends Database {
         when: string;
         then: string;
     }[], final?: string): string | [];
+    abstract getConnection(options: ConnectionOptions): Connection;
 }
 export { AbstractDB };
 export default AbstractDB;

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

@@ -6,14 +6,15 @@ declare abstract class AbstractDatabase {
     };
     protected $constants: Function;
     protected $state: {
+        original: Function;
         get: Function;
         set: Function;
         clone: Function;
     };
     protected $pool: {
-        get: Function;
+        query: Function;
         set: Function;
-        load: Function;
+        get: Function;
     };
     protected $logger: {
         get: Function;
@@ -22,12 +23,12 @@ declare abstract class AbstractDatabase {
     };
     protected $attributes: {
         [key: string]: any;
-    };
+    } | null;
     abstract void(): this;
     abstract debug(): this;
     abstract dd(): this;
-    abstract select(...params: string[]): this;
-    abstract distinct(...params: string[]): this;
+    abstract select(...columns: string[]): this;
+    abstract distinct(...columns: string[]): this;
     abstract whereNull(column: string): this;
     abstract whereNotNull(column: string): this;
     abstract where(column: string, operator: string, value: string): this;
@@ -51,9 +52,9 @@ declare abstract class AbstractDatabase {
     abstract leftJoin(pk: string, fk: string): this;
     abstract crossJoin(pk: string, fk: string): this;
     abstract orderBy(column: string, order: string): this;
-    abstract latest(column: string): this;
-    abstract oldest(column: string): this;
-    abstract groupBy(column: string): this;
+    abstract latest(...columns: Array<string>): this;
+    abstract oldest(...columns: Array<string>): this;
+    abstract groupBy(...columns: string[]): this;
     abstract limit(number: number): this;
     abstract hidden(...columns: string[]): this;
     abstract insert(objects: object): this;
@@ -67,11 +68,11 @@ declare abstract class AbstractDatabase {
     abstract updateOrCreate(objects: object): this;
     abstract createMultiple(objects: object): this;
     abstract insertMultiple(objects: object): this;
-    abstract except(...params: string[]): this;
-    abstract only(...params: string[]): this;
+    abstract except(...columns: string[]): this;
+    abstract only(...columns: string[]): this;
     abstract drop(): Promise<any>;
     abstract truncate(): Promise<any>;
-    abstract all(): Promise<any>;
+    abstract all(): Promise<Array<any>>;
     abstract find(id: number): Promise<any>;
     abstract pagination({ limit, page }: {
         limit: number;
@@ -97,14 +98,17 @@ declare abstract class AbstractDatabase {
     abstract toJSON(): Promise<any>;
     abstract toSQL(): string;
     abstract toString(): string;
-    abstract count(column: string): Promise<any>;
-    abstract sum(column: string): Promise<any>;
-    abstract avg(column: string): Promise<any>;
-    abstract max(column: string): Promise<any>;
-    abstract min(column: string): Promise<any>;
-    abstract delete(): Promise<any>;
-    abstract exists(): Promise<any>;
-    abstract save(): Promise<any[] | object | null>;
+    abstract count(column: string): Promise<number>;
+    abstract sum(column: string): Promise<number>;
+    abstract avg(column: string): Promise<number>;
+    abstract max(column: string): Promise<number>;
+    abstract min(column: string): Promise<number>;
+    abstract rawQuery(sql: string): Promise<Array<any>>;
+    abstract delete(): Promise<boolean>;
+    abstract exists(): Promise<boolean>;
+    abstract save(): Promise<{
+        [key: string]: any;
+    } | Array<any> | null | undefined>;
     abstract increment(column: string, value: number): Promise<any>;
     abstract decrement(column: string, value: number): Promise<any>;
     abstract faker(round: number): Promise<any>;

package/dist/lib/tspace/AbstractDatabase.js

@@ -1,31 +1,34 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 class AbstractDatabase {
-    $setters = [
-        '$attributes',
-        '$logger',
-        '$utils',
-        '$constants',
-        '$pool',
-        '$state',
-    ];
-    $utils = {};
-    $constants = (name) => { };
-    $state = {
-        get: (key) => { },
-        set: (key, value) => { },
-        clone: (data) => { }
-    };
-    $pool = {
-        get: (sql) => { },
-        set: (pool) => { },
-        load: () => { }
-    };
-    $logger = {
-        get: () => { },
-        set: (value) => { },
-        check: (value) => true || false
-    };
-    $attributes = {};
+    constructor() {
+        this.$setters = [
+            '$attributes',
+            '$logger',
+            '$utils',
+            '$constants',
+            '$pool',
+            '$state',
+        ];
+        this.$utils = {};
+        this.$constants = (name) => { };
+        this.$state = {
+            original: () => { },
+            get: (key) => { },
+            set: (key, value) => { },
+            clone: (data) => { }
+        };
+        this.$pool = {
+            query: (sql) => { },
+            set: (pool) => { },
+            get: () => { }
+        };
+        this.$logger = {
+            get: () => { },
+            set: (value) => { },
+            check: (value) => true || false
+        };
+        this.$attributes = null;
+    }
 }
 exports.default = AbstractDatabase;

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

@@ -17,10 +17,10 @@ declare abstract class AbstractModel extends Database {
     protected abstract belongsTo({ name, model, localKey, foreignKey, freezeTable, as }: Relation): this;
     protected abstract belongsToMany({ name, model, localKey, foreignKey, freezeTable, as }: Relation): this;
     protected abstract buildMethodRelation(name: string, callback?: Function): this;
-    protected abstract hasOneQuery({ name, model, localKey, foreignKey, freezeTable, as }: RelationQuery, callback: Function): this;
-    protected abstract hasManyQuery({ name, model, localKey, foreignKey, freezeTable, as }: RelationQuery, callback: Function): this;
-    protected abstract belongsToQuery({ name, model, localKey, foreignKey, freezeTable, as }: RelationQuery, callback: Function): this;
-    protected abstract belongsToManyQuery({ name, model, localKey, foreignKey, freezeTable, as }: RelationQuery, callback: Function): this;
+    protected abstract hasOneBuilder({ name, model, localKey, foreignKey, freezeTable, as }: RelationQuery, callback: Function): this;
+    protected abstract hasManyBuilder({ name, model, localKey, foreignKey, freezeTable, as }: RelationQuery, callback: Function): this;
+    protected abstract belongsToBuilder({ name, model, localKey, foreignKey, freezeTable, as }: RelationQuery, callback: Function): this;
+    protected abstract belongsToManyBuilder({ name, model, localKey, foreignKey, freezeTable, as }: RelationQuery, callback: Function): this;
     abstract ignoreSoftDelete(): this;
     abstract disableSoftDelete(): this;
     abstract registry(func: {
@@ -32,6 +32,7 @@ declare abstract class AbstractModel extends Database {
     abstract with(...nameRelations: string[]): this;
     abstract withQuery(nameRelations: string, callback: Function): this;
     abstract withExists(...nameRelations: string[]): this;
+    abstract has(...nameRelations: string[]): this;
     abstract relations(...nameRelations: string[]): this;
     abstract relationQuery(nameRelations: string, callback: Function): this;
     abstract relationsExists(...nameRelations: string[]): this;

package/dist/lib/tspace/Blueprint.js

@@ -2,8 +2,10 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Blueprint = void 0;
 class Blueprint {
-    type = '';
-    attrbuites = [];
+    constructor() {
+        this.type = '';
+        this.attrbuites = [];
+    }
     /**
      * Assign type 'int' in table
      * @return {this} this

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

@@ -1,5 +1,5 @@
 import { AbstractDB } from './AbstractDB';
-import { ConnectionTransaction } from '../connection';
+import { Connection, ConnectionOptions, ConnectionTransaction } from './Interface';
 declare class DB extends AbstractDB {
     constructor(table?: string);
     /**
@@ -37,6 +37,17 @@ declare class DB extends AbstractDB {
      * @return {string} string
      */
     raw(sql: string): string;
+    /**
+     * Get a pool connection
+     * @param {Object} options options for connection database with credentials
+     * @param {string} option.host
+     * @param {number} option.port
+     * @param {string} option.database
+     * @param {string} option.username
+     * @param {string} option.password
+     * @return {Connection}
+     */
+    getConnection(options: ConnectionOptions): Connection;
     /**
      * Get a connection
      * @return {ConnectionTransaction} object
@@ -98,8 +109,18 @@ declare class DB extends AbstractDB {
      * @property {function} connection.rollback - rollback transaction of query
      */
     static beginTransaction(): Promise<ConnectionTransaction>;
+    /**
+     * Get a pool connection
+     * @param {Object} options options for connection database with credentials
+     * @param {string} option.host
+     * @param {number} option.port
+     * @param {string} option.database
+     * @param {string} option.username
+     * @param {string} option.password
+     * @return {Connection}
+     */
+    static getConnection(options: ConnectionOptions): Connection;
     private _initialDB;
-    private _setupDB;
 }
 export { DB };
 export default DB;

package/dist/lib/tspace/DB.js

@@ -1,8 +1,29 @@
 "use strict";
+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 __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DB = void 0;
 const AbstractDB_1 = require("./AbstractDB");
 const ProxyHandler_1 = require("./ProxyHandler");
+const connection_1 = require("../connection");
 class DB extends AbstractDB_1.AbstractDB {
     constructor(table) {
         super();
@@ -73,6 +94,25 @@ class DB extends AbstractDB_1.AbstractDB {
     raw(sql) {
         return `${this.$constants('RAW')} ${sql}`;
     }
+    /**
+     * Get a pool connection
+     * @param {Object} options options for connection database with credentials
+     * @param {string} option.host
+     * @param {number} option.port
+     * @param {string} option.database
+     * @param {string} option.username
+     * @param {string} option.password
+     * @return {Connection}
+     */
+    getConnection(options) {
+        const { host, port, database, username: user, password } = options, others = __rest(options, ["host", "port", "database", "username", "password"]);
+        const pool = new connection_1.PoolConnection(Object.assign({ host,
+            port,
+            database,
+            user,
+            password }, others));
+        return pool.connection();
+    }
     /**
      * Get a connection
      * @return {ConnectionTransaction} object
@@ -82,9 +122,11 @@ class DB extends AbstractDB_1.AbstractDB {
      * @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();
+    beginTransaction() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const pool = yield this.$pool.get();
+            return yield pool.connection();
+        });
     }
     /**
      * Assign table name
@@ -165,37 +207,58 @@ class DB extends AbstractDB_1.AbstractDB {
      * @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();
+    static beginTransaction() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const self = new this();
+            const pool = yield self.$pool.get();
+            return yield pool.connection();
+        });
+    }
+    /**
+     * Get a pool connection
+     * @param {Object} options options for connection database with credentials
+     * @param {string} option.host
+     * @param {number} option.port
+     * @param {string} option.database
+     * @param {string} option.username
+     * @param {string} option.password
+     * @return {Connection}
+     */
+    static getConnection(options) {
+        const { host, port, database, username: user, password } = options, others = __rest(options, ["host", "port", "database", "username", "password"]);
+        const pool = new connection_1.PoolConnection(Object.assign({ host,
+            port,
+            database,
+            user,
+            password }, others));
+        return pool.connection();
     }
     _initialDB() {
-        this.$state = this._setupDB();
+        this.$state = (() => {
+            let db = new Map(Object.entries(Object.assign({}, this.$constants('DB'))));
+            return {
+                original: () => db,
+                get: (key) => {
+                    if (key == null)
+                        return db;
+                    if (!db.has(key))
+                        throw new Error(`can't get this [${key}]`);
+                    return db.get(key);
+                },
+                set: (key, value) => {
+                    if (!db.has(key))
+                        throw new Error(`can't set this [${key}]`);
+                    db.set(key, value);
+                    return;
+                },
+                clone: (data) => {
+                    db = new Map(Object.entries(Object.assign({}, data)));
+                    return;
+                }
+            };
+        })();
         return this;
     }
-    _setupDB() {
-        let db = new Map(Object.entries({ ...this.$constants('DB') }));
-        return {
-            get: (key) => {
-                if (key == null)
-                    return db;
-                if (!db.has(key))
-                    throw new Error(`can't get this [${key}]`);
-                return db.get(key);
-            },
-            set: (key, value) => {
-                if (!db.has(key))
-                    throw new Error(`can't set this [${key}]`);
-                db.set(key, value);
-                return;
-            },
-            clone: (data) => {
-                db = new Map(Object.entries({ ...data }));
-                return;
-            }
-        };
-    }
 }
 exports.DB = DB;
 exports.default = DB;