tspace-mysql 1.4.6 → 1.4.7

package/dist/lib/tspace/RelationHandler.d.ts

@@ -0,0 +1,32 @@
+import { Relation, RelationQuery } from "./Interface";
+import { Model } from "./Model";
+declare class RelationHandler {
+    private MODEL;
+    private $constants;
+    private $logger;
+    constructor(model: Model);
+    load(parents: Record<string, any>[], relation: Relation): Promise<any[]>;
+    loadExists(): string;
+    apply(nameRelations: string[], type: 'all' | 'exists' | 'trashed' | 'default'): Relation[];
+    callback(nameRelation: string, cb: Function): void;
+    hasOne({ name, as, model, localKey, foreignKey, freezeTable }: Relation): void;
+    hasMany({ name, as, model, localKey, foreignKey, freezeTable }: Relation): void;
+    belongsTo({ name, as, model, localKey, foreignKey, freezeTable }: Relation): void;
+    belongsToMany({ name, as, model, localKey, foreignKey, freezeTable, pivot, oldVersion, modelPivot }: Relation): void;
+    hasOneBuilder({ name, as, model, localKey, foreignKey, freezeTable, }: RelationQuery, callback?: Function): this | undefined;
+    hasManyBuilder({ name, as, model, localKey, foreignKey, freezeTable, }: RelationQuery, callback?: Function): this | undefined;
+    belongsToBuilder({ name, as, model, localKey, foreignKey, freezeTable, }: RelationQuery, callback?: Function): this | undefined;
+    belongsToManyBuilder({ name, as, model, localKey, foreignKey, freezeTable, pivot }: RelationQuery, callback?: Function): this | undefined;
+    private _handleRelationsExists;
+    private _relationBuilder;
+    private _functionRelationName;
+    private _relationMapData;
+    private _belongsToMany;
+    private _valueInRelation;
+    private _valuePattern;
+    private _assertError;
+    protected _getState(key: string): any;
+    protected _setState(key: string, value: any): void;
+}
+export { RelationHandler };
+export default RelationHandler;

package/dist/lib/tspace/RelationHandler.js

