@reldens/storage 0.87.0 → 0.89.0

package/tests/fixtures/expected-entities-prisma/entities-translations.js

@@ -0,0 +1,13 @@
+/**
+ *
+ * Reldens - Entities Translations
+ *
+ */
+
+module.exports.entitiesTranslations = {
+    labels: {
+        'test_categories': 'Test Categories',
+        'test_products': 'Test Products',
+        'test_reviews': 'Test Reviews'
+    }
+};

package/tests/fixtures/expected-entities-prisma/models/prisma/registered-models-prisma.js

@@ -0,0 +1,23 @@
+/**
+ *
+ * Reldens - Registered Models
+ *
+ */
+
+const { TestCategoriesModel } = require('./test-categories-model');
+const { TestProductsModel } = require('./test-products-model');
+const { TestReviewsModel } = require('./test-reviews-model');
+const { entitiesConfig } = require('../../entities-config');
+const { entitiesTranslations } = require('../../entities-translations');
+
+let rawRegisteredEntities = {
+    testCategories: TestCategoriesModel,
+    testProducts: TestProductsModel,
+    testReviews: TestReviewsModel
+};
+
+module.exports.rawRegisteredEntities = rawRegisteredEntities;
+
+module.exports.entitiesConfig = entitiesConfig;
+
+module.exports.entitiesTranslations = entitiesTranslations;

package/tests/fixtures/expected-entities-prisma/models/prisma/test-categories-model.js

@@ -0,0 +1,43 @@
+/**
+ *
+ * Reldens - TestCategoriesModel
+ *
+ */
+
+class TestCategoriesModel
+{
+
+    constructor(id, name, slug, description, is_active, display_order, created_at, updated_at)
+    {
+        this.id = id;
+        this.name = name;
+        this.slug = slug;
+        this.description = description;
+        this.is_active = is_active;
+        this.display_order = display_order;
+        this.created_at = created_at;
+        this.updated_at = updated_at;
+    }
+
+    static get tableName()
+    {
+        return 'test_categories';
+    }
+    
+
+    static get relationTypes()
+    {
+        return {
+            test_products: 'many'
+        };
+    }
+
+    static get relationMappings()
+    {
+        return {
+            'related_test_products': 'test_products'
+        };
+    }
+}
+
+module.exports.TestCategoriesModel = TestCategoriesModel;

package/tests/fixtures/expected-entities-prisma/models/prisma/test-products-model.js

@@ -0,0 +1,50 @@
+/**
+ *
+ * Reldens - TestProductsModel
+ *
+ */
+
+class TestProductsModel
+{
+
+    constructor(id, category_id, name, sku, description, price, stock_quantity, is_featured, metadata, tags, status, created_at, updated_at)
+    {
+        this.id = id;
+        this.category_id = category_id;
+        this.name = name;
+        this.sku = sku;
+        this.description = description;
+        this.price = price;
+        this.stock_quantity = stock_quantity;
+        this.is_featured = is_featured;
+        this.metadata = metadata;
+        this.tags = tags;
+        this.status = status;
+        this.created_at = created_at;
+        this.updated_at = updated_at;
+    }
+
+    static get tableName()
+    {
+        return 'test_products';
+    }
+    
+
+    static get relationTypes()
+    {
+        return {
+            test_categories: 'one',
+            test_reviews: 'many'
+        };
+    }
+
+    static get relationMappings()
+    {
+        return {
+            'related_test_categories': 'test_categories',
+            'related_test_reviews': 'test_reviews'
+        };
+    }
+}
+
+module.exports.TestProductsModel = TestProductsModel;

package/tests/fixtures/expected-entities-prisma/models/prisma/test-reviews-model.js

