chyz 1.0.12-rc.7 → 1.0.13-rc.2

package/README.md

@@ -12,18 +12,26 @@ Klasör Yapısı<br>
 index.ts<br>
 
 `##Başlangıç<br>
-yarn start 
+yarn start
+
+## index.ts alanlar düzenlenmeli.
+
+```typescript
+require('dotenv-flow').config();
+
+import BaseChyz from "chyz/dist/BaseChyz";
+import Chyz, {DbConnection} from "chyz/dist";
+import {WebUser} from "../web/WebUser";
+import {User} from "./Models/User";
 
-##index.ts alanlar düzenlenmeli.
-```js
 let config = {
     components: {
-        db:{
-            class:DbConnection,
+        db: {
+            class: DbConnection,
             database: process.env.DBDATABASE,
-            username:process.env.DBUSER,
-            password:process.env.DBPASS,
-            options:{
+            username: process.env.DBUSER,
+            password: process.env.DBPASS,
+            options: {
                 host: process.env.DBHOST,
                 dialect: 'postgres',  /* one of 'mysql' | 'mariadb' | 'postgres' | 'mssql' */
                 // disable logging; default: console.log
@@ -31,21 +39,22 @@ let config = {
             }
         },
         user: {
-            'class': User,
-            'identityClass':Identity
+            'class': WebUser,
+            'identityClass': User
         }
     }
 }
 Chyz.app(config).Start();
 ```
 
-##Create Model
+## Create Model
+
 Veritabanı işlemleri için model oluşturma, sequelize desteklidir.
 
-```js
-import {Model,DataTypes} from "chyz/base/Model";
+```typescript
+import {Model, DataTypes} from "chyz/base/Model";
 
