tspace-mysql 1.8.2 → 1.8.4

package/build/lib/core/StoredProcedure.d.ts

@@ -0,0 +1,120 @@
+import type { TStoreProcedure } from "../types";
+/**
+ *
+ * 'StoredProcedure' is a predefined set of SQL statements stored in the database that you can call (execute) by name.
+ * @generic {Type} TS
+ * @generic {Type} TR
+ * @example
+    import { StoredProcedure } from 'tspace-mysql'
+
+    type T = {
+        AddUser: {
+            params: {
+                name : string;
+                email: string;
+            } | [string,string];
+            result: {
+                fieldCount: number;
+                affectedRows: number;
+                insertId: number;
+                info: string;
+                serverStatus: number;
+                warningStatus: number;
+                changedRows: number;
+            }
+        };
+        GetUser: {
+            params: [number];
+            result: any[]
+        },
+        GetUsers: {
+            params: [];
+            result: any[]
+        }
+    };
+
+    class MyStore extends StoredProcedure<T> {
+        protected boot(): void {
+
+            this.createProcedure({
+                name: 'AddUser',
+                expression: `
+                    CREATE PROCEDURE AddUser(IN name VARCHAR(255), IN email VARCHAR(255))
+                    BEGIN
+                    INSERT INTO users (name, email) VALUES (name, email);
+                    END;
+                `,
+                synchronize: true
+            });
+
+            this.createProcedure({
+                name: 'GetUsers',
+                expression: `
+                    CREATE PROCEDURE GetUsers()
+                    BEGIN
+                    SELECT * FROM users LIMIT 5;
+                    END;
+                `,
+                synchronize: true
+            });
+
+            this.createProcedure({
+                name: 'GetUser',
+                expression: `
+                    CREATE PROCEDURE GetUser(IN userId INT)
+                    BEGIN
+                    SELECT * FROM users WHERE id = userId LIMIT 1;
+                    END;
+                `,
+                synchronize: true
+            })
+        }
+    }
+
+    const storeProcedure = new MyStoredProcedure()
+
+    storeProcedure.call('AddUser', { name : 'tspace-mysql' , email : 'tspace-mysql@example.com'})
+    .then(r => console.log(r))
+    .catch(e => console.log(e))
+
+    storeProcedure.call('GetUser',[1])
+    .then(r => console.log(r))
+    .catch(e => console.log(e))
+
+    storeProcedure.call('GetUsers',[])
+    .then(r => console.log(r))
+    .catch(e => console.log(e))
+ */
+declare class StoredProcedure<T extends Record<string, TStoreProcedure>> {
+    private APPLY_STORED;
+    constructor();
+    /**
+     * The 'boot' method is a special method that you can define within a store procedure.
+     * @returns {void} void
+     */
+    protected boot(): void;
+    /**
+     * The 'createProcedure' method is used create store procedure.
+     *
+     * @param    {object}   object { name, expression, synchronize }
+     * @property {string?}  object.name
+     * @property {string}   object.expression
+     * @property {boolean}  object.synchronize
+     * @returns  {void}
+     */
+    protected createProcedure({ name, expression, synchronize }: {
+        name: keyof T & string;
+        expression: string;
+        synchronize?: boolean;
+    }): void;
+    /**
+     * The 'call' method is used create store procedure.
+     *
+     * @param    {string}       name
+     * @param    {object|array} params
+     * @returns  {Promise<any>}
+     */
+    call<K extends keyof T>(name: K, params: T[K]['params']): Promise<T[K]['result']>;
+}
+export { StoredProcedure };
+export default StoredProcedure;

package/build/lib/core/StoredProcedure.js

