chyz 2.0.1-rc.3 → 2.0.1-rc.36

package/base/{Model.js → Model.ts}

@@ -1,34 +1,48 @@
-"use strict";
 /*
  * Copyright (c) 2021. Chy Bilgisayar Bilisim
  * Author: Cihan Ozturk
  * E-mail: cihan@chy.com.tr
  * Github:https://github.com/cihan53/
  */
-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());
-    });
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Model = exports.NOW = exports.DataTypes = void 0;
-const BaseChyz_1 = __importDefault(require("../BaseChyz"));
-const Utils_1 = require("../requiments/Utils");
-const Component_1 = require("./Component");
-const InvalidConfigException_1 = require("./InvalidConfigException");
-const sequelize_1 = require("sequelize");
-const Exception_1 = require("./db/Exception");
-const DataErrorDbException_1 = require("./DataErrorDbException");
-var sequelize_2 = require("sequelize");
-Object.defineProperty(exports, "DataTypes", { enumerable: true, get: function () { return sequelize_2.DataTypes; } });
-Object.defineProperty(exports, "NOW", { enumerable: true, get: function () { return sequelize_2.NOW; } });
+
+import BaseChyz from "../BaseChyz";
+import {Utils} from "../requiments/Utils";
+import {Component} from "./Component";
+import {InvalidConfigException} from "./InvalidConfigException";
+import {
+    DatabaseError,
+    ExclusionConstraintError,
+    ForeignKeyConstraintError,
+    Model as SModel,
+    QueryOptions,
+    QueryOptionsWithType,
+    QueryTypes,
+    Sequelize,
+    TimeoutError,
+    UniqueConstraintError,
+    ValidationError,
+} from "sequelize";
+import {Exception} from "./db/Exception";
+import {DataErrorDbException} from "./DataErrorDbException";
+
+export {DataTypes, NOW} from "sequelize";
+
+
+export interface Relation {
+    [key: string]: any;
+
+    type: "hasOne" | "hasMany" | "belongsToMany" | "belongsTo",
+    allowNull?: boolean,
+    sourceKey?: string,
+    model: SModel,
+    foreignKey: string,
+    name?: string,
+    through?: any,
+    as?: string,
+    on?: any,
+    scope?: any
+}
+
 /**
  * ValidateMe.init({
  bar: {
@@ -82,19 +96,29 @@ Object.defineProperty(exports, "NOW", { enumerable: true, get: function () { ret
  }
  }, { sequelize });
  */