@@ -0,0 +1,46 @@
+/**
+ *
+ * Reldens - TestReviewsModel
+ *
+ */
+
+class TestReviewsModel
+{
+
+    constructor(id, product_id, reviewer_name, reviewer_email, rating, title, comment, is_verified, helpful_count, created_at, updated_at)
+    {
+        this.id = id;
+        this.product_id = product_id;
+        this.reviewer_name = reviewer_name;
+        this.reviewer_email = reviewer_email;
+        this.rating = rating;
+        this.title = title;
+        this.comment = comment;
+        this.is_verified = is_verified;
+        this.helpful_count = helpful_count;
+        this.created_at = created_at;
+        this.updated_at = updated_at;
+    }
+
+    static get tableName()
+    {
+        return 'test_reviews';
+    }
+    
+
+    static get relationTypes()
+    {
+        return {
+            test_products: 'one'
+        };
+    }
+
+    static get relationMappings()
+    {
+        return {
+            'related_test_products': 'test_products'
+        };
+    }
+}
+
+module.exports.TestReviewsModel = TestReviewsModel;

package/tests/fixtures/products-fixtures.js

@@ -0,0 +1,119 @@
+/**
+ *
+ * Reldens - Test Products Fixtures
+ * Universal fixtures for all drivers (no driver-specific nesting)
+ *
+ */
+
+module.exports.ProductsFixtures = {
+    product_create_json: {
+        name: 'Laptop Pro 15',
+        description: 'High-performance laptop',
+        sku: 'LAPTOP-PRO-15',
+        price: 1299.99,
+        stock_quantity: 50,
+        is_featured: 1,
+        metadata: JSON.stringify({warranty: '2 years', color: 'silver'}),
+        tags: 'electronics,computers,featured',
+        status: 'published'
+    },
+    product_create_enum: {
+        name: 'T-Shirt Classic',
+        description: 'Cotton t-shirt',
+        sku: 'TSHIRT-CLASSIC',
+        price: 24.99,
+        stock_quantity: 200,
+        is_featured: 0,
+        metadata: JSON.stringify({size: 'M', material: 'cotton'}),
+        tags: 'clothing,apparel',
+        status: 'published'
+    },
+    product_fk_test: {
+        category_id: 9999,
+        name: 'Invalid Category Product',
+        description: 'Product with invalid category FK',
+        sku: 'INVALID-FK-TEST',
+        price: 9.99,
+        stock_quantity: 1,
+        is_featured: 0,
+        metadata: JSON.stringify({}),
+        tags: 'test',
+        status: 'draft'
+    },
+    product_reviews_crud: {
+        id: 2400,
+        category_id: 1400,
+        name: 'Reviews CRUD Product',
+        description: 'Product for reviews CRUD tests',
+        sku: 'REVIEWS-CRUD-PROD',
+        price: 99.99,
+        stock_quantity: 10,
+        is_featured: 1,
+        metadata: JSON.stringify({test: 'reviews'}),
+        tags: 'test,reviews',
+        status: 'published'
+    },
+    product_filters_1: {
+        id: 2500,
+        category_id: 1500,
+        name: 'Filters Product 1',
+        description: 'First product for filter tests',
+        sku: 'FILTERS-PROD-1',
+        price: 49.99,
+        stock_quantity: 25,
+        is_featured: 1,
+        metadata: JSON.stringify({test: 'filters'}),
+        tags: 'test,filters',
+        status: 'published'
+    },
+    product_filters_2: {
+        id: 2501,
+        category_id: 1500,
+        name: 'Filters Product 2',
+        description: 'Second product for filter tests',
+        sku: 'FILTERS-PROD-2',
+        price: 79.99,
+        stock_quantity: 15,
+        is_featured: 0,
+        metadata: JSON.stringify({test: 'filters'}),
+        tags: 'test,filters',
+        status: 'draft'
+    },
+    product_relations_1: {
+        id: 2600,
+        category_id: 1600,
+        name: 'Relations Product 1',
+        description: 'First product for relations tests',
+        sku: 'RELATIONS-PROD-1',
+        price: 149.99,
+        stock_quantity: 30,
+        is_featured: 1,
+        metadata: JSON.stringify({test: 'relations'}),
+        tags: 'test,relations',
+        status: 'published'
+    },
+    product_relations_2: {
+        id: 2601,
+        category_id: 1601,
+        name: 'Relations Product 2',
+        description: 'Second product for relations tests',
+        sku: 'RELATIONS-PROD-2',
+        price: 199.99,
+        stock_quantity: 20,
+        is_featured: 1,
+        metadata: JSON.stringify({test: 'relations'}),
+        tags: 'test,relations',
+        status: 'published'
+    },
+    product_create_nested: {
+        name: 'Nested Create Product',
+        description: 'Product for createWithRelations test',
+        sku: 'NESTED-PROD-001',
+        price: 99.99,
+        stock_quantity: 10,
+        is_featured: 0,
+        metadata: JSON.stringify({test: 'nested'}),
+        tags: 'test,nested',
+        status: 'draft'
+    }
+};

