@reldens/storage 0.117.0 → 0.119.0

package/lib/query-builder-models-generation.js

@@ -0,0 +1,80 @@
+/**
+ *
+ * Reldens - QueryBuilderModelsGeneration
+ *
+ */
+
+const { BaseGenerator } = require('./generators/base-generator');
+const { sc } = require('@reldens/utils');
+
+class QueryBuilderModelsGeneration extends BaseGenerator
+{
+
+    constructor(relationsDetection)
+    {
+        super();
+        this.relationsDetection = relationsDetection;
+    }
+
+    modelTableName(tableName)
+    {
+        return tableName;
+    }
+
+    generateEntityProperties(columns, tableName, tableData)
+    {
+        return '';
+    }
+
+    generateFkMappings(tableName, tableData)
+    {
+        return '';
+    }
+
+    generateIdColumn(columns)
+    {
+        let primaryKeyColumn = this.relationsDetection.detectPrimaryKeyColumn(columns);
+        if(!primaryKeyColumn){
+            return '';
+        }
+        if('id' === primaryKeyColumn){
+            return '';
+        }
+        return '\n    static get idColumn()\n    {\n        return \''+primaryKeyColumn+'\';\n    }\n';
+    }
+
+    generateRelations(tableName, tableData, relationMetadata)
+    {
+        let allRelations = Object.assign(
+            {},
+            this.relationsDetection.detectForwardRelations(tableName, tableData),
+            this.relationsDetection.detectReverseRelations(tableName)
+        );
+        let relationKeys = Object.keys(allRelations);
+        if(0 === relationKeys.length){
+            return '';
+        }
+        let relationMappings = [];
+        for(let relationKey of relationKeys){
+            relationMappings.push(this.relationMappingDefinition(relationKey, allRelations[relationKey]));
+        }
+        return '\n    static get relationMappings()\n    {\n        return {\n'
+            +relationMappings.join(',\n')
+            +'\n        };\n    }';
+    }
+
+    relationMappingDefinition(relationKey, relation)
+    {
+        let relatedTable = sc.get(relation, 'referencedTable', relation.referencingTable);
+        let relationMapping = '            '+relationKey+': {\n';
+        relationMapping += '                relation: \''+relation.relationType+'\',\n';
+        relationMapping += '                tableName: \''+relatedTable+'\',\n';
+        relationMapping += '                from: \''+relation.fromColumn+'\',\n';
+        relationMapping += '                to: \''+relation.toColumn+'\'\n';
+        relationMapping += '            }';
+        return relationMapping;
+    }
+
+}
+
+module.exports.QueryBuilderModelsGeneration = QueryBuilderModelsGeneration;

package/lib/relations-loader.js