-export class Customer extends Model {
+export class CustomerCLass extends Model {
     public tableName() {
         return 'customer';
     }
@@ -77,11 +86,104 @@ export class Customer extends Model {
     }
 
 }
+const Customer= new CustomerCLass();
+export { Customer };
+
+```
+````typescript
+export class ProductsClass extends Model {
+    [x: string]: any;
+
+    tableName() {
+        return 'products';
+    }
+
+    attributes() {
+        return {
+            // Model attributes are defined here
+            title: {
+                type: DataTypes.STRING,
+                allowNull: false
+            },
+            model_id: {
+                type: DataTypes.INTEGER,
+                allowNull: false
+            },
+            properties: {
+                type: DataTypes.STRING,
+                allowNull: false
+            }
+
+        }
+    }
+
+    relations(): Relation[] {
+        return [
+            {
+                type: "hasOne",
+                foreignKey: "id",
+                sourceKey: "customer_id",
+                model: Customer.model()
+            }
+        ]
+    }
+}
+
+const Products = new ProductsClass()
+export {Products}
+````
+
+## Http POST ve GET verilerini model'e yükleme
+
+````typescript
+
+/**
+ * post data
+ *  {
+ *      "Customer":{
+ *          "firstname":"cihan",
+ *          "lastname":"ozturk"
+ *          ....
+ *      }
+ *  }
+ * @type {Customer}
+ */
+import {Customer} from "./Customer";
+//Customer Model Create
+let customer: Customer = Customer;
+customer.load(req.body, "Customer");//load customer data
+let cus: any = await customer.save();
+
+
+````
+## Transaction
+Transaction oluşturma
+
+
+```typescript
+    let transaction
+    try {
+        // get transaction
+        transaction = await BaseChyz.getComponent("db").transaction();
+        //Customer Model Create
+        let customer: Customer = new Customer();
+        customer.load(data, "Customer");//load customer data
+        let cus: any = await customer.save({}, {transaction});
+        if (!cus) {
+            throw new ValidationHttpException(customer.errors);
+        }
+    } catch (e) {
+        if (transaction) {
+            await transaction.rollback();
+            BaseChyz.warn("Rollback transaction")
+        }
+        ...
+    }
 ```
 
-##Yetkilendirme için kullanıcı modeli
+## Yetkilendirme için kullanıcı modeli
 
-```js
+```typescript
 /*
  * Copyright (c) 2021. Chy Bilgisayar Bilisim
  * Author: Cihan Ozturk

package/base/ActionFilter.ts

@@ -25,7 +25,7 @@ export class ActionFilter extends Behavior {
     }
 
     public async beforeFilter(route: any, req: Request, res: Response) {
-        if (!this.isActive(route.id)) {
+        if (!this.isActive(route)) {
             return;
         }
 
@@ -51,7 +51,7 @@ export class ActionFilter extends Behavior {
         for (const exceptKey in this.except) {
             let pattern = this.except[exceptKey];
             let match = id.match(pattern)
-            if (match.length > 0) {
+            if (match && match.length > 0) {
                 exceptMatch = true;
             }
         }

package/base/BaseError.ts

@@ -8,11 +8,11 @@
 export class BaseError extends Error {
     private statusCode: number;
 
-    constructor(message: string) {
+    constructor(message: string,statusCode=500) {
         super(message);
         this.message=message;
         this.name = this.constructor.name // good practice
-        this.statusCode = 500 // error code for responding to client
+        this.statusCode = statusCode // error code for responding to client
         Error.captureStackTrace(this)
     }
 

package/base/DataErrorDbException.ts

@@ -11,6 +11,6 @@ import {BaseError} from "./BaseError";
 
 export class DataErrorDbException extends BaseError {
     constructor ( public message: string) {
-        super(message);
+        super(message,502);
     }
 }

package/base/DbConnection.ts

@@ -15,6 +15,7 @@ export class DbConnection extends Component {
     public username!: string
     public password!: string
     public options?: object
+    public _transaction:any;
 
     private _db: any
 
@@ -24,10 +25,10 @@ export class DbConnection extends Component {
         sequelize
             .authenticate()
             .then(() => {
-                console.log('Connection has been established successfully.');
+                BaseChyz.info('Connection has been established successfully.');
             })
             .catch((err: any) => {
-                console.error('Unable to connect to the database:', err);
+                BaseChyz.error('Unable to connect to the database:', err);
 
             });
 
@@ -42,4 +43,9 @@ export class DbConnection extends Component {
     set db(value: any) {
         this._db = value;
     }
+
+    public transaction(){
+        return this.db.transaction();
+    }
+
 }

package/base/ForbiddenHttpException.ts

@@ -8,7 +8,7 @@
 import {BaseError} from "./BaseError";
 export class ForbiddenHttpException extends BaseError {
     constructor ( message: string) {
-        super(message);
+        super(message,403);
     }
 }
 

package/base/InvalidConfigException.ts

@@ -11,6 +11,6 @@ import {BaseError} from "./BaseError";
 
 export class InvalidConfigException extends BaseError {
     constructor ( public message: string) {
-        super(message);
+        super(message,500);
     }
 }

package/base/Model.ts

@@ -9,9 +9,21 @@ import BaseChyz from "../BaseChyz";
 import Utils from "../requiments/Utils";
 import {Component} from "./Component";
 import {InvalidConfigException} from "./InvalidConfigException";
-import {DataTypes} from "sequelize";
+import {DatabaseError, DataTypes, ExclusionConstraintError, ForeignKeyConstraintError, Model as SModel, TimeoutError, UniqueConstraintError, ValidationError,} from "sequelize";
+import {Exception} from "./db/Exception";
 
-export {DataTypes} from "sequelize";
+export {DataTypes, NOW} from "sequelize";
+
+export interface Relation{
+    type:  "hasOne"  | "hasMany" | "belongsToMany" | "belongsTo",
+    allowNull?:boolean,
+    sourceKey:string,
+    model:SModel,
+    foreignKey:string,
+    name?:string,
+    through?:string,
+    as?:string
+}
 
 /**
  * ValidateMe.init({
@@ -66,24 +78,64 @@ export {DataTypes} from "sequelize";
   }
 }, { sequelize });
  */
+
 export class Model extends Component {
-    private sequelize: any
+    _sequelize: any ;
     private _tableName: string;
     private _model: any;
     private _attributes: any = {};
+    private _errors: any = {}
+
 
-    constructor() {
+    constructor(sequelize?: IDBDatabase) {
         super();
         this._tableName = this.constructor.name;
-        this.sequelize = BaseChyz.getComponent("db").db;
+        // this._sequelize = BaseChyz.getComponent("db").db;
+        if (sequelize != null)
+            this._sequelize = sequelize;
+        else
+            this._sequelize = BaseChyz.getComponent("db").db;
 
         if (!Utils.isEmpty(this.attributes())) {
-
-            this._model = this.sequelize.define(this.constructor.name, this.attributes(), {
+            this._model = this._sequelize.define(this.constructor.name, this.attributes(), {
                 tableName: this.tableName(),
                 timestamps: false
             });
 
+
+
+            /**
+             * init buraya
+             */
+
+            for (const relation of this.relations()) {
+                let m = relation.model;
+
+                if(relation.type=="hasOne"  ){
+                    // @ts-ignore
+                    delete relation.model
+                    this.model().hasOne(m, relation );
+                }
+
+                if(relation.type=="hasMany" ){
+                    // @ts-ignore
+                    delete relation.model;
+                    this.model().hasMany(m, relation );
+                }
+
+                if(relation.type=="belongsTo"  ){
+                    // @ts-ignore
+                    delete relation.model;
+                    this.model().belongsTo(m, relation );
+                }
+
+                if(relation.type=="belongsToMany"  ){
+                    // @ts-ignore
+                    delete relation.model;
+                    this.model().belongsToMany(m, relation );
+                }
+            }
+
         } else {
             throw new InvalidConfigException(BaseChyz.t("Invalid model configuration, is not emty attributes"))
         }
@@ -92,10 +144,43 @@ export class Model extends Component {
 
     }
 
+
+    /**
+     * Returns the database connection used by this AR class.
+     * By default, the "db" application component is used as the database connection.
+     * You may override this method if you want to use a different database connection.
+     * @return Connection the database connection used by this AR class.
+     */
+    public static getDb()
+    {
+        return BaseChyz.getComponent("db").db
+    }
+
+    get sequelize(): any {
+        return this._sequelize;
+    }
+
+    set sequelize(value: any) {
+        this._sequelize = value;
+    }
+
+
+    /**
+     *
+     */
+    get errors(): any {
+        return this._errors;
+    }
+
+    set errors(value: any) {
+        this._errors = value;
+    }
+
     public init() {
-        BaseChyz.debug("Model init....",this.constructor.name)
+        BaseChyz.debug("Model init....", this.constructor.name)
     }
 
+
     public tableName() {
         return this._tableName;
     }
@@ -112,21 +197,98 @@ export class Model extends Component {
         return this._model;
     }
 
-    public save() {
+    public async save(params = {}, options = {}) {
         // now instantiate an object
-        return this._model.build(this._attributes).save()
+        let p = Object.assign(params, this._attributes)
+        let result: any;
+        try {
+            result = await this.model().create(p, options)
+        } catch (e) {
+            BaseChyz.debug(`Model[${this.constructor.name}].create`, e)
+            if (e instanceof ValidationError) {
+                let validationErrorItems = e.errors;
+                validationErrorItems.forEach(({message, path}) => {
+                    // @ts-ignore
+                    this._errors[path] = message
+                })
+
+                return false;
+            } else if (e instanceof DatabaseError) {
+
+            } else if (e instanceof TimeoutError) {
+
+            } else if (e instanceof UniqueConstraintError) {
+
+            } else if (e instanceof ForeignKeyConstraintError) {
+
+            } else if (e instanceof ExclusionConstraintError) {
+
+            }
+            throw new Exception(e.message, this.errors, e.code);
+        }
+
+        return result;
+
     }
 
-    public update() {
-        return this._model.build(this._attributes).update()
+    public async bulkCreate(params = {}, options = {}) {
+        // now instantiate an object
+        let p = Object.assign(params, this._attributes)
+        let result: any;
+        try {
+            result = await this.model().bulkCreate(p, options)
+        } catch (e) {
+            BaseChyz.debug(`Model[${this.constructor.name}].bulkCreate`, e)
+            if (e instanceof ValidationError) {
+                let validationErrorItems = e.errors;
+                validationErrorItems.forEach(({message, path}) => {
+                    // @ts-ignore
+                    this._errors[path] = message
+                })
+
+                return false;
+            } else if (e instanceof DatabaseError) {
+
+            } else if (e instanceof TimeoutError) {
+
+            } else if (e instanceof UniqueConstraintError) {
+
+            } else if (e instanceof ForeignKeyConstraintError) {
+
+            } else if (e instanceof ExclusionConstraintError) {
+
+            }
+            throw new Exception(e.message, this.errors, e.code);
+        }
+
+        return result;
+
     }
 
-    public findOne(...args: any[]){
+    public update(params = {}, options = {}) {
+        let p = Object.assign(params, this._attributes)
+        return this.model().update(p, options)
+    }
+
+    public delete(params = {}, options = {}) {
+        let p = Object.assign(params, this._attributes)
+        return this.model().delete(p, options)
+    }
+
+    /**
+     *
+     * @param args
+     */
+    public findOne(...args: any[]) {
         return this._model.findOne(...arguments)
     }
 
-    public delete(...args: any[]) {
-        return this._model.delete(...arguments)
+    /**
+     *
+     * @param args
+     */
+    public findAll(...args: any[]) {
+        return this._model.findAll(...arguments)
     }
 
 
@@ -134,6 +296,11 @@ export class Model extends Component {
 
     }
 
+    /**
+     *
+     * @param data
+     * @param formName
+     */
     public load(data: any, formName: any = null) {
         let scope = formName === null ? this.formName() : formName;
         if (scope === '' && !Utils.isEmpty(data)) {
@@ -146,6 +313,18 @@ export class Model extends Component {
         return false;
     }
 
+    public bulkLoad(data: any, formName: any = null) {
+        let scope = formName === null ? this.formName() : formName;
+        if (scope === '' && !Utils.isEmpty(data)) {
+            this.setAttribute(data);
+            return true;
+        } else if (data[scope]) {
+            this.setAttribute(data[scope]);
+            return true;
+        }
+        return false;
+    }
+
     public setAttribute(values: any, safeOnly = true) {
         if (values instanceof Object) {
             let attributes = this.attributes();
@@ -162,4 +341,14 @@ export class Model extends Component {
     public attributes() {
         return {}
     }
+
+    /**
+     * relation return array
+     * [
+     *
+     * ]
+     */
+    public relations():Relation[]{
+        return []
+    }
 }

package/base/NotFoundHttpException.ts

@@ -9,6 +9,6 @@ import {BaseError} from "./BaseError";
 
 export class NotFoundHttpException extends BaseError {
     constructor ( public message: string) {
-        super(message);
+        super(message,404);
     }
 }

package/base/RestClient.ts

@@ -0,0 +1,28 @@
+/*
+ *
+ * Copyright (c) 2021.. Chy Bilgisayar Bilisim
+ * Author: Cihan Ozturk
+ *  E-mail: cihan@chy.com.tr
+ *  Github:https://github.com/cihan53/
+ *
+ */
+
+
+import {Component} from "./Component";
+
+const axios = require('axios')
+
+export class RestClient extends Component {
+    public post(url: string, args: any[]) {
+        return axios.post(url, args)
+    }
+
+    public get(url: string, args: any[]) {
+        return axios.post(url, args)
+    }
+
+    public Rest(params: any) {
+        return axios(params)
+    }
+}
+export default new RestClient();

package/base/UnauthorizedHttpException.ts

@@ -9,8 +9,9 @@ import {BaseError} from "./BaseError";
 
 export class UnauthorizedHttpException extends BaseError {
     constructor ( public message: string) {
-        super(message);
+        super(message,401);
     }
+
 }
 
 

package/base/ValidationHttpException.ts

@@ -0,0 +1,14 @@
+/*
+ * Copyright (c) 2021. Chy Bilgisayar Bilisim
+ * Author: Cihan Ozturk
+ * E-mail: cihan@chy.com.tr
+ * Github:https://github.com/cihan53/
+ */
+
+import {BaseError} from "./BaseError";
+
+export class ValidationHttpException extends BaseError {
+    constructor ( public message: string) {
+        super(message,401);
+    }
+}

package/base/db/Exception.ts

@@ -0,0 +1,14 @@
+import {BaseError} from "../BaseError";
+
+export class Exception extends BaseError {
+    public errorInfo = [];
+    private code: string;
+
+    constructor(message: string, errorInfo:any = [], code = '', previous = null) {
+        super(message);
+        this.errorInfo = errorInfo;
+        this.name = 'Database Exception' // good practice
+        this.code = code // error code for responding to client
+        Error.captureStackTrace(this)
+    }
+}

package/base/index.ts

@@ -11,4 +11,6 @@ export * from "./InvalidConfigException"
 export * from "./NotFoundHttpException"
 export * from "./UnauthorizedHttpException"
 export * from "./DataErrorDbException"
+export * from "./ValidationHttpException"
 export * from "./Model"
+export * from "./RestClient"