@reldens/storage 0.110.0 → 0.112.0

package/CLAUDE.md

@@ -284,6 +284,26 @@ All generated entity relations follow the `related_*` prefix pattern:
 
 This pattern is consistent across all ORM drivers and is defined in `entities-config.js`.
 
+## Reference Properties Delete Rule
+
+Every generated `type: 'reference'` property also carries the foreign key referential action as
+`onDelete: '<rule>'`, so consumers can tell what a parent delete does to the child rows without querying the
+schema themselves.
+
+- `MysqlTablesProvider` joins `information_schema.REFERENTIAL_CONSTRAINTS` on the FK constraint name and stores
+  the raw `DELETE_RULE` as `column.referencedDeleteRule`.
+- `BaseGenerator.mapDeleteRule()` normalizes it to camel case, matching the Prisma vocabulary: `CASCADE` becomes
+  `cascade`, `SET NULL` becomes `setNull`, `NO ACTION` becomes `noAction`, `SET DEFAULT` becomes `setDefault`,
+  `RESTRICT` stays `restrict`.
+- `BaseGenerator.addReferenceDeleteRule()` pushes the attribute, called from
+  `EntitiesGeneration.addTypeAttribute()` right after the `alias`. Only the entities are affected, the ORM model
+  generation does not emit it.
+- The property is omitted when there is no rule to report, so an entity generated before this existed simply has
+  no `onDelete` and consumers must treat a missing value as unknown rather than assuming a default.
+
+Regenerating entities is required after changing a foreign key referential action: the rule is read live from
+`information_schema`, not from `prisma/schema.prisma`, and `prisma db pull` alone does not update it.
+
 ## Prisma Driver Validation System
 
 ### ensureRequiredFields() Method

package/lib/generators/base-generator.js

@@ -16,6 +16,28 @@ class BaseGenerator
         return result;
     }
 
+    addReferenceDeleteRule(props, column)
+    {
+        let deleteRule = this.mapDeleteRule(column.referencedDeleteRule);
+        if(!deleteRule){
+            return;
+        }
+        props.push('onDelete: \''+deleteRule+'\'');
+    }
+
+    mapDeleteRule(deleteRule)
+    {
+        if(!deleteRule){
+            return '';
+        }
+        let ruleParts = String(deleteRule).toLowerCase().split(' ');
+        let mappedRule = ruleParts.shift();
+        for(let rulePart of ruleParts){
+            mappedRule += rulePart.charAt(0).toUpperCase()+rulePart.slice(1);
+        }
+        return mappedRule;
+    }
+
 }
 
 module.exports.BaseGenerator = BaseGenerator;

package/lib/generators/entities-generation.js

@@ -228,6 +228,7 @@ class EntitiesGeneration extends BaseGenerator
             props.push('reference: \''+referenceTable+'\'');
             let alias = this.generateForwardRelationKey(referenceTable, columnName, referenceCounts);
             props.push('alias: \''+alias+'\'');
+            this.addReferenceDeleteRule(props, column);
             return;
         }
         if('date' === type || 'datetime' === type || 'timestamp' === type){

package/lib/mysql-tables-provider.js

@@ -53,16 +53,19 @@ class MySQLTablesProvider
                 };
             }
             let foreignKeysQuery = 'SELECT ' +
-                '    TABLE_NAME, ' +
-                '    COLUMN_NAME, ' +
-                '    REFERENCED_TABLE_NAME, ' +
-                '    REFERENCED_COLUMN_NAME ' +
+                '    keyColumnUsage.TABLE_NAME, ' +
+                '    keyColumnUsage.COLUMN_NAME, ' +
+                '    keyColumnUsage.REFERENCED_TABLE_NAME, ' +
+                '    keyColumnUsage.REFERENCED_COLUMN_NAME, ' +
+                '    referentialConstraints.DELETE_RULE ' +
                 'FROM ' +
-                '    information_schema.KEY_COLUMN_USAGE ' +
+                '    information_schema.KEY_COLUMN_USAGE keyColumnUsage ' +
+                '    LEFT JOIN information_schema.REFERENTIAL_CONSTRAINTS referentialConstraints ' +
+                '        ON referentialConstraints.CONSTRAINT_SCHEMA = keyColumnUsage.CONSTRAINT_SCHEMA ' +
+                '        AND referentialConstraints.CONSTRAINT_NAME = keyColumnUsage.CONSTRAINT_NAME ' +
                 'WHERE ' +
