@aceitadev/adatabase 0.1.0

package/dist/SchemaManager.js

@@ -0,0 +1,200 @@
+"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.SchemaManager = void 0;
+const Table_1 = require("./decorators/Table");
+const Column_1 = require("./decorators/Column");
+const Nullable_1 = require("./decorators/Nullable");
+const Database_1 = require("./Database");
+function camelToSnake(s) {
+    return s.replace(/([a-z0-9])([A-Z])/g, "$1_$2").toLowerCase();
+}
+class SchemaManager {
+    constructor(models, logger = console) {
+        this.models = models;
+        this.logger = logger;
+    }
+    migrate() {
+        return __awaiter(this, void 0, void 0, function* () {
+            for (const model of this.models) {
+                const table = (0, Table_1.getTableName)(model);
+                if (!table)
+                    continue;
+                this.logger.log(`[aMySQL] Syncing model ${model.name} to table ${table}`);
+                const { columns, indexes } = this.getSchemaFromModel(model);
+                const existing = yield this.getExistingColumns(table);
+                if (Object.keys(existing).length === 0) {
+                    yield this.createTable(table, columns, indexes);
+                }
+                else {
+                    yield this.updateTable(table, columns, indexes, existing);
+                }
+            }
+        });
+    }
+    createTable(table, columns, indexes) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const adapter = (0, Database_1.getAdapter)();
+            const colsSql = Object.entries(columns).map(([k, v]) => `\`${k}\` ${v}`).join(", ");
+            let indexSql = "";
+            if (adapter.type === 'mysql' && indexes.length > 0) {
+                indexSql = ", " + indexes.map(col => `INDEX 
+${col}
+ (
+${col}
+)`).join(", ");
+            }
+            const sql = `CREATE TABLE 
+${table}
+ (${colsSql}${indexSql});`;
+            const conn = yield (0, Database_1.getConnection)();
+            try {
+                yield (0, Database_1.execute)(sql, [], conn);
+                this.logger.log(`[aMySQL] Created table ${table}`);
+            }
+            finally {
+                conn.release();
+            }
+            if (adapter.type === 'postgres' && indexes.length > 0) {
+                for (const col of indexes) {
+                    const indexName = `idx_${table}_${col}`;
+                    const indexCreationSql = `CREATE INDEX 
+${indexName}
+ ON 
+${table}
+ (
+${col}
+);`;
+                    const indexConn = yield (0, Database_1.getConnection)();
+                    try {
+                        yield (0, Database_1.execute)(indexCreationSql, [], indexConn);
+                    }
+                    finally {
+                        indexConn.release();
+                    }
+                }
+            }
+        });
+    }
+    updateTable(table, desired, indexes, existing) {
+        return __awaiter(this, void 0, void 0, function* () {
+            for (const [col, type] of Object.entries(desired)) {
+                if (!existing.hasOwnProperty(col)) {
+                    const sql = `ALTER TABLE 
+${table}
+ ADD COLUMN 
+${col}
+ ${type};`;
+                    const conn = yield (0, Database_1.getConnection)();
+                    try {
+                        yield (0, Database_1.execute)(sql, [], conn);
+                        this.logger.log(`[aMySQL] Added column ${col} to ${table}`);
+                    }
+                    finally {
+                        conn.release();
+                    }
+                }
+            }
+        });
+    }
+    getSchemaFromModel(model) {
+        const columns = {};
+        const indexes = [];
+        const colMeta = (0, Column_1.getColumnMeta)(model);
+        const nullableMeta = (0, Nullable_1.getNullableMeta)(model);
+        const adapter = (0, Database_1.getAdapter)();
+        if (!colMeta) {
+            this.logger.warn(`[aMySQL] No @Column or @Id decorators found on model ${model.name}.`);
+            return { columns, indexes };
+        }
+        for (const [prop, opts] of colMeta.entries()) {
+            const colName = opts && opts.name ? opts.name : camelToSnake(prop);
+            if (opts.index) {
+                indexes.push(colName);
+            }
+            if (opts && opts.id) {
+                const type = opts.type || Number;
+                if (adapter.type === 'postgres') {
+                    columns[colName] = "SERIAL PRIMARY KEY";
+                }
+                else {
+                    columns[colName] = this.getSqlTypeForClass(type) + " PRIMARY KEY AUTO_INCREMENT";
+                }
+                continue;
+            }
+            const type = opts.type;
+            if (!type) {
+                this.logger.error(`[aMySQL] Type not provided for property '${prop}' on model '${model.name}'.`);
+                continue;
+            }
+            let sqlType = this.getSqlTypeForClass(type);
+            if (type === String && opts && opts.limit) {
+                sqlType = `VARCHAR(${opts.limit})`;
+            }
+            sqlType += (nullableMeta === null || nullableMeta === void 0 ? void 0 : nullableMeta.get(prop)) ? " NULL" : " NOT NULL";
+            if (opts && opts.unique)
+                sqlType += " UNIQUE";
+            columns[colName] = sqlType;
+        }
+        return { columns, indexes };
+    }
+    getSqlTypeForClass(type) {
+        const adapterType = (0, Database_1.getAdapter)().type;
+        if (!type)
+            return "VARCHAR(255)";
+        switch (type) {
+            case Number:
+                return adapterType === 'postgres' ? "INTEGER" : "INT";
+            case String:
+                return "VARCHAR(255)";
+            case Boolean:
+                return adapterType === 'postgres' ? "BOOLEAN" : "TINYINT(1)";
+            case Date:
+                return "TIMESTAMP";
+            default:
+                if (type.name === "Array" || type.name === "Object")
+                    return "TEXT";
+                return "VARCHAR(255)";
+        }
+    }
+    getExistingColumns(table) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const conn = yield (0, Database_1.getConnection)();
+            const adapter = (0, Database_1.getAdapter)();
+            const columns = {};
+            try {
+                let sql;
+                if (adapter.type === 'postgres') {
+                    sql = `SELECT column_name, data_type FROM information_schema.columns WHERE table_schema = current_schema() AND table_name = ?`;
+                }
+                else { // mysql
+                    sql = `SELECT COLUMN_NAME, DATA_TYPE FROM INFORMATION_SCHEMA.COLUMNS WHERE TABLE_SCHEMA = DATABASE() AND TABLE_NAME = ?`;
+                }
+                const rows = yield (0, Database_1.query)(sql, [table], conn);
+                if (adapter.type === 'postgres') {
+                    for (const r of rows) {
+                        columns[r.column_name] = r.data_type;
+                    }
+                }
+                else {
+                    for (const r of rows) {
+                        columns[r.COLUMN_NAME] = r.DATA_TYPE;
+                    }
+                }
+            }
+            finally {
+                conn.release();
+            }
+            return columns;
+        });
+    }
+}
+exports.SchemaManager = SchemaManager;

