tspace-mysql 1.1.2 → 1.1.4

package/dist/cli/models/model.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 var Model = function (model, npm) {
-    return "import { Model } from '".concat(npm, "'\nclass ").concat(model, " extends Model {\n  constructor(){\n    super()\n    this.useUUID()\n    this.useTimestamp()\n  }\n}\nexport { ").concat(model, " }\nexport default ").concat(model, "\n");
+    return "import { Model } from '".concat(npm, "'\nclass ").concat(model, " extends Model {\n  constructor(){\n    super()\n    /**\n     * \n     * Assign setting global in your model\n     * @useMethod\n     *\n     * this.useDebug() // => runing a uuid (universally unique identifier) when insert new data\n     * this.usePrimaryKey('id') // => runing a uuid (universally unique identifier) when insert new data\n     * this.useTimestamp({ createdAt : 'created_at' , updatedAt : 'updated_at' }) // runing a timestamp when insert or update\n     * this.useSoftDelete()\n     * this.useDisableSoftDeleteInRelations()\n     * this.useTable('Users')\n     * this.useTableSingular()\n     * this.useTablePlural()\n     * this.usePattern('snake_case')   \n     * this.useUUID('uuid')\n     * this.useRegistry()\n    */\n  }\n}\nexport { ").concat(model, " }\nexport default ").concat(model, "\n");
 };
 exports.default = Model;

package/dist/cli/tables/table.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 var Table = function (table, npm) {
-    return "import { Schema , Blueprint , DB } from '".concat(npm, "'\n(async () => {\n    await new Schema().table('").concat(table, "',{ \n        id :  new Blueprint().int().notNull().primary().autoIncrement(),\n        name : new Blueprint().varchar(120).default('my name'),\n        uuid : new Blueprint().varchar(50),\n        email : new Blueprint().varchar(120).unique(),\n        email_verify : new Blueprint().tinyInt(),\n        password : new Blueprint().varchar(120),\n        birthdate : new Blueprint().date(),\n        created_at : new Blueprint().null().timestamp(),\n        updated_at : new Blueprint().null().timestamp()\n    })\n\n    /**\n     * \n     *  @Faker data\n     *  await new DB().table('").concat(table, "').faker(5)\n    */\n})()\n");
+    return "import { Schema , Blueprint , DB } from '".concat(npm, "'\n(async () => {\n    await new Schema().table('").concat(table, "',{ \n        id :  new Blueprint().int().notNull().primary().autoIncrement(),\n        uuid : new Blueprint().varchar(50),\n        name : new Blueprint().varchar(120).default('my name'),\n        email : new Blueprint().varchar(120).unique(),\n        email_verify : new Blueprint().tinyInt(),\n        password : new Blueprint().varchar(120),\n        birthdate : new Blueprint().date(),\n        created_at : new Blueprint().null().timestamp(),\n        updated_at : new Blueprint().null().timestamp()\n    })\n\n    /**\n     * \n     *  @Faker data\n     *  await new DB().table('").concat(table, "').faker(5)\n    */\n})()\n");
 };
 exports.default = Table;

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

@@ -4,5 +4,11 @@ declare const env: Readonly<{
     DB_USERNAME: string | undefined;
     DB_PASSWORD: string | undefined;
     DB_DATABASE: string | undefined;
+    TSPACE_MYSQL_HOST: string | undefined;
+    TSPACE_MYSQL_PORT: string | undefined;
+    TSPACE_MYSQL_USERNAME: string | undefined;
+    TSPACE_MYSQL_PASSWORD: string | undefined;
+    TSPACE_MYSQL_DATABASE: string | undefined;
 }>;
+export { env };
 export default env;

package/dist/lib/config/env.js

@@ -3,6 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.env = void 0;
 var dotenv_1 = __importDefault(require("dotenv"));
 var path_1 = __importDefault(require("path"));
 var fs_1 = __importDefault(require("fs"));
@@ -23,6 +24,12 @@ var env = Object.freeze({
     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_DATABASE: process.env.DB_DATABASE,
+    TSPACE_MYSQL_HOST: process.env.TSPACE_MYSQL_HOST,
+    TSPACE_MYSQL_PORT: process.env.TSPACE_MYSQL_PORT,
+    TSPACE_MYSQL_USERNAME: process.env.TSPACE_MYSQL_USERNAME,
+    TSPACE_MYSQL_PASSWORD: process.env.TSPACE_MYSQL_PASSWORD,
+    TSPACE_MYSQL_DATABASE: process.env.TSPACE_MYSQL_DATABASE
 });
+exports.env = env;
 exports.default = env;

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