@@ -0,0 +1,161 @@
+"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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StoredProcedure = void 0;
+const DB_1 = require("./DB");
+/**
+ *
+ * 'StoredProcedure' is a predefined set of SQL statements stored in the database that you can call (execute) by name.
+ * @generic {Type} TS
+ * @generic {Type} TR
+ * @example
+    import { StoredProcedure } from 'tspace-mysql'
+
+    type T = {
+        AddUser: {
+            params: {
+                name : string;
+                email: string;
+            } | [string,string];
+            result: {
+                fieldCount: number;
+                affectedRows: number;
+                insertId: number;
+                info: string;
+                serverStatus: number;
+                warningStatus: number;
+                changedRows: number;
+            }
+        };
+        GetUser: {
+            params: [number];
+            result: any[]
+        },
+        GetUsers: {
+            params: [];
+            result: any[]
+        }
+    };
+
+    class MyStore extends StoredProcedure<T> {
+        protected boot(): void {
+
+            this.createProcedure({
+                name: 'AddUser',
+                expression: `
+                    CREATE PROCEDURE AddUser(IN name VARCHAR(255), IN email VARCHAR(255))
+                    BEGIN
+                    INSERT INTO users (name, email) VALUES (name, email);
+                    END;
+                `,
+                synchronize: true
+            });
+
+            this.createProcedure({
+                name: 'GetUsers',
+                expression: `
+                    CREATE PROCEDURE GetUsers()
+                    BEGIN
+                    SELECT * FROM users LIMIT 5;
+                    END;
+                `,
+                synchronize: true
+            });
+
+            this.createProcedure({
+                name: 'GetUser',
+                expression: `
+                    CREATE PROCEDURE GetUser(IN userId INT)
+                    BEGIN
+                    SELECT * FROM users WHERE id = userId LIMIT 1;
+                    END;
+                `,
+                synchronize: true
+            })
+        }
+    }
+
+    const storeProcedure = new MyStoredProcedure()
+
+    storeProcedure.call('AddUser', { name : 'tspace-mysql' , email : 'tspace-mysql@example.com'})
+    .then(r => console.log(r))
+    .catch(e => console.log(e))
+
+    storeProcedure.call('GetUser',[1])
+    .then(r => console.log(r))
+    .catch(e => console.log(e))
+
+    storeProcedure.call('GetUsers',[])
+    .then(r => console.log(r))
+    .catch(e => console.log(e))
+ */
+class StoredProcedure {
+    constructor() {
+        this.APPLY_STORED = new Map();
+        this.boot();
+    }
+    /**
+     * The 'boot' method is a special method that you can define within a store procedure.
+     * @returns {void} void
+     */
+    boot() { }
+    /**
+     * The 'createProcedure' method is used create store procedure.
+     *
+     * @param    {object}   object { name, expression, synchronize }
+     * @property {string?}  object.name
+     * @property {string}   object.expression
+     * @property {boolean}  object.synchronize
+     * @returns  {void}
+     */
+    createProcedure({ name, expression, synchronize }) {
+        const fn = () => __awaiter(this, void 0, void 0, function* () {
+            if (synchronize) {
+                yield DB_1.DB.query(`DROP PROCEDURE IF EXISTS ${name}`);
+            }
+            yield DB_1.DB.query(expression)
+                .catch(err => {
+                const message = err.message;
+                const exists = String(message).includes(`PROCEDURE ${name} already exists`);
+                if (exists)
+                    return;
+                console.log(`\n\x1b[31mFAIL QUERY:\x1b[0m \x1b[33m${expression.trim()};\x1b[0m`);
+                throw err;
+            });
+        });
+        this.APPLY_STORED.set(name, fn);
+    }
+    /**
+     * The 'call' method is used create store procedure.
+     *
+     * @param    {string}       name
+     * @param    {object|array} params
+     * @returns  {Promise<any>}
+     */
+    call(name, params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const storeProcedure = this.APPLY_STORED.get(name);
+            if (!storeProcedure)
+                throw new Error(`Stored procedure "${String(name)}" not registered.`);
+            yield storeProcedure();
+            const placeholders = Object.keys(params).map(key => `:${key}`);
+            const sql = `CALL ${String(name)}(${placeholders.join(', ')})`;
+            const result = yield DB_1.DB.query(sql, params);
+            if (Array.isArray(result) && Array.isArray(result[0])) {
+                return result[0];
+            }
+            return result;
+        });
+    }
+}
+exports.StoredProcedure = StoredProcedure;
+exports.default = StoredProcedure;
+//# sourceMappingURL=StoredProcedure.js.map

