@aceitadev/adatabase 0.1.0

package/README.md

@@ -0,0 +1,66 @@
+```markdown
+# aMySQL - Node.js (TypeScript) port
+
+Esta é uma implementação inicial do seu sistema aMySQL para Node.js usando TypeScript e decorators.
+
+Principais características
+- Pool de conexões (mysql2/promise)
+- Decorators: @Table, @Column, @Id, @Nullable
+- ColumnAdapter para tipos serializados customizados
+- ActiveRecord com save/update/delete
+- QueryBuilder (where/order/limit)
+- SchemaManager para criar/atualizar colunas automaticamente
+
+Como usar (exemplo rápido)
+
+1) Instale dependências
+npm install
+
+2) Configure tsconfig (já incluído) e habilite experimentalDecorators e emitDecoratorMetadata.
+
+3) Exemplo de modelo (src/example.ts)
+```ts
+import "reflect-metadata";
+import { init } from "./MySQL";
+import { Table } from "./decorators/Table";
+import { Column } from "./decorators/Column";
+import { Id } from "./decorators/Id";
+import { ActiveRecord } from "./ActiveRecord";
+import { SchemaManager } from "./SchemaManager";
+
+@Table("users")
+class User extends ActiveRecord {
+  @Id()
+  id!: number;
+
+  @Column({ limit: 150 })
+  name!: string;
+
+  @Column()
+  email!: string;
+}
+
+async function main() {
+  await init({ host: "127.0.0.1", database: "test", user: "root", password: "" });
+  const sm = new SchemaManager([User]);
+  await sm.migrate();
+
+  const u = new User();
+  u.name = "Fulano";
+  u.email = "fulano@example.com";
+  await u.save();
+
+  const fetched = await User.find().where("email", "=", "fulano@example.com").first();
+  console.log(fetched);
+}
+
+main().catch(console.error);
+```
+
+Limitações & próximos passos
+- QueryBuilder suporta nomes de campos como strings; não foi implementado introspecção de lambda getter como no Java.
+- Adapters: você fornece uma classe com métodos serialize/deserialize para o Column decorator.
+- Migração: apenas cria tabelas e adiciona colunas que faltam; não altera ou remove colunas existentes.
+- Recomendado: adicionar testes, melhorar mapeamento de tipos (enums, UUID), e adicionar caching e transações.
+
+```

package/dist/ActiveRecord.d.ts

@@ -0,0 +1,12 @@
+import { QueryBuilder } from "./QueryBuilder";
+import { GenericConnection } from "./adapters/IDatabaseAdapter";
+type Constructor<T> = {
+    new (...args: any[]): T;
+};
+export declare abstract class ActiveRecord {
+    private static getIdField;
+    save<T extends ActiveRecord>(this: T, tx?: GenericConnection): Promise<T>;
+    static find<T extends ActiveRecord>(this: Constructor<T>): QueryBuilder<T>;
+    delete(this: ActiveRecord, tx?: GenericConnection): Promise<void>;
+}
+export {};

package/dist/ActiveRecord.js