package/tests/fixtures/reviews-fixtures.js

@@ -0,0 +1,42 @@
+/**
+ *
+ * Reldens - Test Reviews Fixtures
+ * Universal fixtures for all drivers (no driver-specific nesting)
+ *
+ */
+
+module.exports.ReviewsFixtures = {
+    review_crud_1: {
+        id: 3400,
+        product_id: 2400,
+        reviewer_name: 'John Doe',
+        reviewer_email: 'john@example.com',
+        rating: 5,
+        title: 'Excellent product!',
+        comment: 'Very satisfied with this purchase',
+        is_verified: 1,
+        helpful_count: 10
+    },
+    review_relations_1: {
+        id: 3600,
+        product_id: 2600,
+        reviewer_name: 'Jane Smith',
+        reviewer_email: 'jane@example.com',
+        rating: 4,
+        title: 'Good value',
+        comment: 'Works as expected',
+        is_verified: 1,
+        helpful_count: 5
+    },
+    review_relations_2: {
+        id: 3601,
+        product_id: 2601,
+        reviewer_name: 'Bob Johnson',
+        reviewer_email: 'bob@example.com',
+        rating: 5,
+        title: 'Great quality',
+        comment: 'Highly recommended',
+        is_verified: 1,
+        helpful_count: 8
+    }
+};

package/tests/fixtures/sql/test-schema.sql

@@ -0,0 +1,59 @@
+DROP TABLE IF EXISTS `test_reviews`;
+DROP TABLE IF EXISTS `test_products`;
+DROP TABLE IF EXISTS `test_categories`;
+
+CREATE TABLE `test_categories` (
+  `id` INT UNSIGNED NOT NULL AUTO_INCREMENT,
+  `name` VARCHAR(100) NOT NULL,
+  `slug` VARCHAR(100) NOT NULL,
+  `description` TEXT NULL,
+  `is_active` TINYINT(1) NOT NULL DEFAULT 1,
+  `display_order` INT NOT NULL DEFAULT 0,
+  `created_at` TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
+  `updated_at` TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
+  PRIMARY KEY (`id`),
+  UNIQUE KEY `slug` (`slug`),
+  KEY `is_active` (`is_active`),
+  KEY `display_order` (`display_order`)
+) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci;
+
+CREATE TABLE `test_products` (
+  `id` INT UNSIGNED NOT NULL AUTO_INCREMENT,
+  `category_id` INT UNSIGNED NOT NULL,
+  `name` VARCHAR(200) NOT NULL,
+  `sku` VARCHAR(50) NOT NULL,
+  `description` TEXT NULL,
+  `price` DECIMAL(10,2) NOT NULL,
+  `stock_quantity` INT NOT NULL DEFAULT 0,
+  `is_featured` TINYINT(1) NOT NULL DEFAULT 0,
+  `metadata` JSON NULL,
+  `tags` VARCHAR(255) NULL,
+  `status` ENUM('draft','published','archived') NOT NULL DEFAULT 'draft',
+  `created_at` TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
+  `updated_at` TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
+  PRIMARY KEY (`id`),
+  UNIQUE KEY `sku` (`sku`),
+  KEY `category_id` (`category_id`),
+  KEY `status` (`status`),
+  KEY `is_featured` (`is_featured`),
+  CONSTRAINT `fk_products_category` FOREIGN KEY (`category_id`) REFERENCES `test_categories` (`id`) ON DELETE CASCADE
+) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci;
+
+CREATE TABLE `test_reviews` (
+  `id` INT UNSIGNED NOT NULL AUTO_INCREMENT,
+  `product_id` INT UNSIGNED NOT NULL,
+  `reviewer_name` VARCHAR(100) NOT NULL,
+  `reviewer_email` VARCHAR(255) NOT NULL,
+  `rating` TINYINT UNSIGNED NOT NULL,
+  `title` VARCHAR(200) NULL,
+  `comment` TEXT NULL,
+  `is_verified` TINYINT(1) NOT NULL DEFAULT 0,
+  `helpful_count` INT NOT NULL DEFAULT 0,
+  `created_at` TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
+  `updated_at` TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
+  PRIMARY KEY (`id`),
+  KEY `product_id` (`product_id`),
+  KEY `rating` (`rating`),
+  KEY `is_verified` (`is_verified`),
+  CONSTRAINT `fk_reviews_product` FOREIGN KEY (`product_id`) REFERENCES `test_products` (`id`) ON DELETE CASCADE
+) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci;