package/build/lib/core/StoredProcedure.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"StoredProcedure.js","sourceRoot":"","sources":["../../../src/lib/core/StoredProcedure.ts"],"names":[],"mappings":";;;;;;;;;;;;AAAA,6BAA2B;AAK3B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqFG;AACH,MAAM,eAAe;IAIjB;QAFQ,iBAAY,GAAqC,IAAI,GAAG,EAAE,CAAC;QAG/D,IAAI,CAAC,IAAI,EAAE,CAAA;IACf,CAAC;IAED;;;OAGG;IACO,IAAI,KAAU,CAAC;IAEzB;;;;;;;;OAQG;IACO,eAAe,CAAC,EAAE,IAAI,EAAE,UAAU,EAAE,WAAW,EAIxD;QACG,MAAM,EAAE,GAAG,GAAS,EAAE;YAElB,IAAI,WAAW,EAAE,CAAC;gBACd,MAAM,OAAE,CAAC,KAAK,CAAC,4BAA4B,IAAI,EAAE,CAAC,CAAC;YACvD,CAAC;YAED,MAAM,OAAE,CAAC,KAAK,CAAC,UAAU,CAAC;iBACzB,KAAK,CAAC,GAAG,CAAC,EAAE;gBACT,MAAM,OAAO,GAAG,GAAG,CAAC,OAAO,CAAA;gBAE3B,MAAM,MAAM,GAAG,MAAM,CAAC,OAAO,CAAC,CAAC,QAAQ,CAAC,aAAa,IAAI,iBAAiB,CAAC,CAAA;gBAE3E,IAAG,MAAM;oBAAE,OAAO;gBAElB,OAAO,CAAC,GAAG,CAAC,wCAAwC,UAAU,CAAC,IAAI,EAAE,UAAU,CAAC,CAAA;gBAEhF,MAAM,GAAG,CAAA;YAEb,CAAC,CAAC,CAAA;QACN,CAAC,CAAA,CAAC;QAEF,IAAI,CAAC,YAAY,CAAC,GAAG,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC;IACpC,CAAC;IAED;;;;;;OAMG;IACU,IAAI,CACb,IAAO,EACP,MAAsB;;YAGtB,MAAM,cAAc,GAAG,IAAI,CAAC,YAAY,CAAC,GAAG,CAAC,IAAc,CAAC,CAAC;YAE7D,IAAI,CAAC,cAAc;gBAAE,MAAM,IAAI,KAAK,CAAC,qBAAqB,MAAM,CAAC,IAAI,CAAC,mBAAmB,CAAC,CAAC;YAE3F,MAAM,cAAc,EAAE,CAAC;YAEvB,MAAM,YAAY,GAAa,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,CAAC,IAAI,GAAG,EAAE,CAAC,CAAC;YAEzE,MAAM,GAAG,GAAG,QAAQ,MAAM,CAAC,IAAI,CAAC,IAAI,YAAY,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC;YAE/D,MAAM,MAAM,GAAG,MAAM,OAAE,CAAC,KAAK,CAAC,GAAG,EAAC,MAAM,CAAC,CAAC;YAE1C,IAAI,KAAK,CAAC,OAAO,CAAC,MAAM,CAAC,IAAI,KAAK,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC;gBACpD,OAAO,MAAM,CAAC,CAAC,CAAmB,CAAC;YACvC,CAAC;YAED,OAAO,MAAwB,CAAC;QACpC,CAAC;KAAA;CACJ;AAEQ,0CAAe;AACxB,kBAAe,eAAe,CAAC"}

package/build/lib/core/UtilityTypes.d.ts

@@ -1,14 +1,14 @@
-import { TPagination, TRelationResults, TRepositoryRequest } from "../types";
 import { Blueprint } from "./Blueprint";
 import { Model } from "./Model";
 import { Repository } from "./Repository";
+import type { TPagination, TRelationResults, TRepositoryRequest } from "../types";
 /**
  * The 'TSchemaStrict' type is used to specify the type of the schema.
  *
  * @param {type} T typeof the schema
  * @param {type} S override type in the schema
  * @example
- * import { Blueprint , TSchema , Model } from 'tspace-mysql'
+ * import { Blueprint, TSchema, Model, Schema } from 'tspace-mysql';
  * const schemaUser = {
  *    id :new Blueprint().int().notNull().primary().autoIncrement(),
  *    uuid :new Blueprint().varchar(50).null(),
@@ -212,24 +212,6 @@ export type RelationType<R> = {
  *
  */
 export type TSchemaModel<M extends Model> = ReturnType<M['typeOfSchema']>;