package/dist/adapters/IDatabaseAdapter.d.ts

@@ -0,0 +1,12 @@
+export type GenericConnection = any;
+export interface IDatabaseAdapter {
+    type: 'mysql' | 'postgres';
+    init(config: any): void;
+    query(sql: string, params: any[], connection?: GenericConnection): Promise<any[]>;
+    execute(sql: string, params: any[], connection?: GenericConnection): Promise<{
+        insertId?: number;
+        affectedRows?: number;
+    }>;
+    getConnection(): Promise<GenericConnection>;
+    close(): Promise<void>;
+}

package/dist/adapters/IDatabaseAdapter.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/adapters/MySQLAdapter.d.ts

@@ -0,0 +1,14 @@
+import { IDatabaseAdapter, GenericConnection } from './IDatabaseAdapter';
+export declare class MySQLAdapter implements IDatabaseAdapter {
+    readonly type = "mysql";
+    private pool;
+    init(config: any): void;
+    private getPool;
+    query(sql: string, params: any[], connection?: GenericConnection): Promise<any[]>;
+    execute(sql: string, params: any[], connection?: GenericConnection): Promise<{
+        insertId?: number;
+        affectedRows?: number;
+    }>;
+    getConnection(): Promise<GenericConnection>;
+    close(): Promise<void>;
+}

package/dist/adapters/MySQLAdapter.js

