@arcaelas/dynamite 1.0.19 → 1.0.24

package/package.json

@@ -9,22 +9,20 @@
     "url": "https://github.com/arcaelas/dynamite/issues"
   },
   "dependencies": {
+    "@arcaelas/utils": "^2.0.8",
     "@aws-sdk/client-dynamodb": "3.329.0",
     "@aws-sdk/lib-dynamodb": "3.329.0",
     "pluralize": "^8.0.0",
     "uuid": "^11.1.0"
   },
   "devDependencies": {
-    "@types/jest": "^30.0.0",
+    "@eslint/js": "^9.39.1",
     "@types/node": "^24.0.6",
-    "jest": "^30.0.3",
-    "reflect-metadata": "^0.2.2",
-    "ts-jest": "^29.4.0",
-    "ts-node": "^10.9.2",
+    "globals": "^16.5.0",
     "tsc-alias": "^1.8.16",
-    "tsconfig-paths": "^4.2.0",
     "tsx": "^4.20.3",
-    "typescript": "^5.8.3"
+    "typescript": "^5.8.3",
+    "typescript-eslint": "^8.49.0"
   },
   "files": [
     "src/**/*.js",
@@ -48,44 +46,15 @@
     "deploy": "npm version patch && npm publish --access=public",
     "prepublishOnly": "yarn build",
     "postpublish": "find src -type f \\( -name '*.js' -o -name '*.d.ts' -o -name '*.map' \\) -delete",
+    "seed:generate": "tsx scripts/generate_seed.ts",
+    "seed:load": "tsx scripts/load_seed.ts",
+    "seed:full": "yarn seed:generate && yarn seed:load",
     "test": "yarn test:db:start && yarn test:run; yarn test:db:stop",
-    "test:run": "node --expose-gc ./node_modules/.bin/jest src/index.test.ts --runInBand --verbose",
-    "test:watch": "yarn test:db:start && node --expose-gc ./node_modules/.bin/jest src/index.test.ts --watch --runInBand",
+    "test:run": "NODE_OPTIONS='--expose-gc' tsx --tsconfig tsx.config.json src/index.test.ts",
+    "test:watch": "yarn test:db:start && NODE_OPTIONS='--expose-gc' tsx watch src/index.test.ts",
     "test:db:start": "docker run -d -p 8000:8000 --name dynamite-test-db amazon/dynamodb-local -jar DynamoDBLocal.jar -sharedDb || echo 'DynamoDB ya está corriendo'",
     "test:db:stop": "docker stop dynamite-test-db && docker rm dynamite-test-db || true",
     "test:db:clean": "docker stop dynamite-test-db && docker rm dynamite-test-db; docker run -d -p 8000:8000 --name dynamite-test-db amazon/dynamodb-local -jar DynamoDBLocal.jar -sharedDb"
   },
-  "version": "1.0.19",
-  "jest": {
-    "preset": "ts-jest",
-    "testEnvironment": "node",
-    "roots": [
-      "<rootDir>/src"
-    ],
-    "testMatch": [
-      "**/*.test.ts"
-    ],
-    "moduleNameMapper": {
-      "^~/(.*)$": "<rootDir>/src/$1",
-      "^@type/(.*)$": "<rootDir>/src/@types/$1"
-    },
-    "transform": {
-      "^.+\\.ts$": [
-        "ts-jest",
-        {
-          "tsconfig": {
-            "experimentalDecorators": true,
-            "emitDecoratorMetadata": true,
-            "esModuleInterop": true,
-            "target": "ES2022",
-            "module": "commonjs"
-          }
-        }
-      ]
-    },
-    "testTimeout": 60000,
-    "maxWorkers": 1,
-    "detectOpenHandles": false,
-    "forceExit": true
-  }
+  "version": "1.0.24"
 }

package/src/scripts/load_seed.d.ts

@@ -0,0 +1,5 @@
+/**
+ * @file load_seed.ts
+ * @description Carga archivos JSON de seed en DynamoDB con inserción por lotes
+ */
+export declare function load_all(): Promise<void>;

package/src/scripts/load_seed.js

