eggi-ai-db-schema-2 0.1.1

package/dist/utils/mapping-job-operations.js

@@ -0,0 +1,833 @@
+"use strict";
+/**
+ * =============================================================================
+ * MAPPING JOB OPERATIONS UTILITIES - CONSOLIDATED SCHEMA
+ * =============================================================================
+ * Utility functions for creating and managing mapping jobs with direct LinkedIn account references
+ *
+ * USAGE EXAMPLES:
+ *
+ * 1. SINGLE LINKEDIN ACCOUNT MAPPING JOB:
+ * ```typescript
+ * const result = await createMappingJobForLinkedInAccount({
+ *   linkedinAccountId: 123,
+ *   jobMetadata: {
+ *     service: "feed_analyzer",
+ *     triggered_by: "preparation_handler",
+ *     linkedin_identifier: "ACoAABCDEFG"
+ *   }
+ * });
+ * // Creates: 1 job with direct linkedin_account_id reference
+ * ```
+ *
+ * 2. BATCH PROCESSING (Multiple Jobs):
+ * ```typescript
+ * const results = await createMappingJobsForLinkedInAccounts([
+ *   { linkedinAccountId: 123, metadata: { priority: "high" } },
+ *   { linkedinAccountId: 456, metadata: { priority: "normal" } },
+ *   { linkedinAccountId: 789, metadata: { priority: "low" } }
+ * ]);
+ * // Creates: 3 separate jobs, each with direct linkedin_account_id reference
+ * ```
+ *
+ * 3. PROCESSING LIFECYCLE:
+ * ```typescript
+ * // When processing starts
+ * await startMappingJob(jobId, {
+ *   service_version: "v2.1.0",
+ *   model_version: "gpt-4-turbo",
+ *   started_by: "mapping_service_lambda"
+ * });
+ *
+ * // When processing completes
+ * await completeMappingJob(jobId, {
+ *   completion_status: "success",
+ *   processed_items: 150,
+ *   completion_reason: "all_items_processed"
+ * });
+ * ```
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createMappingJobForLinkedInAccount = createMappingJobForLinkedInAccount;
+exports.createMappingJobsForLinkedInAccounts = createMappingJobsForLinkedInAccounts;
+exports.startMappingJob = startMappingJob;
+exports.completeMappingJob = completeMappingJob;
+exports.validateMappingJobCompletion = validateMappingJobCompletion;
+exports.getMappingJobById = getMappingJobById;
+exports.getMappingJobWithLinkedInAccount = getMappingJobWithLinkedInAccount;
+exports.getMappingJobsForLinkedInAccount = getMappingJobsForLinkedInAccount;
+exports.getPendingMappingJobs = getPendingMappingJobs;
+exports.getRunningMappingJobs = getRunningMappingJobs;
+exports.getCompletedMappingJobs = getCompletedMappingJobs;
+exports.getRelationshipScoresForMappingJob = getRelationshipScoresForMappingJob;
+exports.getEnrichedRelationshipScoresForMappingJob = getEnrichedRelationshipScoresForMappingJob;
+exports.deleteMappingJob = deleteMappingJob;
+exports.createMappingJobWithSingleLinkedInAccount = createMappingJobWithSingleLinkedInAccount;
+exports.createMappingJobWithLinkedInAccounts = createMappingJobWithLinkedInAccounts;
+exports.checkMappingAvailability = checkMappingAvailability;
+const pg_client_1 = require("../lib/pg-client");
+const db_1 = require("../lib/db");
+/**
+ * Creates a new mapping job for a single LinkedIn account
+ */
+async function createMappingJobForLinkedInAccount(db, params) {
+    const { linkedinAccountId, jobMetadata = {}, companyMappingJobId = null, recursiveMappingJobId = null } = params;
+    (0, db_1.debugLogDbOperation)("insert", "monitoring.mapping_jobs", { linkedinAccountId, jobMetadata }, undefined, {
+        operation: "createMappingJobForLinkedInAccount",
+        linkedinAccountId,
+    });
+    try {
+        // Verify LinkedIn account exists
+        const accountCheckSql = `
+      SELECT id FROM linkedin.accounts WHERE id = $1 LIMIT 1
+    `;
+        const linkedinAccount = await (0, pg_client_1.query)(db, accountCheckSql, [
+            linkedinAccountId,
+        ]);
+        if (linkedinAccount.length === 0) {
+            throw new Error(`LinkedIn account with ID ${linkedinAccountId} not found`);
+        }
+        // Create the mapping job
+        const insertSql = `
+      INSERT INTO monitoring.mapping_jobs (linkedin_account_id, company_mapping_job_id, recursive_mapping_job_id, metadata, created_at, queued_at)
+      VALUES ($1, $2, $3, $4, NOW(), NOW())
+      RETURNING id, linkedin_account_id, company_mapping_job_id, recursive_mapping_job_id, metadata, created_at, queued_at, started_at, completed_at
+    `;
+        const mappingJob = await (0, pg_client_1.queryOne)(db, insertSql, [
+            linkedinAccountId,
+            companyMappingJobId,
+            recursiveMappingJobId,
+            JSON.stringify(jobMetadata),
+        ]);
+        if (!mappingJob) {
+            throw new Error("Failed to create mapping job");
+        }
+        return { mappingJob };
+    }
+    catch (error) {
+        console.error("Error creating mapping job for LinkedIn account:", error);
+        throw error;
+    }
+}
+/**
+ * Creates mapping jobs for multiple LinkedIn accounts
+ */
+async function createMappingJobsForLinkedInAccounts(db, accountsData) {
+    if (accountsData.length === 0) {
+        return { mappingJobs: [] };
+    }
+    (0, db_1.debugLogDbOperation)("insert", "monitoring.mapping_jobs", { count: accountsData.length }, undefined, {
+        operation: "createMappingJobsForLinkedInAccounts",
+        accountCount: accountsData.length,
+    });
+    try {
+        // Verify all LinkedIn accounts exist
+        const linkedinAccountIds = accountsData.map(data => data.linkedinAccountId);
+        const placeholders = linkedinAccountIds.map((_, i) => `$${i + 1}`).join(", ");
+        const accountCheckSql = `
+      SELECT id FROM linkedin.accounts WHERE id IN (${placeholders})
+    `;
+        const existingAccounts = await (0, pg_client_1.query)(db, accountCheckSql, linkedinAccountIds);
+        const existingAccountIds = new Set(existingAccounts.map(acc => acc.id));
+        const missingAccountIds = linkedinAccountIds.filter(id => !existingAccountIds.has(id));
+        if (missingAccountIds.length > 0) {
+            throw new Error(`LinkedIn accounts not found: ${missingAccountIds.join(", ")}`);
+        }
+        // Create mapping jobs
+        const values = [];
+        const params = [];
+        let paramIndex = 1;
+        accountsData.forEach(data => {
+            values.push(`($${paramIndex}, NULL, NULL, $${paramIndex + 1}, NOW(), NOW())`);
+            params.push(data.linkedinAccountId, JSON.stringify(data.metadata || {}));
+            paramIndex += 2;
+        });
+        const insertSql = `
+      INSERT INTO monitoring.mapping_jobs (linkedin_account_id, company_mapping_job_id, recursive_mapping_job_id, metadata, created_at, queued_at)
+      VALUES ${values.join(", ")}
+      RETURNING id, linkedin_account_id, company_mapping_job_id, recursive_mapping_job_id, metadata, created_at, queued_at, started_at, completed_at
+    `;
+        const createdJobs = await (0, pg_client_1.query)(db, insertSql, params);
+        return { mappingJobs: createdJobs };
+    }
+    catch (error) {
+        console.error("Error creating mapping jobs for LinkedIn accounts:", error);
+        throw error;
+    }
+}
+/**
+ * Start a mapping job (mark as started)
+ */
+async function startMappingJob(db, mappingJobId, startMetadata) {
+    (0, db_1.debugLogDbOperation)("update", "monitoring.mapping_jobs", { id: mappingJobId, startMetadata }, undefined, {
+        operation: "startMappingJob",
+        mappingJobId,
+    });
+    try {
+        if (startMetadata) {
+            // Get existing metadata and merge
+            const selectSql = `
+        SELECT metadata FROM monitoring.mapping_jobs WHERE id = $1 LIMIT 1
+      `;
+            const existingJob = await (0, pg_client_1.queryOne)(db, selectSql, [mappingJobId]);
+            const mergedMetadata = existingJob
+                ? { ...(existingJob.metadata || {}), ...startMetadata }
+                : startMetadata;
+            const updateSql = `
+        UPDATE monitoring.mapping_jobs
+        SET started_at = NOW(), metadata = $2
+        WHERE id = $1
+        RETURNING id, linkedin_account_id, company_mapping_job_id, metadata, created_at, queued_at, started_at, completed_at
+      `;
+            const updatedJob = await (0, pg_client_1.queryOne)(db, updateSql, [
+                mappingJobId,
+                JSON.stringify(mergedMetadata),
+            ]);
+            if (!updatedJob) {
+                throw new Error(`Mapping job with ID ${mappingJobId} not found`);
+            }
+            return updatedJob;
+        }
+        else {
+            const updateSql = `
+        UPDATE monitoring.mapping_jobs
+        SET started_at = NOW()
+        WHERE id = $1
+        RETURNING id, linkedin_account_id, company_mapping_job_id, metadata, created_at, queued_at, started_at, completed_at
+      `;
+            const updatedJob = await (0, pg_client_1.queryOne)(db, updateSql, [
+                mappingJobId,
+            ]);
+            if (!updatedJob) {
+                throw new Error(`Mapping job with ID ${mappingJobId} not found`);
+            }
+            return updatedJob;
+        }
+    }
+    catch (error) {
+        console.error("Error starting mapping job:", error);
+        throw error;
+    }
+}
+/**
+ * Complete a mapping job (mark as completed)
+ */
+async function completeMappingJob(db, mappingJobId, completionMetadata) {
+    (0, db_1.debugLogDbOperation)("update", "monitoring.mapping_jobs", { id: mappingJobId, completionMetadata }, undefined, {
+        operation: "completeMappingJob",
+        mappingJobId,
+    });
+    try {
+        if (completionMetadata) {
+            // Get existing metadata and merge
+            const selectSql = `
+        SELECT metadata FROM monitoring.mapping_jobs WHERE id = $1 LIMIT 1
+      `;
+            const existingJob = await (0, pg_client_1.queryOne)(db, selectSql, [mappingJobId]);
+            const mergedMetadata = existingJob
+                ? { ...(existingJob.metadata || {}), ...completionMetadata }
+                : completionMetadata;
+            const updateSql = `
+        UPDATE monitoring.mapping_jobs
+        SET completed_at = NOW(), metadata = $2
+        WHERE id = $1
+        RETURNING id, linkedin_account_id, company_mapping_job_id, metadata, created_at, queued_at, started_at, completed_at
+      `;
+            const updatedJob = await (0, pg_client_1.queryOne)(db, updateSql, [
+                mappingJobId,
+                JSON.stringify(mergedMetadata),
+            ]);
+            if (!updatedJob) {
+                throw new Error(`Mapping job with ID ${mappingJobId} not found`);
+            }
+            return updatedJob;
+        }
+        else {
+            const updateSql = `
+        UPDATE monitoring.mapping_jobs
+        SET completed_at = NOW()
+        WHERE id = $1
+        RETURNING id, linkedin_account_id, company_mapping_job_id, metadata, created_at, queued_at, started_at, completed_at
+      `;
+            const updatedJob = await (0, pg_client_1.queryOne)(db, updateSql, [
+                mappingJobId,
+            ]);
+            if (!updatedJob) {
+                throw new Error(`Mapping job with ID ${mappingJobId} not found`);
+            }
+            return updatedJob;
+        }
+    }
+    catch (error) {
+        console.error("Error completing mapping job:", error);
+        throw error;
+    }
+}
+/**
+ * Validate that a mapping job exists and has been completed
+ */
+async function validateMappingJobCompletion(db, mappingJobId) {
+    (0, db_1.debugLogDbOperation)("select", "monitoring.mapping_jobs", { id: mappingJobId }, undefined, {
+        operation: "validateMappingJobCompletion",
+        mappingJobId,
+    });
+    try {
+        const sql = `
+      SELECT id, linkedin_account_id, company_mapping_job_id, recursive_mapping_job_id, metadata, created_at, queued_at, started_at, completed_at
+      FROM monitoring.mapping_jobs
+      WHERE id = $1
+      LIMIT 1
+    `;
+        const row = await (0, pg_client_1.queryOne)(db, sql, [mappingJobId]);
+        if (!row) {
+            return {
+                isValid: false,
+                error: `Mapping job with ID ${mappingJobId} not found`,
+            };
+        }
+        // Map snake_case to camelCase
+        const mappingJob = {
+            id: row.id,
+            linkedinAccountId: row.linkedin_account_id,
+            companyMappingJobId: row.company_mapping_job_id,
+            recursiveMappingJobId: row.recursive_mapping_job_id,
+            metadata: row.metadata || {},
+            createdAt: row.created_at,
+            queuedAt: row.queued_at,
+            startedAt: row.started_at,
+            completedAt: row.completed_at,
+        };
+        if (!mappingJob.completedAt) {
+            return {
+                isValid: false,
+                error: `Mapping job ${mappingJobId} has not been completed yet`,
+            };
+        }
+        return {
+            isValid: true,
+            mappingJob: mappingJob,
+        };
+    }
+    catch (error) {
+        console.error("Error validating mapping job completion:", error);
+        return {
+            isValid: false,
+            error: `Failed to validate mapping job: ${error instanceof Error ? error.message : String(error)}`,
+        };
+    }
+}
+/**
+ * Get mapping job by ID
+ * Returns basic mapping job information including completion status
+ *
+ * @param db - Database instance
+ * @param mappingJobId - Mapping job ID
+ * @returns Mapping job or null if not found
+ */
+async function getMappingJobById(db, mappingJobId) {
+    (0, db_1.debugLogDbOperation)("select", "monitoring.mapping_jobs", { mappingJobId }, undefined, {
+        operation: "getMappingJobById",
+        mappingJobId,
+    });
+    try {
+        const sql = `
+      SELECT id, linkedin_account_id, completed_at
+      FROM monitoring.mapping_jobs
+      WHERE id = $1
+      LIMIT 1
+    `;
+        const result = await (0, pg_client_1.queryOne)(db, sql, [mappingJobId]);
+        return result;
+    }
+    catch (error) {
+        console.error("Error getting mapping job by ID:", error);
+        throw error;
+    }
+}
+/**
+ * Get mapping job with LinkedIn account details
+ */
+async function getMappingJobWithLinkedInAccount(db, mappingJobId) {
+    (0, db_1.debugLogDbOperation)("select", "monitoring.mapping_jobs + linkedin.accounts + users", { mappingJobId }, undefined, {
+        operation: "getMappingJobWithLinkedInAccount",
+        mappingJobId,
+    });
+    try {
+        const sql = `
+      SELECT
+        -- Mapping job fields
+        mj.id as mj_id,
+        mj.linkedin_account_id as mj_linkedin_account_id,
+        mj.company_mapping_job_id as mj_company_mapping_job_id,
+        mj.recursive_mapping_job_id as mj_recursive_mapping_job_id,
+        mj.created_at as mj_created_at,
+        mj.queued_at as mj_queued_at,
+        mj.started_at as mj_started_at,
+        mj.completed_at as mj_completed_at,
+        mj.metadata as mj_metadata,
+        -- LinkedIn account fields
+        la.id as la_id,
+        la.user_id as la_user_id,
+        la.linkedin_identifier_acoa as la_linkedin_identifier_acoa,
+        la.public_identifier as la_public_identifier,
+        la.forager_id as la_forager_id,
+        la.first_name as la_first_name,
+        la.last_name as la_last_name,
+        la.headline as la_headline,
+        la.summary as la_summary,
+        la.location as la_location,
+        COALESCE(la.profile_image_cloudfront_url, la.profile_picture_url) as la_profile_picture_url,
+        NULL::text as la_profile_image_cloudfront_url,
+        la.follower_count as la_follower_count,
+        la.connections_count as la_connections_count,
+        la.profiles_updated_at as la_profiles_updated_at,
+        la.created_at as la_created_at,
+        -- User fields (optional)
+        u.id as u_id,
+        u.given_name as u_given_name,
+        u.family_name as u_family_name,
+        u.summary as u_summary,
+        u.embedding_summary as u_embedding_summary,
+        u.embedding as u_embedding,
+        u.created_at as u_created_at
+      FROM monitoring.mapping_jobs mj
+      INNER JOIN linkedin.accounts la ON mj.linkedin_account_id = la.id
+      LEFT JOIN public.users u ON la.user_id = u.id
+      WHERE mj.id = $1
+      LIMIT 1
+    `;
+        const result = await (0, pg_client_1.queryOne)(db, sql, [mappingJobId]);
+        if (!result) {
+            return null;
+        }
+        return {
+            mappingJob: {
+                id: result.mj_id,
+                linkedinAccountId: result.mj_linkedin_account_id,
+                companyMappingJobId: result.mj_company_mapping_job_id,
+                recursiveMappingJobId: result.mj_recursive_mapping_job_id,
+                createdAt: result.mj_created_at,
+                queuedAt: result.mj_queued_at,
+                startedAt: result.mj_started_at,
+                completedAt: result.mj_completed_at,
+                metadata: result.mj_metadata,
+            },
+            linkedinAccount: {
+                id: result.la_id,
+                user_id: result.la_user_id,
+                linkedin_identifier_acoa: result.la_linkedin_identifier_acoa,
+                public_identifier: result.la_public_identifier,
+                forager_id: result.la_forager_id,
+                first_name: result.la_first_name,
+                last_name: result.la_last_name,
+                headline: result.la_headline,
+                summary: result.la_summary,
+                location: result.la_location,
+                profile_picture_url: result.la_profile_picture_url,
+                profile_image_cloudfront_url: result.la_profile_image_cloudfront_url,
+                follower_count: result.la_follower_count,
+                connections_count: result.la_connections_count,
+                profiles_updated_at: result.la_profiles_updated_at,
+                created_at: result.la_created_at,
+            },
+            user: result.u_id
+                ? {
+                    id: result.u_id,
+                    given_name: result.u_given_name,
+                    family_name: result.u_family_name,
+                    summary: result.u_summary,
+                    embedding_summary: result.u_embedding_summary,
+                    embedding: result.u_embedding,
+                    created_at: result.u_created_at,
+                }
+                : undefined,
+        };
+    }
+    catch (error) {
+        console.error("Error getting mapping job with LinkedIn account:", error);
+        throw error;
+    }
+}
+/**
+ * Get all mapping jobs for a LinkedIn account
+ */
+async function getMappingJobsForLinkedInAccount(db, linkedinAccountId, options) {
+    const { limit = 50, includeCompleted = true } = options || {};
+    (0, db_1.debugLogDbOperation)("select", "monitoring.mapping_jobs", { linkedinAccountId, limit, includeCompleted }, undefined, {
+        operation: "getMappingJobsForLinkedInAccount",
+        linkedinAccountId,
+    });
+    try {
+        const sql = includeCompleted
+            ? `
+        SELECT id, linkedin_account_id, company_mapping_job_id, metadata, created_at, queued_at, started_at, completed_at
+        FROM monitoring.mapping_jobs
+        WHERE linkedin_account_id = $1
+        ORDER BY created_at DESC
+        LIMIT $2
+      `
+            : `
+        SELECT id, linkedin_account_id, company_mapping_job_id, metadata, created_at, queued_at, started_at, completed_at
+        FROM monitoring.mapping_jobs
+        WHERE linkedin_account_id = $1 AND completed_at IS NULL
+        ORDER BY created_at DESC
+        LIMIT $2
+      `;
+        return await (0, pg_client_1.query)(db, sql, [linkedinAccountId, limit]);
+    }
+    catch (error) {
+        console.error("Error getting mapping jobs for LinkedIn account:", error);
+        throw error;
+    }
+}
+/**
+ * Get pending mapping jobs (not started yet)
+ */
+async function getPendingMappingJobs(db, options) {
+    const { limit = 100, linkedinAccountId } = options || {};
+    (0, db_1.debugLogDbOperation)("select", "monitoring.mapping_jobs", { limit, linkedinAccountId, status: "pending" }, undefined, {
+        operation: "getPendingMappingJobs",
+    });
+    try {
+        const sql = linkedinAccountId
+            ? `
+        SELECT id, linkedin_account_id, company_mapping_job_id, metadata, created_at, queued_at, started_at, completed_at
+        FROM monitoring.mapping_jobs
+        WHERE started_at IS NULL AND linkedin_account_id = $1
+        ORDER BY queued_at ASC
+        LIMIT $2
+      `
+            : `
+        SELECT id, linkedin_account_id, company_mapping_job_id, metadata, created_at, queued_at, started_at, completed_at
+        FROM monitoring.mapping_jobs
+        WHERE started_at IS NULL
+        ORDER BY queued_at ASC
+        LIMIT $1
+      `;
+        const params = linkedinAccountId ? [linkedinAccountId, limit] : [limit];
+        return await (0, pg_client_1.query)(db, sql, params);
+    }
+    catch (error) {
+        console.error("Error getting pending mapping jobs:", error);
+        throw error;
+    }
+}
+/**
+ * Get running mapping jobs (started but not completed)
+ */
+async function getRunningMappingJobs(db, options) {
+    const { limit = 100, linkedinAccountId } = options || {};
+    (0, db_1.debugLogDbOperation)("select", "monitoring.mapping_jobs", { limit, linkedinAccountId, status: "running" }, undefined, {
+        operation: "getRunningMappingJobs",
+    });
+    try {
+        const sql = linkedinAccountId
+            ? `
+        SELECT id, linkedin_account_id, company_mapping_job_id, metadata, created_at, queued_at, started_at, completed_at
+        FROM monitoring.mapping_jobs
+        WHERE started_at IS NOT NULL AND completed_at IS NULL AND linkedin_account_id = $1
+        ORDER BY started_at ASC
+        LIMIT $2
+      `
+            : `
+        SELECT id, linkedin_account_id, company_mapping_job_id, metadata, created_at, queued_at, started_at, completed_at
+        FROM monitoring.mapping_jobs
+        WHERE started_at IS NOT NULL AND completed_at IS NULL
+        ORDER BY started_at ASC
+        LIMIT $1
+      `;
+        const params = linkedinAccountId ? [linkedinAccountId, limit] : [limit];
+        return await (0, pg_client_1.query)(db, sql, params);
+    }
+    catch (error) {
+        console.error("Error getting running mapping jobs:", error);
+        throw error;
+    }
+}
+/**
+ * Get completed mapping jobs
+ */
+async function getCompletedMappingJobs(db, options) {
+    const { limit = 100, linkedinAccountId, since } = options || {};
+    (0, db_1.debugLogDbOperation)("select", "monitoring.mapping_jobs", { limit, linkedinAccountId, since, status: "completed" }, undefined, {
+        operation: "getCompletedMappingJobs",
+    });
+    try {
+        let sql = `
+      SELECT id, linkedin_account_id, company_mapping_job_id, metadata, created_at, queued_at, started_at, completed_at
+      FROM monitoring.mapping_jobs
+      WHERE completed_at IS NOT NULL
+    `;
+        const params = [];
+        let paramIndex = 1;
+        if (linkedinAccountId) {
+            sql += ` AND linkedin_account_id = $${paramIndex}`;
+            params.push(linkedinAccountId);
+            paramIndex++;
+        }
+        if (since) {
+            sql += ` AND completed_at >= $${paramIndex}`;
+            params.push(since);
+            paramIndex++;
+        }
+        sql += ` ORDER BY completed_at DESC LIMIT $${paramIndex}`;
+        params.push(limit);
+        return await (0, pg_client_1.query)(db, sql, params);
+    }
+    catch (error) {
+        console.error("Error getting completed mapping jobs:", error);
+        throw error;
+    }
+}
+/**
+ * Get relationship scores for a mapping job
+ */
+async function getRelationshipScoresForMappingJob(db, mappingJobId, options) {
+    const { limit = 50, minScore } = options || {};
+    (0, db_1.debugLogDbOperation)("select", "linkedin.relationships", { mappingJobId, limit, minScore }, undefined, {
+        operation: "getRelationshipScoresForMappingJob",
+        mappingJobId,
+    });
+    try {
+        const sql = minScore !== undefined
+            ? `
+        SELECT id, linkedin_account_id_a, linkedin_account_id_b, score, model_version, analysis_type, mapping_job_id, metadata, created_at
+        FROM linkedin.relationships
+        WHERE mapping_job_id = $1 AND score >= $2
+        ORDER BY score DESC
+        LIMIT $3
+      `
+            : `
+        SELECT id, linkedin_account_id_a, linkedin_account_id_b, score, model_version, analysis_type, mapping_job_id, metadata, created_at
+        FROM linkedin.relationships
+        WHERE mapping_job_id = $1
+        ORDER BY score DESC
+        LIMIT $2
+      `;
+        const params = minScore !== undefined ? [mappingJobId, minScore, limit] : [mappingJobId, limit];
+        return await (0, pg_client_1.query)(db, sql, params);
+    }
+    catch (error) {
+        console.error("Error getting relationship scores for mapping job:", error);
+        throw error;
+    }
+}
+/**
+ * Gets enriched relationship scores for a specific mapping job with LinkedIn account details
+ * This function properly filters by mapping job ID at the database level (avoiding the bug
+ * where getRelationshipScoresForAccount followed by client-side filtering would miss records)
+ *
+ * @param db - Database instance
+ * @param mappingJobId - The mapping job ID to filter by
+ * @param mainLinkedinAccountId - The main LinkedIn account ID (to determine which is the "other" account)
+ * @param options - Query options
+ * @returns Promise resolving to array of enriched relationship scores
+ */
+async function getEnrichedRelationshipScoresForMappingJob(db, mappingJobId, mainLinkedinAccountId, options) {
+    const { limit = 50, minScore, sortOrder = "desc" } = options || {};
+    (0, db_1.debugLogDbOperation)("select", "linkedin.relationships + linkedin.accounts", { mappingJobId, mainLinkedinAccountId, limit, minScore }, undefined, {
+        operation: "getEnrichedRelationshipScoresForMappingJob",
+        mappingJobId,
+        mainLinkedinAccountId,
+    });
+    try {
+        let sql = `
+      SELECT
+        r.score,
+        r.model_version,
+        r.analysis_type,
+        r.mapping_job_id,
+        r.metadata,
+        r.created_at,
+        CASE 
+          WHEN r.linkedin_account_id_a = $2 
+          THEN r.linkedin_account_id_b
+          ELSE r.linkedin_account_id_a
+        END as other_account_id,
+        CASE 
+          WHEN r.linkedin_account_id_a = $2 
+          THEN account_b.linkedin_identifier_acoa
+          ELSE account_a.linkedin_identifier_acoa
+        END as other_account_linkedin_identifier_acoa,
+        CASE 
+          WHEN r.linkedin_account_id_a = $2 
+          THEN account_b.public_identifier
+          ELSE account_a.public_identifier
+        END as other_account_public_identifier,
+        CASE 
+          WHEN r.linkedin_account_id_a = $2 
+          THEN account_b.first_name
+          ELSE account_a.first_name
+        END as other_account_first_name,
+        CASE 
+          WHEN r.linkedin_account_id_a = $2 
+          THEN account_b.last_name
+          ELSE account_a.last_name
+        END as other_account_last_name,
+        CASE 
+          WHEN r.linkedin_account_id_a = $2 
+          THEN account_b.headline
+          ELSE account_a.headline
+        END as other_account_headline,
+        CASE 
+          WHEN r.linkedin_account_id_a = $2 
+          THEN account_b.profile_image_cloudfront_url
+          ELSE account_a.profile_image_cloudfront_url
+        END as other_account_profile_picture_url
+      FROM linkedin.relationships r
+      INNER JOIN linkedin.accounts account_a ON r.linkedin_account_id_a = account_a.id
+      INNER JOIN linkedin.accounts account_b ON r.linkedin_account_id_b = account_b.id
+      WHERE r.mapping_job_id = $1
+    `;
+        const params = [mappingJobId, mainLinkedinAccountId];
+        let paramIndex = 3;
+        if (minScore !== undefined) {
+            sql += ` AND r.score >= $${paramIndex}`;
+            params.push(minScore);
+            paramIndex++;
+        }
+        sql += ` ORDER BY r.score ${sortOrder === "desc" ? "DESC" : "ASC"} LIMIT $${paramIndex}`;
+        params.push(limit);
+        const results = await (0, pg_client_1.query)(db, sql, params);
+        return results.map(result => ({
+            score: result.score,
+            modelVersion: result.model_version,
+            analysisType: result.analysis_type,
+            mappingJobId: result.mapping_job_id,
+            metadata: result.metadata,
+            createdAt: result.created_at,
+            otherAccount: {
+                id: result.other_account_id,
+                linkedinIdentifierAcoa: result.other_account_linkedin_identifier_acoa,
+                publicIdentifier: result.other_account_public_identifier,
+                firstName: result.other_account_first_name,
+                lastName: result.other_account_last_name,
+                headline: result.other_account_headline,
+                profilePictureUrl: result.other_account_profile_picture_url,
+            },
+        }));
+    }
+    catch (error) {
+        console.error("Error getting enriched relationship scores for mapping job:", error);
+        throw error;
+    }
+}
+/**
+ * Delete a mapping job and all related data
+ */
+async function deleteMappingJob(db, mappingJobId) {
+    (0, db_1.debugLogDbOperation)("delete", "monitoring.mapping_jobs", { mappingJobId }, undefined, {
+        operation: "deleteMappingJob",
+        mappingJobId,
+    });
+    try {
+        const sql = `
+      DELETE FROM monitoring.mapping_jobs
+      WHERE id = $1
+      RETURNING id
+    `;
+        const result = await (0, pg_client_1.query)(db, sql, [mappingJobId]);
+        return result.length > 0;
+    }
+    catch (error) {
+        console.error("Error deleting mapping job:", error);
+        throw error;
+    }
+}
+// =============================================================================
+// LEGACY COMPATIBILITY (DEPRECATED)
+// =============================================================================
+/**
+ * @deprecated Use createMappingJobForLinkedInAccount instead
+ * This function is kept for backward compatibility but will be removed
+ */
+async function createMappingJobWithSingleLinkedInAccount(db, params) {
+    console.warn("createMappingJobWithSingleLinkedInAccount is deprecated. Use createMappingJobForLinkedInAccount instead.");
+    return await createMappingJobForLinkedInAccount(db, {
+        linkedinAccountId: params.linkedinAccountId,
+        jobMetadata: {
+            ...params.jobMetadata,
+            ...params.linkedinAccountMetadata,
+        },
+    });
+}
+/**
+ * @deprecated Use createMappingJobsForLinkedInAccounts instead
+ */
+async function createMappingJobWithLinkedInAccounts(db, params) {
+    console.warn("createMappingJobWithLinkedInAccounts is deprecated. Use createMappingJobsForLinkedInAccounts instead.");
+    return await createMappingJobsForLinkedInAccounts(db, params.linkedinAccounts.map(acc => ({
+        linkedinAccountId: acc.linkedinAccountId,
+        metadata: {
+            ...params.jobMetadata,
+            ...acc.metadata,
+        },
+    })));
+}
+/**
+ * Check if a target LinkedIn profile has been mapped before
+ * Uses UNION query to check both on-demand and regular mapping jobs
+ *
+ * @param db - Database connection
+ * @param targetLinkedInIdentifier - LinkedIn identifier (ACoA format) to check
+ * @returns Promise<MappingAvailabilityResult> - Availability information
+ */
+async function checkMappingAvailability(db, targetLinkedInIdentifier) {
+    // First check if the target LinkedIn account exists
+    const targetCheckSql = `
+    SELECT id, linkedin_identifier_acoa
+    FROM linkedin.accounts
+    WHERE linkedin_identifier_acoa = $1
+    LIMIT 1
+  `;
+    const targetAccount = await (0, pg_client_1.query)(db, targetCheckSql, [targetLinkedInIdentifier]);
+    const targetExists = targetAccount.length > 0;
+    // Check for existing mappings using UNION of both tables
+    const mappingCheckSql = `
+    -- Check on-demand mapping jobs by internal_identifier_acoa
+    SELECT 
+      'on_demand' as source,
+      odmj.id as job_id,
+      odmj.created_at,
+      mj.completed_at
+    FROM monitoring.on_demand_mapping_jobs odmj
+    LEFT JOIN monitoring.mapping_jobs mj ON odmj.mapping_job_id = mj.id
+    WHERE odmj.internal_identifier_acoa = $1
+    
+    UNION ALL
+    
+    -- Check regular mapping jobs by target LinkedIn account
+    SELECT 
+      'regular' as source,
+      mj.id as job_id,
+      mj.created_at,
+      mj.completed_at
+    FROM monitoring.mapping_jobs mj
+    JOIN linkedin.accounts la ON mj.linkedin_account_id = la.id
+    WHERE la.linkedin_identifier_acoa = $1
+    
+    ORDER BY created_at DESC
+    LIMIT 1
+  `;
+    const mappingCheck = await (0, pg_client_1.query)(db, mappingCheckSql, [
+        targetLinkedInIdentifier,
+    ]);
+    const hasExistingMapping = mappingCheck.length > 0;
+    let mappingDetails = undefined;
+    if (hasExistingMapping) {
+        const row = mappingCheck[0];
+        mappingDetails = {
+            source: row.source,
+            jobId: Number(row.job_id),
+            createdAt: new Date(row.created_at),
+            completedAt: row.completed_at ? new Date(row.completed_at) : null,
+        };
+    }
+    return {
+        isAvailable: targetExists && !hasExistingMapping,
+        targetExists,
+        hasExistingMapping,
+        mappingDetails,
+    };
+}
+//# sourceMappingURL=mapping-job-operations.js.map