tspace-mysql 1.1.2 → 1.1.3

package/dist/lib/index.d.ts

@@ -2,7 +2,7 @@
   * The entry point.
   *
   * @module tspace-mysql
-*/
+  */
 import * as tspace from './tspace';
 export * from './tspace';
 export default tspace;

package/dist/lib/index.js

@@ -30,7 +30,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
   * The entry point.
   *
   * @module tspace-mysql
-*/
-var tspace = __importStar(require("./tspace"));
+  */
+const tspace = __importStar(require("./tspace"));
 __exportStar(require("./tspace"), exports);
 exports.default = tspace;

package/dist/lib/tspace/AbstractDB.js

@@ -1,31 +1,11 @@
 "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 __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AbstractDB = void 0;
-var Database_1 = __importDefault(require("./Database"));
-var AbstractDB = /** @class */ (function (_super) {
-    __extends(AbstractDB, _super);
-    function AbstractDB() {
-        return _super !== null && _super.apply(this, arguments) || this;
-    }
-    return AbstractDB;
-}(Database_1.default));
+const Database_1 = __importDefault(require("./Database"));
+class AbstractDB extends Database_1.default {
+}
 exports.AbstractDB = AbstractDB;
 exports.default = AbstractDB;

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

@@ -8,10 +8,12 @@ declare abstract class AbstractDatabase {
     protected $db: {
         get: Function;
         set: Function;
+        clone: Function;
     };
     protected $pool: {
         get: Function;
         set: Function;
+        load: Function;
     };
     protected $logger: {
         get: Function;
@@ -33,10 +35,7 @@ declare abstract class AbstractDatabase {
     abstract whereId(id: number): void;
     abstract whereUser(id: number): void;
     abstract whereEmail(value: string): void;
-    abstract whereGroupStart(column: string, operator: string, value: string): void;
-    abstract whereGroupEnd(column: string, operator: string, value: string): void;
-    abstract orWhereGroupStart(column: string, operator: string, value: string): void;
-    abstract orWhereGroupEnd(column: string, operator: string, 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;
@@ -82,6 +81,12 @@ declare abstract class AbstractDatabase {
         page: number;
     }): Promise<Pagination>;
     abstract first(): Promise<any>;
+    abstract firstOrError(message: string, options?: {
+        [key: string]: any;
+    }): Promise<any>;
+    abstract findOneOrError(message: string, options?: {
+        [key: string]: any;
+    }): Promise<any>;
     abstract get(): Promise<any>;
     abstract findOne(): Promise<any>;
     abstract findMany(): Promise<any>;

package/dist/lib/tspace/AbstractDatabase.js

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

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

@@ -1,21 +1,35 @@
-import { Relation } from './Interface';
+import { Relation, RelationQuery } from './Interface';
 import Database from './Database';
 declare abstract class AbstractModel extends Database {
-    abstract useDebug(): void;
-    abstract useTable(table: string): void;
-    abstract useTimestamp(): void;
-    abstract useSoftDelete(): void;
-    abstract usePattern(pattern: string): void;
-    abstract onlyTrashed(): void;
-    abstract trashed(): void;
-    abstract restore(): void;
-    abstract with(...nameRelations: string[]): void;
-    abstract withQuery(nameRelations: string, callback: Function): void;
-    abstract withExists(...nameRelations: string[]): void;
-    abstract hasOne({ name, model, localKey, foreignKey, freezeTable, as }: Relation): void;
-    abstract hasMany({ name, model, localKey, foreignKey, freezeTable, as }: Relation): void;
-    abstract belongsTo({ name, model, localKey, foreignKey, freezeTable, as }: Relation): void;
-    abstract belongsToMany({ name, model, localKey, foreignKey, freezeTable, as }: Relation): void;
+    abstract useUUID(): this;
+    abstract usePrimaryKey(primaryKey: string): this;
+    abstract useRegistry(): this;
+    abstract useDebug(): this;
+    abstract useTable(table: string): this;
+    abstract useTablePlural(): this;
+    abstract useTableSingular(): this;
+    abstract useTimestamp(): this;
+    abstract useSoftDelete(): this;
+    abstract usePattern(pattern: string): this;
+    abstract onlyTrashed(): Promise<any>;
+    abstract trashed(): Promise<any>;
+    abstract restore(): Promise<any>;
+    abstract ignoreSoftDelete(): this;
+    abstract disableSoftDelete(): this;
+    abstract registry(func: {
+        [key: string]: Function;
+    }): this;
+    abstract with(...nameRelations: string[]): this;
+    abstract withQuery(nameRelations: string, callback: Function): this;
+    abstract withExists(...nameRelations: string[]): this;
+    abstract hasOne({ name, model, localKey, foreignKey, freezeTable, as }: Relation): this;
+    abstract hasMany({ name, model, localKey, foreignKey, freezeTable, as }: Relation): this;
+    abstract belongsTo({ name, model, localKey, foreignKey, freezeTable, as }: Relation): this;
+    abstract belongsToMany({ name, model, localKey, foreignKey, freezeTable, as }: Relation): this;
+    abstract hasOneQuery({ name, model, localKey, foreignKey, freezeTable, as }: RelationQuery, callback: Function): this;
+    abstract hasManyQuery({ name, model, localKey, foreignKey, freezeTable, as }: RelationQuery, callback: Function): this;
+    abstract belongsToQuery({ name, model, localKey, foreignKey, freezeTable, as }: RelationQuery, callback: Function): this;
+    abstract belongsToManyQuery({ name, model, localKey, foreignKey, freezeTable, as }: RelationQuery, callback: Function): this;
 }
 export { AbstractModel };
 export default AbstractModel;

package/dist/lib/tspace/AbstractModel.js

@@ -1,31 +1,11 @@
 "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 __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AbstractModel = void 0;
-var Database_1 = __importDefault(require("./Database"));
-var AbstractModel = /** @class */ (function (_super) {
-    __extends(AbstractModel, _super);
-    function AbstractModel() {
-        return _super !== null && _super.apply(this, arguments) || this;
-    }
-    return AbstractModel;
-}(Database_1.default));
+const Database_1 = __importDefault(require("./Database"));
+class AbstractModel extends Database_1.default {
+}
 exports.AbstractModel = AbstractModel;
 exports.default = AbstractModel;

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

@@ -1,65 +1,136 @@
 declare class Blueprint {
     protected type: string;
     protected attrbuites: Array<string>;
-    private _addAssignType;
-    private _addAssignAttrbuite;
+    /**
+     * Assign type 'int' in table
+     * @return {this} this
+     */
     int(): this;
     /**
-     * Assign type
-     * @param {number}
+     * Assign type 'TINYINT' in table
+     * @param {number} number
+     * @return {this} this
      */
-    tinyInt(n?: number): this;
+    tinyInt(number?: number): this;
     /**
-     * Assign type
-     * @param {number}
+     * Assign type 'BIGINT' in table
+     * @param {number} number [number = 10]
+     * @return {this} this
      */
-    bigInt(n?: number): this;
+    bigInt(number?: number): this;
     /**
-     * Assign type
+     * Assign type 'DOUBLE' in table
      * @param {number} length  between 1-255
      * @param {number} decimal  0.000...n
+     * @return {this} this
      */
     double(length?: number, decimal?: number): this;
     /**
-     * Assign type
+     * Assign type 'FLOAT' in table
      * @param {number} length  between 1-255
      * @param {number} decimal 0.000...n
+     * @return {this} this
      */
     float(length?: number, decimal?: number): 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
      */
-    varchar(n?: number): this;
+    varchar(length?: number): 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
+     */
+    char(length?: number): this;
+    /**
+     * Assign type 'LONGTEXT' in table
+     * @return {this} this
      */
-    char(n?: number): this;
     longText(): this;
+    /**
+     * Assign type 'MEDIUMTEXT' in table
+     * @param {number} length [length = 1] length of string
+     * @return {this} this
+     */
     mediumText(): this;
+    /**
+     * Assign type 'TINYTEXT' in table
+     * @param {number} length [length = 1] length of string
+     * @return {this} this
+     */
     tinyText(): this;
+    /**
+     * Assign type 'TEXT' in table
+     * @param {number} length [length = 1] length of string
+     * @return {this} this
+     */
     text(): this;
     /**
-     * Assign type
-     * @param {...string} enum n1, n2, n3, ...n
+     * Assign type 'ENUM'
+     * @param {...string} enums n1, n2, n3, ...n
+     * @return {this} this
      */
     enum(...enums: Array<string>): this;
+    /**
+     * Assign type 'DATE' in table
+     * @return {this} this
+     */
     date(): this;
+    /**
+     * Assign type 'DATETIME' in table
+     * @return {this} this
+     */
     dateTime(): this;
+    /**
+     * Assign type 'TIMESTAMP' in table
+     * @return {this} this
+     */
     timestamp(): this;
+    /**
+     * Assign type 'UNSIGNED' in table
+     * @return {this} this
+     */
     unsigned(): this;
+    /**
+     * Assign type 'UNIQUE' in table
+     * @return {this} this
+     */
     unique(): this;
+    /**
+     * Assign type 'NULL' in table
+     * @return {this} this
+     */
     null(): this;
+    /**
+     * Assign type 'NOT NULL' in table
+     * @return {this} this
+     */
     notNull(): this;
+    /**
+     * Assign type 'PRIMARY KEY' in table
+     * @return {this} this
+     */
     primary(): this;
     /**
-     * Assign attrbuites
-     * @param {string | number} default value
+     * Assign attrbuites 'default' in table
+     * @param {string | number} n  default value
+     * @return {this} this
      */
     default(n: string | number): this;
-    defaultTimestamp(): this;
+    /**
+     * Assign attrbuites 'default currentTimestamp' in table
+     * @return {this} this
+     */
+    currentTimestamp(): this;
+    /**
+     * Assign attrbuites 'autoIncrement' in table
+     * @return {this} this
+     */
     autoIncrement(): this;
+    private _addAssignType;
+    private _addAssignAttrbuite;
 }
 export { Blueprint };
 export default Blueprint;