pg-manipulator 1.0.1

package/dist/class/bettings/teams.js

@@ -0,0 +1,58 @@
+"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 });
+const base_1 = __importDefault(require("../../base"));
+class teams extends base_1.default {
+    static get(fields, transaction) {
+        const _super = Object.create(null, {
+            b_get: { get: () => super.b_get }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield _super.b_get.call(this, 'bettings', fields, 'teams', transaction);
+        });
+    }
+    static get_all(fields, transaction) {
+        const _super = Object.create(null, {
+            b_get_all: { get: () => super.b_get_all }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield _super.b_get_all.call(this, 'bettings', fields, 'teams', transaction);
+        });
+    }
+    static create(fields, transaction) {
+        const _super = Object.create(null, {
+            b_create: { get: () => super.b_create }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield _super.b_create.call(this, 'bettings', fields, 'teams', transaction);
+        });
+    }
+    static update(fields, transaction) {
+        const _super = Object.create(null, {
+            b_update: { get: () => super.b_update }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield _super.b_update.call(this, 'bettings', fields, 'teams', transaction);
+        });
+    }
+    static delete(fields, transaction) {
+        const _super = Object.create(null, {
+            b_delete: { get: () => super.b_delete }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield _super.b_delete.call(this, 'bettings', fields, 'teams', transaction);
+        });
+    }
+}
+exports.default = teams;

package/dist/class/users/index.d.ts

@@ -0,0 +1,13 @@
+import { PoolClient } from 'pg';
+import { pool_tsx } from '../../@types';
+import users from './users';
+import transactions from './transactions';
+import transaction_historics from './transaction_historics';
+declare const _default: {
+    query(query_string: string, query_params: Array<any>, transaction: PoolClient): Promise<any>;
+    transaction(callback: pool_tsx): Promise<void>;
+    users: typeof users;
+    transactions: typeof transactions;
+    transaction_historics: typeof transaction_historics;
+};
+export default _default;

package/dist/class/users/index.js

@@ -0,0 +1,33 @@
+"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 });
+const database_1 = __importDefault(require("../../../src/database"));
+const users_1 = __importDefault(require("./users"));
+const transactions_1 = __importDefault(require("./transactions"));
+const transaction_historics_1 = __importDefault(require("./transaction_historics"));
+exports.default = {
+    query(query_string, query_params, transaction) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield database_1.default.query('users', query_string, query_params, transaction);
+        });
+    },
+    transaction(callback) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield database_1.default.transaction('users', callback);
+        });
+    },
+    users: users_1.default,
+    transactions: transactions_1.default,
+    transaction_historics: transaction_historics_1.default
+};

package/dist/class/users/transaction_historics.d.ts

@@ -0,0 +1,13 @@
+import base from '../../base';
+import { PoolClient } from 'pg';
+import { transaction_historics_select } from '../../@types/users/transaction_historics_select';
+import { transaction_historics_where } from '../../@types/users/transaction_historics_where';
+import { transaction_historics_update } from '../../@types/users/transaction_historics_update';
+import { transaction_historics_fields } from '../../@types/users/transaction_historics_fields';
+export default class transaction_historics extends base {
+    static get(fields: transaction_historics_select, transaction: PoolClient | undefined): Promise<transaction_historics_fields>;
+    static get_all(fields: transaction_historics_select, transaction: PoolClient | undefined): Promise<transaction_historics_fields[]>;
+    static create(fields: transaction_historics, transaction: PoolClient | undefined): Promise<transaction_historics_fields>;
+    static update(fields: transaction_historics_update, transaction: PoolClient | undefined): Promise<any>;
+    static delete(fields: transaction_historics_where, transaction: PoolClient | undefined): Promise<any>;
+}

package/dist/class/users/transaction_historics.js