-/**
- * The 'SchemaModelType' type is used to get type of schema in the model
- * @generic {Model} M Model
- * @example
- * import { TSchemaModel } from 'tspace-mysql'
- * import { User } from '../Models/User'
- *
- *  type TSchemaModelOfUser = TSchemaModel<User>
- *   // now you can see the schema like that
- *   {
- *       id : number,
- *       uuid : string | null,
- *       name : string
- *       // ....
- *   }
- *
- */
-export type SchemaModelType<M extends Model> = ReturnType<M['typeOfSchema']>;
 /**
  * The 'TRelationModel' type is used to get type of schema in the model
  * @generic {Model} M Model
@@ -247,30 +229,7 @@ export type SchemaModelType<M extends Model> = ReturnType<M['typeOfSchema']>;
  *   }
  *
  */
-export type RelationModelType<M extends Model> = ReturnType<M['typeOfRelation']>;
-/**
- * The 'RelationModelType' type is used to get type of schema in the model
- * @generic {Model} M Model
- * @example
- * import { RelationModelType } from 'tspace-mysql'
- * import { User } from '../Models/User
- *
- *  type TRelationModelOfUser = TRelationModel<User>
- *
- *   {
- *       phone : {
- *          id : number,
- *          // ....
- *       }
- *   }
- *
- */
 export type TRelationModel<M extends Model> = ReturnType<M['typeOfRelation']>;
-/**
- * The 'TRepository' type is used to get type of repository
- * @generic {Model} M Model
- */
-export type TRepository<M extends Model> = TRepositoryRequest<TSchemaModel<M>, TRelationModel<M>>;
 /**
  * The 'TResult' type is used to get type of result from model
  * @generic {Model} M Model
@@ -281,11 +240,16 @@ export type TResult<M extends Model> = TRelationResults<TRelationModel<M>> & TSc
  * @generic {Model} M Model
  */
 export type TResultPaginate<M extends Model> = TPagination<TRelationResults<TRelationModel<M>> & TSchemaModel<M>>;
+/**
+ * The 'TRepository' type is used to get type of repository
+ * @generic {Model} M Model
+ */
+export type TRepository<M extends Model> = TRepositoryRequest<TSchemaModel<M>, TRelationModel<M>>;
 /**
  * The 'TypeOfRepository' type is used to return typeof repository
  * @generic {Model} M Model
  */
