vatts 2.1.2 → 2.1.3-canary.1.0.1

package/dist/database/OrmDatabase.d.ts

@@ -0,0 +1,54 @@
+export declare enum DataType {
+    STRING = "VARCHAR(255)",
+    TEXT = "TEXT",
+    INT = "INT",
+    LONG = "BIGINT",
+    BOOLEAN = "BOOLEAN",
+    JSON = "JSON",
+    UUID = "VARCHAR(36)"
+}
+export interface SchemaColumn {
+    name: string;
+    type: DataType;
+    indexed?: boolean;
+    primaryKey?: boolean;
+    nullable?: boolean;
+    autoIncrement?: boolean;
+}
+export type DbConfig = {
+    type: 'mysql' | 'postgres' | 'sqlite';
+    host?: string;
+    port?: number;
+    user?: string;
+    password?: string;
+    database?: string;
+    filepath?: string;
+};
+interface DatabaseAdapter {
+    query<T>(sql: string, params?: any[]): Promise<T[]>;
+    execute(sql: string, params?: any[]): Promise<any>;
+    formatPlaceholder(index: number): string;
+    getAutoIncrementSyntax(): string;
+}
+export declare class DatabaseConnector {
+    adapter: DatabaseAdapter;
+    constructor(config: DbConfig);
+}
+export declare class BaseEntity<ID_TYPE, TData> {
+    data: TData;
+    constructor(data: TData);
+    toJSON(): TData;
+}
+export declare abstract class BaseTable<ID_TYPE, TEntity extends BaseEntity<ID_TYPE, any>, TData> {
+    abstract tableName: string;
+    protected abstract entityConstructor: new (data: TData) => TEntity;
+    abstract defineSchema(): SchemaColumn[];
+    protected connector: DatabaseConnector | undefined;
+    setConnector(connector: DatabaseConnector): void;
+    protected get adapter(): DatabaseAdapter;
+    create(data: Omit<TData, "id"> & Partial<TData>): Promise<TEntity>;
+    findMany(conditions: Partial<TData>): Promise<TEntity[]>;
+    findOne(conditions: Partial<TData>): Promise<TEntity | null>;
+    syncSchema(): Promise<void>;
+}
+export {};

package/dist/database/OrmDatabase.js

