sqlew 3.9.0 → 4.0.0

package/dist/tests/docker/native/constraint-operations.test.js

@@ -8,7 +8,7 @@
  *
  * Key Tests:
  * - Basic constraint insertion with required fields
- * - Foreign key constraint enforcement (category_id, layer_id, agent_id)
+ * - Foreign key constraint enforcement (category_id, layer_id)
  * - UNIQUE constraint on (constraint_text, project_id)
  * - Priority levels (1-4)
  * - active flag (0/1)
@@ -29,7 +29,6 @@ function hashConstraintText(text) {
 }
 runTestsOnAllDatabases('Constraint Operations', (getDb, dbType) => {
     let projectId;
-    let systemAgentId;
     let businessLayerId;
     let dataLayerId;
     let presentationLayerId;
@@ -52,118 +51,114 @@ runTestsOnAllDatabases('Constraint Operations', (getDb, dbType) => {
     it('should get project ID and master data', async () => {
         const db = getDb();
         // Get project ID
-        const project = await db('m_projects').where({ id: 1 }).first();
+        const project = await db('v4_projects').where({ id: 1 }).first();
         assert.ok(project, 'Project should exist');
         projectId = project.id;
-        // Get system agent
-        const systemAgent = await db('m_agents').where({ name: 'system' }).first();
-        assert.ok(systemAgent, 'System agent should exist');
-        systemAgentId = systemAgent.id;
         // Get layer IDs
-        const businessLayer = await db('m_layers').where({ name: 'business' }).first();
+        const businessLayer = await db('v4_layers').where({ name: 'business' }).first();
         assert.ok(businessLayer, 'Business layer should exist');
         businessLayerId = businessLayer.id;
-        const dataLayer = await db('m_layers').where({ name: 'data' }).first();
+        const dataLayer = await db('v4_layers').where({ name: 'data' }).first();
         assert.ok(dataLayer, 'Data layer should exist');
         dataLayerId = dataLayer.id;
-        const presentationLayer = await db('m_layers').where({ name: 'presentation' }).first();
+        const presentationLayer = await db('v4_layers').where({ name: 'presentation' }).first();
         assert.ok(presentationLayer, 'Presentation layer should exist');
         presentationLayerId = presentationLayer.id;
-        const crossCuttingLayer = await db('m_layers').where({ name: 'cross-cutting' }).first();
+        const crossCuttingLayer = await db('v4_layers').where({ name: 'cross-cutting' }).first();
         assert.ok(crossCuttingLayer, 'Cross-cutting layer should exist');
         crossCuttingLayerId = crossCuttingLayer.id;
         // Get or create constraint categories
-        const architectureCategory = await db('m_constraint_categories')
+        const architectureCategory = await db('v4_constraint_categories')
             .where({ name: 'architecture' })
             .first();
         if (!architectureCategory) {
-            const [id] = await db('m_constraint_categories').insert({ name: 'architecture' });
+            const [id] = await db('v4_constraint_categories').insert({ name: 'architecture' });
             categoryArchitectureId = id;
         }
         else {
             categoryArchitectureId = architectureCategory.id;
         }
-        const securityCategory = await db('m_constraint_categories')
+        const securityCategory = await db('v4_constraint_categories')
             .where({ name: 'security' })
             .first();
         if (!securityCategory) {
-            const [id] = await db('m_constraint_categories').insert({ name: 'security' });
+            const [id] = await db('v4_constraint_categories').insert({ name: 'security' });
             categorySecurityId = id;
         }
         else {
             categorySecurityId = securityCategory.id;
         }
-        const testingCategory = await db('m_constraint_categories')
+        const testingCategory = await db('v4_constraint_categories')
             .where({ name: 'testing' })
             .first();
         if (!testingCategory) {
-            const [id] = await db('m_constraint_categories').insert({ name: 'testing' });
+            const [id] = await db('v4_constraint_categories').insert({ name: 'testing' });
             categoryTestingId = id;
         }
         else {
             categoryTestingId = testingCategory.id;
         }
-        const performanceCategory = await db('m_constraint_categories')
+        const performanceCategory = await db('v4_constraint_categories')
             .where({ name: 'performance' })
             .first();
         if (!performanceCategory) {
-            const [id] = await db('m_constraint_categories').insert({ name: 'performance' });
+            const [id] = await db('v4_constraint_categories').insert({ name: 'performance' });
             categoryPerformanceId = id;
         }
         else {
             categoryPerformanceId = performanceCategory.id;
         }
-        const styleCategory = await db('m_constraint_categories')
+        const styleCategory = await db('v4_constraint_categories')
             .where({ name: 'style' })
             .first();
         if (!styleCategory) {
-            const [id] = await db('m_constraint_categories').insert({ name: 'style' });
+            const [id] = await db('v4_constraint_categories').insert({ name: 'style' });
             categoryStyleId = id;
         }
         else {
             categoryStyleId = styleCategory.id;
         }
-        const codeStyleCategory = await db('m_constraint_categories')
+        const codeStyleCategory = await db('v4_constraint_categories')
             .where({ name: 'code-style' })
             .first();
         if (!codeStyleCategory) {
-            const [id] = await db('m_constraint_categories').insert({ name: 'code-style' });
+            const [id] = await db('v4_constraint_categories').insert({ name: 'code-style' });
             categoryCodeStyleId = id;
         }
         else {
             categoryCodeStyleId = codeStyleCategory.id;
         }
-        const obsoleteCategory = await db('m_constraint_categories')
+        const obsoleteCategory = await db('v4_constraint_categories')
             .where({ name: 'obsolete' })
             .first();
         if (!obsoleteCategory) {
-            const [id] = await db('m_constraint_categories').insert({ name: 'obsolete' });
+            const [id] = await db('v4_constraint_categories').insert({ name: 'obsolete' });
             categoryObsoleteId = id;
         }
         else {
             categoryObsoleteId = obsoleteCategory.id;
         }
-        const criticalCategory = await db('m_constraint_categories')
+        const criticalCategory = await db('v4_constraint_categories')
             .where({ name: 'critical' })
             .first();
         if (!criticalCategory) {
-            const [id] = await db('m_constraint_categories').insert({ name: 'critical' });
+            const [id] = await db('v4_constraint_categories').insert({ name: 'critical' });
             categoryTestId = id;
         }
         else {
             categoryTestId = criticalCategory.id;
         }
         // Get tag IDs
-        const testTag = await db('m_tags').where({ name: 'test', project_id: projectId }).first();
+        const testTag = await db('v4_tags').where({ name: 'test', project_id: projectId }).first();
         assert.ok(testTag, 'Test tag should exist');
         tagTestId = testTag.id;
-        const apiTag = await db('m_tags').where({ name: 'api', project_id: projectId }).first();
+        const apiTag = await db('v4_tags').where({ name: 'api', project_id: projectId }).first();
         assert.ok(apiTag, 'API tag should exist');
         tagApiId = apiTag.id;
-        const performanceTag = await db('m_tags').where({ name: 'performance', project_id: projectId }).first();
+        const performanceTag = await db('v4_tags').where({ name: 'performance', project_id: projectId }).first();
         assert.ok(performanceTag, 'Performance tag should exist');
         tagPerformanceId = performanceTag.id;
-        const securityTag = await db('m_tags').where({ name: 'security', project_id: projectId }).first();
+        const securityTag = await db('v4_tags').where({ name: 'security', project_id: projectId }).first();
         assert.ok(securityTag, 'Security tag should exist');
         tagSecurityId = securityTag.id;
     });
@@ -174,7 +169,7 @@ runTestsOnAllDatabases('Constraint Operations', (getDb, dbType) => {
         it('should insert constraint with required fields', async () => {
             const db = getDb();
             const constraintText1 = 'All API endpoints must use async/await';
-            const [constraintId] = await db('t_constraints').insert({
+            const [constraintId] = await db('v4_constraints').insert({
                 constraint_text: constraintText1,
                 constraint_text_hash: hashConstraintText(constraintText1),
                 category_id: categoryCodeStyleId,
@@ -182,12 +177,11 @@ runTestsOnAllDatabases('Constraint Operations', (getDb, dbType) => {
                 layer_id: businessLayerId,
                 project_id: projectId,
                 active: 1,
-                agent_id: systemAgentId,
                 ts: Math.floor(Date.now() / 1000),
             });
             assert.ok(constraintId, 'Should return constraint ID');
             // Verify constraint exists
-            const constraint = await db('t_constraints')
+            const constraint = await db('v4_constraints')
                 .where({ id: constraintId })
                 .first();
             assert.strictEqual(constraint.constraint_text, 'All API endpoints must use async/await');
@@ -197,7 +191,7 @@ runTestsOnAllDatabases('Constraint Operations', (getDb, dbType) => {
         it('should insert constraint with all fields', async () => {
             const db = getDb();
             const constraintTextDb = 'Database queries must use parameterized statements';
-            const [constraintId] = await db('t_constraints').insert({
+            const [constraintId] = await db('v4_constraints').insert({
                 constraint_text: constraintTextDb,
                 constraint_text_hash: hashConstraintText(constraintTextDb),
                 category_id: categorySecurityId,
@@ -205,11 +199,10 @@ runTestsOnAllDatabases('Constraint Operations', (getDb, dbType) => {
                 layer_id: dataLayerId,
                 project_id: projectId,
                 active: 1,
-                agent_id: systemAgentId,
                 ts: Math.floor(Date.now() / 1000),
             });
             // Verify constraint is stored with all fields
-            const constraint = await db('t_constraints')
+            const constraint = await db('v4_constraints')
                 .where({ id: constraintId })
                 .first();
             assert.strictEqual(constraint.constraint_text, 'Database queries must use parameterized statements');
@@ -220,7 +213,7 @@ runTestsOnAllDatabases('Constraint Operations', (getDb, dbType) => {
             const db = getDb();
             // Priority 1 (low)
             const constraintTextLow = 'Low priority rule';
-            const [p1Id] = await db('t_constraints').insert({
+            const [p1Id] = await db('v4_constraints').insert({
                 constraint_text: constraintTextLow,
                 constraint_text_hash: hashConstraintText(constraintTextLow),
                 category_id: categoryStyleId,
@@ -228,12 +221,11 @@ runTestsOnAllDatabases('Constraint Operations', (getDb, dbType) => {
                 layer_id: presentationLayerId,
                 project_id: projectId,
                 active: 1,
-                agent_id: systemAgentId,
                 ts: Math.floor(Date.now() / 1000),
             });
             // Priority 4 (critical)
             const constraintTextCritical = 'Critical security rule';
-            const [p4Id] = await db('t_constraints').insert({
+            const [p4Id] = await db('v4_constraints').insert({
                 constraint_text: constraintTextCritical,
                 constraint_text_hash: hashConstraintText(constraintTextCritical),
                 category_id: categorySecurityId,
@@ -241,15 +233,14 @@ runTestsOnAllDatabases('Constraint Operations', (getDb, dbType) => {
                 layer_id: businessLayerId,
                 project_id: projectId,
                 active: 1,
-                agent_id: systemAgentId,
                 ts: Math.floor(Date.now() / 1000),
             });
             assert.ok(p1Id && p4Id, 'Both constraints should be created');
             // Verify priority values
-            const lowPriority = await db('t_constraints')
+            const lowPriority = await db('v4_constraints')
                 .where({ id: p1Id })
                 .first();
-            const highPriority = await db('t_constraints')
+            const highPriority = await db('v4_constraints')
                 .where({ id: p4Id })
                 .first();
             assert.strictEqual(lowPriority.priority, 1);
@@ -264,7 +255,7 @@ runTestsOnAllDatabases('Constraint Operations', (getDb, dbType) => {
             const db = getDb();
             // Insert constraint
             const constraintTextUnitTests = 'All components must have unit tests';
-            const [constraintId] = await db('t_constraints').insert({
+            const [constraintId] = await db('v4_constraints').insert({
                 constraint_text: constraintTextUnitTests,
                 constraint_text_hash: hashConstraintText(constraintTextUnitTests),
                 category_id: categoryTestingId,
@@ -272,7 +263,6 @@ runTestsOnAllDatabases('Constraint Operations', (getDb, dbType) => {
                 layer_id: crossCuttingLayerId,
                 project_id: projectId,
                 active: 1,
-                agent_id: systemAgentId,
                 ts: Math.floor(Date.now() / 1000),
             });
             // Associate with tags
@@ -297,7 +287,7 @@ runTestsOnAllDatabases('Constraint Operations', (getDb, dbType) => {
             const db = getDb();
             // Add constraints in different layers
             const constraintTextBusiness = 'Business layer rule';
-            await db('t_constraints').insert({
+            await db('v4_constraints').insert({
                 constraint_text: constraintTextBusiness,
                 constraint_text_hash: hashConstraintText(constraintTextBusiness),
                 category_id: categoryArchitectureId,
@@ -305,11 +295,10 @@ runTestsOnAllDatabases('Constraint Operations', (getDb, dbType) => {
                 layer_id: businessLayerId,
                 project_id: projectId,
                 active: 1,
-                agent_id: systemAgentId,
                 ts: Math.floor(Date.now() / 1000),
             });
             const constraintTextData = 'Data layer rule';
-            await db('t_constraints').insert({
+            await db('v4_constraints').insert({
                 constraint_text: constraintTextData,
                 constraint_text_hash: hashConstraintText(constraintTextData),
                 category_id: categoryArchitectureId,
@@ -317,11 +306,10 @@ runTestsOnAllDatabases('Constraint Operations', (getDb, dbType) => {
                 layer_id: dataLayerId,
                 project_id: projectId,
                 active: 1,
-                agent_id: systemAgentId,
                 ts: Math.floor(Date.now() / 1000),
             });
             // Filter by business layer
-            const businessConstraints = await db('t_constraints')
+            const businessConstraints = await db('v4_constraints')
                 .where({ layer_id: businessLayerId, active: 1, project_id: projectId })
                 .select('*');
             const businessConstraint = businessConstraints.find(c => c.constraint_text === 'Business layer rule');
@@ -330,7 +318,7 @@ runTestsOnAllDatabases('Constraint Operations', (getDb, dbType) => {
         it('should filter constraints by category', async () => {
             const db = getDb();
             const constraintTextSecurity = 'Security constraint';
-            await db('t_constraints').insert({
+            await db('v4_constraints').insert({
                 constraint_text: constraintTextSecurity,
                 constraint_text_hash: hashConstraintText(constraintTextSecurity),
                 category_id: categorySecurityId,
@@ -338,11 +326,10 @@ runTestsOnAllDatabases('Constraint Operations', (getDb, dbType) => {
                 layer_id: businessLayerId,
                 project_id: projectId,
                 active: 1,
-                agent_id: systemAgentId,
                 ts: Math.floor(Date.now() / 1000),
             });
             const constraintTextPerformance = 'Performance constraint';
-            await db('t_constraints').insert({
+            await db('v4_constraints').insert({
                 constraint_text: constraintTextPerformance,
                 constraint_text_hash: hashConstraintText(constraintTextPerformance),
                 category_id: categoryPerformanceId,
@@ -350,11 +337,10 @@ runTestsOnAllDatabases('Constraint Operations', (getDb, dbType) => {
                 layer_id: businessLayerId,
                 project_id: projectId,
                 active: 1,
-                agent_id: systemAgentId,
                 ts: Math.floor(Date.now() / 1000),
             });
             // Filter by security category
-            const securityConstraints = await db('t_constraints')
+            const securityConstraints = await db('v4_constraints')
                 .where({ category_id: categorySecurityId, active: 1, project_id: projectId })
                 .select('*');
             const securityConstraint = securityConstraints.find(c => c.constraint_text === 'Security constraint');
@@ -363,7 +349,7 @@ runTestsOnAllDatabases('Constraint Operations', (getDb, dbType) => {
         it('should filter constraints by priority', async () => {
             const db = getDb();
             const constraintTextHighPriority = 'High priority constraint';
-            await db('t_constraints').insert({
+            await db('v4_constraints').insert({
                 constraint_text: constraintTextHighPriority,
                 constraint_text_hash: hashConstraintText(constraintTextHighPriority),
                 category_id: categoryTestId,
@@ -371,11 +357,10 @@ runTestsOnAllDatabases('Constraint Operations', (getDb, dbType) => {
                 layer_id: businessLayerId,
                 project_id: projectId,
                 active: 1,
-                agent_id: systemAgentId,
                 ts: Math.floor(Date.now() / 1000),
             });
             const constraintTextLowPriority = 'Low priority constraint';
-            await db('t_constraints').insert({
+            await db('v4_constraints').insert({
                 constraint_text: constraintTextLowPriority,
                 constraint_text_hash: hashConstraintText(constraintTextLowPriority),
                 category_id: categoryStyleId,
@@ -383,11 +368,10 @@ runTestsOnAllDatabases('Constraint Operations', (getDb, dbType) => {
                 layer_id: presentationLayerId,
                 project_id: projectId,
                 active: 1,
-                agent_id: systemAgentId,
                 ts: Math.floor(Date.now() / 1000),
             });
             // Filter by priority 4
-            const highPriorityConstraints = await db('t_constraints')
+            const highPriorityConstraints = await db('v4_constraints')
                 .where({ priority: 4, active: 1, project_id: projectId })
                 .select('*');
             const highPriorityConstraint = highPriorityConstraints.find(c => c.constraint_text === 'High priority constraint');
@@ -397,7 +381,7 @@ runTestsOnAllDatabases('Constraint Operations', (getDb, dbType) => {
             const db = getDb();
             // Insert constraint
             const constraintTextTagged = 'Tagged constraint 1';
-            const [constraintId] = await db('t_constraints').insert({
+            const [constraintId] = await db('v4_constraints').insert({
                 constraint_text: constraintTextTagged,
                 constraint_text_hash: hashConstraintText(constraintTextTagged),
                 category_id: categoryTestingId,
@@ -405,7 +389,6 @@ runTestsOnAllDatabases('Constraint Operations', (getDb, dbType) => {
                 layer_id: businessLayerId,
                 project_id: projectId,
                 active: 1,
-                agent_id: systemAgentId,
                 ts: Math.floor(Date.now() / 1000),
             });
             // Associate with tags
@@ -414,7 +397,7 @@ runTestsOnAllDatabases('Constraint Operations', (getDb, dbType) => {
                 { constraint_id: constraintId, tag_id: tagTestId },
             ]);
             // Filter by api tag
-            const apiTaggedConstraints = await db('t_constraints')
+            const apiTaggedConstraints = await db('v4_constraints')
                 .join('t_constraint_tags', 't_constraints.id', 't_constraint_tags.constraint_id')
                 .where({
                 't_constraint_tags.tag_id': tagApiId,
@@ -429,7 +412,7 @@ runTestsOnAllDatabases('Constraint Operations', (getDb, dbType) => {
             const db = getDb();
             // Add and immediately deactivate a constraint
             const constraintTextDeactivated = 'Deactivated constraint';
-            const [constraintId] = await db('t_constraints').insert({
+            const [constraintId] = await db('v4_constraints').insert({
                 constraint_text: constraintTextDeactivated,
                 constraint_text_hash: hashConstraintText(constraintTextDeactivated),
                 category_id: categoryObsoleteId,
@@ -437,15 +420,14 @@ runTestsOnAllDatabases('Constraint Operations', (getDb, dbType) => {
                 layer_id: businessLayerId,
                 project_id: projectId,
                 active: 1,
-                agent_id: systemAgentId,
                 ts: Math.floor(Date.now() / 1000),
             });
             // Deactivate
-            await db('t_constraints')
+            await db('v4_constraints')
                 .where({ id: constraintId })
                 .update({ active: 0 });
             // Get only active constraints
-            const activeConstraints = await db('t_constraints')
+            const activeConstraints = await db('v4_constraints')
                 .where({ active: 1, project_id: projectId })
                 .select('*');
             const deactivatedConstraint = activeConstraints.find(c => c.constraint_text === 'Deactivated constraint');
@@ -460,7 +442,7 @@ runTestsOnAllDatabases('Constraint Operations', (getDb, dbType) => {
             const db = getDb();
             // Add constraint
             const constraintTextToDeactivate = 'Constraint to deactivate';
-            const [constraintId] = await db('t_constraints').insert({
+            const [constraintId] = await db('v4_constraints').insert({
                 constraint_text: constraintTextToDeactivate,
                 constraint_text_hash: hashConstraintText(constraintTextToDeactivate),
                 category_id: categoryTestingId,
@@ -468,16 +450,15 @@ runTestsOnAllDatabases('Constraint Operations', (getDb, dbType) => {
                 layer_id: businessLayerId,
                 project_id: projectId,
                 active: 1,
-                agent_id: systemAgentId,
                 ts: Math.floor(Date.now() / 1000),
             });
             // Deactivate
-            const updateCount = await db('t_constraints')
+            const updateCount = await db('v4_constraints')
                 .where({ id: constraintId, project_id: projectId })
                 .update({ active: 0 });
             assert.strictEqual(updateCount, 1, 'Should update 1 row');
             // Verify active flag is set to 0
-            const constraint = await db('t_constraints')
+            const constraint = await db('v4_constraints')
                 .where({ id: constraintId })
                 .first();
             assert.strictEqual(constraint.active, 0, 'active should be 0');
@@ -486,7 +467,7 @@ runTestsOnAllDatabases('Constraint Operations', (getDb, dbType) => {
             const db = getDb();
             // Add and deactivate
             const constraintTextReDeactivate = 'Re-deactivate test';
-            const [constraintId] = await db('t_constraints').insert({
+            const [constraintId] = await db('v4_constraints').insert({
                 constraint_text: constraintTextReDeactivate,
                 constraint_text_hash: hashConstraintText(constraintTextReDeactivate),
                 category_id: categoryTestingId,
@@ -494,14 +475,13 @@ runTestsOnAllDatabases('Constraint Operations', (getDb, dbType) => {
                 layer_id: businessLayerId,
                 project_id: projectId,
                 active: 1,
-                agent_id: systemAgentId,
                 ts: Math.floor(Date.now() / 1000),
             });
-            await db('t_constraints')
+            await db('v4_constraints')
                 .where({ id: constraintId })
                 .update({ active: 0 });
             // Deactivate again
-            const updateCount = await db('t_constraints')
+            const updateCount = await db('v4_constraints')
                 .where({ id: constraintId })
                 .update({ active: 0 });
             // Should succeed (no error thrown)
@@ -515,7 +495,7 @@ runTestsOnAllDatabases('Constraint Operations', (getDb, dbType) => {
         it('should enforce foreign key constraint on category_id', async () => {
             const db = getDb();
             const constraintTextFkCategory = 'Test constraint';
-            const insertPromise = db('t_constraints').insert({
+            const insertPromise = db('v4_constraints').insert({
                 constraint_text: constraintTextFkCategory,
                 constraint_text_hash: hashConstraintText(constraintTextFkCategory),
                 category_id: 99999, // Non-existent category
@@ -523,29 +503,6 @@ runTestsOnAllDatabases('Constraint Operations', (getDb, dbType) => {
                 layer_id: businessLayerId,
                 project_id: projectId,
                 active: 1,
-                agent_id: systemAgentId,
-                ts: Math.floor(Date.now() / 1000),
-            });
-            await assert.rejects(insertPromise, (error) => {
-                const msg = error.message.toLowerCase();
-                return msg.includes('foreign key') ||
-                    msg.includes('constraint') ||
-                    msg.includes('violates') ||
-                    msg.includes('cannot add');
-            }, 'Should throw foreign key constraint error');
-        });
-        it('should enforce foreign key constraint on agent_id', async () => {
-            const db = getDb();
-            const constraintTextFkAgent = 'Test constraint with invalid agent';
-            const insertPromise = db('t_constraints').insert({
-                constraint_text: constraintTextFkAgent,
-                constraint_text_hash: hashConstraintText(constraintTextFkAgent),
-                category_id: categoryTestingId,
-                priority: 2,
-                layer_id: businessLayerId,
-                project_id: projectId,
-                active: 1,
-                agent_id: 99999, // Non-existent agent
                 ts: Math.floor(Date.now() / 1000),
             });
             await assert.rejects(insertPromise, (error) => {
@@ -560,7 +517,7 @@ runTestsOnAllDatabases('Constraint Operations', (getDb, dbType) => {
             const db = getDb();
             const constraintTextValue = `Unique constraint test ${Date.now()}`;
             // Insert first constraint
-            await db('t_constraints').insert({
+            await db('v4_constraints').insert({
                 constraint_text: constraintTextValue,
                 constraint_text_hash: hashConstraintText(constraintTextValue),
                 category_id: categoryTestingId,
@@ -568,11 +525,10 @@ runTestsOnAllDatabases('Constraint Operations', (getDb, dbType) => {
                 layer_id: businessLayerId,
                 project_id: projectId,
                 active: 1,
-                agent_id: systemAgentId,
                 ts: Math.floor(Date.now() / 1000),
             });
             // Try to insert duplicate
-            const duplicatePromise = db('t_constraints').insert({
+            const duplicatePromise = db('v4_constraints').insert({
                 constraint_text: constraintTextValue, // Same constraint_text
                 constraint_text_hash: hashConstraintText(constraintTextValue),
                 category_id: categoryTestingId,
@@ -580,7 +536,6 @@ runTestsOnAllDatabases('Constraint Operations', (getDb, dbType) => {
                 layer_id: businessLayerId,
                 project_id: projectId, // Same project_id
                 active: 1,
-                agent_id: systemAgentId,
                 ts: Math.floor(Date.now() / 1000),
             });
             await assert.rejects(duplicatePromise, (error) => {
@@ -596,7 +551,7 @@ runTestsOnAllDatabases('Constraint Operations', (getDb, dbType) => {
         it('should handle long rule text', async () => {
             const db = getDb();
             const longRule = 'A'.repeat(500) + ' - This is a very long constraint rule';
-            const [constraintId] = await db('t_constraints').insert({
+            const [constraintId] = await db('v4_constraints').insert({
                 constraint_text: longRule,
                 constraint_text_hash: hashConstraintText(longRule),
                 category_id: categoryTestingId,
@@ -604,11 +559,10 @@ runTestsOnAllDatabases('Constraint Operations', (getDb, dbType) => {
                 layer_id: businessLayerId,
                 project_id: projectId,
                 active: 1,
-                agent_id: systemAgentId,
                 ts: Math.floor(Date.now() / 1000),
             });
             assert.ok(constraintId, 'Should handle long rule text');
-            const constraint = await db('t_constraints')
+            const constraint = await db('v4_constraints')
                 .where({ id: constraintId })
                 .first();
             assert.strictEqual(constraint.constraint_text, longRule);
@@ -616,7 +570,7 @@ runTestsOnAllDatabases('Constraint Operations', (getDb, dbType) => {
         it('should handle special characters in rules', async () => {
             const db = getDb();
             const specialRule = "Rule with 'quotes', \"double quotes\", and \\backslashes";
-            const [constraintId] = await db('t_constraints').insert({
+            const [constraintId] = await db('v4_constraints').insert({
                 constraint_text: specialRule,
                 constraint_text_hash: hashConstraintText(specialRule),
                 category_id: categoryTestingId,
@@ -624,11 +578,10 @@ runTestsOnAllDatabases('Constraint Operations', (getDb, dbType) => {
                 layer_id: businessLayerId,
                 project_id: projectId,
                 active: 1,
-                agent_id: systemAgentId,
                 ts: Math.floor(Date.now() / 1000),
             });
             assert.ok(constraintId);
-            const constraint = await db('t_constraints')
+            const constraint = await db('v4_constraints')
                 .where({ id: constraintId })
                 .first();
             assert.strictEqual(constraint.constraint_text, specialRule);
@@ -636,7 +589,7 @@ runTestsOnAllDatabases('Constraint Operations', (getDb, dbType) => {
         it('should handle unicode characters in constraint_text', async () => {
             const db = getDb();
             const unicodeText = '日本語のルール: Unicode support test 🎯';
-            const [constraintId] = await db('t_constraints').insert({
+            const [constraintId] = await db('v4_constraints').insert({
                 constraint_text: unicodeText,
                 constraint_text_hash: hashConstraintText(unicodeText),
                 category_id: categoryTestingId,
@@ -644,11 +597,10 @@ runTestsOnAllDatabases('Constraint Operations', (getDb, dbType) => {
                 layer_id: businessLayerId,
                 project_id: projectId,
                 active: 1,
-                agent_id: systemAgentId,
                 ts: Math.floor(Date.now() / 1000),
             });
             assert.ok(constraintId);
-            const constraint = await db('t_constraints')
+            const constraint = await db('v4_constraints')
                 .where({ id: constraintId })
                 .first();
             assert.strictEqual(constraint.constraint_text, unicodeText);
@@ -668,7 +620,7 @@ runTestsOnAllDatabases('Constraint Operations', (getDb, dbType) => {
             }
             // Insert test constraint
             const constraintTextViewTest = 'View test constraint';
-            const [constraintId] = await db('t_constraints').insert({
+            const [constraintId] = await db('v4_constraints').insert({
                 constraint_text: constraintTextViewTest,
                 constraint_text_hash: hashConstraintText(constraintTextViewTest),
                 category_id: categoryArchitectureId,
@@ -676,7 +628,6 @@ runTestsOnAllDatabases('Constraint Operations', (getDb, dbType) => {
                 layer_id: businessLayerId,
                 project_id: projectId,
                 active: 1,
-                agent_id: systemAgentId,
                 ts: Math.floor(Date.now() / 1000),
             });
             // Query view