-export type TypeOfRepository<M extends Model> = ReturnType<typeof Repository<M>>;
+export type TRepositoryTypeOf<M extends Model> = ReturnType<typeof Repository<M>>;
 /**
  * The 'TSchemaKeyOf' type is used to get keyof type TSchemaModel<Model>
  * @generic {Model} M Model
@@ -295,3 +259,20 @@ export type TSchemaKeyOf<M extends Model, T = TSchemaModel<M>> = keyof {
 } extends never ? string : keyof {
     [K in keyof T as string extends K ? never : K]: T[K];
 };
+export declare namespace T {
+    type Schema<T, S = {}> = TSchema<T, S>;
+    type SchemaStrict<T, S = {}> = TSchemaStrict<T, S>;
+    type SchemaModel<M extends Model> = TSchemaModel<M>;
+    type KeyOf<M extends Model> = TSchemaKeyOf<M>;
+    type Column<M extends Model> = TSchemaKeyOf<M>;
+    type Relation<R> = TRelation<R>;
+    type RelationModel<M extends Model> = TRelationModel<M>;
+    type Repository<M extends Model> = TRepository<M>;
+    type RepositoryTypeOf<M extends Model> = TRepositoryTypeOf<M>;
+    type Result<M extends Model, Opts extends {
+        paginate?: boolean;
+    } = {}> = Opts['paginate'] extends true ? TResultPaginate<M> : TResult<M>;
+    type Results<M extends Model, Opts extends {
+        paginate?: boolean;
+    } = {}> = Opts['paginate'] extends true ? TResultPaginate<M> : TResult<M>;
+}

package/build/lib/core/View.d.ts

@@ -0,0 +1,96 @@
+import { AbstractView } from "./Abstracts/AbstractView";
+/**
+ *
+ * 'View' class represents a database view, similar to a table, but based on a stored SQL query.
+ * @generic {Type} TS
+ * @generic {Type} TR
+ * @example
+    import { type T, Blueprint, Model , View , Meta } from 'tspace-mysql'
+
+    const schemaUser = {
+        id: Blueprint.int().notNull().primary().autoIncrement(),
+        uuid: Blueprint.varchar(50).null().index(),
+        name: Blueprint.varchar(191).notNull(),
+        email: Blueprint.varchar(191).notNull()
+    }
+
+    type TUser = T.Schema<typeof schemaUser>
+
+    class User extends Model<TUser> {
+        protected boot(): void {
+            this.useCamelCase()
+            this.useSchema(schemaUser)
+        }
+    }
+
+    const schemaPost = {
+        id: Blueprint.int().notNull().primary().autoIncrement(),
+        uuid: Blueprint.varchar(50).null().index(),
+        userId :Blueprint.int().notnull(),
+        title: Blueprint.varchar(191).notNull(),
+        content: Blueprint.varchar(191).notNull()
+    }
+
+    type TPost = T.Schema<typeof schemaPost>
+
+    class Post extends Model<TPost> {
+        protected boot(): void {
+        this.useSchema(schemaPost)
+        }
+    }
+
+    const schemaUserPostCountView = {
+        id :Blueprint.int().notNull().primary().autoIncrement(),
+        userId :Blueprint.int().notnull(),
+        name :Blueprint.varchar(255).null(),
+        postCount : Blueprint.int().notnull()
+    }
+
+    type TSUserPostCountView = T.Schema<typeof schemaUserPostCountView>
+    type TRUserPostCountView = T.Relation<{
+        user: User
+    }>
+
+    class UserPostCountView extends View<TSUserPostCountView,TRUserPostCountView> {
+        protected boot(): void {
+            this.useCamelCase()
+            this.useSchema(schemaUserPostCountView)
+            const metaUser = Meta(User)
+            const metaPost = Meta(Post)
+
+            this.createView({
+                synchronize: true,
+                expression : new User()
+                .selectRaw(`ROW_NUMBER() OVER (ORDER BY ${metaUser.columnRef('id')}) AS id`)
+                .selectRaw(`${metaUser.columnRef('id')} AS userId`)
+                .selectRaw(metaUser.columnRef('name'))
+                .select(metaUser.columnRef('email'))
+                .selectRaw(`COUNT(${metaPost.columnRef('id')}) AS postCount`)
+                .leftJoin(metaUser.columnRef('id'),metaPost.columnRef('userId'))
+                .groupBy(metaUser.columnRef('id'))
+                .groupBy(metaUser.columnRef('name'))
+                .toString()
+            })
+
+            this.belongsTo({ name : 'user' , model : User })
+        }
+    }
+ */
+declare class View<TS extends Record<string, any> = any, TR = unknown> extends AbstractView<TS, TR> {
+    /**
+     * The 'createView' method is used create table and stored SQL query.
+     *
+     * @param    {object}   object { name, expression, synchronize }
+     * @property {string?}  object.name
+     * @property {string}   object.expression
+     * @property {boolean}  object.synchronize
+     * @returns  {void}
+     */
+    protected createView({ name, expression, synchronize }: {
+        name?: string;
+        expression: string;
+        synchronize?: boolean;
+    }): void;
+}
+export { View };
+export default View;

package/build/lib/core/View.js