@@ -0,0 +1,529 @@
+"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());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RelationHandler = void 0;
+const pluralize_1 = __importDefault(require("pluralize"));
+const Model_1 = require("./Model");
+class RelationHandler {
+    constructor(model) {
+        this.MODEL = model;
+        this.$constants = this.MODEL["$constants"];
+        this.$logger = this.MODEL["$logger"];
+    }
+    load(parents, relation) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            const relationIsBelongsToMany = relation.relation === this.$constants('RELATIONSHIP').belongsToMany;
+            if (relationIsBelongsToMany) {
+                return yield this._belongsToMany(parents, relation);
+            }
+            if (!((_a = Object.keys(relation)) === null || _a === void 0 ? void 0 : _a.length))
+                return [];
+            const { localKey, foreignKey } = this._valueInRelation(relation);
+            const localKeyId = parents
+                .map((parent) => {
+                const data = parent[localKey];
+                if (parent.hasOwnProperty(localKey))
+                    return data;
+                this.MODEL['_assertError'](data == null, `Unknown relationship without primary or foreign key in Relation : [${relation === null || relation === void 0 ? void 0 : relation.name}]`);
+            })
+                .filter(d => d != null);
+            const parentIds = Array.from(new Set(localKeyId)) || [];
+            if (!parentIds.length && this._getState('RELATIONS_EXISTS'))
+                return [];
+            const query = relation.query;
+            this._assertError(query == null, `Unknown callback query in [Relation : ${relation.name}]`);
+            const results = yield query
+                .whereIn(foreignKey, parentIds)
+                .debug(this._getState('DEBUG'))
+                .when(relation.trashed, (query) => query.onlyTrashed())
+                .when(relation.all, (query) => query.disableSoftDelete())
+                .bind(this.MODEL['$pool'].get())
+                .get();
+            return this._relationMapData(parents, results, relation);
+        });
+    }
+    loadExists() {
+        var _a, _b, _c;
+        const relations = this._getState('RELATIONS');
+        for (const index in relations) {
+            const relation = relations[index];
+            if (!((_a = Object.keys(relation)) === null || _a === void 0 ? void 0 : _a.length))
+                continue;
+            if (relation.exists == null)
+                continue;
+            const { localKey, foreignKey, pivot, modelPivot } = this._valueInRelation(relation);
+            const query = relation.query;
+            this._assertError(query == null, `Unknown callback query in [Relation : '${relation.name}']`);
+            let clone = new Model_1.Model().clone(query);
+            const cloneRelations = clone['_getState']('RELATIONS');
+            if (cloneRelations.length) {
+                for (const r of cloneRelations) {
+                    if (r.query == null)
+                        continue;
+                    const sql = (_c = (_b = clone['$relation']) === null || _b === void 0 ? void 0 : _b._handleRelationsExists(r)) !== null && _c !== void 0 ? _c : '';
+                    clone.whereExists(sql);
+                }
+            }
+            if (relation.relation === this.$constants('RELATIONSHIP').belongsToMany) {
+                const thisPivot = modelPivot
+                    ? new modelPivot
+                    : new Model_1.Model().table(String(pivot));
+                const sql = clone
+                    .bind(this.MODEL['$pool'].get())
+                    .select(this._getState('PRIMARY_KEY'))
+                    .whereReference(`\`${query.getTableName()}\`.\`${foreignKey}\``, `\`${pivot}\`.\`${localKey}\``)
+                    .toString();
+                thisPivot.whereExists(sql);
+                const sqlPivot = thisPivot
+                    .bind(this.MODEL['$pool'].get())
+                    .select(thisPivot['$state'].get('PRIMARY_KEY'))
+                    .whereReference(`\`${this.MODEL['getTableName']()}\`.\`${foreignKey}\``, `\`${pivot}\`.\`${this._valuePattern([pluralize_1.default.singular(this.MODEL['getTableName']()), foreignKey].join("_"))}\``)
+                    .toString();
+                this.MODEL['whereExists'](sqlPivot);
+                continue;
+            }
+            const sql = clone
+                .bind(this.MODEL['$pool'].get())
+                .select(this._getState('PRIMARY_KEY'))
+                .whereReference(`\`${this.MODEL['getTableName']()}\`.\`${localKey}\``, `\`${query.getTableName()}\`.\`${foreignKey}\``)
+                .toString();
+            this.MODEL['whereExists'](sql);
+        }
+        const sql = this.MODEL['_queryBuilder']().select();
+        return sql;
+    }
+    apply(nameRelations, type) {
+        const relations = nameRelations.map((name) => {
+            var _a, _b, _c;
+            const relation = (_a = this._getState('RELATION')) === null || _a === void 0 ? void 0 : _a.find((data) => data.name === name);
+            this._assertError(relation == null, `This Relation "${name}" not be register in Model "${(_b = this.constructor) === null || _b === void 0 ? void 0 : _b.name}"`);
+            const relationHasExists = (_c = Object.values(this.$constants('RELATIONSHIP'))) === null || _c === void 0 ? void 0 : _c.includes(relation.relation);
+            this._assertError(!relationHasExists, `Unknown relationship in [${this.$constants('RELATIONSHIP')}] !`);
+            if (relation.query == null)
+                relation.query = new relation.model();
+            return relation;
+        });
+        for (const relation of relations) {
+            if (type === 'default')
+                break;
+            relation[type] = true;
+        }
+        return this._getState('RELATIONS').length
+            ? [...relations.map((w) => {
+                    const exists = this._getState('RELATIONS').find((r) => r.name === w.name);
+                    if (exists)
+                        return null;
+                    return w;
+                }).filter((d) => d != null),
+                ...this._getState('RELATIONS')]
+            : relations;
+    }
+    callback(nameRelation, cb) {
+        var _a, _b;
+        const relation = this._getState('RELATIONS').find((data) => data.name === nameRelation);
+        this._assertError(relation == null, `This Relation "${nameRelation}" not be register in Model "${(_a = this.constructor) === null || _a === void 0 ? void 0 : _a.name}"`);
+        const relationHasExists = (_b = Object.values(this.$constants('RELATIONSHIP'))) === null || _b === void 0 ? void 0 : _b.includes(relation.relation);
+        this._assertError(!relationHasExists, `unknown relationship in [${this.$constants('RELATIONSHIP')}] !`);
+        relation.query = cb(new relation.model());
+        return;
+    }
+    hasOne({ name, as, model, localKey, foreignKey, freezeTable }) {
+        const relation = {
+            name,
+            model,
+            as,
+            relation: this.$constants('RELATIONSHIP').hasOne,
+            localKey,
+            foreignKey,
+            freezeTable,
+            query: null
+        };
+        return this._setState('RELATION', [...this._getState('RELATION'), relation]);
+    }
+    hasMany({ name, as, model, localKey, foreignKey, freezeTable }) {
+        const relation = {
+            name,
+            model,
+            as,
+            relation: this.$constants('RELATIONSHIP').hasMany,
+            localKey,
+            foreignKey,
+            freezeTable,
+            query: null
+        };
+        return this._setState('RELATION', [...this._getState('RELATION'), relation]);
+    }
+    belongsTo({ name, as, model, localKey, foreignKey, freezeTable }) {
+        const relation = {
+            name,
+            model,
+            as,
+            relation: this.$constants('RELATIONSHIP').belongsTo,
+            localKey,
+            foreignKey,
+            freezeTable,
+            query: null
+        };
+        return this._setState('RELATION', [...this._getState('RELATION'), relation]);
+    }
+    belongsToMany({ name, as, model, localKey, foreignKey, freezeTable, pivot, oldVersion, modelPivot }) {
+        const relation = {
+            name,
+            model,
+            as,
+            relation: this.$constants('RELATIONSHIP').belongsToMany,
+            localKey,
+            foreignKey,
+            freezeTable,
+            pivot,
+            oldVersion,
+            query: null,
+            modelPivot
+        };
+        return this._setState('RELATION', [...this._getState('RELATION'), relation]);
+    }
+    hasOneBuilder({ name, as, model, localKey, foreignKey, freezeTable, }, callback) {
+        const nameRelation = name == null
+            ? this._functionRelationName()
+            : String(name);
+        const relation = {
+            name: nameRelation,
+            model,
+            as,
+            relation: this.$constants('RELATIONSHIP').hasOne,
+            localKey,
+            foreignKey,
+            freezeTable,
+            query: null
+        };
+        const r = this._relationBuilder(nameRelation, relation);
+        if (callback == null) {
+            r.query = new r.model();
+            return this;
+        }
+        r.query = callback(new r.model());
+        return;
+    }
+    hasManyBuilder({ name, as, model, localKey, foreignKey, freezeTable, }, callback) {
+        const nameRelation = name == null
+            ? this._functionRelationName()
+            : String(name);
+        const relation = {
+            name: nameRelation,
+            model,
+            as,
+            relation: this.$constants('RELATIONSHIP').hasMany,
+            localKey,
+            foreignKey,
+            freezeTable,
+            query: null
+        };
+        const r = this._relationBuilder(nameRelation, relation);
+        if (callback == null) {
+            r.query = new r.model();
+            return this;
+        }
+        r.query = callback(new r.model());
+        return;
+    }
+    belongsToBuilder({ name, as, model, localKey, foreignKey, freezeTable, }, callback) {
+        const nameRelation = name == null
+            ? this._functionRelationName()
+            : String(name);
+        const relation = {
+            name: nameRelation,
+            model,
+            as,
+            relation: this.$constants('RELATIONSHIP').belongsTo,
+            localKey,
+            foreignKey,
+            freezeTable,
+            query: null
+        };
+        const r = this._relationBuilder(nameRelation, relation);
+        if (callback == null) {
+            r.query = new r.model();
+            return this;
+        }
+        r.query = callback(new r.model());
+        return;
+    }
+    belongsToManyBuilder({ name, as, model, localKey, foreignKey, freezeTable, pivot }, callback) {
+        const nameRelation = name == null
+            ? this._functionRelationName()
+            : String(name);
+        const relation = {
+            name: nameRelation,
+            model,
+            as,
+            relation: this.$constants('RELATIONSHIP').belongsToMany,
+            localKey,
+            foreignKey,
+            freezeTable,
+            pivot,
+            query: null
+        };
+        const r = this._relationBuilder(nameRelation, relation);
+        if (callback == null) {
+            r.query = new r.model();
+            return this;
+        }
+        r.query = callback(new r.model());
+        return;
+    }
+    _handleRelationsExists(relation) {
+        var _a, _b, _c;
+        this._assertError(!((_a = Object.keys(relation)) === null || _a === void 0 ? void 0 : _a.length), `unknown [relation]`);
+        const { localKey, foreignKey } = this._valueInRelation(relation);
+        const query = relation.query;
+        this._assertError(query == null, `Unknown callback query in [Relation : '${relation.name}']`);
+        const clone = new Model_1.Model().clone(query);
+        const cloneRelations = clone['_getState']('RELATIONS');
+        if (cloneRelations.length) {
+            for (const r of cloneRelations) {
+                if (r.query == null)
+                    continue;
+                const sql = (_c = (_b = clone['$relation']) === null || _b === void 0 ? void 0 : _b._handleRelationsExists(r)) !== null && _c !== void 0 ? _c : '';
+                clone.whereExists(sql);
+            }
+        }
+        const sql = clone
+            .bind(this.MODEL['$pool'].get())
+            .select(this._getState('PRIMARY_KEY'))
+            .whereReference(`\`${this.MODEL['getTableName']()}\`.\`${localKey}\``, `\`${query.getTableName()}\`.\`${foreignKey}\``)
+            .toString();
+        return sql;
+    }
+    _relationBuilder(nameRelation, relation) {
+        var _a;
+        this._setState('RELATION', [...this._getState('RELATION'), relation]);
+        this.MODEL['with'](nameRelation);
+        const r = this._getState('RELATIONS').find((data) => data.name === nameRelation);
+        this._assertError(relation == null, `This Relation "${nameRelation}" not be register in Model "${(_a = this.constructor) === null || _a === void 0 ? void 0 : _a.name}"`);
+        this._assertError(!Object.values(this.$constants('RELATIONSHIP')).includes(r.relation), `unknown relationship in [${this.$constants('RELATIONSHIP')}] !`);
+        return r;
+    }
+    _functionRelationName() {
+        const functionName = [...this.$logger.get()][this.$logger.get().length - 2];
+        return functionName.replace(/([A-Z])/g, (str) => `_${str.toLowerCase()}`);
+    }
+    _relationMapData(dataParents, dataChilds, relations) {
+        const { name, as, relation, localKey, foreignKey } = this._valueInRelation(relations);
+        const keyRelation = as !== null && as !== void 0 ? as : name;
+        for (const dataParent of dataParents) {
+            const relationIsHasOneOrBelongsTo = [
+                this.$constants('RELATIONSHIP').hasOne,
+                this.$constants('RELATIONSHIP').belongsTo
+            ].some(r => r === relation);
+            dataParent[keyRelation] = [];
+            if (relationIsHasOneOrBelongsTo)
+                dataParent[keyRelation] = null;
+            if (!dataChilds.length)
+                continue;
+            for (const dataChild of dataChilds) {
+                if (dataChild[foreignKey] === dataParent[localKey]) {
+                    const relationIsHasOneOrBelongsTo = [
+                        this.$constants('RELATIONSHIP').hasOne,
+                        this.$constants('RELATIONSHIP').belongsTo
+                    ].some(r => r === relation);
+                    if (relationIsHasOneOrBelongsTo) {
+                        dataParent[keyRelation] = dataParent[keyRelation] || dataChild;
+                        continue;
+                    }
+                    if (dataParent[keyRelation] == null)
+                        dataParent[keyRelation] = [];
+                    dataParent[keyRelation].push(dataChild);
+                }
+            }
+        }
+        return dataParents;
+    }
+    _belongsToMany(parents, relation) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            const { name, foreignKey, localKey, pivot, oldVersion, modelPivot } = this._valueInRelation(relation);
+            const localKeyId = parents.map((parent) => {
+                const data = parent[foreignKey];
+                if (parent.hasOwnProperty(foreignKey))
+                    return data;
+                this._assertError(data == null, `Unknown relationship without primary or foreign key in Relation : [${relation === null || relation === void 0 ? void 0 : relation.name}]`);
+            }).filter((d) => d != null);
+            const mainResultIds = Array.from(new Set(localKeyId));
+            if (!mainResultIds.length && this._getState('RELATIONS_EXISTS'))
+                return [];
+            const modelRelation = new relation.model();
+            const relationColumn = this.MODEL['_classToTableName'](modelRelation.constructor.name, { singular: true });
+            const mainlocalKey = 'id';
+            const relationForeignKey = this._valuePattern(`${relationColumn}Id`);
+            const localKeyPivotTable = this._valuePattern([pluralize_1.default.singular(this.MODEL['getTableName']()), foreignKey].join("_"));
+            const pivotTable = String(((_a = relation.pivot) !== null && _a !== void 0 ? _a : pivot));
+            const sqlPivotExists = new Model_1.Model()
+                .copyModel(modelRelation)
+                .select(this._getState('PRIMARY_KEY'))
+                .whereReference(`\`${modelRelation.getTableName()}\`.\`${foreignKey}\``, `\`${pivotTable}\`.\`${localKey}\``)
+                .toString();
+            const queryPivot = modelPivot
+                ? new modelPivot()
+                : new Model_1.Model().table(pivotTable);
+            const sqlPivot = queryPivot
+                .whereIn(localKeyPivotTable, mainResultIds)
+                .when(relation.exists, (query) => query.whereExists(sqlPivotExists))
+                .when(relation.trashed, (query) => query.onlyTrashed())
+                .when(relation.all, (query) => query.disableSoftDelete())
+                .toString();
+            const pivotResults = yield this.MODEL['_queryStatement'](sqlPivot);
+            const relationIds = Array.from(new Set(pivotResults
+                .map((pivotResult) => pivotResult[relationForeignKey])
+                .filter((d) => d != null)));
+            const relationResults = yield this.MODEL['_queryStatement'](modelRelation
+                .whereIn(mainlocalKey, relationIds)
+                .when(relation.trashed, (query) => query.disableSoftDelete())
+                .toString());
+            if (oldVersion) {
+                for (const pivotResult of pivotResults) {
+                    for (const relationResult of relationResults) {
+                        if (relationResult[mainlocalKey] !== pivotResult[relationForeignKey])
+                            continue;
+                        pivotResult[relationColumn] = relationResult;
+                    }
+                }
+                for (const parent of parents) {
+                    if (parent[name] == null)
+                        parent[name] = [];
+                    for (const pivotResult of pivotResults) {
+                        if (pivotResult[localKeyPivotTable] !== parent[foreignKey])
+                            continue;
+                        parent[name].push(pivotResult);
+                    }
+                }
+                if (this._getState('HIDDEN').length)
+                    this.MODEL['_hiddenColumnModel'](parents);
+                return parents;
+            }
+            for (const parent of parents) {
+                if (parent[name] == null)
+                    parent[name] = [];
+                for (const pivotResult of pivotResults) {
+                    if (pivotResult[localKeyPivotTable] !== parent[foreignKey])
+                        continue;
+                    const data = relationResults.find(relationResult => relationResult[foreignKey] === pivotResult[localKey]);
+                    if (data == null)
+                        continue;
+                    data.pivot = {
+                        [localKeyPivotTable]: pivotResult[localKeyPivotTable],
+                        [localKey]: pivotResult[localKey],
+                    };
+                    parent[name].push(data);
+                }
+            }
+            if (this._getState('HIDDEN').length)
+                this.MODEL['_hiddenColumnModel'](parents);
+            return parents;
+        });
+    }
+    _valueInRelation(relationModel) {
+        var _a, _b, _c;
+        this._assertError((relationModel === null || relationModel === void 0 ? void 0 : relationModel.query) instanceof Promise, 'Nested Relation isn\'t supported Promise method');
+        this._assertError(!((relationModel === null || relationModel === void 0 ? void 0 : relationModel.query) instanceof Model_1.Model), 'Callback function supported instance of Model only');
+        const relation = relationModel.relation;
+        const model = (_a = relationModel.model) === null || _a === void 0 ? void 0 : _a.name;
+        const modelPivot = relationModel.modelPivot;
+        const oldVersion = relationModel.oldVersion;
+        const table = relationModel.freezeTable
+            ? relationModel.freezeTable
+            : (_b = relationModel.query) === null || _b === void 0 ? void 0 : _b.getTableName();
+        let pivot = null;
+        const name = relationModel.name;
+        const as = relationModel.as;
+        this._assertError(!model || model == null, 'Not found model');
+        let localKey = this._valuePattern(relationModel.localKey
+            ? relationModel.localKey
+            : this._getState('PRIMARY_KEY'));
+        let foreignKey = relationModel.foreignKey
+            ? relationModel.foreignKey
+            : this._valuePattern([
+                `${pluralize_1.default.singular(this.MODEL['getTableName']())}`,
+                `${this._getState('PRIMARY_KEY')}`
+            ].join('_'));
+        const checkRelationIsBelongsTo = [
+            relationModel.localKey == null,
+            relationModel.foreignKey == null,
+            relation === this.$constants('RELATIONSHIP').belongsTo
+        ].every(r => r);
+        if (checkRelationIsBelongsTo) {
+            foreignKey = localKey;
+            localKey = this._valuePattern([
+                `${pluralize_1.default.singular(table !== null && table !== void 0 ? table : '')}`,
+                `${this._getState('PRIMARY_KEY')}`
+            ].join('_'));
+        }
+        const checkRelationIsBelongsToMany = [
+            relationModel.localKey == null,
+            relationModel.foreignKey == null,
+            relation === this.$constants('RELATIONSHIP').belongsToMany
+        ].every(r => r);
+        if (checkRelationIsBelongsToMany) {
+            localKey = this._valuePattern([
+                `${pluralize_1.default.singular(table !== null && table !== void 0 ? table : '')}`,
+                `${this._getState('PRIMARY_KEY')}`
+            ].join('_'));
+            foreignKey = 'id';
+            const pivotModel = relationModel.query;
+            pivot = (_c = relationModel.pivot) !== null && _c !== void 0 ? _c : this._valuePattern([
+                pluralize_1.default.singular(this.MODEL['getTableName']()),
+                pluralize_1.default.singular(pivotModel.getTableName())
+            ].sort().join('_'));
+        }
+        return {
+            name,
+            as,
+            relation,
+            table,
+            localKey,
+            foreignKey,
+            model,
+            pivot,
+            oldVersion,
+            modelPivot
+        };
+    }
+    _valuePattern(value) {
+        switch (this._getState('PATTERN')) {
+            case this.$constants('PATTERN').snake_case: {
+                return value.replace(/([A-Z])/g, (str) => `_${str.toLowerCase()}`);
+            }
+            case this.$constants('PATTERN').camelCase: {
+                return value.replace(/(.(\_|-|\s)+.)/g, (str) => `${str[0]}${str[str.length - 1].toUpperCase()}`);
+            }
+            default: return value;
+        }
+    }
+    _assertError(condition = true, message = 'error') {
+        if (typeof condition === 'string') {
+            throw new Error(condition);
+        }
+        if (condition)
+            throw new Error(message);
+        return;
+    }
+    _getState(key) {
+        return this.MODEL['_getState'](key.toLocaleUpperCase());
+    }
+    _setState(key, value) {
+        return this.MODEL['_setState'](key, value);
+    }
+}
+exports.RelationHandler = RelationHandler;
+exports.default = RelationHandler;