@@ -0,0 +1,192 @@
+/**
+ *
+ * Reldens - RelationsLoader
+ *
+ */
+
+const { Logger, sc } = require('@reldens/utils');
+
+class RelationsLoader
+{
+
+    constructor(props)
+    {
+        this.driver = sc.get(props, 'driver', false);
+        this.server = sc.get(props, 'server', false);
+        this.relationMappings = sc.get(this.driver.rawModel, 'relationMappings', {});
+    }
+
+    normalizeRelations(relations)
+    {
+        if(sc.isString(relations)){
+            relations = this.driver.parseRelationsString(relations);
+        }
+        if(!sc.isArray(relations)){
+            return Object.keys(this.relationMappings);
+        }
+        if(0 === relations.length){
+            return Object.keys(this.relationMappings);
+        }
+        return relations;
+    }
+
+    relatedDriver(mapping)
+    {
+        if(!this.server){
+            Logger.error('Missing server on relations loader for table: '+mapping.tableName);
+            return false;
+        }
+        let entities = this.server.entityManager.entities;
+        for(let entityKey of Object.keys(entities)){
+            if(entities[entityKey].tableName() === mapping.tableName){
+                return entities[entityKey];
+            }
+        }
+        Logger.error('Related entity not found for table: '+mapping.tableName);
+        return false;
+    }
+
+    async populate(result, relations)
+    {
+        if(!result){
+            return result;
+        }
+        let rows = sc.isArray(result) ? result : [result];
+        if(0 === rows.length){
+            return result;
+        }
+        for(let relationPath of this.normalizeRelations(relations)){
+            await this.populateRelation(rows, relationPath);
+        }
+        return result;
+    }
+
+    async populateRelation(rows, relationPath)
+    {
+        let pathParts = relationPath.split('.');
+        let relationKey = pathParts.shift();
+        let mapping = sc.get(this.relationMappings, relationKey, false);
+        if(!mapping){
+            Logger.warning('Unknown relation "'+relationKey+'" on table "'+this.driver.tableName()+'".');
+            return false;
+        }
+        let relatedDriver = this.relatedDriver(mapping);
+        if(!relatedDriver){
+            return false;
+        }
+        let relatedRows = await this.fetchRelatedRows(rows, mapping, relatedDriver);
+        this.assignRelatedRows(rows, relatedRows, mapping, relationKey);
+        if(0 === pathParts.length){
+            return true;
+        }
+        if(0 === relatedRows.length){
+            return true;
+        }
+        await relatedDriver.relationsLoader.populate(relatedRows, [pathParts.join('.')]);
+        return true;
+    }
+
+    async fetchRelatedRows(rows, mapping, relatedDriver)
+    {
+        let values = [...new Set(
+            rows.map(row => row[mapping.from]).filter(value => sc.isNumber(value) || sc.isString(value))
+        )];
+        if(0 === values.length){
+            return [];
+        }
+        return await relatedDriver.selectRows(
+            {[mapping.to]: {operator: 'IN', value: values}},
+            Object.assign(relatedDriver.selectOptions(false), {offset: 0})
+        );
+    }
+
+    assignRelatedRows(rows, relatedRows, mapping, relationKey)
+    {
+        let isMany = 'HasManyRelation' === mapping.relation;
+        for(let row of rows){
+            let matches = relatedRows.filter(relatedRow => relatedRow[mapping.to] === row[mapping.from]);
+            if(isMany){
+                row[relationKey] = matches;
+                continue;
+            }
+            row[relationKey] = matches.shift() || null;
+        }
+    }
+
+    extractNestedRelations(params, relations)
+    {
+        let nested = {};
+        for(let relationKey of this.normalizeRelations(relations)){
+            if(!sc.hasOwn(this.relationMappings, relationKey)){
+                continue;
+            }
+            if(!sc.hasOwn(params, relationKey)){
+                continue;
+            }
+            nested[relationKey] = params[relationKey];
+        }
+        return nested;
+    }
+
+    async createWithRelations(params, relations)
+    {
+        let nested = this.extractNestedRelations(params, relations);
+        let nestedKeys = Object.keys(nested);
+        if(0 === nestedKeys.length){
+            return await this.driver.create(params);
+        }
+        let data = sc.omitProps(params, nestedKeys);
+        await this.createParents(data, nested);
+        let created = await this.driver.create(data);
+        if(!created){
+            return false;
+        }
+        await this.createChildren(created, nested);
+        return await this.populate(created, nestedKeys);
+    }
+
+    async createParents(data, nested)
+    {
+        for(let relationKey of Object.keys(nested)){
+            let mapping = sc.get(this.relationMappings, relationKey, false);
+            if('BelongsToOneRelation' !== mapping.relation){
+                continue;
+            }
+            let relatedDriver = this.relatedDriver(mapping);
+            if(!relatedDriver){
+                continue;
+            }
+            let parent = await relatedDriver.create(nested[relationKey]);
+            if(!parent){
+                continue;
+            }
+            data[mapping.from] = parent[mapping.to];
+        }
+    }
+
+    async createChildren(created, nested)
+    {
+        for(let relationKey of Object.keys(nested)){
+            let mapping = sc.get(this.relationMappings, relationKey, false);
+            if('BelongsToOneRelation' === mapping.relation){
+                continue;
+            }
+            let relatedDriver = this.relatedDriver(mapping);
+            if(!relatedDriver){
+                continue;
+            }
+            await this.createChildRows(created, nested[relationKey], mapping, relatedDriver);
+        }
+    }
+
+    async createChildRows(created, children, mapping, relatedDriver)
+    {
+        let childRows = sc.isArray(children) ? children : [children];
+        for(let childRow of childRows){
+            await relatedDriver.create(Object.assign({}, childRow, {[mapping.to]: created[mapping.from]}));
+        }
+    }
+
+}
+
+module.exports.RelationsLoader = RelationsLoader;