@@ -0,0 +1,141 @@
+"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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.View = void 0;
+const DB_1 = require("./DB");
+const AbstractView_1 = require("./Abstracts/AbstractView");
+/**
+ *
+ * 'View' class represents a database view, similar to a table, but based on a stored SQL query.
+ * @generic {Type} TS
+ * @generic {Type} TR
+ * @example
+    import { type T, Blueprint, Model , View , Meta } from 'tspace-mysql'
+
+    const schemaUser = {
+        id: Blueprint.int().notNull().primary().autoIncrement(),
+        uuid: Blueprint.varchar(50).null().index(),
+        name: Blueprint.varchar(191).notNull(),
+        email: Blueprint.varchar(191).notNull()
+    }
+
+    type TUser = T.Schema<typeof schemaUser>
+
+    class User extends Model<TUser> {
+        protected boot(): void {
+            this.useCamelCase()
+            this.useSchema(schemaUser)
+        }
+    }
+
+    const schemaPost = {
+        id: Blueprint.int().notNull().primary().autoIncrement(),
+        uuid: Blueprint.varchar(50).null().index(),
+        userId :Blueprint.int().notnull(),
+        title: Blueprint.varchar(191).notNull(),
+        content: Blueprint.varchar(191).notNull()
+    }
+
+    type TPost = T.Schema<typeof schemaPost>
+
+    class Post extends Model<TPost> {
+        protected boot(): void {
+        this.useSchema(schemaPost)
+        }
+    }
+
+    const schemaUserPostCountView = {
+        id :Blueprint.int().notNull().primary().autoIncrement(),
+        userId :Blueprint.int().notnull(),
+        name :Blueprint.varchar(255).null(),
+        postCount : Blueprint.int().notnull()
+    }
+
+    type TSUserPostCountView = T.Schema<typeof schemaUserPostCountView>
+    type TRUserPostCountView = T.Relation<{
+        user: User
+    }>
+
+    class UserPostCountView extends View<TSUserPostCountView,TRUserPostCountView> {
+        protected boot(): void {
+            this.useCamelCase()
+            this.useSchema(schemaUserPostCountView)
+            const metaUser = Meta(User)
+            const metaPost = Meta(Post)
+
+            this.createView({
+                synchronize: true,
+                expression : new User()
+                .selectRaw(`ROW_NUMBER() OVER (ORDER BY ${metaUser.columnRef('id')}) AS id`)
+                .selectRaw(`${metaUser.columnRef('id')} AS userId`)
+                .selectRaw(metaUser.columnRef('name'))
+                .select(metaUser.columnRef('email'))
+                .selectRaw(`COUNT(${metaPost.columnRef('id')}) AS postCount`)
+                .leftJoin(metaUser.columnRef('id'),metaPost.columnRef('userId'))
+                .groupBy(metaUser.columnRef('id'))
+                .groupBy(metaUser.columnRef('name'))
+                .toString()
+            })
+
+            this.belongsTo({ name : 'user' , model : User })
+        }
+    }
+ */
+class View extends AbstractView_1.AbstractView {
+    /**
+     * The 'createView' method is used create table and stored SQL query.
+     *
+     * @param    {object}   object { name, expression, synchronize }
+     * @property {string?}  object.name
+     * @property {string}   object.expression
+     * @property {boolean}  object.synchronize
+     * @returns  {void}
+     */
+    createView({ name, expression, synchronize }) {
+        const baseViewName = this._classToTableName();
+        const patternViewName = this._valuePattern(baseViewName);
+        const viewName = name !== null && name !== void 0 ? name : patternViewName;
+        let sql = expression;
+        const fn = () => __awaiter(this, void 0, void 0, function* () {
+            try {
+                if (synchronize) {
+                    const dropViewSQL = `${this.$constants('DROP_VIEW')} ${viewName} `;
+                    yield DB_1.DB
+                        .query(dropViewSQL)
+                        .catch(err => {
+                        sql = dropViewSQL;
+                        throw err;
+                    });
+                }
+                const createViewSQL = `${this.$constants('CREATE_VIEW')} ${viewName} ${this.$constants('AS')} ${expression}`;
+                yield DB_1.DB
+                    .query(createViewSQL)
+                    .catch(err => {
+                    sql = createViewSQL;
+                    throw err;
+                });
+            }
+            catch (err) {
+                const message = err.message;
+                const exists = String(message).includes(`Table '${viewName}' already exists`);
+                if (exists)
+                    return;
+                console.log(`\n\x1b[31mFAIL QUERY:\x1b[0m \x1b[33m${sql.trim()};\x1b[0m`);
+                throw err;
+            }
+        });
+        this.table(viewName);
+        this.useMiddleware(fn);
+    }
+}
+exports.View = View;
+exports.default = View;
+//# sourceMappingURL=View.js.map