@@ -0,0 +1,182 @@
+"use strict";
+// ==========================================
+// 1. TIPOS E ENUMS GERAIS
+// ==========================================
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseTable = exports.BaseEntity = exports.DatabaseConnector = exports.DataType = void 0;
+var DataType;
+(function (DataType) {
+    DataType["STRING"] = "VARCHAR(255)";
+    DataType["TEXT"] = "TEXT";
+    DataType["INT"] = "INT";
+    DataType["LONG"] = "BIGINT";
+    DataType["BOOLEAN"] = "BOOLEAN";
+    DataType["JSON"] = "JSON";
+    DataType["UUID"] = "VARCHAR(36)";
+})(DataType || (exports.DataType = DataType = {}));
+class MySQLAdapter {
+    pool;
+    constructor(config) {
+        const mysql = require('mysql2/promise');
+        this.pool = mysql.createPool({
+            host: config.host, port: config.port,
+            user: config.user, password: config.password,
+            database: config.database
+        });
+    }
+    async query(sql, params = []) {
+        const [rows] = await this.pool.query(sql, params);
+        return rows;
+    }
+    async execute(sql, params = []) {
+        const [result] = await this.pool.execute(sql, params);
+        return result;
+    }
+    formatPlaceholder(index) { return '?'; }
+    getAutoIncrementSyntax() { return 'AUTO_INCREMENT'; }
+}
+class PostgresAdapter {
+    pool;
+    constructor(config) {
+        const { Pool } = require('pg');
+        this.pool = new Pool({
+            host: config.host, port: config.port,
+            user: config.user, password: config.password,
+            database: config.database
+        });
+    }
+    async query(sql, params = []) {
+        const result = await this.pool.query(sql, params);
+        return result.rows;
+    }
+    async execute(sql, params = []) {
+        return await this.pool.query(sql, params);
+    }
+    formatPlaceholder(index) { return `$${index + 1}`; }
+    getAutoIncrementSyntax() { return 'SERIAL'; } // Simplificado, idealmente SERIAL é tipo, não constraint
+}
+class SQLiteAdapter {
+    db;
+    constructor(config) {
+        const sqlite3 = require('sqlite3').verbose();
+        this.db = new sqlite3.Database(config.filepath || ':memory:');
+    }
+    query(sql, params = []) {
+        return new Promise((resolve, reject) => {
+            this.db.all(sql, params, (err, rows) => {
+                if (err)
+                    reject(err);
+                else
+                    resolve(rows);
+            });
+        });
+    }
+    execute(sql, params = []) {
+        return new Promise((resolve, reject) => {
+            this.db.run(sql, params, function (err) {
+                if (err)
+                    reject(err);
+                else
+                    resolve(this);
+            });
+        });
+    }
+    formatPlaceholder(index) { return '?'; }
+    getAutoIncrementSyntax() { return 'AUTOINCREMENT'; }
+}
+// ==========================================
+// 3. ENGINE PRINCIPAL E CLASSES BASE
+// ==========================================
+class DatabaseConnector {
+    adapter;
+    constructor(config) {
+        if (config.type === 'mysql')
+            this.adapter = new MySQLAdapter(config);
+        else if (config.type === 'postgres')
+            this.adapter = new PostgresAdapter(config);
+        else if (config.type === 'sqlite')
+            this.adapter = new SQLiteAdapter(config);
+        else
+            throw new Error("Database type not supported");
+    }
+}
+exports.DatabaseConnector = DatabaseConnector;
+// Entidade Base - Representa uma linha no banco
+class BaseEntity {
+    data;
+    constructor(data) {
+        this.data = data;
+        Object.assign(this, data);
+    }
+    // Exemplo de método de instância (pode ser expandido para .save(), .delete())
+    toJSON() {
+        return { ...this.data };
+    }
+}
+exports.BaseEntity = BaseEntity;
+// Tabela Base - Representa o repositório e construtor de query
+class BaseTable {
+    connector;
+    setConnector(connector) {
+        this.connector = connector;
+    }
+    get adapter() {
+        if (!this.connector || !this.connector.adapter)
+            throw new Error("Database not connected! Pass a valid DatabaseConnector instance.");
+        return this.connector.adapter;
+    }
+    // --- OPERAÇÕES CRUD ---
+    async create(data) {
+        const columns = Object.keys(data);
+        const values = Object.values(data);
+        const placeholders = columns.map((_, i) => this.adapter.formatPlaceholder(i)).join(', ');
+        const sql = `INSERT INTO ${this.tableName} (${columns.join(', ')}) VALUES (${placeholders})`;
+        await this.adapter.execute(sql, values);
+        return new this.entityConstructor(data);
+    }
+    async findMany(conditions) {
+        const keys = Object.keys(conditions);
+        const values = Object.values(conditions);
+        let sql = `SELECT * FROM ${this.tableName}`;
+        if (keys.length > 0) {
+            const whereClause = keys.map((k, i) => `${k} = ${this.adapter.formatPlaceholder(i)}`).join(' AND ');
+            sql += ` WHERE ${whereClause}`;
+        }
+        const rows = await this.adapter.query(sql, values);
+        return rows.map(row => new this.entityConstructor(row));
+    }
+    async findOne(conditions) {
+        const results = await this.findMany(conditions);
+        return results.length > 0 ? results[0] : null;
+    }
+    // --- SINCRONIZAÇÃO DE SCHEMA ---
+    async syncSchema() {
+        const schema = this.defineSchema();
+        const columnsSql = schema.map(col => {
+            let def = `${col.name} ${col.type}`;
+            if (col.primaryKey)
+                def += ` PRIMARY KEY`;
+            if (col.autoIncrement)
+                def += ` ${this.adapter.getAutoIncrementSyntax()}`;
+            if (!col.nullable && !col.primaryKey)
+                def += ' NOT NULL';
+            return def;
+        }).join(', ');
+        const createTableSql = `CREATE TABLE IF NOT EXISTS ${this.tableName} (${columnsSql})`;
+        await this.adapter.execute(createTableSql);
+        // Criação de index (Simples)
+        for (const col of schema) {
+            if (col.indexed) {
+                const indexName = `idx_${this.tableName}_${col.name}`;
+                const indexSql = `CREATE INDEX IF NOT EXISTS ${indexName} ON ${this.tableName}(${col.name})`;
+                // Em try/catch pois alguns bancos (como MySQL) dão erro se recriar index de forma diferente
+                try {
+                    await this.adapter.execute(indexSql);
+                }
+                catch (e) { }
+            }
+        }
+        console.log(`Schema for ${this.tableName} synchronized.`);
+    }
+}
+exports.BaseTable = BaseTable;

