@reldens/storage 0.116.0 → 0.118.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.116.0",
+    "version": "0.118.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/utils": "^0.58.0",
         "knex": "3.3.0",
-        "mysql": "2.18.1",
-        "mysql2": "3.24.3",
-        "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

@@ -0,0 +1,72 @@
+/**
+ *
+ * Reldens - TestProductDetailsEntity
+ *
+ */
+
+const { EntityProperties } = require('../../index');
+const { sc } = require('@reldens/utils');
+
+class TestProductDetailsEntity extends EntityProperties
+{
+
+    static propertiesConfig(extraProps)
+    {
+        let properties = {
+            id: {
+                isId: true,
+                type: 'number',
+                isRequired: true,
+                dbType: 'int'
+            },
+            product_id: {
+                type: 'reference',
+                reference: 'test_products',
+                alias: 'related_test_products',
+                onDelete: 'cascade',
+                isRequired: true,
+                isUnique: true,
+                dbType: 'int'
+            },
+            weight: {
+                type: 'number',
+                dbType: 'decimal'
+            },
+            dimensions: {
+                dbType: 'varchar'
+            },
+            customData: {
+                type: 'textarea',
+                dbType: 'text'
+            },
+            useTimeOut: {
+                type: 'number',
+                dbType: 'int'
+            },
+            created_at: {
+                type: 'datetime',
+                dbType: 'timestamp'
+            },
+            updated_at: {
+                type: 'datetime',
+                dbType: 'timestamp'
+            }
+        };
+        let propertiesKeys = Object.keys(properties);
+        let showProperties = propertiesKeys;
+        let editProperties = sc.removeFromArray([...propertiesKeys], ['id', 'created_at', 'updated_at']);
+        let listProperties = [...propertiesKeys];
+        listProperties.splice(listProperties.indexOf('customData'), 1);
+        return {
+            showProperties,
+            editProperties,
+            listProperties,
+            filterProperties: listProperties,
+            properties,
+            ...extraProps
+        };
+    }
+
+}
+
+module.exports.TestProductDetailsEntity = TestProductDetailsEntity;

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

@@ -4,13 +4,15 @@
  *
  */
 
-const { TestCategoriesEntity } = require('./entities/test-categories-entity');
-const { TestProductsEntity } = require('./entities/test-products-entity');
+const { TestCategoriesEntity } = require('./entities/test-categories-entity');
+const { TestProductDetailsEntity } = require('./entities/test-product-details-entity');
+const { TestProductsEntity } = require('./entities/test-products-entity');
 const { TestReviewsEntity } = require('./entities/test-reviews-entity');
 
 let entitiesConfig = {
-    testCategories: TestCategoriesEntity.propertiesConfig(),
-    testProducts: TestProductsEntity.propertiesConfig(),
+    testCategories: TestCategoriesEntity.propertiesConfig(),
+    testProductDetails: TestProductDetailsEntity.propertiesConfig(),
+    testProducts: TestProductsEntity.propertiesConfig(),
     testReviews: TestReviewsEntity.propertiesConfig()
 };
 

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

@@ -1,16 +1,17 @@
-/**
- *
- * Reldens - Entities Translations
- *
- */
-
-module.exports.entitiesTranslations = {
-    labels: {
+/**
+ *
+ * Reldens - Entities Translations
+ *
+ */
+
+module.exports.entitiesTranslations = {
+    labels: {
         'test_categories': 'Test Categories',
+        'test_product_details': 'Test Product Details',
         'test_products': 'Test Products',
-        'test_reviews': 'Test Reviews'
-    },
-    fields: {
+        'test_reviews': 'Test Reviews'
+    },
+    fields: {
         'test_categories': {
             'id': 'ID',
             'name': 'Name',
@@ -21,6 +22,16 @@ module.exports.entitiesTranslations = {
             'created_at': 'Created At',
             'updated_at': 'Updated At'
         },
+        'test_product_details': {
+            'id': 'ID',
+            'product_id': 'Product ID',
+            'weight': 'Weight',
+            'dimensions': 'Dimensions',
+            'customData': 'CustomData',
+            'useTimeOut': 'UseTimeOut',
+            'created_at': 'Created At',
+            'updated_at': 'Updated At'
+        },
         'test_products': {
             'id': 'ID',
             'category_id': 'Category ID',
@@ -48,6 +59,6 @@ module.exports.entitiesTranslations = {
             'helpful_count': 'Helpful Count',
             'created_at': 'Created At',
             'updated_at': 'Updated At'
-        }
-    }
-};
+        }
+    }
+};

package/tests/fixtures/expected-entities-mikro-orm/models/mikro-orm/registered-models-mikro-orm.js

@@ -5,6 +5,7 @@
  */
 
 const testCategoriesModel = require('./test-categories-model');
+const testProductDetailsModel = require('./test-product-details-model');
 const testProductsModel = require('./test-products-model');
 const testReviewsModel = require('./test-reviews-model');
 const { entitiesConfig } = require('../../entities-config');
@@ -12,6 +13,7 @@ const { entitiesTranslations } = require('../../entities-translations');
 
 let rawRegisteredEntities = {
     testCategories: testCategoriesModel,
+    testProductDetails: testProductDetailsModel,
     testProducts: testProductsModel,
     testReviews: testReviewsModel
 };

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

@@ -0,0 +1,80 @@
+/**
+ *
+ * Reldens - TestProductDetailsModel
+ *
+ */
+
+const { MikroOrmCore } = require('../../../index');
+const { EntitySchema } = MikroOrmCore;
+
+class TestProductDetailsModel
+{
+
+    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, 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);
+    }
+
+}
+
+const schema = new EntitySchema({
+    class: TestProductDetailsModel,
+    tableName: 'test_product_details',
+    properties: {
+        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'],
+            persist: false
+        },
+        related_test_categories: {
+            kind: 'm:1',
+            entity: () => require('./test-categories-model').TestCategoriesModel,
+            joinColumns: ['category_id'],
+            nullable: true,
+            persist: false
+        }
+    },
+});
+schema._fkMappings = {
+    "product_id": {
+        "relationKey": "related_test_products",
+        "entityName": "TestProductsModel",
+        "referencedColumn": "id",
+        "nullable": false
+    },
+    "category_id": {
+        "relationKey": "related_test_categories",
+        "entityName": "TestCategoriesModel",
+        "referencedColumn": "id",
+        "nullable": true
+    }
+};
+module.exports = {
+    TestProductDetailsModel,
+    entity: TestProductDetailsModel,
+    schema: schema
+};