package/build/lib/core/View.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"View.js","sourceRoot":"","sources":["../../../src/lib/core/View.ts"],"names":[],"mappings":";;;;;;;;;;;;AAAA,6BAAoC;AACpC,2DAAwD;AAExD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4EG;AACH,MAAM,IAAwD,SAAQ,2BAAmB;IAErF;;;;;;;;OAQG;IACO,UAAU,CAAC,EAAE,IAAI,EAAE,UAAU,EAAE,WAAW,EAIlD;QACE,MAAM,YAAY,GAAG,IAAI,CAAC,iBAAiB,EAAE,CAAC;QAC9C,MAAM,eAAe,GAAG,IAAI,CAAC,aAAa,CAAC,YAAY,CAAC,CAAC;QACzD,MAAM,QAAQ,GAAG,IAAI,aAAJ,IAAI,cAAJ,IAAI,GAAI,eAAe,CAAC;QACzC,IAAI,GAAG,GAAG,UAAU,CAAC;QAErB,MAAM,EAAE,GAAG,GAAS,EAAE;YAClB,IAAI,CAAC;gBAED,IAAG,WAAW,EAAE,CAAC;oBACb,MAAM,WAAW,GAAG,GAAG,IAAI,CAAC,UAAU,CAAC,WAAW,CAAC,IAAI,QAAQ,GAAG,CAAC;oBACnE,MAAM,OAAE;yBACP,KAAK,CAAC,WAAW,CAAC;yBAClB,KAAK,CAAC,GAAG,CAAC,EAAE;wBACT,GAAG,GAAG,WAAW,CAAA;wBACjB,MAAM,GAAG,CAAA;oBACb,CAAC,CAAC,CAAA;gBACN,CAAC;gBAED,MAAM,aAAa,GAAG,GAAG,IAAI,CAAC,UAAU,CAAC,aAAa,CAAC,IAAI,QAAQ,IAAI,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,IAAI,UAAU,EAAE,CAAC;gBAE7G,MAAM,OAAE;qBACP,KAAK,CAAC,aAAa,CAAC;qBACpB,KAAK,CAAC,GAAG,CAAC,EAAE;oBACT,GAAG,GAAG,aAAa,CAAA;oBACnB,MAAM,GAAG,CAAA;gBACb,CAAC,CAAC,CAAA;YAEN,CAAC;YAAC,OAAO,GAAO,EAAE,CAAC;gBACf,MAAM,OAAO,GAAG,GAAG,CAAC,OAAO,CAAA;gBAC3B,MAAM,MAAM,GAAG,MAAM,CAAC,OAAO,CAAC,CAAC,QAAQ,CAAC,UAAU,QAAQ,kBAAkB,CAAC,CAAA;gBAE7E,IAAG,MAAM;oBAAE,OAAO;gBAElB,OAAO,CAAC,GAAG,CAAC,wCAAwC,GAAG,CAAC,IAAI,EAAE,UAAU,CAAC,CAAA;gBAEzE,MAAM,GAAG,CAAA;YACb,CAAC;QAEL,CAAC,CAAA,CAAA;QAED,IAAI,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAC;QACrB,IAAI,CAAC,aAAa,CAAC,EAAE,CAAC,CAAC;IAC3B,CAAC;CACJ;AAEQ,oBAAI;AACb,kBAAe,IAAI,CAAC"}

package/build/lib/core/index.d.ts

@@ -1,20 +1,25 @@
-import DB from './DB';
-import Model from './Model';
-import Schema from './Schema';
-import Blueprint from './Blueprint';
-import Pool from '../connection';
-import sql from './SqlLike';
+import DB from "./DB";
+import Model from "./Model";
+import Schema from "./Schema";
+import Blueprint from "./Blueprint";
+import Pool from "./Pool";
+import sql from "./SqlLike";
+import Meta from "./Meta";
+import View from './View';
+export { View };
+export { Meta };
 export { sql };
 export { DB };
 export { Model };
 export { Blueprint };
 export { Pool };
-export * from './Decorator';
-export * from './Schema';
-export * from './UtilityTypes';
-export * from './Repository';
-export * from './Operator';
-export * from './Nest';
+export * from "./Decorator";
+export * from "./Schema";
+export * from "./UtilityTypes";
+export * from "./Repository";
+export * from "./Operator";
+export * from "./Nest";
+export * from './StoredProcedure';
 declare const _default: {
     DB: typeof DB;
     Model: typeof Model;