package/tests/integration/test-drivers.js

@@ -0,0 +1,257 @@
+/**
+ *
+ * Reldens - Drivers Integration Test
+ * Tests CRUD operations across all three storage drivers
+ *
+ */
+
+const { TestRunner, assert } = require('../utils/test-runner');
+const { TestHelpers } = require('../utils/test-helpers');
+const { CategoriesFixtures } = require('../fixtures/categories-fixtures');
+const { ProductsFixtures } = require('../fixtures/products-fixtures');
+const { ReviewsFixtures } = require('../fixtures/reviews-fixtures');
+
+class DriversTest
+{
+
+    constructor(dataServer, repos, driverName)
+    {
+        this.dataServer = dataServer;
+        this.categoriesRepo = repos.testCategories;
+        this.productsRepo = repos.testProducts;
+        this.reviewsRepo = repos.testReviews;
+        this.driverName = driverName;
+        this.runner = new TestRunner();
+    }
+
+    async run()
+    {
+        this.runner.suite('Driver: '+this.driverName);
+        await this.testCreateOperations();
+        await this.testUpdateOperations();
+        await this.testQueryOperations();
+        await this.testDeleteOperations();
+        await this.testReviewsCrud();
+        return this.runner.getResults();
+    }
+
+    async testCreateOperations()
+    {
+        this.runner.group('CREATE Operations');
+        await TestHelpers.cleanDatabase(this.dataServer);
+        await this.categoriesRepo.create(CategoriesFixtures.category_create_single);
+        let categoryJson = await this.categoriesRepo.create(CategoriesFixtures.category_create_json);
+        await this.productsRepo.create({...ProductsFixtures.product_create_json, category_id: categoryJson.id});
+        let categoryEnum = await this.categoriesRepo.create(CategoriesFixtures.category_create_enum);
+        await this.productsRepo.create({...ProductsFixtures.product_create_enum, category_id: categoryEnum.id});
+        await this.categoriesRepo.create(CategoriesFixtures.category_unique_test);
+        await this.runner.test('should create single record', async () => {
+            let created = await this.categoriesRepo.loadOne({slug: 'electronics'});
+            assert.ok(created);
+            assert.ok(created.id);
+            assert.strictEqual(created.name, 'Electronics');
+        });
+        await this.runner.test('should create record with JSON field', async () => {
+            let category = await this.categoriesRepo.loadOne({slug: 'books'});
+            let product = await this.productsRepo.loadOne({sku: 'LAPTOP-PRO-15'});
+            assert.ok(category);
+            assert.ok(product);
+            assert.ok(product.metadata);
+        });
+        await this.runner.test('should create record with ENUM field', async () => {
+            let category = await this.categoriesRepo.loadOne({slug: 'clothing'});
+            let product = await this.productsRepo.loadOne({sku: 'TSHIRT-CLASSIC'});
+            assert.ok(category);
+            assert.ok(product);
+            assert.strictEqual(product.status, 'published');
+        });
+        await this.runner.test('should enforce UNIQUE constraints', async () => {
+            let categoryData = CategoriesFixtures.category_unique_test;
+            try {
+                await this.categoriesRepo.create(categoryData);
+                assert.fail('Should have thrown duplicate key error');
+            } catch(error){
+                assert.ok(error);
+            }
+        });
+        await this.runner.test('should enforce FOREIGN KEY constraints', async () => {
+            let productData = ProductsFixtures.product_fk_test;
+            try {
+                await this.productsRepo.create(productData);
+                assert.fail('Should have thrown foreign key error');
+            } catch(error){
+                assert.ok(error);
+            }
+        });
+    }
+
+    async testUpdateOperations()
+    {
+        this.runner.group('UPDATE Operations');
+        await TestHelpers.cleanDatabase(this.dataServer);
+        await TestHelpers.insertFixturesViaRawSQL(this.dataServer, 'test_categories', [
+            CategoriesFixtures.category_update_by_id
+        ]);
+        await this.runner.test('should update record by ID', async () => {
+            let updated = await this.categoriesRepo.updateById(1100, {name: 'Updated Name'});
+            assert.ok(updated);
+            assert.strictEqual(updated.name, 'Updated Name');
+        });
+        await this.runner.test('should update record by filters', async () => {
+            let updated = await this.categoriesRepo.updateBy('id', 1100, {name: 'Updated via filters'});
+            assert.ok(updated);
+        });
+        await this.runner.test('should update record by single field', async () => {
+            let updated = await this.categoriesRepo.updateBy('id', 1100, {name: 'Updated via field'});
+            assert.ok(updated);
+        });
+        await this.runner.test('should upsert when record does not exist', async () => {
+            let newData = CategoriesFixtures.category_upsert_new;
+            let result = await this.categoriesRepo.upsert(newData, {id: newData.id});
+            assert.ok(result);
+        });
+        await this.runner.test('should upsert when record exists', async () => {
+            let result = await this.categoriesRepo.upsert({id: 1100}, {name: 'Upserted Name'});
+            assert.ok(result);
+        });
+    }
+
+    async testQueryOperations()
+    {
+        this.runner.group('QUERY Operations');
+        await TestHelpers.cleanDatabase(this.dataServer);
+        await TestHelpers.insertFixturesViaRawSQL(this.dataServer, 'test_categories', [
+            CategoriesFixtures.category_query_1,
+            CategoriesFixtures.category_query_2,
+            CategoriesFixtures.category_query_3
+        ]);
+        await this.runner.test('should load all records', async () => {
+            let all = await this.categoriesRepo.loadAll();
+            assert.strictEqual(all.length, 3);
+        });
+        await this.runner.test('should load records by filters', async () => {
+            let filtered = await this.categoriesRepo.load({name: 'Query Test 1'});
+            assert.strictEqual(filtered.length, 1);
+            assert.strictEqual(filtered[0].id, 1300);
+        });
+        await this.runner.test('should load records by single field', async () => {
+            let result = await this.categoriesRepo.loadBy('name', 'Query Test 2');
+            assert.strictEqual(result.length, 1);
+            assert.strictEqual(result[0].id, 1301);
+        });
+        await this.runner.test('should load record by ID', async () => {
+            let record = await this.categoriesRepo.loadById(1300);
+            assert.ok(record);
+            assert.strictEqual(record.id, 1300);
+        });
+        await this.runner.test('should load records by multiple IDs', async () => {
+            let records = await this.categoriesRepo.loadByIds([1300, 1301]);
+            assert.strictEqual(records.length, 2);
+        });
+        await this.runner.test('should load one record', async () => {
+            let record = await this.categoriesRepo.loadOne({name: 'Query Test 1'});
+            assert.ok(record);
+            assert.strictEqual(record.id, 1300);
+        });
+        await this.runner.test('should load one record by field', async () => {
+            let record = await this.categoriesRepo.loadOneBy('name', 'Query Test 3');
+            assert.ok(record);
+            assert.strictEqual(record.id, 1302);
+        });
+        await this.runner.test('should count records with filters', async () => {
+            let count = await this.categoriesRepo.count({name: 'Query Test 1'});
+            assert.strictEqual(count, 1);
+        });
+        await this.runner.test('should apply limit', async () => {
+            this.categoriesRepo.limit = 2;
+            let records = await this.categoriesRepo.load();
+            assert.strictEqual(records.length, 2);
+            this.categoriesRepo.limit = 0;
+        });
+        await this.runner.test('should apply offset', async () => {
+            this.categoriesRepo.offset = 1;
+            this.categoriesRepo.limit = 2;
+            let records = await this.categoriesRepo.load();
+            assert.strictEqual(records.length, 2);
+            this.categoriesRepo.offset = 0;
+            this.categoriesRepo.limit = 0;
+        });
+        await this.runner.test('should apply sortBy and sortDirection', async () => {
+            this.categoriesRepo.sortBy = 'name';
+            this.categoriesRepo.sortDirection = 'DESC';
+            let records = await this.categoriesRepo.load();
+            assert.strictEqual(records.length, 3);
+            assert.strictEqual(records[0].name, 'Query Test 3');
+            assert.strictEqual(records[1].name, 'Query Test 2');
+            assert.strictEqual(records[2].name, 'Query Test 1');
+            this.categoriesRepo.sortBy = false;
+            this.categoriesRepo.sortDirection = 'ASC';
+        });
+    }
+
+    async testDeleteOperations()
+    {
+        this.runner.group('DELETE Operations');
+        await TestHelpers.cleanDatabase(this.dataServer);
+        await TestHelpers.insertFixturesViaRawSQL(this.dataServer, 'test_categories', [
+            CategoriesFixtures.category_delete_by_id,
+            CategoriesFixtures.category_delete_by_filters
+        ]);
+        await this.runner.test('should delete record by ID', async () => {
+            let result = await this.categoriesRepo.deleteById(1200);
+            assert.ok(result);
+            let remaining = await this.categoriesRepo.loadAll();
+            assert.strictEqual(remaining.length, 1);
+        });
+        await this.runner.test('should delete records by filters', async () => {
+            let result = await this.categoriesRepo.delete({name: 'Art'});
+            assert.ok(result);
+            let remaining = await this.categoriesRepo.loadAll();
+            assert.strictEqual(remaining.length, 0);
+        });
+    }
+
+    async testReviewsCrud()
+    {
+        this.runner.group('REVIEWS CRUD Operations');
+        await TestHelpers.cleanDatabase(this.dataServer);
+        await TestHelpers.insertFixturesViaRawSQL(this.dataServer, 'test_categories', [
+            CategoriesFixtures.category_reviews_crud
+        ]);
+        await TestHelpers.insertFixturesViaRawSQL(this.dataServer, 'test_products', [
+            ProductsFixtures.product_reviews_crud
+        ]);
+        await TestHelpers.insertFixturesViaRawSQL(this.dataServer, 'test_reviews', [
+            ReviewsFixtures.review_crud_1
+        ]);
+        await this.runner.test('should create review record', async () => {
+            let created = await this.reviewsRepo.loadById(3400);
+            assert.ok(created);
+            assert.strictEqual(created.product_id, 2400);
+        });
+        await this.runner.test('should load review by ID', async () => {
+            let record = await this.reviewsRepo.loadById(3400);
+            assert.ok(record);
+            assert.strictEqual(record.id, 3400);
+        });
+        await this.runner.test('should update review by ID', async () => {
+            let updated = await this.reviewsRepo.updateById(3400, {rating: 5});
+            assert.ok(updated);
+            assert.strictEqual(updated.rating, 5);
+        });
+        await this.runner.test('should delete review by ID', async () => {
+            let result = await this.reviewsRepo.deleteById(3400);
+            assert.ok(result);
+        });
+        await this.runner.test('should load reviews by product_id', async () => {
+            await TestHelpers.insertFixturesViaRawSQL(this.dataServer, 'test_reviews', [
+                ReviewsFixtures.review_crud_1
+            ]);
+            let reviews = await this.reviewsRepo.loadBy('product_id', 2400);
+            assert.strictEqual(reviews.length, 1);
+        });
+    }
+
+}
+
+module.exports = DriversTest;