@@ -0,0 +1,58 @@
+"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 });
+const base_1 = __importDefault(require("../../base"));
+class transaction_historics extends base_1.default {
+    static get(fields, transaction) {
+        const _super = Object.create(null, {
+            b_get: { get: () => super.b_get }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield _super.b_get.call(this, 'users', fields, 'transaction_historics', transaction);
+        });
+    }
+    static get_all(fields, transaction) {
+        const _super = Object.create(null, {
+            b_get_all: { get: () => super.b_get_all }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield _super.b_get_all.call(this, 'users', fields, 'transaction_historics', transaction);
+        });
+    }
+    static create(fields, transaction) {
+        const _super = Object.create(null, {
+            b_create: { get: () => super.b_create }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield _super.b_create.call(this, 'users', fields, 'transaction_historics', transaction);
+        });
+    }
+    static update(fields, transaction) {
+        const _super = Object.create(null, {
+            b_update: { get: () => super.b_update }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield _super.b_update.call(this, 'users', fields, 'transaction_historics', transaction);
+        });
+    }
+    static delete(fields, transaction) {
+        const _super = Object.create(null, {
+            b_delete: { get: () => super.b_delete }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield _super.b_delete.call(this, 'users', fields, 'transaction_historics', transaction);
+        });
+    }
+}
+exports.default = transaction_historics;

package/dist/class/users/transactions.d.ts

@@ -0,0 +1,13 @@
+import base from '../../base';
+import { PoolClient } from 'pg';
+import { transactions_select } from '../../@types/users/transactions_select';
+import { transactions_where } from '../../@types/users/transactions_where';
+import { transactions_update } from '../../@types/users/transactions_update';
+import { transactions_fields } from '../../@types/users/transactions_fields';
+export default class transactions extends base {
+    static get(fields: transactions_select, transaction: PoolClient | undefined): Promise<transactions_fields>;
+    static get_all(fields: transactions_select, transaction: PoolClient | undefined): Promise<transactions_fields[]>;
+    static create(fields: transactions, transaction: PoolClient | undefined): Promise<transactions_fields>;
+    static update(fields: transactions_update, transaction: PoolClient | undefined): Promise<any>;
+    static delete(fields: transactions_where, transaction: PoolClient | undefined): Promise<any>;
+}

package/dist/class/users/transactions.js

@@ -0,0 +1,58 @@
+"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 });
+const base_1 = __importDefault(require("../../base"));
+class transactions extends base_1.default {
+    static get(fields, transaction) {
+        const _super = Object.create(null, {
+            b_get: { get: () => super.b_get }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield _super.b_get.call(this, 'users', fields, 'transactions', transaction);
+        });
+    }
+    static get_all(fields, transaction) {
+        const _super = Object.create(null, {
+            b_get_all: { get: () => super.b_get_all }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield _super.b_get_all.call(this, 'users', fields, 'transactions', transaction);
+        });
+    }
+    static create(fields, transaction) {
+        const _super = Object.create(null, {
+            b_create: { get: () => super.b_create }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield _super.b_create.call(this, 'users', fields, 'transactions', transaction);
+        });
+    }
+    static update(fields, transaction) {
+        const _super = Object.create(null, {
+            b_update: { get: () => super.b_update }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield _super.b_update.call(this, 'users', fields, 'transactions', transaction);
+        });
+    }
+    static delete(fields, transaction) {
+        const _super = Object.create(null, {
+            b_delete: { get: () => super.b_delete }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield _super.b_delete.call(this, 'users', fields, 'transactions', transaction);
+        });
+    }
+}
+exports.default = transactions;

package/dist/class/users/users.d.ts

@@ -0,0 +1,13 @@
+import base from '../../base';
+import { PoolClient } from 'pg';
+import { users_select } from '../../@types/users/users_select';
+import { users_where } from '../../@types/users/users_where';
+import { users_update } from '../../@types/users/users_update';
+import { users_fields } from '../../@types/users/users_fields';
+export default class users extends base {
+    static get(fields: users_select, transaction: PoolClient | undefined): Promise<users_fields>;
+    static get_all(fields: users_select, transaction: PoolClient | undefined): Promise<users_fields[]>;
+    static create(fields: users, transaction: PoolClient | undefined): Promise<users_fields>;
+    static update(fields: users_update, transaction: PoolClient | undefined): Promise<any>;
+    static delete(fields: users_where, transaction: PoolClient | undefined): Promise<any>;
+}

package/dist/class/users/users.js

