sqlew 4.3.0 → 5.0.0

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

@@ -1,800 +0,0 @@
-/**
- * Task Operations - Native RDBMS Integration Tests
- *
- * Tests task table schema and operations (CRUD, dependencies, status transitions,
- * FK constraints, cascade delete) on fresh MySQL, MariaDB, and PostgreSQL installations.
- *
- * Task #532: Refactor task-operations.test.ts to use direct Knex operations
- *
- * ARCHITECTURE: Native RDBMS tests focus on database layer validation.
- * - NO MCP tool function imports
- * - Direct Knex operations only
- * - Tests database constraints, indexes, views, triggers
- * - Cross-database compatibility validation
- */
-import { describe, it } from 'node:test';
-import assert from 'node:assert';
-import { runTestsOnAllDatabases, getLayerId, getTagId } from './test-harness.js';
-// ============================================================================
-// Test Helpers
-// ============================================================================
-/**
- * Get task status ID by status name
- */
-async function getStatusId(db, statusName) {
-    const status = await db('v4_task_statuses').where({ name: statusName }).first();
-    assert.ok(status, `Status "${statusName}" should exist`);
-    return status.id;
-}
-/**
- * Insert a task with required fields (helper for test setup)
- */
-async function insertTask(db, data) {
-    const statusId = await getStatusId(db, data.status || 'todo');
-    const layerId = data.layer ? await getLayerId(db, data.layer) : await getLayerId(db, 'business');
-    const timestamp = Math.floor(Date.now() / 1000);
-    const insertData = {
-        title: data.title,
-        status_id: statusId,
-        priority: data.priority || 2,
-        layer_id: layerId,
-        project_id: 1,
-        created_ts: timestamp,
-        updated_ts: timestamp,
-    };
-    const result = await db('v4_tasks').insert(insertData);
-    // Get the inserted ID (different return format across databases)
-    let taskId;
-    if (Array.isArray(result) && result.length > 0) {
-        taskId = result[0];
-    }
-    else if (typeof result === 'number') {
-        taskId = result;
-    }
-    else {
-        // Fallback: query the last inserted task
-        const task = await db('v4_tasks')
-            .where({ title: data.title, project_id: 1 })
-            .orderBy('id', 'desc')
-            .first();
-        taskId = task.id;
-    }
-    // Insert task details if description provided
-    if (data.description) {
-        await db('v4_task_details').insert({
-            task_id: taskId,
-            description: data.description,
-        });
-    }
-    return taskId;
-}
-/**
- * Assert task has expected status
- */
-async function assertTaskHasStatus(db, taskId, expectedStatus) {
-    const task = await db('v4_tasks')
-        .join('v4_task_statuses', 'v4_tasks.status_id', 'v4_task_statuses.id')
-        .where({ 'v4_tasks.id': taskId })
-        .select('v4_task_statuses.name as status')
-        .first();
-    assert.ok(task, `Task ${taskId} should exist`);
-    assert.strictEqual(task.status, expectedStatus, `Task ${taskId} status should be ${expectedStatus}`);
-}
-// ============================================================================
-// Test Suite
-// ============================================================================
-runTestsOnAllDatabases('Task Operations', (getDb, dbType) => {
-    // ============================================================================
-    // Basic CRUD Operations
-    // ============================================================================
-    describe('Task CRUD', () => {
-        it('should insert task with required fields', async () => {
-            const db = getDb();
-            const taskId = await insertTask(db, {
-                title: 'Implement authentication',
-                priority: 3,
-                layer: 'business',
-            });
-            assert.ok(taskId, 'Should return task ID');
-            // Verify task exists
-            const task = await db('v4_tasks').where({ id: taskId, project_id: 1 }).first();
-            assert.strictEqual(task.title, 'Implement authentication');
-            assert.strictEqual(task.priority, 3);
-            await assertTaskHasStatus(db, taskId, 'todo');
-        });
-        it('should insert task with all optional fields', async () => {
-            const db = getDb();
-            const taskId = await insertTask(db, {
-                title: 'Complex task with all fields',
-                description: 'This is a detailed description',
-                priority: 4,
-                layer: 'infrastructure',
-            });
-            // Verify core task data
-            const task = await db('v4_tasks').where({ id: taskId, project_id: 1 }).first();
-            assert.strictEqual(task.title, 'Complex task with all fields');
-            assert.strictEqual(task.priority, 4);
-            const layerId = await getLayerId(db, 'infrastructure');
-            assert.strictEqual(task.layer_id, layerId);
-            // Verify task details
-            const details = await db('v4_task_details').where({ task_id: taskId }).first();
-            assert.ok(details, 'Task details should exist');
-            assert.strictEqual(details.description, 'This is a detailed description');
-        });
-        it('should update task fields', async () => {
-            const db = getDb();
-            const taskId = await insertTask(db, {
-                title: 'Original title',
-                priority: 2,
-            });
-            // Update title and priority
-            await db('v4_tasks')
-                .where({ id: taskId, project_id: 1 })
-                .update({
-                title: 'Updated title',
-                priority: 4,
-                updated_ts: Math.floor(Date.now() / 1000),
-            });
-            // Verify update
-            const task = await db('v4_tasks').where({ id: taskId, project_id: 1 }).first();
-            assert.strictEqual(task.title, 'Updated title');
-            assert.strictEqual(task.priority, 4);
-        });
-        it('should delete task', async () => {
-            const db = getDb();
-            const taskId = await insertTask(db, {
-                title: 'Task to delete',
-            });
-            // Delete task
-            await db('v4_tasks').where({ id: taskId, project_id: 1 }).delete();
-            // Verify deletion
-            const task = await db('v4_tasks').where({ id: taskId, project_id: 1 }).first();
-            assert.strictEqual(task, undefined, 'Task should be deleted');
-        });
-    });
-    // ============================================================================
-    // Foreign Key Constraints
-    // ============================================================================
-    describe('Foreign Key Constraints', () => {
-        it('should enforce FK constraint on status_id', async () => {
-            const db = getDb();
-            const insertPromise = db('v4_tasks').insert({
-                title: 'Invalid status task',
-                status_id: 99999, // Non-existent status
-                priority: 2,
-                project_id: 1,
-                layer_id: 1,
-                created_ts: Math.floor(Date.now() / 1000),
-                updated_ts: Math.floor(Date.now() / 1000),
-            });
-            await assert.rejects(insertPromise, {
-                message: /foreign key constraint|violates foreign key|Cannot add or update a child row/i,
-            });
-        });
-        it('should enforce FK constraint on layer_id', async () => {
-            const db = getDb();
-            const statusId = await getStatusId(db, 'todo');
-            const insertPromise = db('v4_tasks').insert({
-                title: 'Invalid layer task',
-                status_id: statusId,
-                priority: 2,
-                project_id: 1,
-                layer_id: 99999, // Non-existent layer
-                created_ts: Math.floor(Date.now() / 1000),
-                updated_ts: Math.floor(Date.now() / 1000),
-            });
-            await assert.rejects(insertPromise, {
-                message: /foreign key constraint|violates foreign key|Cannot add or update a child row/i,
-            });
-        });
-    });
-    // ============================================================================
-    // Task Status Transitions
-    // ============================================================================
-    describe('Task Status Transitions', () => {
-        it('should transition from todo to in_progress', async () => {
-            const db = getDb();
-            const taskId = await insertTask(db, { title: 'Move to in_progress' });
-            await assertTaskHasStatus(db, taskId, 'todo');
-            // Move to in_progress
-            const inProgressId = await getStatusId(db, 'in_progress');
-            await db('v4_tasks')
-                .where({ id: taskId })
-                .update({
-                status_id: inProgressId,
-                updated_ts: Math.floor(Date.now() / 1000),
-            });
-            await assertTaskHasStatus(db, taskId, 'in_progress');
-        });
-        it('should transition from in_progress to done', async () => {
-            const db = getDb();
-            const taskId = await insertTask(db, { title: 'Complete task', status: 'in_progress' });
-            await assertTaskHasStatus(db, taskId, 'in_progress');
-            // Move to done
-            const doneId = await getStatusId(db, 'done');
-            const completedTs = Math.floor(Date.now() / 1000);
-            await db('v4_tasks')
-                .where({ id: taskId })
-                .update({
-                status_id: doneId,
-                completed_ts: completedTs,
-                updated_ts: completedTs,
-            });
-            await assertTaskHasStatus(db, taskId, 'done');
-            // Verify completed_ts was set
-            const task = await db('v4_tasks').where({ id: taskId }).first();
-            assert.ok(task.completed_ts, 'completed_ts should be set');
-        });
-        it('should transition to blocked status', async () => {
-            const db = getDb();
-            const taskId = await insertTask(db, { title: 'Blocked task' });
-            const blockedId = await getStatusId(db, 'blocked');
-            await db('v4_tasks')
-                .where({ id: taskId })
-                .update({
-                status_id: blockedId,
-                updated_ts: Math.floor(Date.now() / 1000),
-            });
-            await assertTaskHasStatus(db, taskId, 'blocked');
-        });
-        it('should transition to archived status', async () => {
-            const db = getDb();
-            const taskId = await insertTask(db, { title: 'Archive task' });
-            const archivedId = await getStatusId(db, 'archived');
-            await db('v4_tasks')
-                .where({ id: taskId })
-                .update({
-                status_id: archivedId,
-                updated_ts: Math.floor(Date.now() / 1000),
-            });
-            await assertTaskHasStatus(db, taskId, 'archived');
-        });
-    });
-    // ============================================================================
-    // Task File Links
-    // ============================================================================
-    describe('Task File Links', () => {
-        it('should insert file links for task', async () => {
-            const db = getDb();
-            const taskId = await insertTask(db, { title: 'Task with files' });
-            const timestamp = Math.floor(Date.now() / 1000);
-            // First, create file records in m_files
-            const file1Result = await db('v4_files').insert({ project_id: 1, path: 'src/auth/login.ts' });
-            const file2Result = await db('v4_files').insert({ project_id: 1, path: 'src/auth/types.ts' });
-            const file3Result = await db('v4_files').insert({ project_id: 1, path: 'src/auth/old.ts' });
-            // Get file IDs
-            const file1 = await db('v4_files').where({ path: 'src/auth/login.ts', project_id: 1 }).first();
-            const file2 = await db('v4_files').where({ path: 'src/auth/types.ts', project_id: 1 }).first();
-            const file3 = await db('v4_files').where({ path: 'src/auth/old.ts', project_id: 1 }).first();
-            // Insert file links
-            await db('v4_task_file_links').insert([
-                { task_id: taskId, file_id: file1.id, project_id: 1, linked_ts: timestamp },
-                { task_id: taskId, file_id: file2.id, project_id: 1, linked_ts: timestamp },
-                { task_id: taskId, file_id: file3.id, project_id: 1, linked_ts: timestamp },
-            ]);
-            // Verify file links
-            const fileLinks = await db('v4_task_file_links')
-                .join('v4_files', 'v4_task_file_links.file_id', 'v4_files.id')
-                .where({ 'v4_task_file_links.task_id': taskId })
-                .select('v4_task_file_links.*', 'v4_files.path')
-                .orderBy('v4_files.path');
-            assert.strictEqual(fileLinks.length, 3);
-            assert.strictEqual(fileLinks[0].path, 'src/auth/login.ts');
-            assert.strictEqual(fileLinks[1].path, 'src/auth/old.ts');
-            assert.strictEqual(fileLinks[2].path, 'src/auth/types.ts');
-        });
-        it('should enforce unique constraint on task-file combination', async () => {
-            const db = getDb();
-            const taskId = await insertTask(db, { title: 'Unique file link test' });
-            const timestamp = Math.floor(Date.now() / 1000);
-            // Create a file record
-            await db('v4_files').insert({ project_id: 1, path: 'src/unique-test.ts' });
-            const file = await db('v4_files').where({ path: 'src/unique-test.ts', project_id: 1 }).first();
-            await db('v4_task_file_links').insert({
-                task_id: taskId,
-                file_id: file.id,
-                project_id: 1,
-                linked_ts: timestamp,
-            });
-            // Try to insert duplicate
-            const duplicatePromise = db('v4_task_file_links').insert({
-                task_id: taskId,
-                file_id: file.id,
-                project_id: 1,
-                linked_ts: timestamp,
-            });
-            await assert.rejects(duplicatePromise, {
-                message: /UNIQUE constraint|unique constraint|Duplicate entry/i,
-            });
-        });
-        it('should cascade delete file links when task deleted', async () => {
-            const db = getDb();
-            const taskId = await insertTask(db, { title: 'Cascade delete file links' });
-            const timestamp = Math.floor(Date.now() / 1000);
-            // Create a file record
-            await db('v4_files').insert({ project_id: 1, path: 'src/cascade-test.ts' });
-            const file = await db('v4_files').where({ path: 'src/cascade-test.ts', project_id: 1 }).first();
-            await db('v4_task_file_links').insert({
-                task_id: taskId,
-                file_id: file.id,
-                project_id: 1,
-                linked_ts: timestamp,
-            });
-            // Delete task
-            await db('v4_tasks').where({ id: taskId }).delete();
-            // Verify file links were cascade deleted
-            const fileLinks = await db('v4_task_file_links').where({ task_id: taskId });
-            assert.strictEqual(fileLinks.length, 0, 'File links should be cascade deleted');
-        });
-    });
-    // ============================================================================
-    // Task Tags
-    // ============================================================================
-    describe('Task Tags', () => {
-        it('should associate tags with task', async () => {
-            const db = getDb();
-            const taskId = await insertTask(db, { title: 'Tagged task' });
-            // Get tag IDs
-            const apiTagId = await getTagId(db, 'api');
-            const securityTagId = await getTagId(db, 'security');
-            const perfTagId = await getTagId(db, 'performance');
-            // Insert tag associations (v4_task_tags requires project_id)
-            await db('v4_task_tags').insert([
-                { task_id: taskId, tag_id: apiTagId, project_id: 1 },
-                { task_id: taskId, tag_id: securityTagId, project_id: 1 },
-                { task_id: taskId, tag_id: perfTagId, project_id: 1 },
-            ]);
-            // Verify tags
-            const tags = await db('v4_task_tags as tt')
-                .join('v4_tags as t', 'tt.tag_id', 't.id')
-                .where({ 'tt.task_id': taskId })
-                .select('t.name as tag_name');
-            assert.strictEqual(tags.length, 3);
-            const tagNames = tags.map(t => t.tag_name);
-            assert.ok(tagNames.includes('api'));
-            assert.ok(tagNames.includes('security'));
-            assert.ok(tagNames.includes('performance'));
-        });
-        it('should cascade delete tags when task deleted', async () => {
-            const db = getDb();
-            const taskId = await insertTask(db, { title: 'Task with tags for cascade' });
-            const tagId = await getTagId(db, 'test');
-            await db('v4_task_tags').insert({
-                task_id: taskId,
-                tag_id: tagId,
-                project_id: 1,
-            });
-            // Delete task
-            await db('v4_tasks').where({ id: taskId }).delete();
-            // Verify tags were cascade deleted
-            const tags = await db('v4_task_tags').where({ task_id: taskId });
-            assert.strictEqual(tags.length, 0, 'Tags should be cascade deleted');
-        });
-    });
-    // ============================================================================
-    // Task Dependencies
-    // ============================================================================
-    describe('Task Dependencies', () => {
-        it('should add dependency between tasks', async () => {
-            const db = getDb();
-            const blockerTaskId = await insertTask(db, { title: 'Blocker task' });
-            const blockedTaskId = await insertTask(db, { title: 'Blocked task' });
-            // Add dependency: blocker blocks blocked
-            await db('v4_task_dependencies').insert({
-                blocker_task_id: blockerTaskId,
-                blocked_task_id: blockedTaskId,
-                project_id: 1,
-                created_ts: Math.floor(Date.now() / 1000),
-            });
-            // Verify dependency exists
-            const dependency = await db('v4_task_dependencies')
-                .where({ blocker_task_id: blockerTaskId, blocked_task_id: blockedTaskId })
-                .first();
-            assert.ok(dependency, 'Dependency should exist');
-        });
-        it('should prevent self-dependency (circular dependency)', async () => {
-            const db = getDb();
-            const taskId = await insertTask(db, { title: 'Self-blocking task' });
-            // Try to create self-dependency
-            const selfDepPromise = db('v4_task_dependencies').insert({
-                blocker_task_id: taskId,
-                blocked_task_id: taskId, // Same task
-                project_id: 1,
-                created_ts: Math.floor(Date.now() / 1000),
-            });
-            // Should fail (either via trigger or application-level check)
-            // Note: Some databases may allow this at schema level but fail at trigger level
-            // For now, we just test if it rejects
-            const shouldReject = async () => {
-                try {
-                    await selfDepPromise;
-                    // If insert succeeds, check if there's a trigger that prevents it
-                    // This is database-specific behavior
-                    const dep = await db('v4_task_dependencies')
-                        .where({ blocker_task_id: taskId, blocked_task_id: taskId })
-                        .first();
-                    // If dependency was inserted, we need to check if the application
-                    // layer prevents this. For now, we'll fail the test if it was inserted.
-                    if (dep) {
-                        throw new Error('Self-dependency should not be allowed');
-                    }
-                }
-                catch (error) {
-                    // Expected: trigger or constraint prevents self-dependency
-                    if (!error.message.includes('should not be allowed')) {
-                        // This is expected database error
-                        return;
-                    }
-                    throw error;
-                }
-            };
-            // For databases without trigger, this test will pass
-            // For databases with trigger, this will throw expected error
-            try {
-                await shouldReject();
-            }
-            catch (error) {
-                // Acceptable error messages
-                if (error.message.includes('circular') ||
-                    error.message.includes('self') ||
-                    error.message.includes('should not be allowed')) {
-                    // Expected behavior
-                    return;
-                }
-                throw error;
-            }
-        });
-        it('should detect transitive circular dependency (A→B→A)', async () => {
-            const db = getDb();
-            const taskA = await insertTask(db, { title: 'Task A' });
-            const taskB = await insertTask(db, { title: 'Task B' });
-            // Create A blocks B
-            await db('v4_task_dependencies').insert({
-                blocker_task_id: taskA,
-                blocked_task_id: taskB,
-                project_id: 1,
-                created_ts: Math.floor(Date.now() / 1000),
-            });
-            // Try to create B blocks A (circular)
-            // Note: Detection of transitive circular dependencies requires
-            // application-level logic or recursive triggers.
-            // The schema may allow this at database level.
-            // This test documents expected behavior.
-            const circularPromise = db('v4_task_dependencies').insert({
-                blocker_task_id: taskB,
-                blocked_task_id: taskA,
-                project_id: 1,
-                created_ts: Math.floor(Date.now() / 1000),
-            });
-            // For now, we expect application-level validation to prevent this
-            // If the database allows it, we'll just document it
-            try {
-                await circularPromise;
-                // If it succeeds, verify both dependencies exist
-                const deps = await db('v4_task_dependencies')
-                    .whereIn('blocker_task_id', [taskA, taskB])
-                    .whereIn('blocked_task_id', [taskA, taskB]);
-                // Note: Schema allows this, but application should prevent it
-                // This documents the current behavior
-                if (deps.length === 2) {
-                    console.log(`  ⚠️  [${dbType}] Database allows circular dependencies A→B→A (application must validate)`);
-                }
-            }
-            catch (error) {
-                // If database prevents it, that's good
-                if (error.message.includes('circular') || error.message.includes('cycle')) {
-                    console.log(`  ✅ [${dbType}] Database prevents circular dependencies at schema level`);
-                }
-                else {
-                    throw error;
-                }
-            }
-        });
-        it('should remove dependency', async () => {
-            const db = getDb();
-            const blockerTaskId = await insertTask(db, { title: 'Blocker for removal' });
-            const blockedTaskId = await insertTask(db, { title: 'Blocked for removal' });
-            await db('v4_task_dependencies').insert({
-                blocker_task_id: blockerTaskId,
-                blocked_task_id: blockedTaskId,
-                project_id: 1,
-                created_ts: Math.floor(Date.now() / 1000),
-            });
-            // Remove dependency
-            await db('v4_task_dependencies')
-                .where({ blocker_task_id: blockerTaskId, blocked_task_id: blockedTaskId })
-                .delete();
-            // Verify removal
-            const dependency = await db('v4_task_dependencies')
-                .where({ blocker_task_id: blockerTaskId, blocked_task_id: blockedTaskId })
-                .first();
-            assert.strictEqual(dependency, undefined, 'Dependency should be removed');
-        });
-        it('should cascade delete dependencies when task deleted', async () => {
-            const db = getDb();
-            const blockerTaskId = await insertTask(db, { title: 'Blocker for cascade' });
-            const blockedTaskId = await insertTask(db, { title: 'Blocked for cascade' });
-            await db('v4_task_dependencies').insert({
-                blocker_task_id: blockerTaskId,
-                blocked_task_id: blockedTaskId,
-                project_id: 1,
-                created_ts: Math.floor(Date.now() / 1000),
-            });
-            // Delete blocker task
-            await db('v4_tasks').where({ id: blockerTaskId }).delete();
-            // Verify dependencies were cascade deleted
-            const dependencies = await db('v4_task_dependencies')
-                .where({ blocker_task_id: blockerTaskId })
-                .orWhere({ blocked_task_id: blockerTaskId });
-            assert.strictEqual(dependencies.length, 0, 'Dependencies should be cascade deleted');
-        });
-        it('should get task blocking relationships', async () => {
-            const db = getDb();
-            const blockerTaskId = await insertTask(db, { title: 'Blocker' });
-            const blocked1Id = await insertTask(db, { title: 'Blocked 1' });
-            const blocked2Id = await insertTask(db, { title: 'Blocked 2' });
-            // Blocker blocks both blocked tasks
-            await db('v4_task_dependencies').insert([
-                {
-                    blocker_task_id: blockerTaskId,
-                    blocked_task_id: blocked1Id,
-                    project_id: 1,
-                    created_ts: Math.floor(Date.now() / 1000),
-                },
-                {
-                    blocker_task_id: blockerTaskId,
-                    blocked_task_id: blocked2Id,
-                    project_id: 1,
-                    created_ts: Math.floor(Date.now() / 1000),
-                },
-            ]);
-            // Query what blocker is blocking
-            const blocking = await db('v4_task_dependencies')
-                .where({ blocker_task_id: blockerTaskId })
-                .select('blocked_task_id');
-            assert.strictEqual(blocking.length, 2);
-            const blockedIds = blocking.map(b => b.blocked_task_id);
-            assert.ok(blockedIds.includes(blocked1Id));
-            assert.ok(blockedIds.includes(blocked2Id));
-        });
-        it('should get task blocker relationships', async () => {
-            const db = getDb();
-            const blockedTaskId = await insertTask(db, { title: 'Blocked' });
-            const blocker1Id = await insertTask(db, { title: 'Blocker 1' });
-            const blocker2Id = await insertTask(db, { title: 'Blocker 2' });
-            // Blocked is blocked by both blockers
-            await db('v4_task_dependencies').insert([
-                {
-                    blocker_task_id: blocker1Id,
-                    blocked_task_id: blockedTaskId,
-                    project_id: 1,
-                    created_ts: Math.floor(Date.now() / 1000),
-                },
-                {
-                    blocker_task_id: blocker2Id,
-                    blocked_task_id: blockedTaskId,
-                    project_id: 1,
-                    created_ts: Math.floor(Date.now() / 1000),
-                },
-            ]);
-            // Query what is blocking this task
-            const blockers = await db('v4_task_dependencies')
-                .where({ blocked_task_id: blockedTaskId })
-                .select('blocker_task_id');
-            assert.strictEqual(blockers.length, 2);
-            const blockerIds = blockers.map(b => b.blocker_task_id);
-            assert.ok(blockerIds.includes(blocker1Id));
-            assert.ok(blockerIds.includes(blocker2Id));
-        });
-    });
-    // ============================================================================
-    // Task-Decision Links
-    // ============================================================================
-    describe('Task-Decision Links', () => {
-        it('should link task to decision', async () => {
-            const db = getDb();
-            const taskId = await insertTask(db, { title: 'Task implementing decision' });
-            const timestamp = Math.floor(Date.now() / 1000);
-            // Create a decision
-            const layerId = await getLayerId(db, 'business');
-            // v4_context_keys has no project_id column
-            await db('v4_context_keys').insert({
-                key_name: 'test/link-decision',
-            });
-            const contextKey = await db('v4_context_keys')
-                .where({ key_name: 'test/link-decision' })
-                .first();
-            await db('v4_decisions').insert({
-                key_id: contextKey.id,
-                project_id: 1,
-                value: 'test value',
-                version: '1.0.0',
-                ts: timestamp,
-                layer_id: layerId,
-                status: 1, // 1=active (integer enum, not string)
-            });
-            // Link task to decision (using decision_key_id, not decision_id)
-            await db('v4_task_decision_links').insert({
-                task_id: taskId,
-                decision_key_id: contextKey.id,
-                project_id: 1,
-                link_type: 'implements',
-                linked_ts: timestamp,
-            });
-            // Verify link
-            const link = await db('v4_task_decision_links')
-                .where({ task_id: taskId, decision_key_id: contextKey.id })
-                .first();
-            assert.ok(link, 'Link should exist');
-            assert.strictEqual(link.link_type, 'implements');
-        });
-        it('should cascade delete task-decision links when task deleted', async () => {
-            const db = getDb();
-            const taskId = await insertTask(db, { title: 'Task for cascade link delete' });
-            const timestamp = Math.floor(Date.now() / 1000);
-            // Create decision and link (simplified)
-            const layerId = await getLayerId(db, 'business');
-            // m_context_keys has no project_id column
-            await db('v4_context_keys').insert({ key_name: 'test/cascade-link' });
-            const contextKey = await db('v4_context_keys')
-                .where({ key_name: 'test/cascade-link' })
-                .first();
-            await db('v4_decisions').insert({
-                key_id: contextKey.id,
-                project_id: 1,
-                value: 'test',
-                version: '1.0.0',
-                ts: timestamp,
-                layer_id: layerId,
-                status: 1, // 1=active (integer enum)
-            });
-            await db('v4_task_decision_links').insert({
-                task_id: taskId,
-                decision_key_id: contextKey.id,
-                project_id: 1,
-                link_type: 'implements',
-                linked_ts: timestamp,
-            });
-            // Delete task
-            await db('v4_tasks').where({ id: taskId }).delete();
-            // Verify links were cascade deleted
-            const links = await db('v4_task_decision_links').where({ task_id: taskId });
-            assert.strictEqual(links.length, 0, 'Task-decision links should be cascade deleted');
-        });
-    });
-    // ============================================================================
-    // Task-Constraint Links
-    // ============================================================================
-    describe('Task-Constraint Links', () => {
-        it('should link task to constraint', async () => {
-            const db = getDb();
-            const taskId = await insertTask(db, { title: 'Task with constraint' });
-            // Create a constraint
-            const layerId = await getLayerId(db, 'business');
-            // Get constraint category
-            const category = await db('v4_constraint_categories')
-                .where({ name: 'architecture' })
-                .first();
-            const constraintText = 'Test constraint for linking';
-            await db('v4_constraints').insert({
-                constraint_text: constraintText,
-                // Note: v4 schema does not have constraint_text_hash column
-                category_id: category.id,
-                priority: 2,
-                project_id: 1,
-                layer_id: layerId,
-                ts: Math.floor(Date.now() / 1000),
-                active: 1,
-            });
-            const constraint = await db('v4_constraints')
-                .where({ constraint_text: constraintText, project_id: 1 })
-                .first();
-            // Link task to constraint
-            await db('v4_task_constraint_links').insert({
-                task_id: taskId,
-                constraint_id: constraint.id,
-            });
-            // Verify link
-            const link = await db('v4_task_constraint_links')
-                .where({ task_id: taskId, constraint_id: constraint.id })
-                .first();
-            assert.ok(link, 'Constraint link should exist');
-        });
-        it('should cascade delete task-constraint links when task deleted', async () => {
-            const db = getDb();
-            const taskId = await insertTask(db, { title: 'Task for constraint cascade' });
-            // Create constraint and link (simplified)
-            const layerId = await getLayerId(db, 'business');
-            const category = await db('v4_constraint_categories')
-                .where({ name: 'architecture' })
-                .first();
-            const constraintText = 'Cascade test constraint';
-            await db('v4_constraints').insert({
-                constraint_text: constraintText,
-                // Note: v4 schema does not have constraint_text_hash column
-                category_id: category.id,
-                priority: 2,
-                project_id: 1,
-                layer_id: layerId,
-                ts: Math.floor(Date.now() / 1000),
-                active: 1,
-            });
-            const constraint = await db('v4_constraints')
-                .where({ constraint_text: constraintText, project_id: 1 })
-                .first();
-            await db('v4_task_constraint_links').insert({
-                task_id: taskId,
-                constraint_id: constraint.id,
-            });
-            // Delete task
-            await db('v4_tasks').where({ id: taskId }).delete();
-            // Verify links were cascade deleted
-            const links = await db('v4_task_constraint_links').where({ task_id: taskId });
-            assert.strictEqual(links.length, 0, 'Task-constraint links should be cascade deleted');
-        });
-    });
-    // ============================================================================
-    // Cross-Database Compatibility Tests
-    // ============================================================================
-    describe(`Cross-database compatibility - ${dbType}`, () => {
-        it('should handle long task titles', async () => {
-            const db = getDb();
-            const longTitle = 'A'.repeat(200);
-            const taskId = await insertTask(db, {
-                title: longTitle,
-                priority: 2,
-            });
-            const task = await db('v4_tasks').where({ id: taskId, project_id: 1 }).first();
-            assert.strictEqual(task.title, longTitle);
-        });
-        it('should handle special characters in descriptions', async () => {
-            const db = getDb();
-            const specialDesc = "Description with 'quotes', \"double quotes\", and \\backslashes";
-            const taskId = await insertTask(db, {
-                title: 'Special chars test',
-                description: specialDesc,
-            });
-            const details = await db('v4_task_details').where({ task_id: taskId }).first();
-            assert.strictEqual(details.description, specialDesc);
-        });
-        it('should handle unicode in task fields', async () => {
-            const db = getDb();
-            const unicodeTitle = 'タスク 任务 작업 🚀';
-            const taskId = await insertTask(db, {
-                title: unicodeTitle,
-            });
-            const task = await db('v4_tasks').where({ id: taskId, project_id: 1 }).first();
-            assert.strictEqual(task.title, unicodeTitle);
-        });
-        it('should handle NULL optional fields', async () => {
-            const db = getDb();
-            const statusId = await getStatusId(db, 'todo');
-            const layerId = await getLayerId(db, 'business');
-            // Insert with NULL optional fields (completed_ts is nullable)
-            const timestamp = Math.floor(Date.now() / 1000);
-            const result = await db('v4_tasks').insert({
-                title: 'Task with NULL completed_ts',
-                status_id: statusId,
-                priority: 2,
-                project_id: 1,
-                layer_id: layerId,
-                completed_ts: null, // NULL is allowed
-                created_ts: timestamp,
-                updated_ts: timestamp,
-            });
-            let taskId;
-            if (Array.isArray(result) && result.length > 0) {
-                taskId = result[0];
-            }
-            else {
-                const task = await db('v4_tasks')
-                    .where({ title: 'Task with NULL completed_ts', project_id: 1 })
-                    .first();
-                taskId = task.id;
-            }
-            const task = await db('v4_tasks').where({ id: taskId, project_id: 1 }).first();
-            assert.strictEqual(task.completed_ts, null);
-        });
-    });
-});
-//# sourceMappingURL=task-operations.test.js.map