-class Model extends Component_1.Component {
-    constructor(sequelize) {
+
+export class Model extends Component {
+    _provider: any;
+    _register: any;
+    private readonly _tableName: string;
+    private _model: any;
+    private _attributes: any = {};
+    private _errors: any = {}
+
+
+    constructor(sequelize?: IDBDatabase) {
         super();
-        this._attributes = {};
-        this._errors = {};
         this._tableName = this.alias();
-        BaseChyz_1.default.debug("Model constructor", this._tableName);
+
+        BaseChyz.debug("Model constructor", this._tableName)
         // this._sequelize = BaseChyz.getComponent("db").db;
+
         if (sequelize != null) {
             this._provider = sequelize;
-        }
-        else
+        } else
             this._provider = this.getDb();
+
+
         /**
          * override query
          */
@@ -107,19 +131,22 @@ class Model extends Component_1.Component {
         //         throw new DatabaseError(err);
         //     }
         // };
-        this._provider.query = function (sql, options) {
-            return sequelize_1.Sequelize.prototype.query.apply(this, [sql, options]).catch((err) => {
-                if (process.env.NODE_ENV == "development" || process.env.NODE_ENV == "dev") {
+
+        this._provider.query = function (sql: string | { query: string; values: unknown[] }, options?: QueryOptions | QueryOptionsWithType<QueryTypes.RAW> | undefined,) {
+            return Sequelize.prototype.query.apply(this, [sql, options]).catch((err ) => {
+
+
+                if( process.env.NODE_ENV=="development" || process.env.NODE_ENV=="dev"){
                     // e.stack = e.original;
-                    if (err instanceof sequelize_1.DatabaseError) {
+                    if( err instanceof  DatabaseError){
                         // @ts-ignore
                         delete err.parent;
                         // @ts-ignore
                         delete err.original;
                     }
                 }
-                throw new DataErrorDbException_1.DataErrorDbException(err);
-            });
+                throw new DataErrorDbException(err);
+            })
             // try {
             //       let r =
             //       console.log(r)
@@ -127,55 +154,68 @@ class Model extends Component_1.Component {
             //     console.log(err)
             //     throw new DatabaseError(err);
             // }
-        };
-        if (!Utils_1.Utils.isEmpty(this.attributes())) {
+        }
+
+        if (!Utils.isEmpty(this.attributes())) {
             this._model = this._provider.define(this._tableName, this.attributes(), {
                 tableName: this.tableName(),
                 timestamps: false,
                 createdAt: false,
                 updateAt: false
             });
+
+        } else {
+            throw new InvalidConfigException(BaseChyz.t("Invalid model configuration, is not emty attributes"))
         }
-        else {
-            throw new InvalidConfigException_1.InvalidConfigException(BaseChyz_1.default.t("Invalid model configuration, is not emty attributes"));
-        }
+
         // this.init();
+
     }
+
+
     /**
      * 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.
      */
-    getDb() {
-        return BaseChyz_1.default.getComponent("db") ? BaseChyz_1.default.getComponent("db").db : null;
+    public getDb() {
+        return BaseChyz.getComponent("db") ? BaseChyz.getComponent("db").db : null
     }
-    getDbConnection() {
-        return BaseChyz_1.default.getComponent("db");
+
+    public getDbConnection() {
+        return BaseChyz.getComponent("db");
     }
-    get provider() {
+
+    get provider(): any {
         return this._provider;
     }
-    set provider(value) {
+
+    set provider(value: any) {
         this._provider = value;
     }
+
+
     /**
      *
      */
-    get errors() {
+    get errors(): any {
         return this._errors;
     }
-    set errors(value) {
+
+    set errors(value: any) {
         this._errors = value;
     }
-    init() {
-        BaseChyz_1.default.debug("Model init....", this.constructor.name);
+
+    public init() {
+        BaseChyz.debug("Model init....", this.constructor.name)
         /**
          * init buraya
          */
-        BaseChyz_1.default.debug("Relation init....", this.constructor.name);
+        BaseChyz.debug("Relation init....", this.constructor.name)
         for (const relation of this.relations()) {
             let m = relation.model;
+
             if (relation.type == "hasOne") {
                 // @ts-ignore
                 delete relation.model;
@@ -187,114 +227,132 @@ class Model extends Component_1.Component {
                 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);
             }
         }
+
+
     }
-    alias() {
+
+    public alias() {
         return this.constructor.name;
     }
-    tableName() {
+
+    public tableName() {
         return this._tableName;
     }
-    formName() {
+
+    public formName() {
         return this.constructor.name;
     }
-    rules() {
-        return [];
+
+    public rules() {
+        return []
     }
-    setModel(value) {
+
+
+    public setModel(value: any) {
         this._model = value;
     }
-    model() {
+
+    public model() {
         return this._model;
     }
-    save(params = {}, options = {}) {
-        return __awaiter(this, void 0, void 0, function* () {
-            this.errors = {};
-            // now instantiate an object
-            let p = Object.assign(params, this._attributes);
-            let result;
-            try {
-                result = yield this.model().create(p, options);
-            }
-            catch (e) {
-                BaseChyz_1.default.debug(`Model[${this.constructor.name}].create`, e);
-                if (e instanceof sequelize_1.ValidationError) {
-                    let validationErrorItems = e.errors;
-                    validationErrorItems.forEach(({ message, path }) => {
-                        // @ts-ignore
-                        this._errors[path] = message;
-                    });
-                    return false;
-                }
-                else if (e instanceof sequelize_1.DatabaseError) {
-                }
-                else if (e instanceof sequelize_1.TimeoutError) {
-                }
-                else if (e instanceof sequelize_1.UniqueConstraintError) {
-                }
-                else if (e instanceof sequelize_1.ForeignKeyConstraintError) {
-                }
-                else if (e instanceof sequelize_1.ExclusionConstraintError) {
-                }
-                throw new Exception_1.Exception(e.message, this.errors, e.code);
+
+
+    public async save(params = {}, options = {}) {
+
+        this.errors = {};
+        // now instantiate an object
+        let p = Object.assign(params, this._attributes)
+        let result: any;
+        try {
+            result = await this.model().create(p, options)
+        } catch (e: any) {
+            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) {
+
             }
-            return result;
-        });
+            throw new Exception(e.message, this.errors, e.code);
+        }
+
+        return result;
+
     }
-    bulkCreate(params = {}, options = {}) {
-        return __awaiter(this, void 0, void 0, function* () {
-            this.errors = {};
-            // now instantiate an object
-            let p = Object.assign(params, this._attributes);
-            let result;
-            try {
-                result = yield this.model().bulkCreate(p, options);
-            }
-            catch (e) {
-                BaseChyz_1.default.debug(`Model[${this.constructor.name}].bulkCreate`, e);
-                if (e instanceof sequelize_1.ValidationError) {
-                    let validationErrorItems = e.errors;
-                    validationErrorItems.forEach(({ message, path }) => {
-                        // @ts-ignore
-                        this._errors[path] = message;
-                    });
-                    return false;
-                }
-                else if (e instanceof sequelize_1.DatabaseError) {
-                }
-                else if (e instanceof sequelize_1.TimeoutError) {
-                }
-                else if (e instanceof sequelize_1.UniqueConstraintError) {
-                }
-                else if (e instanceof sequelize_1.ForeignKeyConstraintError) {
-                }
-                else if (e instanceof sequelize_1.ExclusionConstraintError) {
-                }
-                throw new Exception_1.Exception(e.message, this.errors, e.code);
+
+    public async bulkCreate(params = {}, options = {}) {
+        this.errors = {};
+        // now instantiate an object
+        let p = Object.assign(params, this._attributes)
+        let result: any;
+        try {
+            result = await this.model().bulkCreate(p, options)
+        } catch (e: any) {
+            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) {
+
             }
-            return result;
-        });
+            throw new Exception(e.message, this.errors, e.code);
+        }
+
+        return result;
+
     }
-    update(params = {}, options = {}) {
+
+    public update(params = {}, options = {}) {
         this.errors = {};
-        let p = Object.assign(params, this._attributes);
-        return this.model().update(p, options);
+        let p = Object.assign(params, this._attributes)
+        return this.model().update(p, options)
     }
-    delete(params = {}, options = {}) {
+
+    public delete(params = {}, options = {}) {
         this.errors = {};
-        let p = Object.assign(params, this._attributes);
-        return this.model().destroy(p, options);
+        let p = Object.assign(params, this._attributes)
+        return this.model().destroy(p, options)
     }
+
     /**
      * As there are often use cases in which it is just easier to execute raw / already prepared SQL queries, you can use the sequelize.query method.
      *
@@ -459,87 +517,96 @@ class Model extends Component_1.Component {
      * @param query
      * @param options
      */
-    rawQuery(query, options = { type: sequelize_1.QueryTypes.SELECT, nest: true }) {
-        return __awaiter(this, void 0, void 0, function* () {
-            this.errors = {};
-            return yield this.model().query(query, options);
-        });
+    public async rawQuery(query: string, options: any = {type: QueryTypes.SELECT, nest: true}) {
+        this.errors = {};
+        return await this.model().query(query, options);
     }
+
+
     /**
      *
      * @param args
      */
-    findOne(...args) {
-        return this._model.findOne(...arguments);
+    public findOne(...args: any[]) {
+        return this._model.findOne(...arguments)
     }
+
     /**
      *
      * @param args
      */
-    findAll(...args) {
-        return this._model.findAll(...arguments);
+    public findAll(...args: any[]) {
+        return this._model.findAll(...arguments)
     }
+
     /**
      * return {count : number , rows: any}
      * @param args
      */
-    findAndCountAll(...args) {
-        return this._model.findAndCountAll(...arguments);
+    public findAndCountAll(...args: any[]) {
+        return this._model.findAndCountAll(...arguments)
     }
-    validate() {
+
+
+    public validate() {
+
     }
+
     /**
      *
      * @param data
      * @param formName
      */
-    load(data, formName = null) {
+    public load(data: any, formName: any = null) {
         let scope = formName === null ? this.formName() : formName;
-        if (scope === '' && !Utils_1.Utils.isEmpty(data)) {
+        if (scope === '' && !Utils.isEmpty(data)) {
             this.setAttribute(data);
             return true;
-        }
-        else if (data[scope]) {
+        } else if (data[scope]) {
             this.setAttribute(data[scope]);
             return true;
         }
         return false;
     }
-    bulkLoad(data, formName = null) {
+
+    public bulkLoad(data: any, formName: any = null) {
         let scope = formName === null ? this.formName() : formName;
-        if (scope === '' && !Utils_1.Utils.isEmpty(data)) {
+        if (scope === '' && !Utils.isEmpty(data)) {
             this.setAttribute(data);
             return true;
-        }
-        else if (data[scope]) {
+        } else if (data[scope]) {
             this.setAttribute(data[scope]);
             return true;
         }
         return false;
     }
-    setAttribute(values, safeOnly = true) {
+
+    public setAttribute(values: any, safeOnly = true) {
         if (values instanceof Object) {
             let attributes = this.attributes();
             for (const valueKey in values) {
                 if (Object.keys(attributes).indexOf(valueKey) != -1) {
                     // @ts-ignore
-                    BaseChyz_1.default.debug("Model[" + this.formName() + "] attributes value set ", valueKey, values[valueKey]);
+                    BaseChyz.debug("Model[" + this.formName() + "] attributes value set ", valueKey, values[valueKey])
                     this._attributes[valueKey] = values[valueKey];
                 }
             }
         }
     }
-    attributes() {
-        return {};
+
+    public attributes() {
+        return {}
     }
+
     /**
      * relation return array
      * [
      *
      * ]
      */
-    relations() {
-        return [];
+    public relations(): Relation[] {
+        return []
     }
+
+
 }
-exports.Model = Model;

package/base/{ModelManager.js → ModelManager.ts}

@@ -1,6 +1,5 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ModelManager = void 0;
+import {Model} from "./Model"
+
 /*
  *
  * Copyright (c) 2021.. Chy Bilgisayar Bilisim
@@ -12,8 +11,9 @@ exports.ModelManager = void 0;
 // interface ObjectConstructor {
 //     _register(o: Model): void;
 // }
-exports.ModelManager = {
-    _register(map) {
-        Object.assign(this, map);
+
+export const ModelManager: any = {
+    _register(map: Model) {
+        Object.assign(this, map)
     }
-};
+}

package/base/NotFoundHttpException.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 NotFoundHttpException extends BaseError {
+    constructor ( public message: any) {
+        super(message,404);
+    }
+}

package/base/RestClient.ts

@@ -0,0 +1,26 @@
+/*
+ *
+ * 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,headers?:any) {
+        return axios.post(url, {...args,headers:headers})
+    }
+
+    public get(url: string, args?: any,headers?:any) {
+        return axios.get(url, {...args,headers:headers}  )
+    }
+
+    public Rest(params: any) {
+        return axios(params)
+    }
+}

package/base/UnauthorizedHttpException.ts

@@ -0,0 +1,17 @@
+/*
+ * 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 UnauthorizedHttpException extends BaseError {
+    constructor ( public message: any) {
+        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: any) {
+        super(message,400);
+    }
+}

package/base/db/Exception.ts

@@ -0,0 +1,14 @@
+import {BaseError} from "../BaseError";
+
+export class Exception extends BaseError {
+    public errorInfo = [];
+    protected 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)
+    }
+}