@@ -0,0 +1,58 @@
+"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 });
+const base_1 = __importDefault(require("../../base"));
+class users extends base_1.default {
+    static get(fields, transaction) {
+        const _super = Object.create(null, {
+            b_get: { get: () => super.b_get }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield _super.b_get.call(this, 'users', fields, 'users', transaction);
+        });
+    }
+    static get_all(fields, transaction) {
+        const _super = Object.create(null, {
+            b_get_all: { get: () => super.b_get_all }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield _super.b_get_all.call(this, 'users', fields, 'users', transaction);
+        });
+    }
+    static create(fields, transaction) {
+        const _super = Object.create(null, {
+            b_create: { get: () => super.b_create }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield _super.b_create.call(this, 'users', fields, 'users', transaction);
+        });
+    }
+    static update(fields, transaction) {
+        const _super = Object.create(null, {
+            b_update: { get: () => super.b_update }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield _super.b_update.call(this, 'users', fields, 'users', transaction);
+        });
+    }
+    static delete(fields, transaction) {
+        const _super = Object.create(null, {
+            b_delete: { get: () => super.b_delete }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield _super.b_delete.call(this, 'users', fields, 'users', transaction);
+        });
+    }
+}
+exports.default = users;

package/dist/database/client/index.d.ts

@@ -0,0 +1,9 @@
+import { Client, Pool } from 'pg';
+import { pool_tsx } from '../../@types';
+export default class core_client {
+    client: Client;
+    name: string;
+    constructor(client: Client, db_name: string);
+    query(query_string: string, query_params: Array<any>, transaction?: Pool | undefined): Promise<any[]>;
+    transaction(callback: pool_tsx): Promise<void>;
+}

package/dist/database/client/index.js

@@ -0,0 +1,61 @@
+"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 });
+const pg_1 = require("pg");
+const fs_1 = __importDefault(require("fs"));
+const env_data = JSON.parse(fs_1.default.readFileSync('env.json', { encoding: 'utf8' }));
+class core_client {
+    constructor(client, db_name) {
+        this.name = db_name;
+        this.client = client;
+    }
+    query(query_string_1, query_params_1) {
+        return __awaiter(this, arguments, void 0, function* (query_string, query_params, transaction = undefined) {
+            if (transaction) {
+                return yield transaction.query(query_string, query_params).then((res) => {
+                    return res.rows;
+                }).catch((error) => {
+                    throw error;
+                });
+            }
+            return yield this.client.query(query_string, query_params).then((res) => {
+                return res.rows;
+            }).catch((error) => {
+                throw error;
+            });
+        });
+    }
+    transaction(callback) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const conn = new pg_1.Pool({
+                connectionString: env_data[this.name],
+                query_timeout: 5000,
+                statement_timeout: undefined,
+            });
+            const tsx = yield conn.connect();
+            try {
+                yield tsx.query('BEGIN');
+                yield callback(tsx);
+                yield tsx.query('COMMIT');
+            }
+            catch (e) {
+                yield tsx.query('ROLLBACK');
+            }
+            finally {
+                yield tsx.release(true);
+            }
+        });
+    }
+}
+exports.default = core_client;

package/dist/database/index.d.ts

@@ -0,0 +1,10 @@
+import { PoolClient } from 'pg';
+import { pool_tsx } from '../@types';
+export default class db {
+    static connections: any;
+    static open(): Promise<void>;
+    static set(db_name: string): Promise<void>;
+    static get(db_name: string): any;
+    static query(db_name: string, query_string: string, query_params: Array<any>, transaction?: PoolClient | undefined): Promise<any>;
+    static transaction(db_name: string, callback: pool_tsx): Promise<void>;
+}

package/dist/database/index.js