package/dist/lib/tspace/Schema.d.ts

@@ -4,9 +4,11 @@ declare class Schema extends Builder {
     createTable: (table: string, schemas: Record<string, any>) => string;
     /**
      *
-     * Sync will check for create or update table or columns with useSchema in your model.
+     * The 'Sync' method is used to check for create or update table or columns with your schema in your model.
+     *
+     * The schema can define with method 'useSchema'
      * @param {string} pathFolders directory to models
-     * @property {boolean} options.force - forec to always check columns is exists
+     * @property {boolean} options.force - forec always check all columns if not exists will be created
      * @property {boolean} options.log   - show log execution with sql statements
      * @property {boolean} options.delay - wait for execution
      * @example
@@ -43,7 +45,7 @@ declare class Schema extends Builder {
      *          this.useSchema ({
      *               id          : new Blueprint().int().notNull().primary().autoIncrement(),
      *               uuid        : new Blueprint().varchar(50).null(),
-     *               user_id     : new Blueprint().int().notNull(),
+     *               user_id     : new Blueprint().int().notNull().foreign({ references : 'id' , on : User , onDelete : 'CASCADE' , onUpdate : 'CASCADE' }),,
      *               title       : new Blueprint().varchar(255).null(),
      *               created_at  : new Blueprint().timestamp().null(),
      *               updated_at  : new Blueprint().timestamp().null(),
@@ -54,12 +56,15 @@ declare class Schema extends Builder {
      *
      *  await Schema.sync(`app/Models` , { force : true })
      */
-    static sync(pathFolders: string, { force, log, delay }?: {
+    static sync(pathFolders: string, { force, log, foreign, delay }?: {
         force?: boolean | undefined;
         log?: boolean | undefined;
+        foreign?: boolean | undefined;
         delay?: number | undefined;
     }): Promise<void>;
+    private static _import;
     private static _syncExecute;
+    private static _syncForeignKey;
 }
 export { Schema };
 export default Schema;