-                '    TABLE_SCHEMA = \'' + server.config.database + '\' ' +
-                '    AND REFERENCED_TABLE_NAME IS NOT NULL;';
-
+                '    keyColumnUsage.TABLE_SCHEMA = \'' + server.config.database + '\' ' +
+                '    AND keyColumnUsage.REFERENCED_TABLE_NAME IS NOT NULL;';
             let foreignKeysResult = await server.rawQuery(foreignKeysQuery);
             if(!sc.isArray(foreignKeysResult) || 0 === foreignKeysResult.length){
                 return tables;
@@ -71,6 +74,7 @@ class MySQLTablesProvider
                 if(tables[row.TABLE_NAME] && tables[row.TABLE_NAME].columns[row.COLUMN_NAME]){
                     tables[row.TABLE_NAME].columns[row.COLUMN_NAME].referencedTable = row.REFERENCED_TABLE_NAME;
                     tables[row.TABLE_NAME].columns[row.COLUMN_NAME].referencedColumn = row.REFERENCED_COLUMN_NAME;
+                    tables[row.TABLE_NAME].columns[row.COLUMN_NAME].referencedDeleteRule = row.DELETE_RULE;
                 }
             }
             return tables;

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "@reldens/storage",
     "scope": "@reldens",
-    "version": "0.110.0",
+    "version": "0.112.0",
     "description": "Reldens - Storage",
     "author": "Damian A. Pastorini",
     "license": "MIT",

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

@@ -24,6 +24,7 @@ class TestProductsEntity extends EntityProperties
                 type: 'reference',
                 reference: 'test_categories',
                 alias: 'related_test_categories',
+                onDelete: 'cascade',
                 isRequired: true,
                 dbType: 'int'
             },

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

@@ -24,6 +24,7 @@ class TestReviewsEntity extends EntityProperties
                 type: 'reference',
                 reference: 'test_products',
                 alias: 'related_test_products',
+                onDelete: 'cascade',
                 isRequired: true,
                 dbType: 'int'
             },

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

@@ -38,9 +38,43 @@ class EntitiesGenerationTest
         await this.testAddUniqueAttribute();
         await this.testGetPropertyAttributesUnique();
         await this.testGeneratePropertiesConfigUnique();
+        await this.testAddReferenceDeleteRule();
         return this.runner.getResults();
     }
 
+    async testAddReferenceDeleteRule()
+    {
+        this.runner.group('addReferenceDeleteRule');
+        let generation = new EntitiesGeneration({});
+        await this.runner.test('should map a CASCADE rule', async () => {
+            let props = [];
+            generation.addReferenceDeleteRule(props, this.createColumn({referencedDeleteRule: 'CASCADE'}));
+            assert.deepStrictEqual(props, ['onDelete: \'cascade\'']);
+        });
+        await this.runner.test('should map a multi word rule to camel case', async () => {
+            let props = [];
+            generation.addReferenceDeleteRule(props, this.createColumn({referencedDeleteRule: 'SET NULL'}));
+            assert.deepStrictEqual(props, ['onDelete: \'setNull\'']);
+            let noActionProps = [];
+            generation.addReferenceDeleteRule(noActionProps, this.createColumn({referencedDeleteRule: 'NO ACTION'}));
+            assert.deepStrictEqual(noActionProps, ['onDelete: \'noAction\'']);
+        });
+        await this.runner.test('should push nothing when the column has no delete rule', async () => {
+            let props = [];
+            generation.addReferenceDeleteRule(props, this.createColumn({}));
+            assert.deepStrictEqual(props, []);
+        });
+        await this.runner.test('should include the delete rule on a reference property', async () => {
+            let column = this.createColumn({
+                type: 'int',
+                referencedTable: 'test_categories',
+                referencedDeleteRule: 'SET NULL'
+            });
+            let props = generation.getPropertyAttributes(column, 'category_id', {test_categories: 1});
+            assert.ok(-1 !== props.indexOf('onDelete: \'setNull\''));
+        });
+    }
+
     async testAddUniqueAttribute()
     {
         this.runner.group('addUniqueAttribute');