@reldens/storage 0.116.0 → 0.117.0

package/lib/generators/models-generation.js

@@ -346,7 +346,7 @@ class ModelsGeneration extends BaseGenerator
                 continue;
             }
             let relationKey = this.generateForwardRelationKey(column.referencedTable, columnName, referenceCounts);
-            let relationType = this.determineForwardRelationType(tableName, columnName, column);
+            let relationType = this.determineRelationType(column, true);
             relations[relationKey] = {
                 fromColumn: columnName,
                 toColumn: column.referencedColumn,
@@ -375,7 +375,7 @@ class ModelsGeneration extends BaseGenerator
                     continue;
                 }
                 let relationKey = this.generateReverseRelationKey(otherTableName, columnName, referenceCounts);
-                let relationType = this.determineReverseRelationType(otherTableName, columnName, column);
+                let relationType = this.determineRelationType(column, false);
                 reverseRelations[relationKey] = {
                     fromColumn: column.referencedColumn,
                     toColumn: columnName,
@@ -442,25 +442,12 @@ class ModelsGeneration extends BaseGenerator
         return RELATION_PREFIX+referencingTable+'_'+columnSuffix;
     }
 
-    determineForwardRelationType(tableName, columnName, column)
+    determineMikroOrmForwardKind(column)
     {
-        return 'BelongsToOneRelation';
-    }
-
-    determineReverseRelationType(referencingTableName, referencingColumnName, referencingColumn)
-    {
-        if(!this.allTablesData[referencingTableName]){
-            return 'HasManyRelation';
-        }
-        let referencingTableData = this.allTablesData[referencingTableName];
-        let referencingColumnData = referencingTableData.columns[referencingColumnName];
-        if(!referencingColumnData){
-            return 'HasManyRelation';
+        if('HasOneRelation' === this.determineRelationType(column, false)){
+            return this.mikroOrmRelationKindMap.HasOneRelation;
         }
-        if('UNI' === referencingColumnData.key || 'PRI' === referencingColumnData.key){
-            return 'HasOneRelation';
-        }
-        return 'HasManyRelation';
+        return this.mikroOrmRelationKindMap.BelongsToOneRelation;
     }
 
     determineRelationType(column, isForwardRelation)
@@ -529,7 +516,7 @@ class ModelsGeneration extends BaseGenerator
                 let relation = relations[relationKey];
                 let relatedModelClass = sc.capitalizedCamelCase(relation.referencedTable)+'Model';
                 let relatedModelFile = sc.kebabCase(relation.referencedTable)+'-model';
-                let kind = sc.get(this.mikroOrmRelationKindMap, relation.relationType, 'm:1');
+                let kind = this.determineMikroOrmForwardKind(columns[relation.fromColumn]);
                 let propDef = relationKey+': {\n';
                 propDef += '            kind: \''+kind+'\',\n';
                 propDef += '            entity: () => require(\'./'+relatedModelFile+'\').'+relatedModelClass;

package/lib/mikro-orm/mikro-orm-driver.js

@@ -76,13 +76,64 @@ class MikroOrmDriver extends BaseDriver
         let relations = [];
         for(let propName of Object.keys(this.entitySchema.meta.properties)){
             let prop = this.entitySchema.meta.properties[propName];
-            if(prop.kind === 'm:1' || prop.kind === '1:m' || prop.kind === 'm:n'){
+            if('m:1' === prop.kind || '1:1' === prop.kind || '1:m' === prop.kind || 'm:n' === prop.kind){
                 relations.push(propName);
             }
         }
         return relations;
     }
 
+    isOwningRelation(prop)
+    {
+        if('m:1' === prop.kind){
+            return true;
+        }
+        return '1:1' === prop.kind && Boolean(prop.owner);
+    }
+
+    isInverseRelation(prop)
+    {
+        if('1:m' === prop.kind){
+            return true;
+        }
+        return '1:1' === prop.kind && !prop.owner;
+    }
+
+    inverseRelationOwnerJoinColumn(prop, relationDriver)
+    {
+        if(!this.isInverseRelation(prop)){
+            return false;
+        }
+        if(!prop.mappedBy){
+            return false;
+        }
+        if(!relationDriver.entitySchema){
+            return false;
+        }
+        if(!relationDriver.entitySchema.meta){
+            return false;
+        }
+        let mappedProp = relationDriver.entitySchema.meta.properties[prop.mappedBy];
+        if(!mappedProp){
+            return false;
+        }
+        if(!mappedProp.joinColumns){
+            return false;
+        }
+        return mappedProp.joinColumns[0] || false;
+    }
+
+    nestedFkColumn(prop, relationDriver)
+    {
+        if(!this.isOwningRelation(prop)){
+            return this.inverseRelationOwnerJoinColumn(prop, relationDriver);
+        }
+        if(!prop.joinColumns){
+            return false;
+        }
+        return prop.joinColumns[0] || false;
+    }
+
     async create(params)
     {
         let transformed = this.transformFkToRelations(params);
@@ -207,7 +258,7 @@ class MikroOrmDriver extends BaseDriver
         let aliasCounter = 0;
         for(let relationName of relations){
             let prop = properties[relationName];
-            if(!prop || !prop.kind || (prop.kind !== 'm:1' && prop.kind !== '1:m')){
+            if(!prop || !prop.kind || (!this.isOwningRelation(prop) && !this.isInverseRelation(prop))){
                 continue;
             }
             let relationDriver = this.server.entityManager.get(prop.entity);
@@ -215,14 +266,12 @@ class MikroOrmDriver extends BaseDriver
                 continue;
             }
             let alias = 'rel_'+aliasCounter;
-            if('m:1' === prop.kind && prop.joinColumns && prop.joinColumns[0]){
+            if(this.isOwningRelation(prop) && prop.joinColumns && prop.joinColumns[0]){
                 queryBuilder.leftJoin(relationName, alias, 'e.'+prop.joinColumns[0]+' = '+alias+'.id');
             }
-            if('1:m' === prop.kind && prop.mappedBy){
-                let mappedProp = relationDriver.entitySchema.meta.properties[prop.mappedBy];
-                if(mappedProp && mappedProp.joinColumns && mappedProp.joinColumns[0]){
-                    queryBuilder.leftJoin(relationName, alias, 'e.id = '+alias+'.'+mappedProp.joinColumns[0]);
-                }
+            let ownerJoinColumn = this.inverseRelationOwnerJoinColumn(prop, relationDriver);
+            if(ownerJoinColumn){
+                queryBuilder.leftJoin(relationName, alias, 'e.id = '+alias+'.'+ownerJoinColumn);
             }
             aliasCounter++;
         }
@@ -424,7 +473,7 @@ class MikroOrmDriver extends BaseDriver
             return entity;
         }
         for(let key of Object.keys(entity)){
-            if(entity[key] && entity[key] instanceof Collection){
+            if(entity[key] && entity[key] instanceof Collection && entity[key].isInitialized()){
                 entity[key] = entity[key].getItems();
             }
         }
@@ -479,7 +528,7 @@ class MikroOrmDriver extends BaseDriver
         let properties = this.entitySchema.meta.properties;
         for(let relationName of Object.keys(properties)){
             let prop = properties[relationName];
-            if(!prop.kind || (prop.kind !== 'm:1' && prop.kind !== '1:m')){
+            if(!prop.kind || (!this.isOwningRelation(prop) && !this.isInverseRelation(prop))){
                 continue;
             }
             if(sc.isArray(relations) && 0 < relations.length && -1 === relations.indexOf(relationName)){
@@ -490,14 +539,19 @@ class MikroOrmDriver extends BaseDriver
                 Logger.warning('Entity not found for relation:', prop.entity);
                 continue;
             }
-            let isOneToMany = '1:m' === prop.kind;
-            let isManyToOne = 'm:1' === prop.kind;
-            if(isManyToOne && sc.hasOwn(params, relationName)){
+            if(!sc.hasOwn(params, relationName)){
+                continue;
+            }
+            if(this.isOwningRelation(prop)){
                 await this.createOne(params, relationName, relationDriver, newInstance, prop);
                 continue;
             }
-            if(isOneToMany && sc.hasOwn(params, relationName) && sc.isArray(params[relationName])){
+            if(sc.isArray(params[relationName])){
                 await this.createMany(params, relationName, relationDriver, newInstance, prop);
+                continue;
+            }
+            if('1:1' === prop.kind && sc.isObject(params[relationName])){
+                await this.createOne(params, relationName, relationDriver, newInstance, prop);
             }
         }
     }
@@ -505,8 +559,9 @@ class MikroOrmDriver extends BaseDriver
     async createOne(params, relationName, relationDriver, newInstance, prop)
     {
         let nestedData = params[relationName];
-        if(prop.joinColumns && prop.joinColumns[0]){
-            nestedData[prop.joinColumns[0]] = newInstance.id;
+        let fkColumn = this.nestedFkColumn(prop, relationDriver);
+        if(fkColumn){
+            nestedData[fkColumn] = newInstance.id;
         }
         let nestedObject = await relationDriver.create(nestedData);
         await this.orm.em.flush();

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "@reldens/storage",
     "scope": "@reldens",
-    "version": "0.116.0",
+    "version": "0.117.0",
     "description": "Reldens - Storage",
     "author": "Damian A. Pastorini",
     "license": "MIT",
@@ -58,7 +58,7 @@
         "@reldens/utils": "^0.58.0",
         "knex": "3.3.0",
         "mysql": "2.18.1",
-        "mysql2": "3.24.3",
+        "mysql2": "3.24.4",
         "objection": "3.1.5"
     }
 }

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

@@ -0,0 +1,63 @@
+/**
+ *
+ * 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'
+            },
+            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;
+        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,14 @@ module.exports.entitiesTranslations = {
             'created_at': 'Created At',
             'updated_at': 'Updated At'
         },
+        'test_product_details': {
+            'id': 'ID',
+            'product_id': 'Product ID',
+            'weight': 'Weight',
+            'dimensions': 'Dimensions',
+            'created_at': 'Created At',
+            'updated_at': 'Updated At'
+        },
         'test_products': {
             'id': 'ID',
             'category_id': 'Category ID',
@@ -48,6 +57,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-product-details-model.js

@@ -0,0 +1,60 @@
+/**
+ *
+ * Reldens - TestProductDetailsModel
+ *
+ */
+
+const { MikroOrmCore } = require('../../../index');
+const { EntitySchema } = MikroOrmCore;
+
+class TestProductDetailsModel
+{
+
+    constructor(id, product_id, weight, dimensions, created_at, updated_at)
+    {
+        this.id = id;
+        this.product_id = product_id;
+        this.weight = weight;
+        this.dimensions = dimensions;
+        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 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 },
+        related_test_products: {
+            kind: '1:1',
+            entity: () => require('./test-products-model').TestProductsModel,
+            joinColumns: ['product_id']
+        }
+    },
+});
+schema._fkMappings = {
+    "product_id": {
+        "relationKey": "related_test_products",
+        "entityName": "TestProductsModel",
+        "referencedColumn": "id",
+        "nullable": false
+    }
+};
+module.exports = {
+    TestProductDetailsModel,
+    entity: TestProductDetailsModel,
+    schema: schema
+};

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

@@ -57,6 +57,11 @@ const schema = new EntitySchema({
             entity: () => require('./test-categories-model').TestCategoriesModel,
             joinColumns: ['category_id']
         },
+        related_test_product_details: {
+            kind: '1:1',
+            entity: () => require('./test-product-details-model').TestProductDetailsModel,
+            mappedBy: 'related_test_products'
+        },
         related_test_reviews: {
             kind: '1:m',
             entity: () => require('./test-reviews-model').TestReviewsModel,

package/tests/fixtures/expected-entities-objection-js/models/objection-js/registered-models-objection-js.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-objection-js/models/objection-js/test-product-details-model.js

@@ -0,0 +1,33 @@
+/**
+ *
+ * Reldens - TestProductDetailsModel
+ *
+ */
+
+const { ObjectionJsRawModel } = require('../../../index');
+
+class TestProductDetailsModel extends ObjectionJsRawModel
+{
+
+    static get tableName()
+    {
+        return 'test_product_details';
+    }
+
+    static get relationMappings()
+    {
+        const { TestProductsModel } = require('./test-products-model');
+        return {
+            related_test_products: {
+                relation: this.BelongsToOneRelation,
+                modelClass: TestProductsModel,
+                join: {
+                    from: this.tableName+'.product_id',
+                    to: TestProductsModel.tableName+'.id'
+                }
+            }
+        };
+    }
+}
+
+module.exports.TestProductDetailsModel = TestProductDetailsModel;

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

@@ -17,6 +17,7 @@ class TestProductsModel extends ObjectionJsRawModel
     static get relationMappings()
     {
         const { TestCategoriesModel } = require('./test-categories-model');
+        const { TestProductDetailsModel } = require('./test-product-details-model');
         const { TestReviewsModel } = require('./test-reviews-model');
         return {
             related_test_categories: {
@@ -27,6 +28,14 @@ class TestProductsModel extends ObjectionJsRawModel
                     to: TestCategoriesModel.tableName+'.id'
                 }
             },
+            related_test_product_details: {
+                relation: this.HasOneRelation,
+                modelClass: TestProductDetailsModel,
+                join: {
+                    from: this.tableName+'.id',
+                    to: TestProductDetailsModel.tableName+'.product_id'
+                }
+            },
             related_test_reviews: {
                 relation: this.HasManyRelation,
                 modelClass: TestReviewsModel,

package/tests/fixtures/expected-entities-prisma/models/prisma/registered-models-prisma.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-prisma/models/prisma/test-product-details-model.js

@@ -0,0 +1,41 @@
+/**
+ *
+ * Reldens - TestProductDetailsModel
+ *
+ */
+
+class TestProductDetailsModel
+{
+
+    constructor(id, product_id, weight, dimensions, created_at, updated_at)
+    {
+        this.id = id;
+        this.product_id = product_id;
+        this.weight = weight;
+        this.dimensions = dimensions;
+        this.created_at = created_at;
+        this.updated_at = updated_at;
+    }
+
+    static get tableName()
+    {
+        return 'test_product_details';
+    }
+
+
+    static get relationTypes()
+    {
+        return {
+            test_products: 'one'
+        };
+    }
+
+    static get relationMappings()
+    {
+        return {
+            'related_test_products': 'test_products'
+        };
+    }
+}
+
+module.exports.TestProductDetailsModel = TestProductDetailsModel;

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

@@ -34,6 +34,7 @@ class TestProductsModel
     {
         return {
             test_categories: 'one',
+            test_product_details: 'one',
             test_reviews: 'many'
         };
     }
@@ -42,6 +43,7 @@ class TestProductsModel
     {
         return {
             'related_test_categories': 'test_categories',
+            'related_test_product_details': 'test_product_details',
             'related_test_reviews': 'test_reviews'
         };
     }

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

@@ -0,0 +1,19 @@
+/**
+ *
+ * Reldens - Test Product Details Fixtures
+ * Universal fixtures for all drivers (no driver-specific nesting)
+ *
+ */
+
+module.exports.ProductDetailsFixtures = {
+    product_details_relations_1: {
+        id: 4600,
+        product_id: 2600,
+        weight: 1.25,
+        dimensions: '10x20x30'
+    },
+    product_details_create_nested: {
+        weight: 2.5,
+        dimensions: '5x5x5'
+    }
+};

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

@@ -1,4 +1,5 @@
 DROP TABLE IF EXISTS `test_reviews`;
+DROP TABLE IF EXISTS `test_product_details`;
 DROP TABLE IF EXISTS `test_products`;
 DROP TABLE IF EXISTS `test_categories`;
 
@@ -39,6 +40,18 @@ CREATE TABLE `test_products` (
   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_product_details` (
+  `id` INT UNSIGNED NOT NULL AUTO_INCREMENT,
+  `product_id` INT UNSIGNED NOT NULL,
+  `weight` DECIMAL(10,2) NULL,
+  `dimensions` 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`),
+  UNIQUE KEY `product_id` (`product_id`),
+  CONSTRAINT `fk_product_details_product` FOREIGN KEY (`product_id`) REFERENCES `test_products` (`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,

package/tests/integration/test-relations.js

@@ -10,6 +10,7 @@ const { TestHelpers } = require('../utils/test-helpers');
 const { CategoriesFixtures } = require('../fixtures/categories-fixtures');
 const { ProductsFixtures } = require('../fixtures/products-fixtures');
 const { ReviewsFixtures } = require('../fixtures/reviews-fixtures');
+const { ProductDetailsFixtures } = require('../fixtures/product-details-fixtures');
 
 class RelationsTest
 {
@@ -19,6 +20,7 @@ class RelationsTest
         this.dataServer = dataServer;
         this.categoriesRepo = repos.testCategories;
         this.productsRepo = repos.testProducts;
+        this.productDetailsRepo = repos.testProductDetails;
         this.driverName = driverName;
         this.runner = new TestRunner();
     }
@@ -36,9 +38,71 @@ class RelationsTest
         await this.testCreateWithRelations();
         await this.testNestedRelations();
         await this.testRelationStringParsing();
+        await this.testOneToOneRelations();
         return this.runner.getResults();
     }
 
+    async testOneToOneRelations()
+    {
+        this.runner.group('One To One Relations');
+        await TestHelpers.cleanDatabase(this.dataServer);
+        await TestHelpers.insertFixturesViaRawSQL(this.dataServer, 'test_categories', [
+            CategoriesFixtures.category_relations_1
+        ]);
+        await TestHelpers.insertFixturesViaRawSQL(this.dataServer, 'test_products', [
+            ProductsFixtures.product_relations_1,
+            {...ProductsFixtures.product_relations_2, category_id: 1600}
+        ]);
+        await TestHelpers.insertFixturesViaRawSQL(this.dataServer, 'test_product_details', [
+            ProductDetailsFixtures.product_details_relations_1
+        ]);
+        await this.runner.test('should load the one to one relation from the referenced side as a single object', async () => {
+            let results = await this.productsRepo.loadWithRelations({id: 2600}, ['related_test_product_details']);
+            assert.strictEqual(results.length, 1);
+            let details = results[0].related_test_product_details;
+            assert.ok(details);
+            assert.ok(!Array.isArray(details));
+            assert.strictEqual(details.id, 4600);
+        });
+        await this.runner.test('should load the one to one relation from the owning side as a single object', async () => {
+            let results = await this.productDetailsRepo.loadWithRelations({id: 4600}, ['related_test_products']);
+            assert.strictEqual(results.length, 1);
+            let product = results[0].related_test_products;
+            assert.ok(product);
+            assert.ok(!Array.isArray(product));
+            assert.strictEqual(product.id, 2600);
+        });
+        await this.runner.test('should return no related record on the one to one relation when none exists', async () => {
+            let result = await this.productsRepo.loadByIdWithRelations(2601, ['related_test_product_details']);
+            assert.ok(result);
+            assert.ok(!result.related_test_product_details);
+        });
+        await this.runner.test('should count records joining the one to one relation from the referenced side', async () => {
+            let count = await this.productsRepo.countWithRelations({}, ['related_test_product_details']);
+            assert.strictEqual(count, 2);
+        });
+        await this.runner.test('should count records joining the one to one relation from the owning side', async () => {
+            let count = await this.productDetailsRepo.countWithRelations({}, ['related_test_products']);
+            assert.strictEqual(count, 1);
+        });
+        await this.runner.test('should create a record with a nested one to one relation', async () => {
+            let productWithDetails = {
+                ...ProductsFixtures.product_create_nested,
+                category_id: 1600,
+                related_test_product_details: {...ProductDetailsFixtures.product_details_create_nested}
+            };
+            let created = await this.productsRepo.createWithRelations(
+                productWithDetails,
+                ['related_test_product_details']
+            );
+            assert.ok(created);
+            assert.ok(created.id);
+            let details = await this.productDetailsRepo.loadBy('product_id', created.id);
+            assert.strictEqual(details.length, 1);
+            assert.strictEqual(details[0].dimensions, ProductDetailsFixtures.product_details_create_nested.dimensions);
+        });
+    }
+
     async testLoadWithRelations()
     {
         this.runner.group('loadWithRelations');

package/tests/run-tests.js

@@ -16,6 +16,7 @@ const EntityManagerTest = require('./unit/test-entity-manager');
 const TypeMapperTest = require('./unit/test-type-mapper');
 const DriversUnitTest = require('./unit/test-drivers');
 const EntitiesGenerationTest = require('./unit/test-entities-generation');
+const ModelsGenerationTest = require('./unit/test-models-generation');
 
 if(!process.env.RELDENS_TEST_DB_HOST){
     let envPath = FileHandler.joinPaths(__dirname, '.env.test');
@@ -193,6 +194,11 @@ class RunTests
         this.allCounts.total += entitiesGenerationResult.total;
         this.allCounts.passed += entitiesGenerationResult.passed;
         this.allCounts.failed += entitiesGenerationResult.failed;
+        let modelsGenerationTest = new ModelsGenerationTest();
+        let modelsGenerationResult = await modelsGenerationTest.run();
+        this.allCounts.total += modelsGenerationResult.total;
+        this.allCounts.passed += modelsGenerationResult.passed;
+        this.allCounts.failed += modelsGenerationResult.failed;
     }
 
     async runPreFlightChecks(config)

package/tests/unit/test-models-generation.js

@@ -0,0 +1,164 @@
+/**
+ *
+ * Reldens - ModelsGeneration Test
+ *
+ */
+
+const { TestRunner, assert } = require('../utils/test-runner');
+const { ModelsGeneration } = require('../../lib/generators/models-generation');
+
+class ModelsGenerationTest
+{
+
+    constructor()
+    {
+        this.runner = new TestRunner();
+    }
+
+    createColumn(props)
+    {
+        return Object.assign(
+            {
+                name: 'test_column',
+                type: 'int',
+                columnType: 'int(10) unsigned',
+                length: null,
+                nullable: false,
+                key: '',
+                extra: '',
+                default: null
+            },
+            props
+        );
+    }
+
+    createForeignKeyColumn(name, key)
+    {
+        return this.createColumn({
+            name,
+            key,
+            referencedTable: 'test_products',
+            referencedColumn: 'id',
+            referencedDeleteRule: 'CASCADE'
+        });
+    }
+
+    createTables()
+    {
+        return {
+            test_products: {
+                name: 'test_products',
+                columns: {
+                    id: this.createColumn({name: 'id', key: 'PRI', extra: 'auto_increment'}),
+                    name: this.createColumn({name: 'name', type: 'varchar', columnType: 'varchar(200)', length: '200'})
+                }
+            },
+            test_product_details: {
+                name: 'test_product_details',
+                columns: {
+                    id: this.createColumn({name: 'id', key: 'PRI', extra: 'auto_increment'}),
+                    product_id: this.createForeignKeyColumn('product_id', 'UNI')
+                }
+            },
+            test_reviews: {
+                name: 'test_reviews',
+                columns: {
+                    id: this.createColumn({name: 'id', key: 'PRI', extra: 'auto_increment'}),
+                    product_id: this.createForeignKeyColumn('product_id', 'MUL')
+                }
+            }
+        };
+    }
+
+    createGeneration()
+    {
+        let generation = new ModelsGeneration({});
+        generation.setAllTablesData(this.createTables());
+        return generation;
+    }
+
+    mikroOrmDefinition(generation, tableName)
+    {
+        let tableData = generation.allTablesData[tableName];
+        return generation.getEntityPropertiesDefinition(tableData.columns, 'mikro-orm', tableName, tableData);
+    }
+
+    async run()
+    {
+        this.runner.suite('ModelsGeneration');
+        await this.testDetermineMikroOrmForwardKind();
+        await this.testMikroOrmOneToOneDefinitions();
+        await this.testObjectionJsRelationTypes();
+        return this.runner.getResults();
+    }
+
+    async testDetermineMikroOrmForwardKind()
+    {
+        this.runner.group('determineMikroOrmForwardKind');
+        let generation = this.createGeneration();
+        await this.runner.test('should return 1:1 for a unique foreign key column', async () => {
+            let kind = generation.determineMikroOrmForwardKind(this.createColumn({key: 'UNI'}));
+            assert.strictEqual(kind, '1:1');
+        });
+        await this.runner.test('should return 1:1 for a primary foreign key column', async () => {
+            let kind = generation.determineMikroOrmForwardKind(this.createColumn({key: 'PRI'}));
+            assert.strictEqual(kind, '1:1');
+        });
+        await this.runner.test('should return m:1 for an indexed foreign key column', async () => {
+            let kind = generation.determineMikroOrmForwardKind(this.createColumn({key: 'MUL'}));
+            assert.strictEqual(kind, 'm:1');
+        });
+        await this.runner.test('should return m:1 for a non indexed foreign key column', async () => {
+            let kind = generation.determineMikroOrmForwardKind(this.createColumn({key: ''}));
+            assert.strictEqual(kind, 'm:1');
+        });
+    }
+
+    async testMikroOrmOneToOneDefinitions()
+    {
+        this.runner.group('getEntityPropertiesDefinition - mikro-orm one to one');
+        let generation = this.createGeneration();
+        await this.runner.test('should emit a 1:1 owning side with joinColumns for a unique foreign key', async () => {
+            let definition = this.mikroOrmDefinition(generation, 'test_product_details');
+            assert.ok(definition.includes('related_test_products: {\n            kind: \'1:1\','));
+            assert.ok(definition.includes('joinColumns: [\'product_id\']'));
+            assert.ok(!definition.includes('mappedBy'));
+        });
+        await this.runner.test('should emit a 1:1 inverse side with mappedBy for a unique foreign key', async () => {
+            let definition = this.mikroOrmDefinition(generation, 'test_products');
+            assert.ok(definition.includes('related_test_product_details: {\n            kind: \'1:1\','));
+            assert.ok(definition.includes('mappedBy: \'related_test_products\''));
+        });
+        await this.runner.test('should emit a 1:m inverse side for a non unique foreign key', async () => {
+            let definition = this.mikroOrmDefinition(generation, 'test_products');
+            assert.ok(definition.includes('related_test_reviews: {\n            kind: \'1:m\','));
+        });
+        await this.runner.test('should emit a m:1 owning side for a non unique foreign key', async () => {
+            let definition = this.mikroOrmDefinition(generation, 'test_reviews');
+            assert.ok(definition.includes('related_test_products: {\n            kind: \'m:1\','));
+            assert.ok(definition.includes('joinColumns: [\'product_id\']'));
+        });
+    }
+
+    async testObjectionJsRelationTypes()
+    {
+        this.runner.group('ObjectionJS relation types for unique foreign keys');
+        let generation = this.createGeneration();
+        let tables = generation.allTablesData;
+        await this.runner.test('should keep BelongsToOneRelation on the owning side', async () => {
+            let relations = generation.detectObjectionJsRelations('test_product_details', tables.test_product_details);
+            assert.strictEqual(relations.related_test_products.relationType, 'BelongsToOneRelation');
+        });
+        await this.runner.test('should use HasOneRelation on the referenced side of a unique foreign key', async () => {
+            let reverseRelations = generation.detectReverseObjectionJsRelations('test_products');
+            assert.strictEqual(reverseRelations.related_test_product_details.relationType, 'HasOneRelation');
+        });
+        await this.runner.test('should use HasManyRelation on the referenced side of a non unique foreign key', async () => {
+            let reverseRelations = generation.detectReverseObjectionJsRelations('test_products');
+            assert.strictEqual(reverseRelations.related_test_reviews.relationType, 'HasManyRelation');
+        });
+    }
+
+}
+
+module.exports = ModelsGenerationTest;

package/tests/utils/driver-registry.js

@@ -22,7 +22,7 @@ class DriverRegistry
             instanceId: Math.random()
         };
         this.schemaPath = FileHandler.joinPaths(__dirname, '..', 'fixtures', 'sql', 'test-schema.sql');
-        this.repoNames = ['testCategories', 'testProducts', 'testReviews'];
+        this.repoNames = ['testCategories', 'testProductDetails', 'testProducts', 'testReviews'];
         this.driverNames = TestHelpers.activeDriverNames();
         this.skipGeneration = false;
     }

package/tests/utils/test-helpers.js

@@ -156,6 +156,7 @@ class TestHelpers
         try {
             await dataServer.rawQuery('SET FOREIGN_KEY_CHECKS=0;');
             await dataServer.rawQuery('DELETE FROM test_reviews;');
+            await dataServer.rawQuery('DELETE FROM test_product_details;');
             await dataServer.rawQuery('DELETE FROM test_products;');
             await dataServer.rawQuery('DELETE FROM test_categories;');
             await dataServer.rawQuery('SET FOREIGN_KEY_CHECKS=1;');
@@ -210,6 +211,7 @@ class TestHelpers
         try {
             await dataServer.rawQuery('SET FOREIGN_KEY_CHECKS=0;');
             await dataServer.rawQuery('DROP TABLE IF EXISTS test_reviews;');
+            await dataServer.rawQuery('DROP TABLE IF EXISTS test_product_details;');
             await dataServer.rawQuery('DROP TABLE IF EXISTS test_products;');
             await dataServer.rawQuery('DROP TABLE IF EXISTS test_categories;');
             await dataServer.rawQuery('SET FOREIGN_KEY_CHECKS=1;');
@@ -719,9 +721,7 @@ class TestHelpers
             for(let filename of expectedFiles){
                 let expectedContent = FileHandler.readFile(FileHandler.joinPaths(expectedPath, filename));
                 let generatedContent = FileHandler.readFile(FileHandler.joinPaths(generatedPath, filename));
-                let normalizedExpected = expectedContent.replace(/\r\n/g, '\n');
-                let normalizedGenerated = generatedContent.replace(/\r\n/g, '\n');
-                if(normalizedExpected !== normalizedGenerated){
+                if(this.normalizeGeneratedContent(expectedContent) !== this.normalizeGeneratedContent(generatedContent)){
                     Logger.warning('File content mismatch: '+filename);
                     Logger.warning('Expected: '+FileHandler.joinPaths(expectedPath, filename));
                     Logger.warning('Generated: '+FileHandler.joinPaths(generatedPath, filename));
@@ -735,9 +735,7 @@ class TestHelpers
         if(!isExpectedDir && !isGeneratedDir){
             let expectedContent = FileHandler.readFile(expectedPath);
             let generatedContent = FileHandler.readFile(generatedPath);
-            let normalizedExpected = expectedContent.replace(/\r\n/g, '\n');
-            let normalizedGenerated = generatedContent.replace(/\r\n/g, '\n');
-            if(normalizedExpected !== normalizedGenerated){
+            if(this.normalizeGeneratedContent(expectedContent) !== this.normalizeGeneratedContent(generatedContent)){
                 Logger.warning('File content mismatch: '+relativePath);
             }
             Logger.info('File '+relativePath+' matches expected output');
@@ -746,6 +744,11 @@ class TestHelpers
         throw new Error('Path type mismatch for: '+relativePath);
     }
 
+    static normalizeGeneratedContent(content)
+    {
+        return content.replace(/\r\n/g, '\n').replace(/[ \t]+\n/g, '\n');
+    }
+
     static async loadGeneratedEntities(dataServer, driverName)
     {
         let modelsPath = FileHandler.joinPaths(