@@ -0,0 +1,54 @@
+"use strict";
+/**
+ * @file load_seed.ts
+ * @description Carga archivos JSON de seed en DynamoDB con inserción por lotes
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.load_all = load_all;
+const promises_1 = require("fs/promises");
+const client_dynamodb_1 = require("@aws-sdk/client-dynamodb");
+const util_dynamodb_1 = require("@aws-sdk/util-dynamodb");
+const client_1 = require("../src/core/client");
+async function load_file(filepath, table_name) {
+    const file_content = await (0, promises_1.readFile)(filepath, "utf-8");
+    const json = JSON.parse(file_content);
+    const client = (0, client_1.requireClient)();
+    console.log(`  Total records: ${json.count}`);
+    for (let i = 0; i < json.data.length; i += 25) {
+        const chunk = json.data.slice(i, i + 25);
+        await Promise.all(chunk.map((item) => client.send(new client_dynamodb_1.PutItemCommand({
+            TableName: table_name,
+            Item: (0, util_dynamodb_1.marshall)(item, { removeUndefinedValues: true }),
+        }))));
+        if ((i + 25) % 1000 === 0 || i + 25 >= json.data.length) {
+            const loaded = Math.min(i + 25, json.data.length);
+            console.log(`  Loaded ${loaded}/${json.count} records...`);
+        }
+    }
+    return json.count;
+}
+async function load_all() {
+    console.log("📦 Loading seed data into DynamoDB...\n");
+    const start_time = Date.now();
+    const loads = [
+        { file: "/tmp/dynamite_seed_users.json", table: "test_users" },
+        { file: "/tmp/dynamite_seed_categories.json", table: "test_categories" },
+        { file: "/tmp/dynamite_seed_roles.json", table: "test_roles" },
+        { file: "/tmp/dynamite_seed_products.json", table: "test_products" },
+        { file: "/tmp/dynamite_seed_orders.json", table: "test_orders" },
+    ];
+    for (const { file, table } of loads) {
+        console.log(`\n📄 Loading ${file}...`);
+        const count = await load_file(file, table);
+        console.log(`✅ Loaded ${count} records into ${table}`);
+    }
+    const elapsed = ((Date.now() - start_time) / 1000).toFixed(2);
+    console.log(`\n✅ Seed loading complete in ${elapsed}s`);
+}
+if (require.main === module) {
+    load_all().catch((error) => {
+        console.error("❌ Error loading seed data:", error);
+        process.exit(1);
+    });
+}
+//# sourceMappingURL=load_seed.js.map

package/src/src/@types/index.d.ts

@@ -0,0 +1,188 @@
+/**
+ * @file index.ts
+ * @description Sistema de tipos para Dynamite ORM - Arquitectura con type-safety completo
+ * @autor Miguel Alejandro
+ * @fecha 2025-01-28
+ */
+/**
+ * Marca para identificar campos que no son atributos de BD (relaciones, métodos).
+ */
+export declare const NonAttributeBrand: unique symbol;
+/**
+ * Marca para identificar campos opcionales en create() pero presentes en el modelo.
+ */
+export declare const CreationOptionalBrand: unique symbol;
+/**
+ * Wrapper para marcar relaciones y campos virtuales que no se persisten en BD.
+ * @example
+ * ```typescript
+ * class User extends Table<User> {
+ *   @HasMany(() => Post, 'user_id')
+ *   declare posts: NonAttribute<Post[]>;
+ * }
+ * ```
+ */
+export type NonAttribute<T> = T & {
+    [NonAttributeBrand]?: true;
+};
+/**
+ * Wrapper para marcar campos opcionales en create() (auto-generados: id, timestamps).
+ * @example
+ * ```typescript
+ * class User extends Table<User> {
+ *   @PrimaryKey() id: CreationOptional<string>;
+ *   @CreatedAt() created_at: CreationOptional<number>;
+ *   name: string;
+ * }
+ * await User.create({ name: 'Juan' }); // id y created_at opcionales
+ * ```
+ */
+export type CreationOptional<T> = T & {
+    [CreationOptionalBrand]?: true;
+};
+/**
+ * Extrae atributos de BD usando intersección:
+ * - Primera parte: atributos REQUERIDOS con modificador `-?`
+ * - Segunda parte: atributos OPCIONALES (solo CreationOptional)
+ * - Ambos excluyen: never, undefined, null, NonAttribute, métodos
+ * @example
+ * ```typescript
+ * class User {
+ *   id: CreationOptional<string>;
+ *   created_at: CreationOptional<number>;
+ *   name: string;
+ *   email: string;
+ *   posts: NonAttribute<Post[]>;
+ *   save(): void;
+ * }
+ * // InferAttributes<User> = { name: string, email: string } & { id?: string, created_at?: number }
+ * // = { name: string, email: string, id?: string, created_at?: number }
+ * ```
+ */
+export type InferAttributes<T> = {
+    [K in keyof T as T[K] extends ((...args: any[]) => any) | {
+        [NonAttributeBrand]?: true;
+    } | {
+        [CreationOptionalBrand]?: true;
+    } ? never : K]-?: Exclude<T[K], null | undefined | never>;
+} & {
+    [K in keyof T as T[K] extends {
+        [CreationOptionalBrand]?: true;
+    } ? K : never]?: Exclude<T[K], null | undefined | never>;
+};
+/**
+ * Extrae solo relaciones (NonAttribute) preservando tipo Model | Model[]
+ * Excluye propiedades de Object.prototype para evitar conflictos
+ * @example
+ * ```typescript
+ * class User extends Table<User> {
+ *   id: string;
+ *   posts: NonAttribute<Post[]>;      // Array
+ *   profile: NonAttribute<Profile>;   // Individual
+ *   settings: NonAttribute<Settings | null>; // Nullable
+ * }
+ * // InferRelations<User> = { posts: Post[], profile: Profile, settings: Settings | null }
+ * ```
+ */
+type ObjectBuiltinKeys = keyof Record<string, never> | 'toString' | 'valueOf' | 'hasOwnProperty' | 'isPrototypeOf' | 'propertyIsEnumerable' | 'toLocaleString' | 'constructor';
+export type InferRelations<T> = {
+    [K in keyof T as T[K] extends NonAttribute<any> ? K extends ObjectBuiltinKeys ? never : K : never]: T[K] extends NonAttribute<infer P> ? P : never;
+};
+/**
+ * Extrae solo relaciones (campos NonAttribute).
+ * Usado internamente para validación.
+ * @example
+ * ```typescript
+ * class User {
+ *   id: string;
+ *   name: string;
+ *   posts: NonAttribute<Post[]>;
+ *   profile: NonAttribute<Profile>;
+ * }
+ * // PickRelations<User> = { posts: Post[], profile: Profile }
+ * ```
+ */
+export type PickRelations<T> = {
+    [K in keyof T as T[K] extends NonAttribute<any> ? K : never]: T[K] extends NonAttribute<infer U> ? U : never;
+};
+/**
+ * Operadores de comparación soportados.
+ * Solo 8 operadores permitidos según especificación del usuario.
+ */
+export type QueryOperator = "=" | "$eq" | "<>" | "!=" | "$ne" | "<" | "$lt" | "<=" | "$lte" | ">" | "$gt" | ">=" | "$gte" | "in" | "$in" | "include" | "$include";
+/**
+ * Opciones de query con pre-cache de atributos (A) y relaciones (R)
+ * @template T - Modelo de tabla
+ * @template A - Cache de InferAttributes<T>
+ * @template R - Cache de InferRelations<T>
+ * @example
+ * ```typescript
+ * await User.where({}, {
+ *   where: {
+ *     name: 'Juan',
+ *     age: { $gte: 18, $lte: 65 }
+ *   },
+ *   order: 'DESC',
+ *   limit: 10,
+ *   attributes: ['name', 'email'],
+ *   include: {
+ *     posts: {
+ *       where: { published: true },
+ *       limit: 5,
+ *       include: { comments: true }
+ *     },
+ *     profile: {
+ *       attributes: ['bio', 'avatar']
+ *     }
+ *   }
+ * });
+ * ```
+ */
+export interface WhereOptions<T, A = InferAttributes<T>, R = InferRelations<T>> {
+    /** Filtros de búsqueda */
+    where?: {
+        [K in keyof A]?: A[K] | {
+            [N in QueryOperator]?: A[K];
+        };
+    };
+    /** Orden de resultados */
+    order?: "ASC" | "DESC";
+    /** Número de items a saltar */
+    offset?: number;
+    /** Alias de offset */
+    skip?: number;
+    /** Número máximo de items a retornar */
+    limit?: number;
+    /** Campos a seleccionar */
+    attributes?: Array<keyof A>;
+    /** Relaciones a cargar (recursivo) */
+    include?: {
+        [K in keyof R]?: NonNullable<R[K]> extends Array<infer U> ? true | WhereOptions<U> : true | Pick<WhereOptions<NonNullable<R[K]>>, "attributes" | "include">;
+    };
+    /** Incluir registros soft-deleted */
+    _includeTrashed?: boolean;
+}
+/**
+ * Input para create() - InferAttributes ya maneja opcional/requerido con intersección
+ * @example
+ * ```typescript
+ * class User extends Table<User> {
+ *   id: CreationOptional<string>;
+ *   created_at: CreationOptional<number>;
+ *   name: string;
+ *   email: string;
+ * }
+ * // CreateInput<User> = { name: string, email: string, id?: string, created_at?: number }
+ * await User.create({ name: 'Juan', email: 'juan@example.com' }); // id y created_at opcionales
+ * ```
+ */
+export type CreateInput<T> = InferAttributes<T>;
+/**
+ * Tipo para update() - todos los campos parciales.
+ * @example
+ * ```typescript
+ * await user.update({ name: 'Ana' }); // Todos los campos opcionales
+ * ```
+ */
+export type UpdateInput<T> = Partial<InferAttributes<T>>;
+export {};