@@ -0,0 +1,115 @@
+"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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ActiveRecord = void 0;
+const Database_1 = require("./Database");
+const Column_1 = require("./decorators/Column");
+const PersistenceException_1 = require("./PersistenceException");
+const QueryBuilder_1 = require("./QueryBuilder");
+const Table_1 = require("./decorators/Table");
+function camelToSnake(s) {
+    return s.replace(/([a-z0-9])([A-Z])/g, "$1_$2").toLowerCase();
+}
+class ActiveRecord {
+    static getIdField(ctor) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const columns = (0, Column_1.getColumnMeta)(ctor);
+            if (!columns)
+                throw new PersistenceException_1.PersistenceException("Model has no @Column decorators", null);
+            for (const [prop, opts] of columns.entries()) {
+                if (opts === null || opts === void 0 ? void 0 : opts.id) {
+                    return prop;
+                }
+            }
+            throw new PersistenceException_1.PersistenceException("No @Id field on class", null);
+        });
+    }
+    save(tx) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const ctor = this.constructor;
+            const table = (0, Table_1.getTableName)(ctor);
+            if (!table)
+                throw new PersistenceException_1.PersistenceException("No @Table defined on class", null);
+            const columns = (0, Column_1.getColumnMeta)(ctor);
+            if (!columns)
+                throw new PersistenceException_1.PersistenceException("No @Column decorators found on class", null);
+            const conn = tx !== null && tx !== void 0 ? tx : yield (0, Database_1.getConnection)();
+            try {
+                const idField = yield ActiveRecord.getIdField(ctor);
+                const colEntries = [];
+                for (const [prop, opts] of columns.entries()) {
+                    if (opts === null || opts === void 0 ? void 0 : opts.id)
+                        continue;
+                    if (!this.hasOwnProperty(prop))
+                        continue;
+                    const value = this[prop];
+                    const colName = (opts === null || opts === void 0 ? void 0 : opts.name) ? opts.name : camelToSnake(prop);
+                    colEntries.push({ colName, value });
+                }
+                const idValue = this[idField];
+                if (idValue == null || idValue === 0) {
+                    const cols = colEntries.map(c => `\`${c.colName}\``).join(", ");
+                    const placeholders = colEntries.map(() => "?").join(", ");
+                    const params = colEntries.map(c => c.value);
+                    const sql = `INSERT INTO \`${table}\` (${cols}) VALUES (${placeholders});`;
+                    const res = yield (0, Database_1.execute)(sql, params, conn);
+                    if (res.insertId) {
+                        this[idField] = res.insertId;
+                    }
+                }
+                else {
+                    const setClause = colEntries.map(c => `\`${c.colName}\` = ?`).join(", ");
+                    const params = [...colEntries.map(c => c.value), idValue];
+                    const idColName = camelToSnake(idField);
+                    const sql = `UPDATE \`${table}\` SET ${setClause} WHERE \`${idColName}\` = ?;`;
+                    yield (0, Database_1.execute)(sql, params, conn);
+                }
+            }
+            catch (e) {
+                if (e.code === 'ER_DUP_ENTRY') {
+                    throw new PersistenceException_1.PersistenceException(`Duplicate entry violation: ${e.message}`, e);
+                }
+                throw new PersistenceException_1.PersistenceException(`Failed to save entity: ${e.message}`, e);
+            }
+            finally {
+                if (!tx && conn.release) {
+                    conn.release();
+                }
+            }
+            return this;
+        });
+    }
+    static find() {
+        return new QueryBuilder_1.QueryBuilder(this);
+    }
+    delete(tx) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const ctor = this.constructor;
+            const table = (0, Table_1.getTableName)(ctor);
+            const idField = yield ActiveRecord.getIdField(ctor);
+            const idValue = this[idField];
+            if (idValue == null)
+                return;
+            const conn = tx !== null && tx !== void 0 ? tx : yield (0, Database_1.getConnection)();
+            try {
+                const idColName = camelToSnake(idField);
+                const sql = `DELETE FROM \`${table}\` WHERE \`${idColName}\` = ?`;
+                yield (0, Database_1.execute)(sql, [idValue], conn);
+            }
+            finally {
+                if (!tx && conn.release) {
+                    conn.release();
+                }
+            }
+        });
+    }
+}
+exports.ActiveRecord = ActiveRecord;

package/dist/ColumnAdapter.d.ts

@@ -0,0 +1,8 @@
+export interface ColumnAdapter<T = any, R = any> {
+    serialize(object: T): R;
+    deserialize(object: R): T;
+}
+export declare class NoneAdapter implements ColumnAdapter<any, any> {
+    serialize(): any;
+    deserialize(): any;
+}

package/dist/ColumnAdapter.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NoneAdapter = void 0;
+class NoneAdapter {
+    serialize() {
+        throw new Error("NoneAdapter should not be used.");
+    }
+    deserialize() {
+        throw new Error("NoneAdapter should not be used.");
+    }
+}
+exports.NoneAdapter = NoneAdapter;

package/dist/Database.d.ts

@@ -0,0 +1,12 @@
+import { IDatabaseAdapter, GenericConnection } from './adapters/IDatabaseAdapter';
+type DbType = 'mysql' | 'postgres';
+export declare function init(dbType: DbType, config: any): void;
+export declare function getAdapter(): IDatabaseAdapter;
+export declare function query(sql: string, params?: any[], connection?: GenericConnection): Promise<any[]>;
+export declare function execute(sql: string, params?: any[], connection?: GenericConnection): Promise<{
+    insertId?: number;
+    affectedRows?: number;
+}>;
+export declare function getConnection(): Promise<GenericConnection>;
+export declare function closePool(): Promise<void>;
+export {};

