@reldens/storage 0.105.0 → 0.106.0

package/lib/generators/entities-generation.js

@@ -215,6 +215,7 @@ class EntitiesGeneration extends BaseGenerator
         let type = column.type.toLowerCase();
         this.addTypeAttribute(props, column, type, columnName, referenceCounts);
         this.addRequiredAttribute(props, column);
+        this.addUniqueAttribute(props, column);
         props.push('dbType: \''+type+'\'');
         return props;
     }
@@ -295,6 +296,13 @@ class EntitiesGeneration extends BaseGenerator
         }
     }
 
+    addUniqueAttribute(props, column)
+    {
+        if('UNI' === column.key){
+            props.push('isUnique: true');
+        }
+    }
+
     getReferenceTable(column)
     {
         if(column.referencedTable){

package/lib/prisma/prisma-metadata-loader.js

@@ -39,6 +39,7 @@ class PrismaMetadataLoader
         let metadata = {
             requiredFields: [],
             optionalFields: [],
+            uniqueFields: [],
             fieldTypes: {},
             fieldDefaults: {},
             idFieldType: 'String',
@@ -81,6 +82,9 @@ class PrismaMetadataLoader
         if(field.isOptional || field.hasDefaultValue){
             metadata.optionalFields.push(field.name);
         }
+        if(field.isUnique){
+            metadata.uniqueFields.push(field.name);
+        }
         if(field.kind === 'scalar' && field.isList === false){
             let isNumericType = this.isNumericFieldType(field.type);
             let isReferenceField = field.relationFromFields && 0 < field.relationFromFields.length;

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "@reldens/storage",
     "scope": "@reldens",
-    "version": "0.105.0",
+    "version": "0.106.0",
     "description": "Reldens - Storage",
     "author": "Damian A. Pastorini",
     "license": "MIT",
@@ -51,16 +51,16 @@
         "test:driver": "node tests/run-tests.js --driver="
     },
     "dependencies": {
-        "@mikro-orm/core": "7.1.5",
-        "@mikro-orm/mongodb": "7.1.5",
-        "@mikro-orm/mysql": "7.1.5",
+        "@mikro-orm/core": "7.1.6",
+        "@mikro-orm/mongodb": "7.1.6",
+        "@mikro-orm/mysql": "7.1.6",
         "@prisma/adapter-mariadb": "7.8.0",
         "@prisma/client": "7.8.0",
         "@reldens/server-utils": "^0.53.0",
         "@reldens/utils": "^0.57.0",
         "knex": "3.3.0",
         "mysql": "2.18.1",
-        "mysql2": "3.22.6",
+        "mysql2": "3.23.0",
         "objection": "3.1.5",
         "prisma": "7.8.0"
     }

package/tests/fixtures/expected-entities/entities/test-categories-entity.js

@@ -26,6 +26,7 @@ class TestCategoriesEntity extends EntityProperties
             },
             slug: {
                 isRequired: true,
+                isUnique: true,
                 dbType: 'varchar'
             },
             description: {

package/tests/fixtures/expected-entities/entities/test-products-entity.js

@@ -33,6 +33,7 @@ class TestProductsEntity extends EntityProperties
             },
             sku: {
                 isRequired: true,
+                isUnique: true,
                 dbType: 'varchar'
             },
             description: {

package/tests/run-tests.js

@@ -15,6 +15,7 @@ const RawQueriesTest = require('./integration/test-raw-queries');
 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');
 
 if(!process.env.RELDENS_TEST_DB_HOST){
     let envPath = FileHandler.joinPaths(__dirname, '.env.test');
@@ -187,6 +188,11 @@ class RunTests
         this.allCounts.total += driversUnitResult.total;
         this.allCounts.passed += driversUnitResult.passed;
         this.allCounts.failed += driversUnitResult.failed;
+        let entitiesGenerationTest = new EntitiesGenerationTest();
+        let entitiesGenerationResult = await entitiesGenerationTest.run();
+        this.allCounts.total += entitiesGenerationResult.total;
+        this.allCounts.passed += entitiesGenerationResult.passed;
+        this.allCounts.failed += entitiesGenerationResult.failed;
     }
 
     async runPreFlightChecks(config)

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

@@ -0,0 +1,152 @@
+/**
+ *
+ * Reldens - EntitiesGeneration Test
+ *
+ */
+
+const { TestRunner, assert } = require('../utils/test-runner');
+const { EntitiesGeneration } = require('../../lib/generators/entities-generation');
+
+class EntitiesGenerationTest
+{
+
+    constructor()
+    {
+        this.runner = new TestRunner();
+    }
+
+    createColumn(props)
+    {
+        return Object.assign(
+            {
+                name: 'test_column',
+                type: 'varchar',
+                columnType: 'varchar(100)',
+                length: '100',
+                nullable: true,
+                key: '',
+                extra: '',
+                default: null
+            },
+            props
+        );
+    }
+
+    async run()
+    {
+        this.runner.suite('EntitiesGeneration');
+        await this.testAddUniqueAttribute();
+        await this.testGetPropertyAttributesUnique();
+        await this.testGeneratePropertiesConfigUnique();
+        return this.runner.getResults();
+    }
+
+    async testAddUniqueAttribute()
+    {
+        this.runner.group('addUniqueAttribute');
+        let generation = new EntitiesGeneration({});
+        await this.runner.test('should push isUnique for a UNI column', async () => {
+            let props = [];
+            generation.addUniqueAttribute(props, this.createColumn({key: 'UNI'}));
+            assert.deepStrictEqual(props, ['isUnique: true']);
+        });
+        await this.runner.test('should not push isUnique for a non indexed column', async () => {
+            let props = [];
+            generation.addUniqueAttribute(props, this.createColumn({key: ''}));
+            assert.deepStrictEqual(props, []);
+        });
+        await this.runner.test('should not push isUnique for a MUL column', async () => {
+            let props = [];
+            generation.addUniqueAttribute(props, this.createColumn({key: 'MUL'}));
+            assert.deepStrictEqual(props, []);
+        });
+        await this.runner.test('should not push isUnique for a PRI column', async () => {
+            let props = [];
+            generation.addUniqueAttribute(props, this.createColumn({key: 'PRI'}));
+            assert.deepStrictEqual(props, []);
+        });
+    }
+
+    async testGetPropertyAttributesUnique()
+    {
+        this.runner.group('getPropertyAttributes - isUnique');
+        let generation = new EntitiesGeneration({});
+        await this.runner.test('should include isUnique for a UNI column', async () => {
+            let column = this.createColumn({name: 'slug', key: 'UNI'});
+            let props = generation.getPropertyAttributes(column, 'slug', {});
+            assert.ok(props.includes('isUnique: true'));
+        });
+        await this.runner.test('should not include isUnique for a non unique column', async () => {
+            let column = this.createColumn({name: 'tags', key: ''});
+            let props = generation.getPropertyAttributes(column, 'tags', {});
+            assert.deepStrictEqual(props, ['dbType: \'varchar\'']);
+        });
+        await this.runner.test('should include both isRequired and isUnique for a required unique column', async () => {
+            let column = this.createColumn({name: 'sku', key: 'UNI', nullable: false});
+            let props = generation.getPropertyAttributes(column, 'sku', {});
+            assert.deepStrictEqual(props, ['isRequired: true', 'isUnique: true', 'dbType: \'varchar\'']);
+        });
+        await this.runner.test('should include isUnique only for a nullable unique column', async () => {
+            let column = this.createColumn({name: 'sku', key: 'UNI', nullable: true});
+            let props = generation.getPropertyAttributes(column, 'sku', {});
+            assert.deepStrictEqual(props, ['isUnique: true', 'dbType: \'varchar\'']);
+        });
+        await this.runner.test('should not include isUnique for a composite unique member column', async () => {
+            let column = this.createColumn({name: 'owner_id', type: 'int', key: 'MUL', nullable: false});
+            let props = generation.getPropertyAttributes(column, 'owner_id', {});
+            assert.deepStrictEqual(props, ['type: \'number\'', 'isRequired: true', 'dbType: \'int\'']);
+        });
+        await this.runner.test('should not include isUnique for the primary key column', async () => {
+            let column = this.createColumn({name: 'id', type: 'int', key: 'PRI', nullable: false, extra: 'auto_increment'});
+            let props = generation.getPropertyAttributes(column, 'id', {});
+            assert.deepStrictEqual(props, ['type: \'number\'', 'isRequired: true', 'dbType: \'int\'']);
+        });
+        await this.runner.test('should include isUnique for a unique reference column', async () => {
+            let column = this.createColumn({
+                name: 'profile_id',
+                type: 'int',
+                key: 'UNI',
+                nullable: false,
+                referencedTable: 'profiles',
+                referencedColumn: 'id'
+            });
+            let props = generation.getPropertyAttributes(column, 'profile_id', {profiles: 1});
+            assert.deepStrictEqual(props, [
+                'type: \'reference\'',
+                'reference: \'profiles\'',
+                'alias: \'related_profiles\'',
+                'isRequired: true',
+                'isUnique: true',
+                'dbType: \'int\''
+            ]);
+        });
+    }
+
+    async testGeneratePropertiesConfigUnique()
+    {
+        this.runner.group('generatePropertiesConfig - isUnique');
+        let generation = new EntitiesGeneration({});
+        await this.runner.test('should render isUnique in the generated properties config', async () => {
+            let columns = {
+                id: this.createColumn({name: 'id', type: 'int', key: 'PRI', nullable: false}),
+                slug: this.createColumn({name: 'slug', key: 'UNI', nullable: false}),
+                tags: this.createColumn({name: 'tags', key: ''})
+            };
+            let propertiesConfig = generation.generatePropertiesConfig(columns, false, 'id');
+            assert.ok(propertiesConfig.includes('slug: {'));
+            assert.ok(propertiesConfig.includes('isUnique: true'));
+            assert.strictEqual(propertiesConfig.split('isUnique: true').length - 1, 1);
+        });
+        await this.runner.test('should not render isUnique when no unique columns exist', async () => {
+            let columns = {
+                id: this.createColumn({name: 'id', type: 'int', key: 'PRI', nullable: false}),
+                tags: this.createColumn({name: 'tags', key: ''})
+            };
+            let propertiesConfig = generation.generatePropertiesConfig(columns, false, 'id');
+            assert.ok(!propertiesConfig.includes('isUnique'));
+        });
+    }
+
+}
+
+module.exports = EntitiesGenerationTest;