@@ -0,0 +1,74 @@
+"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.MySQLAdapter = void 0;
+const promise_1 = __importDefault(require("mysql2/promise"));
+class MySQLAdapter {
+    constructor() {
+        this.type = 'mysql';
+        this.pool = null;
+    }
+    init(config) {
+        var _a;
+        if (this.pool) {
+            console.warn("[MySQLAdapter] Pool já inicializado.");
+            return;
+        }
+        try {
+            this.pool = promise_1.default.createPool(Object.assign(Object.assign({}, config), { waitForConnections: true, connectionLimit: (_a = config.connectionLimit) !== null && _a !== void 0 ? _a : 10, queueLimit: 0 }));
+            console.log("[MySQLAdapter] ✅ Pool de conexões MySQL inicializado.");
+        }
+        catch (error) {
+            console.error("[MySQLAdapter] ❌ Falha ao inicializar pool MySQL:", error);
+            process.exit(1);
+        }
+    }
+    getPool() {
+        if (!this.pool) {
+            throw new Error("Pool MySQL não inicializado.");
+        }
+        return this.pool;
+    }
+    query(sql, params, connection) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const conn = connection !== null && connection !== void 0 ? connection : this.getPool();
+            const [rows] = yield conn.query(sql, params);
+            return rows;
+        });
+    }
+    execute(sql, params, connection) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const conn = connection !== null && connection !== void 0 ? connection : this.getPool();
+            const [result] = yield conn.execute(sql, params);
+            return {
+                insertId: result.insertId,
+                affectedRows: result.affectedRows
+            };
+        });
+    }
+    getConnection() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.getPool().getConnection();
+        });
+    }
+    close() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.pool) {
+                yield this.pool.end();
+                this.pool = null;
+            }
+        });
+    }
+}
+exports.MySQLAdapter = MySQLAdapter;

package/dist/adapters/PostgresAdapter.d.ts

@@ -0,0 +1,16 @@
+import { IDatabaseAdapter, GenericConnection } from './IDatabaseAdapter';
+export declare class PostgresAdapter implements IDatabaseAdapter {
+    readonly type = "postgres";
+    private pool;
+    init(config: any): void;
+    private getPool;
+    private formatSql;
+    private quoteIdentifiers;
+    query(sql: string, params: any[], connection?: GenericConnection): Promise<any[]>;
+    execute(sql: string, params: any[], connection?: GenericConnection): Promise<{
+        insertId?: number;
+        affectedRows?: number;
+    }>;
+    getConnection(): Promise<GenericConnection>;
+    close(): Promise<void>;
+}

package/dist/adapters/PostgresAdapter.js