package/lib/type-mapper.js

@@ -81,6 +81,44 @@ class TypeMapper
         return typeMap[dbType.toLowerCase()] || 'String';
     }
 
+    mapDbTypeToDrizzleBuilder(dbType)
+    {
+        let typeMap = {
+            'int': 'int',
+            'integer': 'int',
+            'tinyint': 'tinyint',
+            'smallint': 'smallint',
+            'mediumint': 'mediumint',
+            'bigint': 'bigint',
+            'decimal': 'decimal',
+            'float': 'float',
+            'double': 'double',
+            'varchar': 'varchar',
+            'char': 'char',
+            'text': 'text',
+            'tinytext': 'text',
+            'mediumtext': 'text',
+            'longtext': 'text',
+            'date': 'date',
+            'datetime': 'datetime',
+            'timestamp': 'timestamp',
+            'time': 'time',
+            'year': 'year',
+            'boolean': 'boolean',
+            'bool': 'boolean',
+            'bit': 'binary',
+            'json': 'json',
+            'enum': 'mysqlEnum',
+            'binary': 'binary',
+            'varbinary': 'varbinary',
+            'blob': 'binary',
+            'tinyblob': 'binary',
+            'mediumblob': 'binary',
+            'longblob': 'binary'
+        };
+        return typeMap[dbType.toLowerCase()] || 'text';
+    }
+
 }
 
 module.exports.TypeMapper = new TypeMapper();

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "@reldens/storage",
     "scope": "@reldens",
-    "version": "0.117.0",
+    "version": "0.119.0",
     "description": "Reldens - Storage",
     "author": "Damian A. Pastorini",
     "license": "MIT",
@@ -27,6 +27,11 @@
         "mikro-orm",
         "prisma",
         "prisma-orm",
+        "knex",
+        "kysely",
+        "drizzle",
+        "drizzle-orm",
+        "query-builder",
         "driver",
         "orm",
         "database",
@@ -51,14 +56,9 @@
         "test:driver": "node tests/run-tests.js --driver="
     },
     "dependencies": {
-        "@mikro-orm/core": "7.2.0",
-        "@mikro-orm/mongodb": "7.2.0",
-        "@mikro-orm/mysql": "7.2.0",
-        "@reldens/server-utils": "^0.57.0",
+        "@reldens/server-utils": "^0.58.0",
         "@reldens/utils": "^0.58.0",
         "knex": "3.3.0",
-        "mysql": "2.18.1",
-        "mysql2": "3.24.4",
-        "objection": "3.1.5"
+        "mysql2": "3.24.4"
     }
 }

package/tests/.env.test.example

@@ -5,4 +5,10 @@ RELDENS_TEST_DB_PASSWORD=test_password
 RELDENS_TEST_DB_NAME=reldens_storage_test
 RELDENS_TEST_DB_CLIENT=mysql
 RELDENS_DB_URL=mysql://test_user:test_password@localhost:3306/reldens_storage_test
+RELDENS_TEST_OBJECTION_ENABLED=0
+RELDENS_TEST_MIKRO_ORM_ENABLED=0
 RELDENS_TEST_PRISMA_ENABLED=0
+RELDENS_TEST_KYSELY_ENABLED=0
+RELDENS_TEST_DRIZZLE_ENABLED=0
+RELDENS_TEST_MIGRATIONS_PATH=
+RELDENS_TEST_RELDENS_DB_NAME=reldens_storage_test_full

package/tests/fixtures/categories-fixtures.js

@@ -154,6 +154,14 @@ module.exports.CategoriesFixtures = {
         display_order: 2,
         slug: 'relations-test-2'
     },