package/dist/database/index.d.ts

@@ -0,0 +1,6 @@
+import { BaseTable, DatabaseConnector, DbConfig } from "./OrmDatabase";
+export default class Database {
+    db: DatabaseConnector;
+    constructor(config: DbConfig, databases: Array<BaseTable<any, any, any>>);
+}
+export * from './OrmDatabase';

package/dist/database/index.js

@@ -0,0 +1,30 @@
+"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 });
+const OrmDatabase_1 = require("./OrmDatabase");
+class Database {
+    db;
+    constructor(config, databases) {
+        this.db = new OrmDatabase_1.DatabaseConnector(config);
+        // Inicializa as tabelas
+        for (const table of databases) {
+            table.setConnector(this.db);
+            table.syncSchema();
+        }
+    }
+}
+exports.default = Database;
+__exportStar(require("./OrmDatabase"), exports);

package/dist/database/teste.d.ts

@@ -0,0 +1,21 @@
+import { BaseEntity, BaseTable, SchemaColumn } from "./OrmDatabase";
+export interface AllocationData {
+    nodeId: string;
+    ip: string;
+    externalIp: string | null;
+    port: number;
+    assignedTo: string | null;
+}
+export declare class Allocation extends BaseEntity<string, AllocationData> {
+    nodeId: string;
+    ip: string;
+    externalIp: string | null;
+    port: number;
+    assignedTo: string | null;
+    isAssigned(): boolean;
+}
+export declare class AllocationTable extends BaseTable<string, Allocation, AllocationData> {
+    protected entityConstructor: typeof Allocation;
+    tableName: string;
+    defineSchema(): SchemaColumn[];
+}

package/dist/database/teste.js

@@ -0,0 +1,56 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AllocationTable = exports.Allocation = void 0;
+// 1. Interface para os dados da Alocação
+const OrmDatabase_1 = require("./OrmDatabase");
+const index_1 = __importDefault(require("./index"));
+// 2. Classe da Entidade Allocation (com tipagem inferida perfeita)
+class Allocation extends OrmDatabase_1.BaseEntity {
+    // Métodos customizados da entidade
+    isAssigned() {
+        return this.assignedTo !== null;
+    }
+}
+exports.Allocation = Allocation;
+// 3. Classe da Tabela de Alocações
+class AllocationTable extends OrmDatabase_1.BaseTable {
+    entityConstructor = Allocation;
+    tableName = 'hAllocations';
+    defineSchema() {
+        return [
+            { name: 'nodeId', type: OrmDatabase_1.DataType.STRING, indexed: true, nullable: false },
+            { name: 'ip', type: OrmDatabase_1.DataType.STRING, nullable: false },
+            { name: 'externalIp', type: OrmDatabase_1.DataType.STRING, nullable: true },
+            { name: 'port', type: OrmDatabase_1.DataType.INT, indexed: true, nullable: false },
+            { name: 'assignedTo', type: OrmDatabase_1.DataType.STRING, indexed: true, nullable: true },
+        ];
+    }
+}
+exports.AllocationTable = AllocationTable;
+async function main() {
+    const allocations = new AllocationTable();
+    new index_1.default({
+        type: 'sqlite',
+        database: ':memory:',
+    }, [
+        allocations
+    ]);
+    // 3. Criando dados COM TIPAGEM E AUTO-COMPLETE MÁXIMO!
+    console.log("Criando nova alocação...");
+    const novaAlocacao = await allocations.create({
+        nodeId: 'node-01',
+        ip: '192.168.1.100',
+        externalIp: null,
+        port: 25565,
+        assignedTo: null
+    });
+    console.log("Alocação criada:", novaAlocacao.ip);
+    console.log("Está assinalada?", novaAlocacao.isAssigned());
+    // 4. Buscando dados com tipagem
+    const buscarNode = await allocations.findMany({ nodeId: 'node-01' });
+    console.log(`Encontrados ${buscarNode.length} resultados para o node-01.`);
+}
+main();