package/dist/Database.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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.init = init;
+exports.getAdapter = getAdapter;
+exports.query = query;
+exports.execute = execute;
+exports.getConnection = getConnection;
+exports.closePool = closePool;
+const MySQLAdapter_1 = require("./adapters/MySQLAdapter");
+const PostgresAdapter_1 = require("./adapters/PostgresAdapter");
+let adapter;
+function init(dbType, config) {
+    if (dbType === 'mysql') {
+        adapter = new MySQLAdapter_1.MySQLAdapter();
+    }
+    else if (dbType === 'postgres') {
+        adapter = new PostgresAdapter_1.PostgresAdapter();
+    }
+    else {
+        throw new Error(`Tipo de banco de dados não suportado: ${dbType}`);
+    }
+    adapter.init(config);
+}
+function getAdapter() {
+    if (!adapter) {
+        throw new Error("O banco de dados não foi inicializado. Chame a função init() primeiro.");
+    }
+    return adapter;
+}
+function query(sql_1) {
+    return __awaiter(this, arguments, void 0, function* (sql, params = [], connection) {
+        return getAdapter().query(sql, params, connection);
+    });
+}
+function execute(sql_1) {
+    return __awaiter(this, arguments, void 0, function* (sql, params = [], connection) {
+        return getAdapter().execute(sql, params, connection);
+    });
+}
+function getConnection() {
+    return __awaiter(this, void 0, void 0, function* () {
+        return getAdapter().getConnection();
+    });
+}
+function closePool() {
+    return __awaiter(this, void 0, void 0, function* () {
+        return getAdapter().close();
+    });
+}

package/dist/MySQL.d.ts

@@ -0,0 +1,18 @@
+import mysql, { PoolConnection } from "mysql2/promise";
+export type Auth = {
+    host: string;
+    port?: number;
+    database: string;
+    user: string;
+    password?: string;
+};
+export type PoolOptions = {
+    connectionLimit?: number;
+    queueLimit?: number;
+    idleTimeout?: number;
+    waitForConnections?: boolean;
+};
+export declare function init(auth: Auth, options?: PoolOptions): void;
+export declare function getConnection(): Promise<PoolConnection>;
+export declare function query(sql: string, params?: any[]): Promise<mysql.QueryResult>;
+export declare function closePool(): Promise<void>;

package/dist/MySQL.js

@@ -0,0 +1,72 @@
+"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.init = init;
+exports.getConnection = getConnection;
+exports.query = query;
+exports.closePool = closePool;
+const promise_1 = __importDefault(require("mysql2/promise"));
+let pool = null;
+function init(auth, options = {}) {
+    var _a, _b, _c, _d, _e;
+    if (pool) {
+        console.warn("[aMySQL] Pool de conexões já foi inicializado. Ignorando nova chamada.");
+        return;
+    }
+    try {
+        pool = promise_1.default.createPool({
+            host: auth.host,
+            port: (_a = auth.port) !== null && _a !== void 0 ? _a : 3306,
+            database: auth.database,
+            user: auth.user,
+            password: auth.password,
+            waitForConnections: (_b = options.waitForConnections) !== null && _b !== void 0 ? _b : true,
+            connectionLimit: (_c = options.connectionLimit) !== null && _c !== void 0 ? _c : 10,
+            queueLimit: (_d = options.queueLimit) !== null && _d !== void 0 ? _d : 0,
+            idleTimeout: (_e = options.idleTimeout) !== null && _e !== void 0 ? _e : 60000,
+            namedPlaceholders: false
+        });
+        console.log("[aMySQL] ✅ Pool de conexões inicializado com sucesso.");
+    }
+    catch (error) {
+        console.error("[aMySQL] ❌ Falha catastrófica ao inicializar o pool de conexões:", error);
+        process.exit(1);
+    }
+}
+function getPool() {
+    if (!pool) {
+        throw new Error("[aMySQL] O pool de conexões não foi inicializado. Chame a função init() na inicialização da sua aplicação.");
+    }
+    return pool;
+}
+function getConnection() {
+    return __awaiter(this, void 0, void 0, function* () {
+        return getPool().getConnection();
+    });
+}
+function query(sql_1) {
+    return __awaiter(this, arguments, void 0, function* (sql, params = []) {
+        const [rows] = yield getPool().query(sql, params);
+        return rows;
+    });
+}
+function closePool() {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (pool) {
+            yield pool.end();
+            pool = null;
+            console.log("[aMySQL] Pool de conexões foi fechado com sucesso.");
+        }
+    });
+}

package/dist/PersistenceException.d.ts

@@ -0,0 +1,4 @@
+export declare class PersistenceException extends Error {
+    cause?: (Error | null) | undefined;
+    constructor(message: string, cause?: (Error | null) | undefined);
+}

package/dist/PersistenceException.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PersistenceException = void 0;
+class PersistenceException extends Error {
+    constructor(message, cause) {
+        var _a, _b;
+        super(message);
+        this.cause = cause;
+        if (cause) {
+            // preserve stack if present
+            this.stack = ((_a = this.stack) !== null && _a !== void 0 ? _a : "") + "\nCaused by: " + ((_b = cause.stack) !== null && _b !== void 0 ? _b : cause.message);
+        }
+        Object.setPrototypeOf(this, PersistenceException.prototype);
+    }
+}
+exports.PersistenceException = PersistenceException;

package/dist/QueryBuilder.d.ts

@@ -0,0 +1,17 @@
+import { ActiveRecord } from "./ActiveRecord";
+export declare class QueryBuilder<T extends ActiveRecord> {
+    private model;
+    private whereClauses;
+    private _limit?;
+    private _includes;
+    private primaryKey;
+    constructor(model: {
+        new (): T;
+    });
+    where(field: keyof T | string, operator: string, value: any): this;
+    include(...models: (new (...args: any[]) => any)[]): this;
+    first(): Promise<T | null>;
+    get(): Promise<T[]>;
+    private getColumnName;
+    private mapRowsToEntities;
+}

package/dist/QueryBuilder.js

@@ -0,0 +1,180 @@
+"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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QueryBuilder = void 0;
+const Table_1 = require("./decorators/Table");
+const Column_1 = require("./decorators/Column");
+const Database_1 = require("./Database");
+const PersistenceException_1 = require("./PersistenceException");
+const BelongsTo_1 = require("./decorators/BelongsTo");
+const HasMany_1 = require("./decorators/HasMany");
+const HasOne_1 = require("./decorators/HasOne");
+function camelToSnake(s) {
+    return s.replace(/([a-z0-g])([A-Z])/g, "$1_$2").toLowerCase();
+}
+class QueryBuilder {
+    constructor(model) {
+        this.model = model;
+        this.whereClauses = [];
+        this._includes = [];
+        this.primaryKey = 'id';
+        const colMeta = (0, Column_1.getColumnMeta)(this.model);
+        if (colMeta) {
+            for (const [prop, opts] of colMeta.entries()) {
+                if (opts.id) {
+                    this.primaryKey = prop;
+                    break;
+                }
+            }
+        }
+    }
+    where(field, operator, value) {
+        this.whereClauses.push({ field: field, operator, value, booleanOp: "AND" });
+        return this;
+    }
+    include(...models) {
+        this._includes.push(...models);
+        return this;
+    }
+    first() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this._limit = 1;
+            const rows = yield this.get();
+            return rows.length > 0 ? rows[0] : null;
+        });
+    }
+    get() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const table = (0, Table_1.getTableName)(this.model);
+            if (!table)
+                throw new PersistenceException_1.PersistenceException("Model has no @Table", null);
+            const columnsMeta = (0, Column_1.getColumnMeta)(this.model);
+            if (!columnsMeta)
+                throw new PersistenceException_1.PersistenceException("Model has no @Column decorators", null);
+            const params = [];
+            const baseAlias = 't1';
+            let selectFields = `${baseAlias}.*`;
+            let joinClause = '';
+            const allRelationMetas = [
+                { meta: (0, BelongsTo_1.getBelongsToMeta)(this.model), type: 'BelongsTo' },
+                { meta: (0, HasMany_1.getHasManyMeta)(this.model), type: 'HasMany' },
+                { meta: (0, HasOne_1.getHasOneMeta)(this.model), type: 'HasOne' }
+            ];
+            if (this._includes.length > 0) {
+                this._includes.forEach((includeModel, index) => {
+                    const relationAlias = `t${index + 2}`;
+                    let relationInfo = null;
+                    for (const { meta, type } of allRelationMetas) {
+                        if (meta) {
+                            for (const [prop, opts] of meta.entries()) {
+                                if (opts.model() === includeModel) {
+                                    relationInfo = { prop, opts, type };
+                                    break;
+                                }
+                            }
+                        }
+                        if (relationInfo)
+                            break;
+                    }
+                    if (relationInfo) {
+                        const relatedTable = (0, Table_1.getTableName)(includeModel);
+                        const relatedColumnsMeta = (0, Column_1.getColumnMeta)(includeModel);
+                        if (!relatedTable || !relatedColumnsMeta)
+                            return;
+                        for (const prop of relatedColumnsMeta.keys()) {
+                            const colName = this.getColumnName(prop, relatedColumnsMeta);
+                            selectFields += `, ${relationAlias}.\`${colName}\` AS \`${relationInfo.prop}__${prop}\``;
+                        }
+                        if (relationInfo.type === 'BelongsTo') {
+                            const foreignKey = relationInfo.opts.foreignKey;
+                            const foreignKeyCol = this.getColumnName(foreignKey, columnsMeta);
+                            joinClause += ` LEFT JOIN \`${relatedTable}\` AS ${relationAlias} ON ${baseAlias}.\`${foreignKeyCol}\` = ${relationAlias}.id`;
+                        }
+                        else { // HasOne or HasMany
+                            const foreignKey = relationInfo.opts.foreignKey;
+                            const foreignKeyCol = this.getColumnName(foreignKey, relatedColumnsMeta);
+                            joinClause += ` LEFT JOIN \`${relatedTable}\` AS ${relationAlias} ON ${baseAlias}.id = ${relationAlias}.\`${foreignKeyCol}\``;
+                        }
+                    }
+                });
+            }
+            let sql = `SELECT ${selectFields} FROM \`${table}\` AS ${baseAlias}${joinClause}`;
+            if (this.whereClauses.length) {
+                sql += " WHERE ";
+                this.whereClauses.forEach((c, i) => {
+                    if (i > 0)
+                        sql += ` ${c.booleanOp} `;
+                    const colName = this.getColumnName(c.field, columnsMeta);
+                    sql += `${baseAlias}.\`${colName}\` ${c.operator} ?`;
+                    params.push(c.value);
+                });
+            }
+            if (this._limit)
+                sql += ` LIMIT ${this._limit}`;
+            sql += ";";
+            const rows = yield (0, Database_1.query)(sql, params);
+            return this.mapRowsToEntities(rows);
+        });
+    }
+    getColumnName(prop, meta) {
+        const opts = meta.get(prop);
+        return (opts === null || opts === void 0 ? void 0 : opts.name) ? opts.name : camelToSnake(prop);
+    }
+    mapRowsToEntities(rows) {
+        const mainEntityMap = new Map();
+        const columnsMeta = (0, Column_1.getColumnMeta)(this.model);
+        const allRelationMetas = [
+            { meta: (0, BelongsTo_1.getBelongsToMeta)(this.model), type: 'BelongsTo' },
+            { meta: (0, HasMany_1.getHasManyMeta)(this.model), type: 'HasMany' },
+            { meta: (0, HasOne_1.getHasOneMeta)(this.model), type: 'HasOne' }
+        ];
+        for (const row of rows) {
+            const pkValue = row[this.primaryKey];
+            if (!mainEntityMap.has(pkValue)) {
+                const obj = new this.model();
+                for (const [prop, opts] of columnsMeta.entries()) {
+                    const colName = this.getColumnName(prop, columnsMeta);
+                    if (row.hasOwnProperty(colName)) {
+                        obj[prop] = row[colName];
+                    }
+                }
+                mainEntityMap.set(pkValue, obj);
+            }
+            const mainEntity = mainEntityMap.get(pkValue);
+            for (const { meta, type } of allRelationMetas) {
+                if (meta) {
+                    for (const [relationProp, opts] of meta.entries()) {
+                        const prefix = `${relationProp}__`;
+                        if (row[`${prefix}id`] === null)
+                            continue;
+                        const relatedModelCtor = opts.model();
+                        const relatedObj = new relatedModelCtor();
+                        const relatedColsMeta = (0, Column_1.getColumnMeta)(relatedModelCtor);
+                        for (const [prop] of relatedColsMeta.entries()) {
+                            relatedObj[prop] = row[`${prefix}${prop}`];
+                        }
+                        if (type === 'HasMany') {
+                            if (!mainEntity[relationProp]) {
+                                mainEntity[relationProp] = [];
+                            }
+                            mainEntity[relationProp].push(relatedObj);
+                        }
+                        else { // BelongsTo or HasOne
+                            mainEntity[relationProp] = relatedObj;
+                        }
+                    }
+                }
+            }
+        }
+        return Array.from(mainEntityMap.values());
+    }
+}
+exports.QueryBuilder = QueryBuilder;

package/dist/SchemaManager.d.ts

@@ -0,0 +1,11 @@
+export declare class SchemaManager {
+    private models;
+    private logger;
+    constructor(models: Function[], logger?: Console);
+    migrate(): Promise<void>;
+    private createTable;
+    private updateTable;
+    private getSchemaFromModel;
+    private getSqlTypeForClass;
+    private getExistingColumns;
+}