@@ -0,0 +1,85 @@
+"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.PostgresAdapter = void 0;
+const pg_1 = require("pg");
+class PostgresAdapter {
+    constructor() {
+        this.type = 'postgres';
+        this.pool = null;
+    }
+    init(config) {
+        if (this.pool) {
+            console.warn("[PostgresAdapter] Pool já inicializado.");
+            return;
+        }
+        try {
+            this.pool = new pg_1.Pool({
+                connectionString: config.url,
+            });
+            console.log("[PostgresAdapter] ✅ Pool de conexões PostgreSQL inicializado.");
+        }
+        catch (error) {
+            console.error("[PostgresAdapter] ❌ Falha ao inicializar pool PostgreSQL:", error);
+            process.exit(1);
+        }
+    }
+    getPool() {
+        if (!this.pool) {
+            throw new Error("Pool PostgreSQL não inicializado.");
+        }
+        return this.pool;
+    }
+    formatSql(sql) {
+        let paramIndex = 1;
+        return sql.replace(/\?/g, () => `$${paramIndex++}`);
+    }
+    quoteIdentifiers(sql) {
+        return sql.replace(/`([^`]+)`/g, '"$1"');
+    }
+    query(sql, params, connection) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const conn = connection !== null && connection !== void 0 ? connection : this.getPool();
+            const pgSql = this.quoteIdentifiers(this.formatSql(sql));
+            const result = yield conn.query(pgSql, params);
+            return result.rows;
+        });
+    }
+    execute(sql, params, connection) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            const conn = connection !== null && connection !== void 0 ? connection : this.getPool();
+            let pgSql = this.quoteIdentifiers(this.formatSql(sql));
+            if (pgSql.trim().toUpperCase().startsWith('INSERT')) {
+                pgSql += ' RETURNING id';
+            }
+            const result = yield conn.query(pgSql, params);
+            return {
+                insertId: (_a = result.rows[0]) === null || _a === void 0 ? void 0 : _a.id,
+                affectedRows: result.rowCount
+            };
+        });
+    }
+    getConnection() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.getPool().connect();
+        });
+    }
+    close() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.pool) {
+                yield this.pool.end();
+                this.pool = null;
+            }
+        });
+    }
+}
+exports.PostgresAdapter = PostgresAdapter;

package/dist/decorators/BelongsTo.d.ts

@@ -0,0 +1,7 @@
+export declare const belongsToMap: Map<Function, Map<string, any>>;
+export type BelongsToOptions = {
+    model: () => new (...args: any[]) => any;
+    foreignKey: string;
+};
+export declare function BelongsTo(options: BelongsToOptions): (target: any, propertyKey: string) => void;
+export declare function getBelongsToMeta(ctor: Function): Map<string, any> | undefined;

package/dist/decorators/BelongsTo.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.belongsToMap = void 0;
+exports.BelongsTo = BelongsTo;
+exports.getBelongsToMeta = getBelongsToMeta;
+exports.belongsToMap = new Map();
+function BelongsTo(options) {
+    return function (target, propertyKey) {
+        const ctor = target.constructor;
+        const relations = exports.belongsToMap.get(ctor) || new Map();
+        relations.set(propertyKey, options);
+        exports.belongsToMap.set(ctor, relations);
+    };
+}
+function getBelongsToMeta(ctor) {
+    return exports.belongsToMap.get(ctor);
+}

package/dist/decorators/Column.d.ts

@@ -0,0 +1,12 @@
+import { ColumnAdapter } from "../ColumnAdapter";
+export declare const columnMap: Map<Function, Map<string, any>>;
+export type ColumnOptions = {
+    name?: string;
+    adapter?: new () => ColumnAdapter;
+    unique?: boolean;
+    limit?: number;
+    type?: any;
+    index?: boolean;
+};
+export declare function Column(options: ColumnOptions): (target: any, propertyKey: string) => void;
+export declare function getColumnMeta(ctor: Function): Map<string, any> | undefined;

package/dist/decorators/Column.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.columnMap = void 0;
+exports.Column = Column;
+exports.getColumnMeta = getColumnMeta;
+exports.columnMap = new Map();
+function Column(options) {
+    return function (target, propertyKey) {
+        const ctor = target.constructor;
+        const cols = getColumnMeta(ctor) || new Map();
+        cols.set(propertyKey, Object.assign(Object.assign({}, options), { propertyKey }));
+        exports.columnMap.set(ctor, cols);
+    };
+}
+function getColumnMeta(ctor) {
+    return exports.columnMap.get(ctor);
+}

package/dist/decorators/HasMany.d.ts

@@ -0,0 +1,7 @@
+export declare const hasManyMap: Map<Function, Map<string, any>>;
+export type HasManyOptions = {
+    model: () => new (...args: any[]) => any;
+    foreignKey: string;
+};
+export declare function HasMany(options: HasManyOptions): (target: any, propertyKey: string) => void;
+export declare function getHasManyMeta(ctor: Function): Map<string, any> | undefined;

package/dist/decorators/HasMany.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hasManyMap = void 0;
+exports.HasMany = HasMany;
+exports.getHasManyMeta = getHasManyMeta;
+exports.hasManyMap = new Map();
+function HasMany(options) {
+    return function (target, propertyKey) {
+        const ctor = target.constructor;
+        const relations = exports.hasManyMap.get(ctor) || new Map();
+        relations.set(propertyKey, options);
+        exports.hasManyMap.set(ctor, relations);
+    };
+}
+function getHasManyMeta(ctor) {
+    return exports.hasManyMap.get(ctor);
+}

package/dist/decorators/HasOne.d.ts

@@ -0,0 +1,7 @@
+export declare const hasOneMap: Map<Function, Map<string, any>>;
+export type HasOneOptions = {
+    model: () => new (...args: any[]) => any;
+    foreignKey: string;
+};
+export declare function HasOne(options: HasOneOptions): (target: any, propertyKey: string) => void;
+export declare function getHasOneMeta(ctor: Function): Map<string, any> | undefined;

package/dist/decorators/HasOne.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hasOneMap = void 0;
+exports.HasOne = HasOne;
+exports.getHasOneMeta = getHasOneMeta;
+exports.hasOneMap = new Map();
+function HasOne(options) {
+    return function (target, propertyKey) {
+        const ctor = target.constructor;
+        const relations = exports.hasOneMap.get(ctor) || new Map();
+        relations.set(propertyKey, options);
+        exports.hasOneMap.set(ctor, relations);
+    };
+}
+function getHasOneMeta(ctor) {
+    return exports.hasOneMap.get(ctor);
+}

package/dist/decorators/Id.d.ts

@@ -0,0 +1 @@
+export declare function Id(): (target: any, propertyKey: string) => void;

package/dist/decorators/Id.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Id = Id;
+const Column_1 = require("./Column");
+function Id() {
+    return function (target, propertyKey) {
+        const ctor = target.constructor;
+        const cols = Column_1.columnMap.get(ctor) || new Map();
+        cols.set(propertyKey, { id: true, propertyKey }); // Adiciona a propriedade com a flag 'id'
+        Column_1.columnMap.set(ctor, cols);
+    };
+}

package/dist/decorators/Nullable.d.ts

@@ -0,0 +1,2 @@
+export declare function Nullable(value?: boolean): (target: any, propertyKey: string) => void;
+export declare function getNullableMeta(ctor: Function): Map<string, boolean> | undefined;

package/dist/decorators/Nullable.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Nullable = Nullable;
+exports.getNullableMeta = getNullableMeta;
+const nullableMap = new Map();
+function Nullable(value = true) {
+    return function (target, propertyKey) {
+        const ctor = target.constructor;
+        const nulls = getNullableMeta(ctor) || new Map();
+        nulls.set(propertyKey, value);
+        nullableMap.set(ctor, nulls);
+    };
+}
+function getNullableMeta(ctor) {
+    return nullableMap.get(ctor);
+}

package/dist/decorators/Table.d.ts

@@ -0,0 +1,2 @@
+export declare function Table(name: string): (constructor: Function) => void;
+export declare function getTableName(target: Function): string | undefined;

package/dist/decorators/Table.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Table = Table;
+exports.getTableName = getTableName;
+const tableMap = new Map();
+function Table(name) {
+    return function (constructor) {
+        tableMap.set(constructor, name);
+    };
+}
+function getTableName(target) {
+    return tableMap.get(target);
+}

package/dist/index.d.ts

@@ -0,0 +1,13 @@
+export * from "./Database";
+export * from "./ActiveRecord";
+export * from "./QueryBuilder";
+export * from "./SchemaManager";
+export * from "./ColumnAdapter";
+export * from "./decorators/Table";
+export * from "./decorators/Column";
+export * from "./decorators/Id";
+export * from "./decorators/Nullable";
+export * from "./decorators/HasMany";
+export * from "./decorators/HasOne";
+export * from "./decorators/BelongsTo";
+export * from "./PersistenceException";

package/dist/index.js

@@ -0,0 +1,29 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./Database"), exports);
+__exportStar(require("./ActiveRecord"), exports);
+__exportStar(require("./QueryBuilder"), exports);
+__exportStar(require("./SchemaManager"), exports);
+__exportStar(require("./ColumnAdapter"), exports);
+__exportStar(require("./decorators/Table"), exports);
+__exportStar(require("./decorators/Column"), exports);
+__exportStar(require("./decorators/Id"), exports);
+__exportStar(require("./decorators/Nullable"), exports);
+__exportStar(require("./decorators/HasMany"), exports);
+__exportStar(require("./decorators/HasOne"), exports);
+__exportStar(require("./decorators/BelongsTo"), exports);
+__exportStar(require("./PersistenceException"), exports);

package/package.json

@@ -0,0 +1,41 @@
+{
+    "name": "@aceitadev/adatabase",
+    "version": "0.1.0",
+    "description": "Uma biblioteca para facilitar a interação com bancos de dados MySQL e PostgreSQL em projetos TypeScript/Node.js.",
+    "main": "dist/index.js",
+    "types": "dist/index.d.ts",
+    "files": [
+        "dist"
+    ],
+    "scripts": {
+        "build": "tsc",
+        "start": "node dist/example.js",
+        "dev": "ts-node-dev --respawn --transpile-only src/example.ts"
+    },
+    "repository": {
+        "type": "git",
+        "url": "git+https://github.com/aceitadev/aMySQL-Node.git"
+    },
+    "keywords": [
+        "mysql",
+        "mysql2",
+        "database",
+        "typescript",
+        "node"
+    ],
+    "author": "Murilo Ribeiro aceitadev@gmail.com",
+    "license": "MIT",
+    "bugs": {
+        "url": "https://github.com/aceitadev/aMySQL-Node/issues"
+    },
+    "homepage": "https://github.com/aceitadev/aMySQL-Node#readme",
+    "dependencies": {
+        "mysql2": "^3.2.0",
+        "pg": "^8.16.3"
+    },
+    "devDependencies": {
+        "@types/pg": "^8.15.5",
+        "ts-node-dev": "^2.0.0",
+        "typescript": "^5.0.0"
+    }
+}