tspace-mysql 1.8.2 → 1.8.4

package/README.md

@@ -18,6 +18,7 @@ tspace-mysql is an Object-Relational Mapping (ORM) tool designed to run seamless
 | **Soft Deletes**               | Marks records as deleted without removing them from the database. This allows for recovery and auditing later. |
 | **Relationships**              | Set up connections between models, such as one-to-one, one-to-many, belongs-to, and many-to-many. Supports nested relationships and checks. |
 | **Type Safety**                | Ensures that queries are safer by checking the types of statements like `SELECT`, `ORDER BY`, `GROUP BY`, and `WHERE`. |
+| **Metadata**                   | Get the metadata of a Model. |
 | **Repository**                 | Follows a pattern for managing database operations like `SELECT`, `INSERT`, `UPDATE`, and `DELETE`. It helps keep the code organized. |
 | **Decorators**                 | Use decorators to add extra functionality or information to model classes and methods, making the code easier to read. |
 | **Caching**                    | Improves performance by storing frequently requested data. Supports in-memory caching (like memory DB) and Redis for distributed caching. |
@@ -91,6 +92,7 @@ npm install tspace-mysql -g
     - [Global Scope](#global-scope)
   - [Schema](#schema)
     - [Schema Model](#schema-model)
+    - [Virtual Column](#virtual-column)
     - [Validation](#validation)
     - [Sync](#sync)
   - [SoftDelete](#softdelete)
@@ -112,14 +114,16 @@ npm install tspace-mysql -g
   - [Cache](#cache)
   - [Decorator](#decorator)
   - [Type Safety](#type-safety)
-    - [Safety Select](#safety-select)
-    - [Safety OrderBy](#safety-order-by)
-    - [Safety GroupBy](#safety-group-by)
-    - [Safety Where](#safety-where)
-    - [Safety Insert](#safety-insert)
-    - [Safety Update](#safety-update)
-    - [Safety Delete](#safety-delete)
-    - [Safety Relationships](#safety-relationships)
+    - [Type Safety Select](#type-safety-select)
+    - [Type Safety OrderBy](#type-safety-order-by)
+    - [Type Safety GroupBy](#type-safety-group-by)
+    - [Type Safety Where](#type-safety-where)
+    - [Type Safety Insert](#type-safety-insert)
+    - [Type Safety Update](#type-safety-update)
+    - [Type Safety Delete](#type-safety-delete)
+    - [Type Safety Relationships](#type-safety-relationships)
+    - [Type Safety Results](#type-safety-results)
+  - [Metadata](#metadata)
 - [Repository](#repository)
   - [Repository Select Statements](#repository-select-statements)
   - [Repository Insert Statements](#repository-insert-statements)
@@ -127,6 +131,8 @@ npm install tspace-mysql -g
   - [Repository Delete Statements](#repository-delete-statements)
   - [Repository Transactions](#repository-transactions)
   - [Repository Relations](#repository-relations)
+- [View](#view)
+- [Stored Procedure](#stored-procedure)
 - [Blueprint](#blueprint)
 - [Cli](#cli)
   - [Make Model](#make-model)
@@ -1229,7 +1235,35 @@ try {
    *
    * @commit commit transaction to database
    */
+  // After your use commit if use same connection for actions this transction will auto commit
   await connection.commit();
+
+  // If you need to start a new transaction again, just use wait connection.startTransaction();
+
+  const postsAfterCommited = await new Post()
+    .createMultiple([
+      {
+        user_id: user.id,
+        title: `tspace-post1`,
+      },
+      {
+        user_id: user.id,
+        title: `tspace-post2`,
+      },
+      {
+        user_id: user.id,
+        title: `tspace-post3`,
+      },
+    ])
+    // Using this connection now will auto-commit to the database.
+    .bind(connection) // If you need to perform additional operations, use await connection.startTransaction(); again.
+    .save();
+
+   
+    // Do not perform any operations with this connection.
+    // The transaction has already been committed, and the connection is closed.
+    // Just ensure everything is handled at the end of the transaction.
+    await connection.end();
   
 } catch (err) {
   /**
@@ -2449,7 +2483,7 @@ using the following:
 #### Schema Model
 
 ```js
-import { Model, Blueprint , TSchema } from "tspace-mysql";
+import { Model, Blueprint , type T } from "tspace-mysql";
 
 const schema = {
   id: Blueprint.int().notNull().primary().autoIncrement(),
@@ -2463,7 +2497,7 @@ const schema = {
 
 
 // make type in TS
-type TS = TSchema<typeof Schema>
+type TS = T.Schema<typeof Schema>
 
 // the TSchemaUser will be created like that
 /**
@@ -2490,6 +2524,60 @@ class User extends Model<TS>  // use the schema for this User model
 
 ```
 
+#### Virtual Column
+```js
+
+import { Model, Blueprint , type T } from "tspace-mysql";
+
+const schema = {
+  id: Blueprint.int().notNull().primary().autoIncrement(),
+  uuid: Blueprint.varchar(50).null().index(),
+  firstName: Blueprint.varchar(191).notNull(),
+  lastName : Blueprint.varchar(191).notNull(),
+  email: Blueprint.varchar(191).notNull(),
+  createdAt: Blueprint.timestamp().null(),
+  updatedAt: Blueprint.timestamp().null(),
+  deletedAt: Blueprint.timestamp().null(),
+
+  // Define you virtual column to schema
+  fullName : new Blueprint().virtual(`CONCAT(firstName,' ', lastName)`),
+  countPosts : new Blueprint().virtual(`(SELECT COUNT(*) FROM posts WHERE posts.userid = users.id)`)
+
+  // if you need to custom the virtual column for some method.
+  // fullName : new Blueprint().virtual({
+  //     select  : `CONCAT(firstName,' ', lastName)`,
+  //     where   : `CONCAT(firstName,' ', lastName)`,
+  //     orderBy : `CONCAT(firstName,' ', lastName)`,
+  //     groupBy : `CONCAT(firstName,' ', lastName)`,
+  // }),
+}
+
+type TS = T.Schema<typeof Schema>
+
+class User extends Model<TS> {
+  constructor() {
+    super();
+    this.useSchema(schema)
+  }
+}
+const users = await new User()
+.select('id','firstName','lastName','fullName','countPosts')
+.where('fullName','LIKE',`%tspace-mysql%`)
+.orderBy('fullName','desc')
+.groupBy('fullName')
+.findMany()
+
+// SELECT 
+//    `users`.`id`, `users`.`firstName`, `users`.`lastName`, 
+//    CONCAT(firstName,' ', lastName) AS fullName , 
+//    (SELECT COUNT(*) FROM posts WHERE posts.userid = users.id) AS countPosts
+// FROM `users` 
+// WHERE CONCAT(firstName,' ', lastName) LIKE '%tspace-mysql%'
+// GROUP BY CONCAT(firstName,' ', lastName)
+// ORDER BY CONCAT(firstName,' ', lastName) DESC
+
+```
+
 #### Validation
 
 Validate the schema of Model
@@ -2648,12 +2736,12 @@ const user = await new User().trashed().findMany()
 ```
 
 ### Type Safety
-Type safety in TypeScript refers to the ability of the language to detect and prevent type errors during compile-time. 
-Type safety still works when you add additional types to your model, using the following:
+Type Type Safety in TypeScript refers to the ability of the language to detect and prevent type errors during compile-time. 
+Type Type Safety still works when you add additional types to your model, using the following:
 
 ```js
 // in file User.ts
-import { Model , Blueprint , TSchema , TSchemaStatic } from 'tspace-mysql'
+import { Model , Blueprint , type T } from 'tspace-mysql'
 import Phone  from '../Phone'
 
 const schemaUser = {
@@ -2667,8 +2755,8 @@ const schemaUser = {
     updatedAt :Blueprint.timestamp().null()
 }
 
-type TSchemaUser = TSchemaStatic<typeof schemaUser>
-// TSchemaUser = TSchema<typeof schemaUser>
+type TSchemaUser = T.SchemaStatic<typeof schemaUser>
+// TSchemaUser = T.Schema<typeof schemaUser>
 
 // TSchema allowed to set any new keys without in the schema to results
 // TSchemaStatic not allowed to set any new keys without in the schema to results
@@ -2688,7 +2776,7 @@ export default User
 +--------------------------------------------------------------------------+
 
 // in file Phone.ts
-import { Model , Blueprint , TSchema , TSchemaStatic } from 'tspace-mysql'
+import { Model , Blueprint , type T } from 'tspace-mysql'
 import { User } from './User.ts'
 const schemaPhone = {
     id :Blueprint.int().notNull().primary().autoIncrement(),
@@ -2699,7 +2787,7 @@ const schemaPhone = {
     updatedAt :Blueprint.timestamp().null()
 }
 
-type TSchemaPhone = TSchemaStatic<typeof schemaPhone>
+type TSchemaPhone = T.SchemaStatic<typeof schemaPhone>
 
 class Phone extends Model<TSchemaPhone>  {
   constructor() {
@@ -2712,10 +2800,25 @@ class Phone extends Model<TSchemaPhone>  {
 export { Phone }
 export default Phone
 
+// example basic
+type TS = T.Schema<typeof TSchemaUser>
+type TR = T.Relation<{ phone : Phone }>
+
+type TSM = T.SchemaModel<User>
+type TRM = T.RelationModel<User>     
+
+type TColumn = T.Column<User>
+
+type TResults = T.Results<User>
+type TPaginateResults = T.Results<User, { paginate : true }>
+
+type TRepository = T.Repository<User>
+type TRepositoryTypeOf = T.RepositoryTypeOf<User>
+
 +--------------------------------------------------------------------------+
 ```
 
-### Safety Select
+### Type Safety Select
 
 ```js
 import { User  } from './User.ts'
@@ -2727,18 +2830,17 @@ const user = await new User().select('idx','username').findOne() ❌
 const user = await new User().except('id','username').findOne() ✅
 const user = await new User().except('idx','username').findOne() ❌
 
-// TSchemaStatic not allowed to set any new keys without in the schema to results
-user.withoutSchema = 1 ✅ // TSchema<User>
-user.withoutSchema = 1 ❌ // TSchemaStatic<User>
+// T.SchemaStatic not allowed to set any new keys without in the schema to results
+user.withoutSchema = 1 ✅ // T.Schema<User>
+user.withoutSchema = 1 ❌ // T.SchemaStatic<User>
 // But can you make like this for cases
 const user = await new User().except('idx','username').findOne<{ withoutSchema : number }>()
 user.withoutSchema = 1 ✅
 ```
 
-### Safety OrderBy
+### Type Safety OrderBy
 
 ```js
-
 import { User } from './User.ts'
 import { Phone } from './Phone.ts'
 
@@ -2753,7 +2855,7 @@ const users = await new User().oldest('idx').findMany() ❌
 
 ```
 
-### Safety GroupBy
+### Type Safety GroupBy
 
 ```js
 import { User  } from './User.ts'
@@ -2764,7 +2866,7 @@ const users = await new User().groupBy('idx').findMany() ❌
 
 ```
 
-### Safety Where
+### Type Safety Where
 
 ```js
 import { User } from './User.ts'
@@ -2802,7 +2904,7 @@ const users = await new User()
 
 ```
 
-### Safety Insert
+### Type Safety Insert
 
 ```js
 import { User } from './User.ts'
@@ -2816,7 +2918,7 @@ const users = await new User().create({ idx : 10 }).save() ❌
 
 ```
 
-### Safety Update
+### Type Safety Update
 
 ```js
 import { User } from './User.ts'
@@ -2829,7 +2931,7 @@ const users = await new User().update({ idx : 10 }).where('idx',1).save() ❌
 
 ```
 
-### Safety Delete
+### Type Safety Delete
 
 ```js
 import { User } from './User.ts'
@@ -2840,10 +2942,10 @@ const users = await new User().where('idx',1).delete() ❌
 
 ```
 
-### Safety Relationships
+### Type Safety Relationships
 
 ```js
-import { TSchemaModel } from 'tspace-mysql'
+import { type T } from 'tspace-mysql'
 import { User } from './User.ts'
 import { Phone } from './Phone.ts'
 // Case #1 : Relationship with 2 relations 'phone' and 'phones'
@@ -2874,7 +2976,7 @@ import { Phone } from './Phone.ts'
 // good 👍👍👍
 const users = await new User()
 .relations('phone','phones')
-.findMany<{ phone : TSchemaModel<Phone> , phones : TSchemaModel<Phone>[] }>()
+.findMany<{ phone : T.SchemaModel<Phone> , phones : T.SchemaModel<Phone>[] }>()
 
 for(const user of users) {
   user.phone  ✅
@@ -2892,7 +2994,7 @@ for(const user of users) {
   .relations('phone','phones')
   .relationQuery('phone' , (query : Phone) => query.relations('user'))
   .relationQuery('phones' , (query : Phone) => query.relations('user'))
-  .findMany<{ phone : TSchemaModel<Phone> , phones : TSchemaModel<Phone>[] }>()
+  .findMany<{ phone : T.SchemaModel<Phone> , phones : T.SchemaModel<Phone>[] }>()
 
   for(const user of users) {
     user.phone.user ❌
@@ -2920,8 +3022,8 @@ for(const user of users) {
   .relationQuery('phone' , (query : Phone) => query.relations('user'))
   .relationQuery('phones' , (query : Phone) => query.relations('user'))
   .findMany<{ 
-    phone : Partial<TSchemaModel<Phone>> & { user : TSchemaModel<User>};
-    phones : (Partial<TSchemaModel<Phone>> & { user : TSchemaModel<User>})[];
+    phone : Partial<T.SchemaModel<Phone>> & { user : T.SchemaModel<User>};
+    phones : (Partial<T.SchemaModel<Phone>> & { user : T.SchemaModel<User>})[];
   }>()
 
   for(const user of users) {
@@ -2936,23 +3038,23 @@ for(const user of users) {
 +--------------------------------------------------------------------------+
 // If you don't want to set types for every returning method such as 'findOne', 'findMany', and so on...
 
-import { Model , Blueprint , TSchema , TSchemaStatic , TRelation } from 'tspace-mysql'
+import { Model , Blueprint , type T } from 'tspace-mysql'
 import { Phone }  from '../Phone'
 
 const schemaUser = {
-    id :Blueprint.int().notNull().primary().autoIncrement(),
-    uuid :Blueprint.varchar(50).null(),
-    email :Blueprint.varchar(50).null(),
-    name :Blueprint.varchar(255).null(),
-    username : Blueprint.varchar(255).null(),
-    password : Blueprint.varchar(255).null(),
+    id        :Blueprint.int().notNull().primary().autoIncrement(),
+    uuid      :Blueprint.varchar(50).null(),
+    email     :Blueprint.varchar(50).null(),
+    name      :Blueprint.varchar(255).null(),
+    username  :Blueprint.varchar(255).null(),
+    password  :Blueprint.varchar(255).null(),
     createdAt :Blueprint.timestamp().null(),
     updatedAt :Blueprint.timestamp().null()
 }
 
-type TSchemaUser = TSchemaStatic<typeof schemaUser>
+type TSchemaUser = T.SchemaStatic<typeof schemaUser>
 
-type TRelationUser =  TRelation<{
+type TRelationUser =  T.Relation<{
   phones : Phone[]
   phone  : Phone
 }>
@@ -2974,28 +3076,25 @@ export { User }
 +--------------------------------------------------------------------------+
 
 // in file Phone.ts
-import { Model , Blueprint , TSchema , TRelation } from 'tspace-mysql'
+import { Model , Blueprint , type T } from 'tspace-mysql'
 import { User } from './User.ts'
 
 const schemaPhone = {
-    id :Blueprint.int().notNull().primary().autoIncrement(),
-    uuid :Blueprint.varchar(50).null(),
-    userId : Blueprint.int().notNull(),
-    number :Blueprint.varchar(50).notNull(),
+    id        :Blueprint.int().notNull().primary().autoIncrement(),
+    uuid      :Blueprint.varchar(50).null(),
+    userId    :Blueprint.int().notNull(),
+    number    :Blueprint.varchar(50).notNull(),
     createdAt :Blueprint.timestamp().null(),
     updatedAt :Blueprint.timestamp().null()
 }
 
-type TSchemaPhone = TSchema<typeof schemaPhone>
+type TSchemaPhone = T.Schema<typeof schemaPhone>
 
-type TRelationPhone = TRelation<{
+type TRelationPhone = T.Relation<{
   user : User[]
 }>
 
-class Phone extends Model<
-  TSchemaPhone,
-  TRelationPhone
->  {
+class Phone extends Model<TSchemaPhone,TRelationPhone>  {
   constructor() {
     super()
     this.useSchema(schemaPhone)
@@ -3045,17 +3144,100 @@ const users = await new User()
 
 ```
 
+## Type Safety Results
+```js
+import { type T } from 'tspace-mysql'
+
+const fError = async () : Promise<T.Results<User>[]> => {
+
+  const users = [{
+    id : 1,
+    uuid: "12d4f08a-a20d-4f41-abac-81391e135d60",
+    email: "tspace@example.com"
+  }]
+      
+  return users // ❌
+}
+
+const fCorrect = async () : Promise<T.Results<User>[]> => {
+
+  const users = await new User().findMany()
+      
+  return users // ✅
+}
+
+```
+
+## Metadata
+Get the metadata of a Model works only when a schema is added to the Model.
+
+```js
+import { Meta, Model , Blueprint , type T } from 'tspace-mysql';
+
+const schema = {
+  id        : Blueprint.int().notNull().primary().autoIncrement(),
+  uuid      : Blueprint.varchar(50).null(),
+  email     : Blueprint.varchar(255).notNull().index('users.email@index'),
+  name      : Blueprint.varchar(255).null(),
+  username  : Blueprint.varchar(255).notNull(),
+  password  : Blueprint.varchar(255).notNull(),
+  status    : Blueprint.tinyInt().notNull().default(0),
+  createdAt : Blueprint.timestamp().null(),
+  updatedAt : Blueprint.timestamp().null()
+}
+
+type TS = T.Schema<typeof schema>
+
+class User extends Model<TS>  {
+  constructor() {
+    super()
+    this.useSchema(schema)
+    this.useUUID()
+    this.useTimestamp()
+  }
+}
+
+const meta = Meta(User)
+
+const table         = meta.table() // 'users'
+const column        = meta.column('id') // 'id'
+const columnRef     = meta.columnReference('id') // `users`.`id`
+const columnTypeOf  = meta.columnTypeOf('id') // number
+const columnType    = meta.columnType('id') // Int
+const columns       = meta.columns() // ['id','uuid',...'updatedAt']
+const hasColumn     = meta.hasColumn('idx') // false
+const primaryKey    = meta.primaryKey() // 'id'
+const indexes       = meta.indexes() // ['users.email@index']
+const nullable      = meta.nullable() // ['uuid','name','createdAt','updatedAt']
+const defaults      = meta.defaults() // { status : 0 }
+
+console.log({
+  table,
+  column,
+  columnRef,
+  columnTypeOf,
+  columnType,
+  columns,
+  hasColumn,
+  primaryKey,
+  indexes,
+  nullable,
+  defaults
+})
+
+```
+
 ## Repository
 ```js
 Repository is a mechanism that encapsulates all database operations related to a specific model. 
 It provides methods for querying, inserting, updating, and deleting records in the database associated with the model.
 
-** The Repository check always type safety if model is used the type of schema 
+** The Repository check always type Type Safety if model is used the type of schema 
 
 ```
 ### Repository Select Statements
 ```js
-import { Repository , TRepository , OP } from 'tspace-mysql'
+import { Repository, OP , type T } from 'tspace-mysql'
 import { User } from '../Models/User'
 
 const userRepository = Repository(User)
@@ -3248,8 +3430,12 @@ try {
     transaction
   })
 
+  // after your use commit if use same transction for actions this transction will auto commit
   await transaction.commit()
 
+  // ensure the nothing with transction just use end of transction
+  await transaction.end();
+
 } catch (err) {
 
   await transaction.rollback()
@@ -3259,39 +3445,228 @@ try {
 
 ### Repository Relations
 ```js
-import { Repository , TRepository , OP } from 'tspace-mysql'
+import { Repository , OP } from 'tspace-mysql'
 import { User } from '../Models/User'
 import { Phone } from '../Models/Phone'
 
 const userRepository = Repository(User)
 
 const userHasPhones = await userRepository.findOne({
-  select : ['*'],
+  select : {
+    id : true,
+    name : true,
+    username : true,
+    phone : {
+      id : true,
+      user_id : true,
+      name: true
+    }
+  },
   where : {
     id: 1
   },
-  relations : ['phone'],
-  relationQuery:{
-    name : 'phone',
-    callback: () : TRepository<Phone> => ({ // add type for the callback know to check type of the model
-      select: ['id', 'userId', 'name'],
-      relations : ['user']
-    }) 
+  relations: {
+    phone: {
+      user : true
+    }
   }
-})
+});
 
 const phoneRepository = Repository(Phone)
 
 const phoneBelongUser = await phoneRepository.findOne({
-  select : ['*'],
+  select : '*',
   where : {
     id: 1
   },
-  relations : ['user']
+  relations : {
+    user : true
+  }
 })
 
 ```
 
+## View
+
+Your database schema can also use views. These views are represented by classes that behave similarly to models, 
+but they are based on stored SQL queries instead of actual tables.
+Let's look at a basic view class example:
+```js
+
+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.useSchema(schemaUser)
+  }
+}
+
+const schemaPost = {
+  id: Blueprint.int().notNull().primary().autoIncrement(),
+  uuid: Blueprint.varchar(50).null().index(),
+  user_id :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(),
+  user_id :Blueprint.int().notnull(),
+  name :Blueprint.varchar(255).null(),
+  post_count : 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.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 user_id`)
+      .selectRaw(metaUser.columnRef('name'))
+      .select(metaUser.columnRef('email'))
+      .selectRaw(`COUNT(${metaPost.columnRef('id')}) AS post_count`)
+      .leftJoin(metaUser.columnRef('id'),metaPost.columnRef('user_id'))
+      .groupBy(metaUser.columnRef('id'))
+      .groupBy(metaUser.columnRef('name'))
+      .toString()
+
+      // Look like this
+      // expression : 
+      // SELECT 
+      //   ROW_NUMBER() OVER (ORDER BY `users`.`id`) AS id, 
+      //   `users`.`id` AS user_id, `users`.`name`, `users`.`email`, 
+      //   COUNT(`posts`.`id`) AS post_count 
+      //   FROM `users` 
+      //   LEFT JOIN `posts` ON `users`.`id` = `posts`.`user_id` 
+      //   GROUP BY `users`.`id`, `users`.`name`
+    })
+
+    this.belongsTo({ name : 'user' , model : User })
+  }
+}
+
+new UserPostCountView()
+.with('user')
+.get()
+.then( v=> {
+  console.log(v)
+})
+
+```
+
+## Stored Procedure
+StoredProcedure is a predefined set of SQL statements stored in the database that you can call (execute) by name.
+```js
+
+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 MyStoreProcedure 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 MyStoreProcedure()
+
+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))
+
+```
 ## Blueprint
 
 Blueprint is a tool used for defining database schemas programmatically.