+    category_cross_driver_create: {
+        id: 1700,
+        name: 'Cross Driver Create',
+        description: 'Category created with the same explicit id by every driver',
+        is_active: 1,
+        display_order: 7,
+        slug: 'cross-driver-create'
+    },
     category_create_nested: {
         name: 'Nested Create Category',
         description: 'Category for createWithRelations test',

package/tests/fixtures/expected-entities/entities/test-product-details-entity.js

@@ -35,6 +35,14 @@ class TestProductDetailsEntity extends EntityProperties
             dimensions: {
                 dbType: 'varchar'
             },
+            customData: {
+                type: 'textarea',
+                dbType: 'text'
+            },
+            useTimeOut: {
+                type: 'number',
+                dbType: 'int'
+            },
             created_at: {
                 type: 'datetime',
                 dbType: 'timestamp'
@@ -47,7 +55,8 @@ class TestProductDetailsEntity extends EntityProperties
         let propertiesKeys = Object.keys(properties);
         let showProperties = propertiesKeys;
         let editProperties = sc.removeFromArray([...propertiesKeys], ['id', 'created_at', 'updated_at']);
-        let listProperties = propertiesKeys;
+        let listProperties = [...propertiesKeys];
+        listProperties.splice(listProperties.indexOf('customData'), 1);
         return {
             showProperties,
             editProperties,

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

@@ -27,6 +27,8 @@ module.exports.entitiesTranslations = {
             'product_id': 'Product ID',
             'weight': 'Weight',
             'dimensions': 'Dimensions',
+            'customData': 'CustomData',
+            'useTimeOut': 'UseTimeOut',
             'created_at': 'Created At',
             'updated_at': 'Updated At'
         },

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

@@ -34,14 +34,19 @@ const schema = new EntitySchema({
     class: TestCategoriesModel,
     tableName: 'test_categories',
     properties: {
-        id: { type: 'number', primary: true },
-        name: { type: 'string' },
-        slug: { type: 'string' },
-        description: { type: 'string', nullable: true },
-        is_active: { type: 'number', nullable: true },
-        display_order: { type: 'number', nullable: true },
-        created_at: { type: 'Date', nullable: true },
-        updated_at: { type: 'Date', nullable: true },
+        id: { type: 'int', primary: true },
+        name: { type: 'varchar' },
+        slug: { type: 'varchar' },
+        description: { type: 'text', nullable: true },
+        is_active: { type: 'tinyint', nullable: true },
+        display_order: { type: 'int', nullable: true },
+        created_at: { type: 'timestamp', nullable: true },
+        updated_at: { type: 'timestamp', nullable: true },
+        related_test_product_details: {
+            kind: '1:m',
+            entity: () => require('./test-product-details-model').TestProductDetailsModel,
+            mappedBy: 'related_test_categories'
+        },
         related_test_products: {
             kind: '1:m',
             entity: () => require('./test-products-model').TestProductsModel,

package/tests/fixtures/expected-entities-mikro-orm/models/mikro-orm/test-product-details-model.js

@@ -10,20 +10,23 @@ const { EntitySchema } = MikroOrmCore;
 class TestProductDetailsModel
 {
 
-    constructor(id, product_id, weight, dimensions, created_at, updated_at)
+    constructor(id, product_id, weight, dimensions, customData, useTimeOut, category_id, created_at, updated_at)
     {
         this.id = id;
         this.product_id = product_id;
         this.weight = weight;
         this.dimensions = dimensions;
+        this.customData = customData;
+        this.useTimeOut = useTimeOut;
+        this.category_id = category_id;
         this.created_at = created_at;
         this.updated_at = updated_at;
     }
 
     static createByProps(props)
     {
-        const {id, product_id, weight, dimensions, created_at, updated_at} = props;
-        return new this(id, product_id, weight, dimensions, created_at, updated_at);
+        const {id, product_id, weight, dimensions, customData, useTimeOut, category_id, created_at, updated_at} = props;
+        return new this(id, product_id, weight, dimensions, customData, useTimeOut, category_id, created_at, updated_at);
     }
 
 }
@@ -32,16 +35,27 @@ const schema = new EntitySchema({
     class: TestProductDetailsModel,
     tableName: 'test_product_details',
     properties: {
-        id: { type: 'number', primary: true },
-        product_id: { type: 'number', persist: false },
-        weight: { type: 'number', nullable: true },
-        dimensions: { type: 'string', nullable: true },
-        created_at: { type: 'Date', nullable: true },
-        updated_at: { type: 'Date', nullable: true },
+        id: { type: 'int', primary: true },
+        product_id: { type: 'int' },
+        weight: { type: 'decimal', nullable: true },
+        dimensions: { type: 'varchar', nullable: true },
+        customData: { type: 'text', nullable: true },
+        useTimeOut: { type: 'int', nullable: true },
+        category_id: { type: 'int', nullable: true },
+        created_at: { type: 'timestamp', nullable: true },
+        updated_at: { type: 'timestamp', nullable: true },
         related_test_products: {
             kind: '1:1',
             entity: () => require('./test-products-model').TestProductsModel,
-            joinColumns: ['product_id']
+            joinColumns: ['product_id'],
+            persist: false
+        },
+        related_test_categories: {
+            kind: 'm:1',
+            entity: () => require('./test-categories-model').TestCategoriesModel,
+            joinColumns: ['category_id'],
+            nullable: true,
+            persist: false
         }
     },
 });
@@ -51,6 +65,12 @@ schema._fkMappings = {
         "entityName": "TestProductsModel",
         "referencedColumn": "id",
         "nullable": false
+    },
+    "category_id": {
+        "relationKey": "related_test_categories",
+        "entityName": "TestCategoriesModel",
+        "referencedColumn": "id",
+        "nullable": true
     }
 };
 module.exports = {

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

@@ -39,23 +39,24 @@ const schema = new EntitySchema({
     class: TestProductsModel,
     tableName: 'test_products',
     properties: {
-        id: { type: 'number', primary: true },
-        category_id: { type: 'number', persist: false },
-        name: { type: 'string' },
-        sku: { type: 'string' },
-        description: { type: 'string', nullable: true },
-        price: { type: 'number' },
-        stock_quantity: { type: 'number', nullable: true },
-        is_featured: { type: 'number', nullable: true },
-        metadata: { type: 'object', nullable: true },
-        tags: { type: 'string', nullable: true },
-        status: { type: 'undefined', nullable: true },
-        created_at: { type: 'Date', nullable: true },
-        updated_at: { type: 'Date', nullable: true },
+        id: { type: 'int', primary: true },
+        category_id: { type: 'int' },
+        name: { type: 'varchar' },
+        sku: { type: 'varchar' },
+        description: { type: 'text', nullable: true },
+        price: { type: 'decimal' },
+        stock_quantity: { type: 'int', nullable: true },
+        is_featured: { type: 'tinyint', nullable: true },
+        metadata: { type: 'json', nullable: true },
+        tags: { type: 'varchar', nullable: true },
+        status: { type: 'enum', nullable: true },
+        created_at: { type: 'timestamp', nullable: true },
+        updated_at: { type: 'timestamp', nullable: true },
         related_test_categories: {
             kind: 'm:1',
             entity: () => require('./test-categories-model').TestCategoriesModel,
-            joinColumns: ['category_id']
+            joinColumns: ['category_id'],
+            persist: false
         },
         related_test_product_details: {
             kind: '1:1',

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

@@ -37,21 +37,22 @@ const schema = new EntitySchema({
     class: TestReviewsModel,
     tableName: 'test_reviews',
     properties: {
-        id: { type: 'number', primary: true },
-        product_id: { type: 'number', persist: false },
-        reviewer_name: { type: 'string' },
-        reviewer_email: { type: 'string' },
-        rating: { type: 'number' },
-        title: { type: 'string', nullable: true },
-        comment: { type: 'string', nullable: true },
-        is_verified: { type: 'number', nullable: true },
-        helpful_count: { type: 'number', nullable: true },
-        created_at: { type: 'Date', nullable: true },
-        updated_at: { type: 'Date', nullable: true },
+        id: { type: 'int', primary: true },
+        product_id: { type: 'int' },
+        reviewer_name: { type: 'varchar' },
+        reviewer_email: { type: 'varchar' },
+        rating: { type: 'tinyint' },
+        title: { type: 'varchar', nullable: true },
+        comment: { type: 'text', nullable: true },
+        is_verified: { type: 'tinyint', nullable: true },
+        helpful_count: { type: 'int', nullable: true },
+        created_at: { type: 'timestamp', nullable: true },
+        updated_at: { type: 'timestamp', nullable: true },
         related_test_products: {
             kind: 'm:1',
             entity: () => require('./test-products-model').TestProductsModel,
-            joinColumns: ['product_id']
+            joinColumns: ['product_id'],
+            persist: false
         }
     },
 });

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

@@ -7,12 +7,14 @@
 class TestProductDetailsModel
 {
 
-    constructor(id, product_id, weight, dimensions, created_at, updated_at)
+    constructor(id, product_id, weight, dimensions, customData, useTimeOut, created_at, updated_at)
     {
         this.id = id;
         this.product_id = product_id;
         this.weight = weight;
         this.dimensions = dimensions;
+        this.customData = customData;
+        this.useTimeOut = useTimeOut;
         this.created_at = created_at;
         this.updated_at = updated_at;
     }

package/tests/fixtures/product-details-fixtures.js

@@ -10,7 +10,10 @@ module.exports.ProductDetailsFixtures = {
         id: 4600,
         product_id: 2600,
         weight: 1.25,
-        dimensions: '10x20x30'
+        dimensions: '10x20x30',
+        customData: '{"origin":"fixture"}',
+        useTimeOut: 45,
+        total_views: 9007199254740991
     },
     product_details_create_nested: {
         weight: 2.5,

package/tests/fixtures/reviews-fixtures.js

@@ -26,7 +26,8 @@ module.exports.ReviewsFixtures = {
         title: 'Good value',
         comment: 'Works as expected',
         is_verified: 1,
-        helpful_count: 5
+        helpful_count: 5,
+        category_slug: 'relations-test-1'
     },
     review_relations_2: {
         id: 3601,

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

@@ -45,11 +45,17 @@ CREATE TABLE `test_product_details` (
   `product_id` INT UNSIGNED NOT NULL,
   `weight` DECIMAL(10,2) NULL,
   `dimensions` VARCHAR(100) NULL,
+  `customData` TEXT NULL,
+  `useTimeOut` INT NULL,
+  `total_views` BIGINT NULL,
+  `category_id` INT UNSIGNED NULL DEFAULT NULL,
   `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 `product_id` (`product_id`),
-  CONSTRAINT `fk_product_details_product` FOREIGN KEY (`product_id`) REFERENCES `test_products` (`id`) ON DELETE CASCADE
+  KEY `category_id` (`category_id`),
+  CONSTRAINT `fk_product_details_product` FOREIGN KEY (`product_id`) REFERENCES `test_products` (`id`) ON DELETE CASCADE,
+  CONSTRAINT `fk_product_details_category` FOREIGN KEY (`category_id`) REFERENCES `test_categories` (`id`) ON DELETE SET NULL
 ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci;
 
 CREATE TABLE `test_reviews` (
@@ -62,11 +68,14 @@ CREATE TABLE `test_reviews` (
   `comment` TEXT NULL,
   `is_verified` TINYINT(1) NOT NULL DEFAULT 0,
   `helpful_count` INT NOT NULL DEFAULT 0,
+  `category_slug` VARCHAR(100) NULL,
   `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
+  KEY `category_slug` (`category_slug`),
+  CONSTRAINT `fk_reviews_product` FOREIGN KEY (`product_id`) REFERENCES `test_products` (`id`) ON DELETE CASCADE,
+  CONSTRAINT `fk_reviews_category_slug` FOREIGN KEY (`category_slug`) REFERENCES `test_categories` (`slug`) ON DELETE SET NULL
 ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci;