tspace-mysql 1.1.7 → 1.1.8

package/README.md

@@ -26,6 +26,7 @@ npm install tspace-mysql --save
   - [One To Many](#one-to-many)
   - [Belongs To](#belongs-to)
   - [Many To Many](#many-to-many)
+  - [Relation in Relation](#relation-in-relation)
 - [Query Builder](#query-builder)
 - [Cli](#cli)
   - [Make Model](#make-model)
@@ -36,11 +37,20 @@ npm install tspace-mysql --save
 ## Configuration
 Created your environment variables is to use a .env file, you may establish a connection is this:
 ```js
-DB_HOST = localhost
-DB_PORT = 3306
-DB_USERNAME = root
-DB_PASSWORD = password
-DB_DATABASE = database
+TSPACE_HOST     = localhost
+TSPACE_PORT     = 3306
+TSPACE_USERNAME = root
+TSPACE_PASSWORD = password
+TSPACE_DATABASE = database
+
+/** default
+    TSPACE_CONNECTION_LIMIT = 10 
+    TSPACE_CONNECTION_ERROR = true
+    TSPACE_QUEUE_LIMIT      = 25
+    TSPACE_TIMEOUT          = 30000
+    TSPACE_DATE_STRINGS     = true
+*/
+
 ```
 ## Running Queries
 Once you have configured your database connection, you may run queries is this :
@@ -66,6 +76,11 @@ const selectQuery = await new DB('users').select('id','username').findOne()
     // selectQuery => { id : 1, username : 'tspace'}
 const selectQueries = await new DB('users').select('id','username').findMany() 
     // selectQueries => [{ id : 1, username : 'tspace' } , { id : 2, username : 'tspace2'}]
+
+/**
+ * @example except
+ */
+await new DB('users').except('id','username').findOne() 
 ```
 Running A Where Query
 ```js
@@ -73,6 +88,14 @@ const user = await new DB('users').where('id',1).findOne()
     // user => { id : 1 , username : 'tspace', email : 'tspace@gmail.com'}
 const users = await new DB('users').where('id','!=',1).findMany()
     // users => [{ id : 2 , username : 'tspace2' , email : 'tspace2@gmail.com' }]
+/**
+ * @example where
+ */
+const whereIn = await new DB('users').whereIn('id',[1,2]).findMany()
+const whereBetween = await new DB('users').whereBetween('id',[1,2]).findMany()
+const whereSubQuery = await new DB('users').whereSubQuery('id','select id from users').findMany()
+// await new DB('users').whereSubQuery('id',new DB('users').select('id').toString()).findMany()
+const whereNull = await new DB('users').whereNull('username').findOne()
 ```
 Running A Insert Query
 ```js
@@ -91,6 +114,23 @@ const reposity = new DB('users')
     await reposity.save()
 const { result } = reposity
     // result =>  { id : 4 , username : 'tspace4', email : 'tspace4@gmail.com'}
+
+const users = await new DB('users')
+    .createMultiple([
+        {
+            name :'tspace4',
+            email : 'tspace4@gmail.com'
+        },
+        {
+            name :'tspace5',
+            email : 'tspace5@gmail.com'
+        },
+        {
+            name :'tspace6',
+            email : 'tspace6@gmail.com'
+        },
+    ]).save()
+
 ```
 Running A Update Query
 ```js
@@ -110,7 +150,19 @@ const reposity = new DB('users').where('id',1)
     await reposity.save()
 const { result } = reposity
     // result =>  { id : 1 , username : 'tspace1++', email : 'tspace1++@gmail.com'} 
-```    
+```
+
+Running A  Update Or Created Query
+```js
+const user = await new DB('users')
+    .where('id',1)
+    .updateOrCreate({
+          name : 'tspace1**',
+          email : 'tspace1@gmail.com'
+    }).save()
+    // user =>  { username : 'tspace1**', email : 'tspace1@gmail.com'} 
+```  
+
 Running A Delete Query
 ```js
 const deleted = await new DB('users').where('id',1).delete()
@@ -157,16 +209,9 @@ try {
             title : `tspace-post3`
         }
     ])
-    /**
-     *
-     * bind method for make sure this connection has same transaction in connection
-     * @params {Function} connection 
-     */
-    .bind(connection)
+    .bind(connection) /** don't forget this /*
     .save()
 
-    // throw new Error('try error')
-
     /**
      *
      * @commit commit transaction to database
@@ -265,7 +310,17 @@ import { Model } from 'tspace-mysql'
 class User extends Model {
   constructor(){
     super()
-    this.useTimestamp()
+    this.useTimestamp() /** created_at , updated_at
+    /**
+     * @custom 
+     * 
+     * 
+     * this.useTimestamp({
+     *    createdAt : 'created_at',
+     *    updatedAt : 'updated_at'
+     * }) 
+     */
+
     /*
      * the "snake case", plural name of the class will be used as the table name 
      * 
@@ -289,7 +344,7 @@ import Phone  from '../Phone'
 class User extends Model {
     constructor(){
         super()
-        this.useTimestamp()
+        this.useTimestamp() 
         /**
          *
          * @hasOne Get the phone associated with the user.
@@ -298,13 +353,11 @@ class User extends Model {
         this.hasOne({ name : 'phone' , model : Phone })
     }
     /**
-     * @hasOneQuery Get the phone associated with the user. using function callback
+     * @hasOne Get the phone associated with the user. using function callback
      * @function 
      */
     phone (callback ?: Function) {
-        return  this.hasOneQuery({ model : Phone }, (query) => {
-            return callback ? callback(query) : query
-        })
+        return this.hasOneQuery({ name : 'phone' , model : Phone } , callback)
     }
 }
 export default User
@@ -339,9 +392,7 @@ class Post extends Model {
      * @function 
      */
     comments (callback ?: Function) {
-        return  this.hasManyQuery({ model : Comment }, (query) => {
-            return callback ? callback(query) : query
-        })
+        return  this.hasManyQuery({ name : 'comments' , model : Comment } , callback)
     }
 }
 export default Post
@@ -376,9 +427,7 @@ class Phone extends Model {
      * @function 
      */
     user (callback ?: Function) {
-        return  this.belongsToQuery({ model : User }, (query) => {
-            return callback ? callback(query) : query
-        })
+        return this.belongsToQuery({ name : 'user' , model : User }, callback)
     }
 }
 export default Phone
@@ -413,9 +462,7 @@ class User extends Model {
      * @function 
      */
     roles (callback ?: Function) {
-        return  this.belongsToManyQuery({ model : Role }, (query) => {
-            return callback ? callback(query) : query
-        })
+        return this.belognsToManyQuery({ model : Role } , callback)
     }
 }
 export default User
@@ -428,6 +475,52 @@ const user = await new User().relations('roles').findOne()
 const userUsingFunction = await new User().roles().findOne()
 // user?.roles => [{...}]
 ```
+
+## Relation in Relation
+Relationships can deep relations. 
+let's example a deep in relations :
+```js
+import { Model } from 'tspace-mysql'
+
+class User extends Model {
+    constructor(){
+        super()
+        this.hasMany({ name : 'posts' , model : Post })
+    }
+}
++--------------------------------------------------------------------------+
+class Post extends Model {
+    constructor(){
+        super()
+        this.hasMany({ name : 'comments' , model : Comment })
+        this.belongsTo({ name : 'user' , model : User })
+    }
+}
++--------------------------------------------------------------------------+
+class Comment extends Model {
+    constructor(){
+        super()
+        this.hasMany({ name : 'users' , model : User })
+        this.belongsTo({ name : 'post' , model : Post })
+    }
+}
++--------------------------------------------------------------------------+
+await new User().relations('posts')
+    .relationQuery('posts', (query : Post) => { // relationQuery return a callback query in model registry
+        return query.relations('comments','user')
+        .relationQuery('comments', (query : Comment) => {
+            return query.relations('user','post')
+        })
+        .relationQuery('user', (query : User) => {
+            return query.relations('posts').relationQuery('posts',(query : Post)=> {
+                return query.relations('comments','user')
+                // relation n to ...n
+            })
+        })
+    })
+    .findMany()
+```
+
 ## Query Builder
 Methods builder for queries
 ```js
@@ -451,8 +544,8 @@ join(primary key , table.foreign key)
 rightJoin (primary key , table.foreign key) 
 leftJoin (primary key , table.foreign key) 
 limit (limit)
-orderBy (column ,'ASC' || 'DSCE')
 having (condition)
+orderBy (column ,'ASC' || 'DSCE')
 latest (column)
 oldest (column)
 groupBy (column)

package/dist/lib/config/env.d.ts

@@ -1,13 +1,4 @@
-declare const env: Readonly<{
-    DB_HOST: string | undefined;
-    DB_PORT: string | undefined;
-    DB_USERNAME: string | undefined;
-    DB_PASSWORD: string | undefined;
-    DB_DATABASE: string | undefined;
-    DB_CONNECTION_LIMIT: string | undefined;
-    DB_DATE_STRING: string | undefined;
-    DB_TIMEOUT: string | undefined;
-    DB_QUEUE_LIMIT: string | undefined;
+declare const _default: Readonly<{
+    [x: string]: string | number | boolean | null | undefined;
 }>;
-export { env };
-export default env;
+export default _default;

package/dist/lib/config/env.js

@@ -3,7 +3,6 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.env = void 0;
 const dotenv_1 = __importDefault(require("dotenv"));
 const path_1 = __importDefault(require("path"));
 const fs_1 = __importDefault(require("fs"));
@@ -18,16 +17,23 @@ const environment = () => {
     return envWithoutEnviroment;
 };
 dotenv_1.default.config({ path: environment() });
-const env = Object.freeze({
-    DB_HOST: process.env.DB_HOST,
-    DB_PORT: process.env.DB_PORT,
-    DB_USERNAME: process.env.DB_USERNAME,
-    DB_PASSWORD: process.env.DB_PASSWORD,
-    DB_DATABASE: process.env.DB_DATABASE,
-    DB_CONNECTION_LIMIT: process.env.DB_CONNECTION_LIMIT,
-    DB_DATE_STRING: process.env.DB_DATE_STRING,
-    DB_TIMEOUT: process.env.DB_TIMEOUT,
-    DB_QUEUE_LIMIT: process.env.DB_QUEUE_LIMIT
-});
-exports.env = env;
-exports.default = env;
+const env = {
+    HOST: process.env.DB_HOST || process.env.TSPACE_HOST,
+    PORT: process.env.DB_PORT || process.env.TSPACE_PORT || 3306,
+    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,
+    QUEUE_LIMIT: process.env.DB_QUEUE_LIMIT || process.env.TSPACE_QUEUE_LIMIT || 25,
+    TIMEOUT: process.env.DB_TIMEOUT || process.env.TSPACE_TIMEOUT || 1000 * 30,
+    DATE_STRINGS: process.env.DB_DATE_STRINGS || process.env.TSPACE_DATE_STRINGS || true
+};
+for (const [key, value] of Object.entries(env)) {
+    if (value == null)
+        continue;
+    if (typeof value === 'string' && ['true', 'false'].some(v => value.toLowerCase() === v)) {
+        env[key] = JSON.parse(value.toLowerCase());
+    }
+}
+exports.default = Object.freeze({ ...env });

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

@@ -3,13 +3,13 @@ export interface PoolCallback {
     release: () => void;
 }
 export interface ConnectionTransaction {
-    query: (sql: string) => Promise<any[]>;
-    startTransaction: () => Promise<any[]>;
-    commit: () => Promise<any[]>;
-    rollback: () => Promise<any[]>;
+    query: (sql: string) => Promise<any>;
+    startTransaction: () => Promise<any>;
+    commit: () => Promise<any>;
+    rollback: () => Promise<any>;
 }
 export interface Connection {
-    query: (sql: string) => Promise<any[]>;
+    query: (sql: string) => Promise<any>;
     connection: () => Promise<ConnectionTransaction>;
 }
 export interface Options {
@@ -26,6 +26,10 @@ export interface Options {
 }
 export declare class PoolConnection {
     private OPTIONS;
+    /**
+     *
+     * @Init a options connection pool
+     */
     constructor(options?: Options);
     /**
      *
@@ -35,14 +39,16 @@ export declare class PoolConnection {
     options(options: Options): this;
     /**
      *
-     * Get a connection pool
+     * Get a connection to database
      * @return {Connection} Connection
+     * @property {Function} Connection.query
+     * @property {Function} Connection.connection
      */
     connection(): Connection;
     private _defaultOptions;
-    private _getJsonOptions;
+    private _loadOptions;
     private _messageError;
 }
-declare const Pool: Connection;
-export { Pool };
-export default Pool;
+declare const pool: Connection;
+export { pool as Pool };
+export default pool;

package/dist/lib/connection/index.js

@@ -6,10 +6,14 @@ 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 = require("../config/env");
-const mysql_1 = require("mysql");
+const env_1 = __importDefault(require("../config/env"));
+const mysql2_1 = require("mysql2");
 class PoolConnection {
-    OPTIONS = this._getJsonOptions();
+    OPTIONS = this._loadOptions();
+    /**
+     *
+     * @Init a options connection pool
+     */
     constructor(options) {
         if (options) {
             this.OPTIONS = new Map(Object.entries({
@@ -29,21 +33,23 @@ class PoolConnection {
     }
     /**
      *
-     * Get a connection pool
+     * Get a connection to database
      * @return {Connection} Connection
+     * @property {Function} Connection.query
+     * @property {Function} Connection.connection
      */
     connection() {
-        const pool = (0, mysql_1.createPool)(Object.fromEntries(this.OPTIONS));
-        pool.getConnection((err, connection) => {
-            if (err) {
-                const message = this._messageError.bind(this);
-                process.nextTick(() => {
-                    console.log(message());
-                    return process.exit();
-                });
-            }
-            if (connection)
-                connection.release();
+        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();
+            });
         });
         return {
             query: (sql) => {
@@ -85,40 +91,30 @@ class PoolConnection {
     }
     _defaultOptions() {
         return new Map(Object.entries({
-            connectionLimit: Number.isNaN(Number(env_1.env.DB_CONNECTION_LIMIT))
-                ? 10 * 5
-                : Number(env_1.env.DB_CONNECTION_LIMIT),
-            dateStrings: true,
-            connectTimeout: Number.isNaN(Number(env_1.env.DB_TIMEOUT))
-                ? 1000 * 30
-                : Number.isNaN(Number(env_1.env.DB_TIMEOUT)),
-            acquireTimeout: Number.isNaN(Number(env_1.env.DB_TIMEOUT))
-                ? 1000 * 30
-                : Number.isNaN(Number(env_1.env.DB_TIMEOUT)),
+            connectionLimit: Number(env_1.default.CONNECTION_LIMIT),
+            dateStrings: Boolean(env_1.default.DATE_STRINGS),
+            connectTimeout: Number(env_1.default.TIMEOUT),
             waitForConnections: true,
-            queueLimit: Number.isNaN(Number(env_1.env.DB_QUEUE_LIMIT))
-                ? 25
-                : Number.isNaN(Number(env_1.env.DB_QUEUE_LIMIT)),
+            queueLimit: Number(env_1.default.QUEUE_LIMIT),
             charset: 'utf8mb4',
-            host: String(env_1.env.DB_HOST),
-            port: Number.isNaN(Number(env_1.env.DB_PORT))
+            host: String(env_1.default.HOST),
+            port: Number.isNaN(Number(env_1.default.PORT))
                 ? 3306
-                : Number(env_1.env.DB_PORT),
-            database: String(env_1.env.DB_DATABASE),
-            user: String(env_1.env.DB_USERNAME),
-            password: String(env_1.env.DB_PASSWORD)
+                : 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)
         }));
     }
-    _getJsonOptions() {
+    _loadOptions() {
         try {
             const jsonPath = path_1.default.join(path_1.default.resolve(), 'tspace-mysql.json');
             const jsonOptionsExists = fs_1.default.existsSync(jsonPath);
-            if (jsonOptionsExists) {
-                const jsonOptions = fs_1.default.readFileSync(jsonPath, 'utf8');
-                const options = JSON.parse(jsonOptions);
-                return new Map(Object.entries(options));
-            }
-            return this._defaultOptions();
+            if (!jsonOptionsExists)
+                return this._defaultOptions();
+            const jsonOptions = fs_1.default.readFileSync(jsonPath, 'utf8');
+            const options = JSON.parse(jsonOptions);
+            return new Map(Object.entries(options));
         }
         catch (e) {
             return this._defaultOptions();
@@ -129,16 +125,16 @@ class PoolConnection {
             \x1b[1m\x1b[31m
             Connection lost to database ! \x1b[0m
             --------------------------------- \x1b[33m
-                DB_HOST     : ${this.OPTIONS.get('host')}         
-                DB_PORT     : ${this.OPTIONS.get('port')}        
-                DB_DATABASE : ${this.OPTIONS.get('database')} 
-                DB_USERNAME : ${this.OPTIONS.get('user')}          
-                DB_PASSWORD : ${this.OPTIONS.get('password')} \x1b[0m  
+                HOST     : ${this.OPTIONS.get('host')}         
+                PORT     : ${this.OPTIONS.get('port')}        
+                DATABASE : ${this.OPTIONS.get('database')} 
+                USERNAME : ${this.OPTIONS.get('user')}          
+                PASSWORD : ${this.OPTIONS.get('password')} \x1b[0m  
             ---------------------------------
         `;
     }
 }
 exports.PoolConnection = PoolConnection;
-const Pool = new PoolConnection().connection();
-exports.Pool = Pool;
-exports.default = Pool;
+const pool = new PoolConnection().connection();
+exports.Pool = pool;
+exports.default = pool;

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

@@ -2,6 +2,15 @@ import Database from './Database';
 declare abstract class AbstractDB extends Database {
     abstract table(tableName: string): void;
     abstract beginTransaction(): Promise<any>;
+    abstract generateUUID(): string;
+    abstract raw(sql: string): string;
+    abstract constants(constants?: string): string | {
+        [key: string]: any;
+    };
+    abstract caseUpdate(cases: {
+        when: string;
+        then: string;
+    }[], final?: string): string | [];
 }
 export { AbstractDB };
 export default AbstractDB;

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

@@ -5,7 +5,7 @@ declare abstract class AbstractDatabase {
         [key: string]: Function;
     };
     protected $constants: Function;
-    protected $db: {
+    protected $state: {
         get: Function;
         set: Function;
         clone: Function;
@@ -23,51 +23,52 @@ declare abstract class AbstractDatabase {
     protected $attributes: {
         [key: string]: any;
     };
-    abstract debug(): void;
-    abstract dd(): void;
-    abstract select(...params: string[]): void;
-    abstract distinct(...params: string[]): void;
-    abstract whereNull(column: string): void;
-    abstract whereNotNull(column: string): void;
-    abstract where(column: string, operator: string, value: string): void;
-    abstract whereSensitive(column: string, operator: string, value: string): void;
-    abstract whereRaw(sql: string): void;
-    abstract whereId(id: number): void;
-    abstract whereUser(id: number): void;
-    abstract whereEmail(value: string): void;
-    abstract whereQuery(callback: Function): void;
-    abstract orWhere(column: string, operator: string, value: string): void;
-    abstract whereIn(column: string, arrayValues: Array<any>): void;
-    abstract orWhereIn(column: string, arrayValues: Array<any>): void;
-    abstract whereNotIn(column: string, arrayValues: Array<any>): void;
-    abstract whereSubQuery(column: string, subQuery: string): void;
-    abstract whereNotSubQuery(column: string, subQuery: string): void;
-    abstract orWhereSubQuery(column: string, subQuery: string): void;
-    abstract whereBetween(column: string, arrayValue: Array<any>): void;
-    abstract having(condition: string): void;
-    abstract join(pk: string, fk: string): void;
-    abstract rightJoin(pk: string, fk: string): void;
-    abstract leftJoin(pk: string, fk: string): void;
-    abstract crossJoin(pk: string, fk: string): void;
-    abstract orderBy(column: string, order: string): void;
-    abstract latest(column: string): void;
-    abstract oldest(column: string): void;
-    abstract groupBy(column: string): void;
-    abstract limit(number: number): void;
-    abstract hidden(...columns: string[]): void;
-    abstract insert(objects: object): void;
-    abstract create(objects: object): void;
-    abstract update(objects: object): void;
-    abstract insertNotExists(objects: object): void;
-    abstract createNotExists(objects: object): void;
-    abstract insertOrUpdate(objects: object): void;
-    abstract createOrUpdate(objects: object): void;
-    abstract updateOrInsert(objects: object): void;
-    abstract updateOrCreate(objects: object): void;
-    abstract createMultiple(objects: object): void;
-    abstract insertMultiple(objects: object): void;
-    abstract except(...params: string[]): void;
-    abstract only(...params: string[]): void;
+    abstract void(): this;
+    abstract debug(): this;
+    abstract dd(): this;
+    abstract select(...params: string[]): this;
+    abstract distinct(...params: string[]): this;
+    abstract whereNull(column: string): this;
+    abstract whereNotNull(column: string): this;
+    abstract where(column: string, operator: string, value: string): this;
+    abstract whereSensitive(column: string, operator: string, value: string): this;
+    abstract whereRaw(sql: string): this;
+    abstract whereId(id: number): this;
+    abstract whereUser(id: number): this;
+    abstract whereEmail(value: string): this;
+    abstract whereQuery(callback: Function): this;
+    abstract orWhere(column: string, operator: string, value: string): this;
+    abstract whereIn(column: string, arrayValues: Array<any>): this;
+    abstract orWhereIn(column: string, arrayValues: Array<any>): this;
+    abstract whereNotIn(column: string, arrayValues: Array<any>): this;
+    abstract whereSubQuery(column: string, subQuery: string): this;
+    abstract whereNotSubQuery(column: string, subQuery: string): this;
+    abstract orWhereSubQuery(column: string, subQuery: string): this;
+    abstract whereBetween(column: string, arrayValue: Array<any>): this;
+    abstract having(condition: string): this;
+    abstract join(pk: string, fk: string): this;
+    abstract rightJoin(pk: string, fk: string): this;
+    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 limit(number: number): this;
+    abstract hidden(...columns: string[]): this;
+    abstract insert(objects: object): this;
+    abstract create(objects: object): this;
+    abstract update(objects: object): this;
+    abstract insertNotExists(objects: object): this;
+    abstract createNotExists(objects: object): this;
+    abstract insertOrUpdate(objects: object): this;
+    abstract createOrUpdate(objects: object): this;
+    abstract updateOrInsert(objects: object): this;
+    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 drop(): Promise<any>;
     abstract truncate(): Promise<any>;
     abstract all(): Promise<any>;

package/dist/lib/tspace/AbstractDatabase.js

@@ -7,11 +7,11 @@ class AbstractDatabase {
         '$utils',
         '$constants',
         '$pool',
-        '$db'
+        '$state',
     ];
     $utils = {};
     $constants = (name) => { };
-    $db = {
+    $state = {
         get: (key) => { },
         set: (key, value) => { },
         clone: (data) => { }