@@ -0,0 +1,80 @@
+"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 });
+const pg_1 = __importDefault(require("pg"));
+const { Client, Pool } = pg_1.default;
+const fs_1 = __importDefault(require("fs"));
+const client_1 = __importDefault(require("./client"));
+const env_data = JSON.parse(fs_1.default.readFileSync('env.json', { encoding: 'utf8' }));
+class db {
+    static open() {
+        return __awaiter(this, void 0, void 0, function* () {
+            for (const db_name in env_data) {
+                console.log(`Connection ${db_name}...`);
+                yield this.set(db_name);
+                console.log(`Connected ${db_name} successful`);
+            }
+        });
+    }
+    static set(db_name) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const conn = new Client(env_data[db_name]);
+            conn.connect();
+            this.connections[db_name] = new client_1.default(conn, db_name);
+        });
+    }
+    static get(db_name) {
+        if (!db_name || typeof db_name != 'string' || !this.connections[db_name]) {
+            throw `Incorrectly reported database`;
+        }
+        return this.connections[db_name];
+    }
+    static query(db_name_1, query_string_1, query_params_1) {
+        return __awaiter(this, arguments, void 0, function* (db_name, query_string, query_params, transaction = undefined) {
+            if (transaction) {
+                return yield transaction.query(query_string, query_params).then((res) => {
+                    return res.rows;
+                }).catch((error) => {
+                    throw error;
+                });
+            }
+            else {
+                return yield this.get(db_name).query(query_string, query_params, transaction);
+            }
+        });
+    }
+    static transaction(db_name, callback) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const conn = new Pool({
+                connectionString: env_data[db_name],
+                query_timeout: 5000,
+                statement_timeout: undefined,
+            });
+            const tsx = yield conn.connect();
+            try {
+                yield tsx.query('BEGIN');
+                yield callback(tsx);
+                yield tsx.query('COMMIT');
+            }
+            catch (e) {
+                yield tsx.query('ROLLBACK');
+            }
+            finally {
+                yield tsx.release(true);
+            }
+        });
+    }
+}
+db.connections = {};
+exports.default = db;

package/dist/generator/index.d.ts

@@ -0,0 +1,4 @@
+export default class generator {
+    static update(): Promise<void>;
+    static dump(): Promise<void>;
+}

package/dist/generator/index.js