package/src/src/@types/index.js

@@ -0,0 +1,9 @@
+"use strict";
+/**
+ * @file index.ts
+ * @description Sistema de tipos para Dynamite ORM - Arquitectura con type-safety completo
+ * @autor Miguel Alejandro
+ * @fecha 2025-01-28
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=index.js.map

package/src/{core → src/core}/client.d.ts

@@ -25,25 +25,13 @@ export declare class Dynamite {
      */
     constructor(config: DynamiteConfig);
     /**
-     * Synchronize all declared tables and their GSIs
+     * Connect client and synchronize all declared tables and their GSIs (upsert pattern)
      */
-    sync(): Promise<void>;
+    connect(): Promise<void>;
     /**
-     * Connect the client for Table operations
+     * Auto-crear pivot tables para relaciones ManyToMany
      */
-    connect(): void;
-    /**
-     * Get the underlying DynamoDB client
-     */
-    getClient(): DynamoDBClient;
-    /**
-     * Check if client is connected and tables are synced
-     */
-    isReady(): boolean;
-    /**
-     * Disconnect and cleanup DynamoDB client
-     */
-    disconnect(): void;
+    private createPivotTables;
     /**
      * Ejecutar operaciones en una transacción atómica.
      * Si cualquier operación falla, todas se revierten automáticamente.

package/src/{core → src/core}/client.js

@@ -5,6 +5,39 @@
  * @autor Miguel Alejandro
  * @fecha 2025-01-27
  */