@@ -1,7 +1,19 @@
-interface Connection {
+export interface PoolCallback {
+    query: (sql: string, callback: (err: any, result: any) => void) => void;
+    release: () => void;
+}
+export interface ConnectionTransaction {
+    query: (sql: string) => Promise<any[]>;
+    startTransaction: () => Promise<any[]>;
+    commit: () => Promise<any[]>;
+    rollback: () => Promise<any[]>;
+}
+export interface Connection {
     query: (sql: string) => Promise<any[]>;
+    connection: () => Promise<ConnectionTransaction>;
 }
-interface Options {
+export interface Options {
+    [key: string]: any;
     connectionLimit?: number;
     dateStrings?: boolean;
     waitForConnections?: boolean;
@@ -12,16 +24,25 @@ interface Options {
     user: string;
     password: string;
 }
-declare class PoolConnection {
-    [x: string]: any;
+export declare class PoolConnection {
     private OPTIONS;
     constructor(options?: Options);
-    private _pool;
-    private _messageError;
-    connection(): Connection;
+    /**
+     *
+     * Set a options connection pool
+     * @return {this} this
+     */
     options(options: Options): this;
+    /**
+     *
+     * Get a connection pool
+     * @return {Connection} Connection
+     */
+    connection(): Connection;
+    private _defaultOptions;
+    private _getJsonOptions;
+    private _messageError;
 }
 declare const Pool: Connection;
 export { Pool };
-export { PoolConnection };
 export default Pool;

package/dist/lib/connection/index.js

@@ -14,46 +14,45 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.PoolConnection = exports.Pool = void 0;
+exports.Pool = exports.PoolConnection = void 0;
+var fs_1 = __importDefault(require("fs"));
+var path_1 = __importDefault(require("path"));
+var env_1 = require("../config/env");
 var mysql_1 = require("mysql");
-var env_1 = __importDefault(require("../config/env"));
 var PoolConnection = /** @class */ (function () {
     function PoolConnection(options) {
-        this.OPTIONS = new Map(Object.entries({
-            connectionLimit: 10,
-            dateStrings: true,
-            waitForConnections: false,
-            charset: 'utf8mb4',
-            host: String(env_1.default.DB_HOST),
-            port: Number.isNaN(Number(env_1.default.DB_PORT))
-                ? 3306
-                : Number(env_1.default.DB_PORT),
-            database: String(env_1.default.DB_DATABASE),
-            user: String(env_1.default.DB_USERNAME),
-            password: String(env_1.default.DB_PASSWORD)
-        }));
+        this.OPTIONS = this._getJsonOptions();
         if (options) {
             this.OPTIONS = new Map(Object.entries(__assign(__assign({}, Object.fromEntries(this.OPTIONS)), JSON.parse(JSON.stringify(options)))));
         }
     }
-    PoolConnection.prototype._pool = function () {
-        return (0, mysql_1.createPool)(Object.fromEntries(this.OPTIONS));
-    };
-    PoolConnection.prototype._messageError = function () {
-        console.log("\u001B[1m\u001B[31m\n            Connection lost to database ! \u001B[0m\n            ------------------------------- \u001B[33m\n                DB_HOST     : ".concat(this.OPTIONS.get('host'), "         \n                DB_PORT     : ").concat(this.OPTIONS.get('port'), "        \n                DB_DATABASE : ").concat(this.OPTIONS.get('database'), " \n                DB_USERNAME : ").concat(this.OPTIONS.get('user'), "          \n                DB_PASSWORD : ").concat(this.OPTIONS.get('password'), " \u001B[0m  \n            -------------------------------\n            "));
-        return;
+    /**
+     *
+     * Set a options connection pool
+     * @return {this} this
+     */
+    PoolConnection.prototype.options = function (options) {
+        this.OPTIONS = new Map(Object.entries(options));
+        return this;
     };
+    /**
+     *
+     * Get a connection pool
+     * @return {Connection} Connection
+     */
     PoolConnection.prototype.connection = function () {
         var _this = this;
-        var pool = this._pool();
+        var pool = (0, mysql_1.createPool)(Object.fromEntries(this.OPTIONS));
         pool.getConnection(function (err, connection) {
             if (err) {
-                _this._messageError();
-                return process.exit();
+                var message_1 = _this._messageError.bind(_this);
+                process.nextTick(function () {
+                    console.log(message_1());
+                    return process.exit();
+                });
             }
             if (connection)
                 connection.release();
-            return;
         });
         return {
             query: function (sql) {
@@ -64,12 +63,70 @@ var PoolConnection = /** @class */ (function () {
                         return resolve(results);
                     });
                 });
+            },
+            connection: function () {
+                return new Promise(function (resolve, reject) {
+                    pool.getConnection(function (err, connection) {
+                        if (err)
+                            return reject(err);
+                        var query = function (sql) {
+                            return new Promise(function (resolve, reject) {
+                                connection.query(sql, function (err, result) {
+                                    if (err)
+                                        return reject(err);
+                                    return resolve(result);
+                                });
+                            });
+                        };
+                        var startTransaction = function () { return query('START TRANSACTION'); };
+                        var commit = function () { return query('COMMIT'); };
+                        var rollback = function () { return query('ROLLBACK'); };
+                        return resolve({
+                            query: query,
+                            startTransaction: startTransaction,
+                            commit: commit,
+                            rollback: rollback
+                        });
+                    });
+                });
             }
         };
     };
-    PoolConnection.prototype.options = function (options) {
-        this.OPTIONS = new Map(Object.entries(options));
-        return this;
+    PoolConnection.prototype._defaultOptions = function () {
+        var _a, _b, _c, _d, _e, _f;
+        return new Map(Object.entries({
+            connectionLimit: 10,
+            dateStrings: true,
+            connectTimeout: 1000 * 30,
+            acquireTimeout: 1000 * 30,
+            waitForConnections: false,
+            charset: 'utf8mb4',
+            host: String((_a = env_1.env.DB_HOST) !== null && _a !== void 0 ? _a : env_1.env.TSPACE_MYSQL_HOST),
+            port: Number.isNaN(Number((_b = env_1.env.DB_PORT) !== null && _b !== void 0 ? _b : env_1.env.TSPACE_MYSQL_PORT))
+                ? 3306
+                : Number((_c = env_1.env.DB_PORT) !== null && _c !== void 0 ? _c : env_1.env.TSPACE_MYSQL_PORT),
+            database: String((_d = env_1.env.DB_DATABASE) !== null && _d !== void 0 ? _d : env_1.env.TSPACE_MYSQL_DATABASE),
+            user: String((_e = env_1.env.DB_USERNAME) !== null && _e !== void 0 ? _e : env_1.env.TSPACE_MYSQL_USERNAME),
+            password: String((_f = env_1.env.DB_PASSWORD) !== null && _f !== void 0 ? _f : env_1.env.TSPACE_MYSQL_PASSWORD)
+        }));
+    };
+    PoolConnection.prototype._getJsonOptions = function () {
+        try {
+            var jsonPath = path_1.default.join(path_1.default.resolve(), 'tspace-mysql.json');
+            var jsonOptionsExists = fs_1.default.existsSync(jsonPath);
+            if (jsonOptionsExists) {
+                var jsonOptions = fs_1.default.readFileSync(jsonPath, 'utf8');
+                var options = JSON.parse(jsonOptions);
+                return new Map(Object.entries(options));
+            }
+            return this._defaultOptions();
+        }
+        catch (e) {
+            return this._defaultOptions();
+        }
+    };
+    PoolConnection.prototype._messageError = function () {
+        return "\n            \u001B[1m\u001B[31m\n            Connection lost to database ! \u001B[0m\n            --------------------------------- \u001B[33m\n                DB_HOST     : ".concat(this.OPTIONS.get('host'), "         \n                DB_PORT     : ").concat(this.OPTIONS.get('port'), "        \n                DB_DATABASE : ").concat(this.OPTIONS.get('database'), " \n                DB_USERNAME : ").concat(this.OPTIONS.get('user'), "          \n                DB_PASSWORD : ").concat(this.OPTIONS.get('password'), " \u001B[0m  \n            ---------------------------------\n        ");
     };
     return PoolConnection;
 }());

package/dist/lib/constants/index.js

@@ -43,6 +43,12 @@ var constant = {
     NOT: 'NOT',
     DUPLICATE: 'DUPLICATE',
     KEY: 'KEY',
+    RAW: 'RAW',
+    WHEN: 'WHEN',
+    THEN: 'THEN',
+    ELSE: 'ELSE',
+    CASE: 'CASE',
+    END: 'END',
     WHERE_NOT_EXISTS: 'WHERE NOT EXISTS',
     EXISTS: 'EXISTS',
     VALUES: 'VALUES',
@@ -67,10 +73,7 @@ var constant = {
         camelCase: 'camelCase'
     },
     DB: {
-        TRANSACTION: { query: [{
-                    table: '',
-                    id: ''
-                }] },
+        PRIMARY_KEY: 'id',
         RESULT: null,
         DISTINCT: '',
         PLUCK: '',
@@ -100,10 +103,6 @@ var constant = {
         PER_PAGE: 1
     },
     MODEL: {
-        TRANSACTION: { query: [{
-                    table: '',
-                    id: ''
-                }] },
         PRIMARY_KEY: 'id',
         SELECT: '',
         DELETE: '',
@@ -132,6 +131,7 @@ var constant = {
         DEBUG: false,
         UUID: false,
         SOFT_DELETE: false,
+        SOFT_DELETE_FORMAT: 'deleted_at',
         SOFT_DELETE_RELATIONS: false,
         RELATION: [],
         WITH: [],
@@ -148,3 +148,4 @@ var constant = {
     }
 };
 exports.default = Object.freeze(constant);
+// export default constant

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"));
 __exportStar(require("./tspace"), exports);
 exports.default = tspace;

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

@@ -14,18 +14,18 @@ var AbstractDatabase = /** @class */ (function () {
         this.$constants = function (name) { };
         this.$db = {
             get: function (key) { },
-            set: function (key, value) { }
+            set: function (key, value) { },
+            clone: function (data) { }
         };
         this.$pool = {
             get: function (sql) { },
-            set: function (pool) { }
+            set: function (pool) { },
+            load: function () { }
         };
         this.$logger = {
             get: function () { },
             set: function (value) { },
-            check: function (value) {
-                return true || false;
-            }
+            check: function (value) { return true || false; }
         };
         this.$attributes = {};
     }

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/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;