@@ -0,0 +1,144 @@
+"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 });
+const scripts_1 = require("../scripts");
+const database_1 = __importDefault(require("./model/database"));
+const entity_1 = __importDefault(require("./template/entity"));
+const schema_1 = __importDefault(require("./template/schema"));
+const select_1 = __importDefault(require("./template/select"));
+const where_1 = __importDefault(require("./template/where"));
+const order_1 = __importDefault(require("./template/order"));
+const update_1 = __importDefault(require("./template/update"));
+const schema_store_1 = __importDefault(require("./template/schema_store"));
+const entity_store_1 = __importDefault(require("./template/entity_store"));
+const database_store_1 = __importDefault(require("./template/database_store"));
+const database_2 = __importDefault(require("../database"));
+const fs_1 = __importDefault(require("fs"));
+const uuid_1 = require("uuid");
+const fields_1 = __importDefault(require("./template/fields"));
+class generator {
+    static update() {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            database_2.default.open();
+            for (const db_name in database_2.default.connections) {
+                try {
+                    yield database_2.default.get(db_name).query(scripts_1.create_scripts_table);
+                    console.log(`\u001b[32m Criando tabela para receber histórico de scripts... ${db_name}`);
+                }
+                catch (error) {
+                    console.log(`\u001b[32m Executando scripts... ${db_name}`);
+                }
+                let scripts = [];
+                let result = [];
+                let usage = [];
+                let fail;
+                const executed = yield database_2.default.get(db_name).query(scripts_1.all_comans_query);
+                try {
+                    scripts.push(...JSON.parse(fs_1.default.readFileSync(`${db_name}-scripts.json`, { encoding: 'utf8' })));
+                }
+                catch (error) {
+                    console.log(`\u001b[31m Arquivo de scripts de ${db_name} inexistente`);
+                    console.log(`\u001b[31m Sera criado arquivo ${db_name}-scripts.json na raiz de seu projeto`);
+                    console.log(`\u001b[31m Insira suas instruções da seguinte forma:`);
+                    console.log(`\u001b[31m [`);
+                    console.log(`\u001b[31m   {`);
+                    console.log(`\u001b[31m     "comand": "INSTRUÇÃO SQL 1"`);
+                    console.log(`\u001b[31m   }`);
+                    console.log(`\u001b[31m   {`);
+                    console.log(`\u001b[31m     "comand": "INSTRUÇÃO SQL 2"`);
+                    console.log(`\u001b[31m   }`);
+                    console.log(`\u001b[31m   {`);
+                    console.log(`\u001b[31m     "comand": "INSTRUÇÃO SQL 3"`);
+                    console.log(`\u001b[31m   }`);
+                    console.log(`\u001b[31m ]`);
+                    fs_1.default.writeFileSync(`${db_name}-scripts.json`, JSON.stringify([], null, '\t'));
+                    continue;
+                }
+                usage = scripts.filter((actual) => !actual.id || executed.findIndex((exec) => exec.id === actual.id) === -1);
+                result = scripts.filter((actual) => actual.id && executed.findIndex((exec) => exec.id === actual.id) > -1);
+                for (const script of usage) {
+                    let success;
+                    try {
+                        yield database_2.default.get(db_name).query(script.comand);
+                        success = true;
+                    }
+                    catch (error) {
+                        success = false;
+                        fail = error;
+                    }
+                    finally {
+                        const comand = (_a = (yield database_2.default
+                            .get(db_name)
+                            .query(scripts_1.save_script_query, [script.id || (0, uuid_1.v4)(), script.comand, new Date(), success, fail]))) === null || _a === void 0 ? void 0 : _a.shift();
+                        if (success)
+                            console.log(`\u001b[32m ${db_name} - Sucesso ao executar script ${comand.id}`);
+                        else
+                            console.log(`\u001b[31m ${db_name} - Erro ao executar script ${comand.id} - ${fail}`);
+                        result.push(Object.assign(Object.assign({}, comand), { date: script.date || comand.date }));
+                        fail = undefined;
+                    }
+                }
+                console.log('\u001b[0m');
+                fs_1.default.writeFileSync(`${db_name}-scripts.json`, JSON.stringify(result, null, '\t'));
+            }
+        });
+    }
+    static dump() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield database_2.default.open();
+            const connections = new database_store_1.default();
+            if (!fs_1.default.existsSync(`src/class`)) {
+                fs_1.default.mkdirSync(`src/class`);
+            }
+            if (!fs_1.default.existsSync(`src/mapping`)) {
+                fs_1.default.mkdirSync(`src/mapping`);
+            }
+            for (const db_name in database_2.default.connections) {
+                if (!fs_1.default.existsSync(`src/class/${db_name}`)) {
+                    fs_1.default.mkdirSync(`src/class/${db_name}`);
+                }
+                if (!fs_1.default.existsSync(`src/mapping/${db_name}`)) {
+                    fs_1.default.mkdirSync(`src/mapping/${db_name}`);
+                }
+                if (!fs_1.default.existsSync(`src/@types/${db_name}`)) {
+                    fs_1.default.mkdirSync(`src/@types/${db_name}`);
+                }
+                const db_class = new database_1.default(yield database_2.default.get(db_name).query(scripts_1.schema_query));
+                const schemas = new schema_store_1.default(db_name);
+                const entityes = new entity_store_1.default(db_name);
+                connections.add(db_name);
+                console.log('\u001b[32m Início do mapeamento concluido');
+                for (let table_name in db_class.tables) {
+                    new entity_1.default(db_class.tables[table_name], db_name).dump();
+                    new schema_1.default(db_class.tables[table_name], db_name).dump();
+                    schemas.add(db_class.tables[table_name].name);
+                    entityes.add(db_class.tables[table_name].name);
+                    new fields_1.default(db_class.tables[table_name], db_name).dump();
+                    new select_1.default(db_class.tables[table_name], db_name).dump();
+                    new where_1.default(db_class.tables[table_name], db_name).dump();
+                    new order_1.default(db_class.tables[table_name], db_name).dump();
+                    new update_1.default(db_class.tables[table_name], db_name).dump();
+                    console.log(`\u001b[36m ${db_class.tables[table_name].name}...`);
+                }
+                console.log('\u001b[32m Dump concluido');
+                console.log('\u001b[0m');
+                schemas.dump();
+                entityes.dump();
+            }
+            connections.dump();
+        });
+    }
+}
+exports.default = generator;

package/dist/generator/model/database.d.ts

@@ -0,0 +1,7 @@
+import table from './table';
+export default class database {
+    tables: any;
+    constructor(registers: any);
+    setTable(name: string): void;
+    getTable(name: string): table;
+}