+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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TransactionContext = exports.requireClient = exports.hasGlobalClient = exports.getGlobalClient = exports.setGlobalClient = exports.Dynamite = void 0;
 const client_dynamodb_1 = require("@aws-sdk/client-dynamodb");
@@ -26,49 +59,90 @@ class Dynamite {
         this.tables = tables;
     }
     /**
-     * Synchronize all declared tables and their GSIs
+     * Connect client and synchronize all declared tables and their GSIs (upsert pattern)
      */
-    async sync() {
+    async connect() {
         if (this.synced && this.connected)
             return;
-        await Promise.all(this.tables.map((table) => this.createTableWithGSI(table)));
-        this.synced = true;
-    }
-    /**
-     * Connect the client for Table operations
-     */
-    connect() {
-        if (this.connected)
-            return;
+        // Set global client for Table operations
         (0, exports.setGlobalClient)(this.client);
         this.connected = true;
+        // Crear tablas principales con GSIs
+        await Promise.all(this.tables.map((table) => this.createTableWithGSI(table)));
+        // Crear pivot tables para relaciones ManyToMany
+        await this.createPivotTables();
+        this.synced = true;
     }
     /**
-     * Get the underlying DynamoDB client
-     */
-    getClient() {
-        return this.client;
-    }
-    /**
-     * Check if client is connected and tables are synced
-     */
-    isReady() {
-        return this.connected && this.synced;
-    }
-    /**
-     * Disconnect and cleanup DynamoDB client
+     * Auto-crear pivot tables para relaciones ManyToMany
      */
-    disconnect() {
-        try {
-            this.client.destroy();
-            this.connected = false;
-            this.synced = false;
-            if (globalClient === this.client)
-                globalClient = undefined;
-        }
-        catch (error) {
-            console.warn("Error during Dynamite disconnect:", error);
+    async createPivotTables() {
+        const pivot_tables = new Map();
+        // Recolectar nombres de pivot tables con metadata
+        for (const table_class of this.tables) {
+            const schema = table_class[decorator_1.SCHEMA];
+            if (!schema)
+                continue;
+            for (const col_name in schema.columns) {
+                const col = schema.columns[col_name];
+                const relation = col.store?.relation;
+                if (relation?.type === "ManyToMany" && relation.pivotTable) {
+                    pivot_tables.set(relation.pivotTable, {
+                        foreignKey: relation.foreignKey || "source_id",
+                        relatedKey: relation.relatedKey || "target_id"
+                    });
+                }
+            }
         }
+        // Crear cada pivot table con GSIs usando los nombres de columna correctos
+        const { CreateTableCommand } = await Promise.resolve().then(() => __importStar(require("@aws-sdk/client-dynamodb")));
+        await Promise.all(Array.from(pivot_tables.entries()).map(async ([pivot_name, metadata]) => {
+            const { foreignKey, relatedKey } = metadata;
+            try {
+                await this.client.send(new CreateTableCommand({
+                    TableName: pivot_name,
+                    KeySchema: [{ AttributeName: "id", KeyType: "HASH" }],
+                    AttributeDefinitions: [
+                        { AttributeName: "id", AttributeType: "S" },
+                        { AttributeName: foreignKey, AttributeType: "S" },
+                        { AttributeName: relatedKey, AttributeType: "S" },
+                    ],
+                    GlobalSecondaryIndexes: [
+                        {
+                            IndexName: `${foreignKey}_index`,
+                            KeySchema: [{ AttributeName: foreignKey, KeyType: "HASH" }],
+                            Projection: { ProjectionType: "ALL" },
+                            ProvisionedThroughput: {
+                                ReadCapacityUnits: 5,
+                                WriteCapacityUnits: 5,
+                            },
+                        },
+                        {
+                            IndexName: `${relatedKey}_index`,
+                            KeySchema: [{ AttributeName: relatedKey, KeyType: "HASH" }],
+                            Projection: { ProjectionType: "ALL" },
+                            ProvisionedThroughput: {
+                                ReadCapacityUnits: 5,
+                                WriteCapacityUnits: 5,
+                            },
+                        },
+                    ],
+                    ProvisionedThroughput: {
+                        ReadCapacityUnits: 5,
+                        WriteCapacityUnits: 5,
+                    },
+                }));
+                console.log(`✓ Pivot table '${pivot_name}' created`);
+            }
+            catch (error) {
+                if (error.name === "ResourceInUseException") {
+                    console.log(`✓ Pivot table '${pivot_name}' already exists`);
+                }
+                else {
+                    throw error;
+                }
+            }
+        }));
     }
     /**
      * Ejecutar operaciones en una transacción atómica.
@@ -103,14 +177,17 @@ class Dynamite {
             throw new Error(`PartitionKey missing in ${ctor.name}`);
         const sk = cols.find((c) => c.store?.indexSort);
         const attr = new Map();
-        attr.set(pk.name || 'id', "S");
+        attr.set(pk.name || "id", "S");
         if (sk)
-            attr.set(sk.name || 'id', "S");
+            attr.set(sk.name || "id", "S");
         // Temporalmente deshabilitamos la creación automática de GSI hasta implementar relaciones
         const gsiDefinitions = [];
-        const schema = [{ AttributeName: pk.name || 'id', KeyType: "HASH" }];
+        const schema = [{ AttributeName: pk.name || "id", KeyType: "HASH" }];
         if (sk && sk.name !== pk.name)
-            schema.push({ AttributeName: sk.name || 'id', KeyType: "RANGE" });
+            schema.push({
+                AttributeName: sk.name || "id",
+                KeyType: "RANGE",
+            });
         try {
             await this.client.send(new client_dynamodb_1.CreateTableCommand({
                 TableName: meta.name,

package/src/{core → src/core}/decorator.d.ts

@@ -5,8 +5,6 @@
  * @fecha 2025-01-28
  */
 export declare const SCHEMA: unique symbol;
-export declare const VALUES: unique symbol;
-declare function toSnakePlural(str: string): string;
 /**
  * @description Factory para crear decoradores con soporte de argumentos y composición
  * @param callback Función que recibe (schema, col, params) para configurar la columna
@@ -29,16 +27,3 @@ export declare function decorator(callback: (schema: any, col: any, params: any[
  * @returns PropertyDecorator
  */
 export declare function relationDecorator(relation_type: string, RelatedTable: any, options?: any): (target: any, propertyKey: string | symbol) => void;
-/**
- * @description Función helper para obtener metadatos del esquema
- * @param ctor Constructor de la clase
- * @returns SchemaEntry
- */
-export declare function getSchema(ctor: Function): any;
-/**
- * @description Función helper para verificar que existe esquema
- * @param ctor Constructor de la clase
- * @returns SchemaEntry
- */
-export declare function ensureSchema(ctor: Function): any;
-export { toSnakePlural };

package/src/{core → src/core}/decorator.js

@@ -6,15 +6,11 @@
  * @fecha 2025-01-28
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.VALUES = exports.SCHEMA = void 0;
+exports.SCHEMA = void 0;
 exports.decorator = decorator;
 exports.relationDecorator = relationDecorator;
-exports.getSchema = getSchema;
-exports.ensureSchema = ensureSchema;
-exports.toSnakePlural = toSnakePlural;
 // Symbols para autocontención (exportados desde table.ts pero también aquí compatibilidad)
 exports.SCHEMA = Symbol('dynamite:schema');
-exports.VALUES = Symbol('dynamite:values');
 // Helper simple para snake_case plural
 function toSnakePlural(str) {
     const snake = str
@@ -41,8 +37,8 @@ function decorator(callback) {
         return function (target, propertyKey) {
             const table_class = target.constructor;
             const column_name = String(propertyKey);
-            // Inicializar SCHEMA si no existe
-            if (!table_class[exports.SCHEMA]) {
+            // Inicializar SCHEMA SI NO TIENE UNO PROPIO (no heredado)
+            if (!Object.prototype.hasOwnProperty.call(table_class, exports.SCHEMA)) {
                 table_class[exports.SCHEMA] = {
                     name: toSnakePlural(table_class.name),
                     primary_key: 'id',
@@ -75,7 +71,8 @@ function relationDecorator(relation_type, RelatedTable, options = {}) {
     return function (target, propertyKey) {
         const table_class = target.constructor;
         const column_name = String(propertyKey);
-        if (!table_class[exports.SCHEMA]) {
+        // Inicializar SCHEMA SI NO TIENE UNO PROPIO (no heredado)
+        if (!Object.prototype.hasOwnProperty.call(table_class, exports.SCHEMA)) {
             table_class[exports.SCHEMA] = {
                 name: toSnakePlural(table_class.name),
                 primary_key: 'id',
@@ -103,31 +100,4 @@ function relationDecorator(relation_type, RelatedTable, options = {}) {
         };
     };
 }
-/**
- * @description Función helper para obtener metadatos del esquema
- * @param ctor Constructor de la clase
- * @returns SchemaEntry
- */
-function getSchema(ctor) {
-    const schema = ctor[exports.SCHEMA];
-    if (!schema) {
-        throw new Error(`Schema not found for ${ctor.name}. Use decorators first.`);
-    }
-    return schema;
-}
-/**
- * @description Función helper para verificar que existe esquema
- * @param ctor Constructor de la clase
- * @returns SchemaEntry
- */
-function ensureSchema(ctor) {
-    if (!ctor[exports.SCHEMA]) {
-        ctor[exports.SCHEMA] = {
-            name: toSnakePlural(ctor.name),
-            primary_key: 'id',
-            columns: {}
-        };
-    }
-    return ctor[exports.SCHEMA];
-}
 //# sourceMappingURL=decorator.js.map