eggi-ai-db-schema-2 0.1.1

package/dist/utils/on-demand-mapping-operations.js

@@ -0,0 +1,728 @@
+"use strict";
+/**
+ * =============================================================================
+ * ON-DEMAND MAPPING OPERATIONS UTILITIES - CONSOLIDATED SCHEMA
+ * =============================================================================
+ * Utility functions for creating and managing on-demand mapping jobs from Chrome extension
+ * Updated to work with the new consolidated linkedin.accounts schema
+ *
+ * USAGE EXAMPLES:
+ *
+ * 1. CREATE ON-DEMAND REQUEST:
+ * ```typescript
+ * const request = await createOnDemandMappingJob({
+ *   requesterLinkedinAccountId: 123,
+ *   internalIdentifierAcoa: "ACoAABCDEFG...", // Target ACoA identifier
+ *   metadata: {
+ *     source: "chrome_extension",
+ *     user_agent: "Mozilla/5.0...",
+ *     requested_by: "user_456"
+ *   }
+ * });
+ * ```
+ *
+ * 2. GET REQUEST WITH STATUS:
+ * ```typescript
+ * const requestWithStatus = await getOnDemandMappingJobWithStatus(123, "ACoAABCDEFG...");
+ * // Returns: { id, mappingJobId, status: "completed", progress: 100, ... }
+ * ```
+ *
+ * 3. UPDATE MAPPING JOB ASSOCIATION:
+ * ```typescript
+ * await updateOnDemandMappingJobId(123, "ACoAABCDEFG...", 789);
+ * ```
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createOnDemandMappingJob = createOnDemandMappingJob;
+exports.getOnDemandMappingJob = getOnDemandMappingJob;
+exports.getOnDemandMappingJobById = getOnDemandMappingJobById;
+exports.getOnDemandMappingJobWithStatus = getOnDemandMappingJobWithStatus;
+exports.updateOnDemandMappingJobId = updateOnDemandMappingJobId;
+exports.getOnDemandMappingJobsMinimal = getOnDemandMappingJobsMinimal;
+exports.getPendingOnDemandMappingJobs = getPendingOnDemandMappingJobs;
+exports.checkOnDemandMappingJobExists = checkOnDemandMappingJobExists;
+exports.getOrCreateOnDemandMappingJob = getOrCreateOnDemandMappingJob;
+exports.getTargetLinkedInAccountIdForOnDemandJobInOrganization = getTargetLinkedInAccountIdForOnDemandJobInOrganization;
+exports.deleteOnDemandMappingJob = deleteOnDemandMappingJob;
+exports.getRelationshipScoresForOnDemandJob = getRelationshipScoresForOnDemandJob;
+const pg_client_1 = require("../lib/pg-client");
+const db_1 = require("../lib/db");
+const database_service_1 = require("../lib/database-service");
+// =============================================================================
+// CORE OPERATIONS
+// =============================================================================
+/**
+ * Create a new on-demand mapping job
+ */
+async function createOnDemandMappingJob(params) {
+    const { requesterLinkedinAccountId, internalIdentifierAcoa, metadata = {} } = params;
+    (0, db_1.debugLogDbOperation)("insert", "monitoring.on_demand_mapping_jobs", { requesterLinkedinAccountId, internalIdentifierAcoa }, undefined, {
+        operation: "createOnDemandMappingJob",
+        requesterLinkedinAccountId,
+        internalIdentifierAcoa,
+    });
+    try {
+        // Verify requester LinkedIn account exists
+        const db = await database_service_1.dbService.getDb();
+        const requesterSql = `SELECT id FROM linkedin.accounts WHERE id = $1 LIMIT 1`;
+        const requesterAccount = await (0, pg_client_1.queryOne)(db, requesterSql, [
+            requesterLinkedinAccountId,
+        ]);
+        if (!requesterAccount) {
+            throw new Error(`Requester LinkedIn account with ID ${requesterLinkedinAccountId} not found`);
+        }
+        // Create the on-demand mapping job
+        const insertSql = `
+      INSERT INTO monitoring.on_demand_mapping_jobs (
+        requester_linkedin_account_id, internal_identifier_acoa, metadata, created_at, updated_at
+      )
+      VALUES ($1, $2, $3, NOW(), NOW())
+      RETURNING id, requester_linkedin_account_id, internal_identifier_acoa, mapping_job_id, metadata, created_at, updated_at
+    `;
+        const onDemandJob = await (0, pg_client_1.queryOne)(db, insertSql, [
+            requesterLinkedinAccountId,
+            internalIdentifierAcoa,
+            JSON.stringify(metadata),
+        ]);
+        if (!onDemandJob) {
+            throw new Error("Failed to create on-demand mapping job");
+        }
+        return {
+            id: onDemandJob.id,
+            requesterLinkedinAccountId: onDemandJob.requester_linkedin_account_id,
+            internalIdentifierAcoa: onDemandJob.internal_identifier_acoa,
+            mappingJobId: onDemandJob.mapping_job_id,
+            metadata: onDemandJob.metadata,
+            createdAt: onDemandJob.created_at,
+            updatedAt: onDemandJob.updated_at,
+        };
+    }
+    catch (error) {
+        console.error("Error creating on-demand mapping job:", error);
+        throw error;
+    }
+}
+/**
+ * Get on-demand mapping job by requester and target identifiers
+ */
+async function getOnDemandMappingJob(requesterLinkedinAccountId, internalIdentifierAcoa) {
+    (0, db_1.debugLogDbOperation)("select", "monitoring.on_demand_mapping_jobs", { requesterLinkedinAccountId, internalIdentifierAcoa }, undefined, {
+        operation: "getOnDemandMappingJob",
+        requesterLinkedinAccountId,
+        internalIdentifierAcoa,
+    });
+    try {
+        const db = await database_service_1.dbService.getDb();
+        const sql = `
+      SELECT id, requester_linkedin_account_id, internal_identifier_acoa, mapping_job_id, metadata, created_at, updated_at
+      FROM monitoring.on_demand_mapping_jobs
+      WHERE requester_linkedin_account_id = $1 AND internal_identifier_acoa = $2
+      LIMIT 1
+    `;
+        const result = await (0, pg_client_1.queryOne)(db, sql, [requesterLinkedinAccountId, internalIdentifierAcoa]);
+        if (!result)
+            return null;
+        return {
+            id: result.id,
+            requesterLinkedinAccountId: result.requester_linkedin_account_id,
+            internalIdentifierAcoa: result.internal_identifier_acoa,
+            mappingJobId: result.mapping_job_id,
+            metadata: result.metadata,
+            createdAt: result.created_at,
+            updatedAt: result.updated_at,
+        };
+    }
+    catch (error) {
+        console.error("Error getting on-demand mapping job:", error);
+        throw error;
+    }
+}
+/**
+ * Get on-demand mapping job by ID
+ */
+async function getOnDemandMappingJobById(jobId) {
+    (0, db_1.debugLogDbOperation)("select", "monitoring.on_demand_mapping_jobs", { jobId }, undefined, {
+        operation: "getOnDemandMappingJobById",
+        jobId,
+    });
+    try {
+        const db = await database_service_1.dbService.getDb();
+        const sql = `
+      SELECT id, requester_linkedin_account_id, internal_identifier_acoa, mapping_job_id, metadata, created_at, updated_at
+      FROM monitoring.on_demand_mapping_jobs
+      WHERE id = $1
+      LIMIT 1
+    `;
+        const result = await (0, pg_client_1.queryOne)(db, sql, [jobId]);
+        if (!result)
+            return null;
+        return {
+            id: result.id,
+            requesterLinkedinAccountId: result.requester_linkedin_account_id,
+            internalIdentifierAcoa: result.internal_identifier_acoa,
+            mappingJobId: result.mapping_job_id,
+            metadata: result.metadata,
+            createdAt: result.created_at,
+            updatedAt: result.updated_at,
+        };
+    }
+    catch (error) {
+        console.error("Error getting on-demand mapping job by ID:", error);
+        throw error;
+    }
+}
+/**
+ * Get on-demand mapping job with complete status information
+ */
+async function getOnDemandMappingJobWithStatus(requesterLinkedinAccountId, internalIdentifierAcoa) {
+    (0, db_1.debugLogDbOperation)("select", "monitoring.on_demand_mapping_jobs + status", { requesterLinkedinAccountId, internalIdentifierAcoa }, undefined, {
+        operation: "getOnDemandMappingJobWithStatus",
+        requesterLinkedinAccountId,
+        internalIdentifierAcoa,
+    });
+    try {
+        const db = await database_service_1.dbService.getDb();
+        // Get the on-demand job with requester details
+        const jobSql = `
+      SELECT 
+        odmj.id, odmj.requester_linkedin_account_id, odmj.internal_identifier_acoa,
+        odmj.mapping_job_id, odmj.created_at, odmj.updated_at, odmj.metadata,
+        la.linkedin_identifier_acoa as requester_linkedin_identifier
+      FROM monitoring.on_demand_mapping_jobs odmj
+      INNER JOIN linkedin.accounts la ON odmj.requester_linkedin_account_id = la.id
+      WHERE odmj.requester_linkedin_account_id = $1 AND odmj.internal_identifier_acoa = $2
+      LIMIT 1
+    `;
+        const job = await (0, pg_client_1.queryOne)(db, jobSql, [requesterLinkedinAccountId, internalIdentifierAcoa]);
+        if (!job) {
+            return null;
+        }
+        // Determine status and get mapping job details if available
+        let status = "pending";
+        let progress = 0;
+        let mappingJobDetails;
+        let linkedinRelationshipsCount = 0;
+        if (job.mapping_job_id) {
+            // Get mapping job details
+            const mappingJobSql = `
+        SELECT created_at, queued_at, started_at, completed_at, metadata
+        FROM monitoring.mapping_jobs
+        WHERE id = $1
+        LIMIT 1
+      `;
+            const mappingJob = await (0, pg_client_1.queryOne)(db, mappingJobSql, [job.mapping_job_id]);
+            if (mappingJob) {
+                mappingJobDetails = {
+                    createdAt: mappingJob.created_at,
+                    queuedAt: mappingJob.queued_at,
+                    startedAt: mappingJob.started_at ?? undefined,
+                    completedAt: mappingJob.completed_at ?? undefined,
+                    metadata: mappingJob.metadata,
+                };
+                // Determine status based on mapping job state
+                if (mappingJob.completed_at) {
+                    status = "completed";
+                    progress = 100;
+                }
+                else if (mappingJob.started_at) {
+                    status = "processing";
+                    progress = 50; // Estimate - could be refined with more detailed progress tracking
+                }
+                else {
+                    status = "queued";
+                    progress = 10;
+                }
+                // Get relationship scores count for completed jobs
+                if (status === "completed") {
+                    const countSql = `SELECT COUNT(*) as count FROM linkedin.relationships WHERE mapping_job_id = $1`;
+                    const scoresCount = await (0, pg_client_1.queryOne)(db, countSql, [
+                        job.mapping_job_id,
+                    ]);
+                    linkedinRelationshipsCount = parseInt(scoresCount?.count || "0");
+                }
+            }
+        }
+        return {
+            id: job.id,
+            requesterLinkedinAccountId: job.requester_linkedin_account_id,
+            internalIdentifierAcoa: job.internal_identifier_acoa,
+            mappingJobId: job.mapping_job_id,
+            createdAt: job.created_at,
+            updatedAt: job.updated_at,
+            metadata: job.metadata,
+            status,
+            progress,
+            requesterLinkedInIdentifier: job.requester_linkedin_identifier || undefined,
+            targetLinkedInIdentifier: job.internal_identifier_acoa,
+            mappingJobDetails,
+            linkedinRelationshipsCount,
+        };
+    }
+    catch (error) {
+        console.error("Error getting on-demand mapping job with status:", error);
+        throw error;
+    }
+}
+/**
+ * Update the mapping job ID for an on-demand mapping job
+ */
+async function updateOnDemandMappingJobId(requesterLinkedinAccountId, internalIdentifierAcoa, mappingJobId) {
+    (0, db_1.debugLogDbOperation)("update", "monitoring.on_demand_mapping_jobs", { requesterLinkedinAccountId, internalIdentifierAcoa, mappingJobId }, undefined, {
+        operation: "updateOnDemandMappingJobId",
+        requesterLinkedinAccountId,
+        internalIdentifierAcoa,
+        mappingJobId,
+    });
+    try {
+        const db = await database_service_1.dbService.getDb();
+        const sql = `
+      UPDATE monitoring.on_demand_mapping_jobs
+      SET mapping_job_id = $1, updated_at = NOW()
+      WHERE requester_linkedin_account_id = $2 AND internal_identifier_acoa = $3
+      RETURNING id, requester_linkedin_account_id, internal_identifier_acoa, mapping_job_id, metadata, created_at, updated_at
+    `;
+        const updatedJob = await (0, pg_client_1.queryOne)(db, sql, [mappingJobId, requesterLinkedinAccountId, internalIdentifierAcoa]);
+        if (!updatedJob) {
+            throw new Error(`On-demand mapping job for requester ${requesterLinkedinAccountId} and target ${internalIdentifierAcoa} not found`);
+        }
+        return {
+            id: updatedJob.id,
+            requesterLinkedinAccountId: updatedJob.requester_linkedin_account_id,
+            internalIdentifierAcoa: updatedJob.internal_identifier_acoa,
+            mappingJobId: updatedJob.mapping_job_id,
+            metadata: updatedJob.metadata,
+            createdAt: updatedJob.created_at,
+            updatedAt: updatedJob.updated_at,
+        };
+    }
+    catch (error) {
+        console.error("Error updating on-demand mapping job ID:", error);
+        throw error;
+    }
+}
+/**
+ * Get minimal on-demand mapping jobs for Chrome extension with pagination
+ * Excludes large metadata blocks to reduce response size
+ * Includes self-targeting jobs (where requester maps themselves)
+ */
+async function getOnDemandMappingJobsMinimal(db, requesterLinkedinAccountId, limit = 50, offset = 0) {
+    (0, db_1.debugLogDbOperation)("select", "monitoring.on_demand_mapping_jobs (minimal with pagination)", { requesterLinkedinAccountId, limit, offset }, undefined, {
+        operation: "getOnDemandMappingJobsMinimal",
+        requesterLinkedinAccountId,
+    });
+    try {
+        // Get the total count (including self-targeting jobs)
+        const countSql = `
+      SELECT COUNT(*) as count FROM monitoring.on_demand_mapping_jobs
+      WHERE requester_linkedin_account_id = $1
+    `;
+        const totalCountResult = await (0, pg_client_1.queryOne)(db, countSql, [
+            requesterLinkedinAccountId,
+        ]);
+        const total_items = parseInt(totalCountResult?.count || "0");
+        // Get paginated on-demand jobs for the requester with minimal data
+        const jobsSql = `
+      SELECT id, requester_linkedin_account_id, internal_identifier_acoa, mapping_job_id, created_at, updated_at
+      FROM monitoring.on_demand_mapping_jobs
+      WHERE requester_linkedin_account_id = $1
+      ORDER BY created_at DESC
+      LIMIT $2 OFFSET $3
+    `;
+        const jobs = await (0, pg_client_1.query)(db, jobsSql, [requesterLinkedinAccountId, limit, offset]);
+        // Get minimal status for each job
+        const jobsWithMinimalStatus = await Promise.all(jobs.map(async (job) => {
+            let status = "pending";
+            let progress = 0;
+            let mappingJobDetails;
+            let linkedinRelationshipsCount;
+            if (job.mapping_job_id) {
+                // Get minimal mapping job details (no large metadata)
+                const mappingJobSql = `
+            SELECT id, created_at, queued_at, started_at, completed_at, metadata
+            FROM monitoring.mapping_jobs
+            WHERE id = $1
+            LIMIT 1
+          `;
+                const mappingJob = await (0, pg_client_1.queryOne)(db, mappingJobSql, [job.mapping_job_id]);
+                if (mappingJob) {
+                    // Determine status from mapping job timestamps, not metadata
+                    // Mapping jobs don't store status in metadata - it's determined by timestamps
+                    if (mappingJob.completed_at) {
+                        status = "completed";
+                        progress = 100;
+                    }
+                    else if (mappingJob.started_at) {
+                        status = "processing";
+                        progress = 50; // Estimate 50% when started
+                    }
+                    else if (mappingJob.queued_at) {
+                        status = "queued";
+                        progress = 10; // Estimate 10% when queued
+                    }
+                    else {
+                        status = "pending";
+                        progress = 0;
+                    }
+                    // Only include timing info, no large metadata blocks
+                    mappingJobDetails = {
+                        createdAt: mappingJob.created_at,
+                        queuedAt: mappingJob.queued_at || undefined,
+                        startedAt: mappingJob.started_at || undefined,
+                        completedAt: mappingJob.completed_at || undefined,
+                    };
+                    // Get relationship scores count if completed
+                    if (status === "completed") {
+                        const scores = await getRelationshipScoresForOnDemandJob(job.requester_linkedin_account_id, job.internal_identifier_acoa);
+                        linkedinRelationshipsCount = scores.length.toString();
+                    }
+                }
+            }
+            // Get organization assignment job status if mapping job is completed
+            let organizationAssignmentStatus = null;
+            let organizationAssignmentJobDetails = null;
+            let organizations = null;
+            if (status === "completed" && job.mapping_job_id) {
+                try {
+                    // Query ALL organization assignment jobs for this mapping job (can be multiple)
+                    const orgAssignmentSql = `
+              SELECT 
+                oaj.id, 
+                oaj.created_at, 
+                oaj.started_at, 
+                oaj.completed_at,
+                oaj.organization_id,
+                o.name as organization_name,
+                o.workspace_type
+              FROM monitoring.organization_assignment_jobs oaj
+              INNER JOIN public.organizations o ON oaj.organization_id = o.id
+              WHERE oaj.mapping_job_id = $1
+              ORDER BY oaj.created_at DESC
+            `;
+                    const orgAssignmentJobs = await (0, pg_client_1.query)(db, orgAssignmentSql, [job.mapping_job_id]);
+                    if (orgAssignmentJobs && orgAssignmentJobs.length > 0) {
+                        // Get the most recent organization assignment job for status
+                        const latestOrgAssignmentJob = orgAssignmentJobs[0];
+                        // Determine status based on latest job
+                        if (latestOrgAssignmentJob.completed_at) {
+                            organizationAssignmentStatus = "completed";
+                        }
+                        else if (latestOrgAssignmentJob.started_at) {
+                            organizationAssignmentStatus = "processing";
+                        }
+                        else {
+                            organizationAssignmentStatus = "queued";
+                        }
+                        // Use the latest job for details
+                        organizationAssignmentJobDetails = {
+                            id: latestOrgAssignmentJob.id,
+                            createdAt: latestOrgAssignmentJob.created_at,
+                            startedAt: latestOrgAssignmentJob.started_at || undefined,
+                            completedAt: latestOrgAssignmentJob.completed_at || undefined,
+                        };
+                        // Collect all unique organizations this job was exported to
+                        const uniqueOrgs = new Map();
+                        for (const orgJob of orgAssignmentJobs) {
+                            if (!uniqueOrgs.has(orgJob.organization_id)) {
+                                uniqueOrgs.set(orgJob.organization_id, {
+                                    id: orgJob.organization_id,
+                                    name: orgJob.organization_name,
+                                    workspaceType: orgJob.workspace_type,
+                                });
+                            }
+                        }
+                        organizations = Array.from(uniqueOrgs.values()).map(org => ({
+                            id: org.id,
+                            name: org.name,
+                            workspaceType: org.workspaceType,
+                        }));
+                    }
+                    else {
+                        // Mapping job completed but no organization assignment job yet
+                        organizationAssignmentStatus = "pending";
+                    }
+                }
+                catch (orgAssignmentError) {
+                    // If organization assignment job query fails, log but continue
+                    console.warn("Failed to fetch organization assignment job:", orgAssignmentError);
+                    // If mapping job is completed but we can't find org assignment job, assume pending
+                    if (status === "completed") {
+                        organizationAssignmentStatus = "pending";
+                    }
+                }
+            }
+            // Fetch profile details for the target LinkedIn identifier
+            // internal_identifier_acoa contains the ACoA identifier, we need to get the public identifier
+            let targetLinkedInIdentifier = job.internal_identifier_acoa; // Fallback to ACoA if public not found
+            let targetProfile = null;
+            try {
+                const profileSql = `
+            SELECT first_name, last_name,
+              COALESCE(profile_image_cloudfront_url, profile_picture_url) as profile_picture_url,
+              headline,
+              public_identifier
+            FROM linkedin.accounts
+            WHERE linkedin_identifier_acoa = $1
+            LIMIT 1
+          `;
+                const profile = await (0, pg_client_1.queryOne)(db, profileSql, [job.internal_identifier_acoa]);
+                // Use public identifier for display if available, otherwise fallback to ACoA
+                if (profile?.public_identifier) {
+                    targetLinkedInIdentifier = profile.public_identifier;
+                }
+                if (profile) {
+                    // Get current position from work experience
+                    let currentPosition = null;
+                    let currentCompany = null;
+                    try {
+                        const workExpSql = `
+                SELECT we.position, we.company, we.start_date, we.end_date, we.is_current
+                FROM linkedin.work_experience we
+                INNER JOIN linkedin.accounts la ON we.linkedin_account_id = la.id
+                WHERE la.linkedin_identifier_acoa = $1 AND we.is_current = true
+                ORDER BY we.start_date DESC
+                LIMIT 1
+              `;
+                        const currentWork = await (0, pg_client_1.queryOne)(db, workExpSql, [job.internal_identifier_acoa]);
+                        if (currentWork) {
+                            currentPosition = currentWork.position || null;
+                            currentCompany = currentWork.company || null;
+                        }
+                    }
+                    catch (workError) {
+                        // If work experience fetch fails, continue without it
+                        console.warn("Failed to fetch work experience for profile:", workError);
+                    }
+                    targetProfile = {
+                        name: `${profile.first_name || ""} ${profile.last_name || ""}`.trim() || "Unknown User",
+                        profileImageUrl: profile.profile_picture_url || null,
+                        position: currentPosition,
+                        currentCompany: currentCompany,
+                        headline: profile.headline || null,
+                    };
+                }
+            }
+            catch (profileError) {
+                // If profile fetch fails, continue without profile details
+                console.warn("Failed to fetch profile details:", profileError);
+            }
+            const minimalJob = {
+                id: job.id,
+                requesterLinkedinAccountId: job.requester_linkedin_account_id,
+                internalIdentifierAcoa: job.internal_identifier_acoa,
+                mappingJobId: job.mapping_job_id,
+                createdAt: job.created_at,
+                updatedAt: job.updated_at,
+                status,
+                progress,
+                targetLinkedInIdentifier,
+                mappingJobDetails,
+                linkedinRelationshipsCount,
+                organizationAssignmentStatus: organizationAssignmentStatus ?? null,
+                organizationAssignmentJobDetails: organizationAssignmentJobDetails ?? null,
+                organizations: organizations ?? null,
+                targetProfile,
+            };
+            return minimalJob;
+        }));
+        return {
+            jobs: jobsWithMinimalStatus,
+            total_items,
+        };
+    }
+    catch (error) {
+        console.error("Error getting minimal on-demand mapping jobs:", error);
+        throw error;
+    }
+}
+/**
+ * Get pending on-demand mapping jobs (no mapping job assigned yet)
+ */
+async function getPendingOnDemandMappingJobs(options) {
+    const { limit = 100 } = options || {};
+    (0, db_1.debugLogDbOperation)("select", "monitoring.on_demand_mapping_jobs", { limit, status: "pending" }, undefined, {
+        operation: "getPendingOnDemandMappingJobs",
+    });
+    try {
+        const db = await database_service_1.dbService.getDb();
+        const sql = `
+      SELECT id, requester_linkedin_account_id, internal_identifier_acoa, mapping_job_id, metadata, created_at, updated_at
+      FROM monitoring.on_demand_mapping_jobs
+      WHERE mapping_job_id IS NULL
+      ORDER BY created_at
+      LIMIT $1
+    `;
+        const results = await (0, pg_client_1.query)(db, sql, [limit]);
+        return results.map(r => ({
+            id: r.id,
+            requesterLinkedinAccountId: r.requester_linkedin_account_id,
+            internalIdentifierAcoa: r.internal_identifier_acoa,
+            mappingJobId: r.mapping_job_id,
+            metadata: r.metadata,
+            createdAt: r.created_at,
+            updatedAt: r.updated_at,
+        }));
+    }
+    catch (error) {
+        console.error("Error getting pending on-demand mapping jobs:", error);
+        throw error;
+    }
+}
+// =============================================================================
+// UTILITY FUNCTIONS
+// =============================================================================
+/**
+ * Check if an on-demand mapping job exists for the given parameters
+ */
+async function checkOnDemandMappingJobExists(requesterLinkedinAccountId, internalIdentifierAcoa) {
+    (0, db_1.debugLogDbOperation)("select", "monitoring.on_demand_mapping_jobs", { requesterLinkedinAccountId, internalIdentifierAcoa }, undefined, {
+        operation: "checkOnDemandMappingJobExists",
+    });
+    try {
+        const db = await database_service_1.dbService.getDb();
+        const sql = `
+      SELECT id, requester_linkedin_account_id, internal_identifier_acoa, mapping_job_id, metadata, created_at, updated_at
+      FROM monitoring.on_demand_mapping_jobs
+      WHERE requester_linkedin_account_id = $1 AND internal_identifier_acoa = $2
+      LIMIT 1
+    `;
+        const result = await (0, pg_client_1.queryOne)(db, sql, [requesterLinkedinAccountId, internalIdentifierAcoa]);
+        if (!result)
+            return null;
+        return {
+            id: result.id,
+            requesterLinkedinAccountId: result.requester_linkedin_account_id,
+            internalIdentifierAcoa: result.internal_identifier_acoa,
+            mappingJobId: result.mapping_job_id,
+            metadata: result.metadata,
+            createdAt: result.created_at,
+            updatedAt: result.updated_at,
+        };
+    }
+    catch (error) {
+        console.error("Error checking on-demand mapping job exists:", error);
+        throw error;
+    }
+}
+/**
+ * Get or create an on-demand mapping job
+ */
+async function getOrCreateOnDemandMappingJob(params) {
+    try {
+        // Check if job already exists
+        const existingJob = await checkOnDemandMappingJobExists(params.requesterLinkedinAccountId, params.internalIdentifierAcoa);
+        if (existingJob) {
+            return { onDemandJob: existingJob, wasCreated: false };
+        }
+        // Create new job
+        const newJob = await createOnDemandMappingJob(params);
+        return { onDemandJob: newJob, wasCreated: true };
+    }
+    catch (error) {
+        console.error("Error getting or creating on-demand mapping job:", error);
+        throw error;
+    }
+}
+/**
+ * Get target LinkedIn account ID for on-demand mapping job in an organization
+ *
+ * For on-demand mapping jobs, relationships are mapped for the TARGET but assigned
+ * to the REQUESTER's personal workspace. This function helps identify which account
+ * to use when querying relationships (the target's account, not the requester's).
+ *
+ * @param db - Database instance
+ * @param requesterLinkedinAccountId - The requester's LinkedIn account ID
+ * @param organizationId - The organization ID (personal workspace)
+ * @returns Target LinkedIn account ID if on-demand job exists, null otherwise
+ */
+async function getTargetLinkedInAccountIdForOnDemandJobInOrganization(db, requesterLinkedinAccountId, organizationId) {
+    (0, db_1.debugLogDbOperation)("select", "monitoring.on_demand_mapping_jobs + organization_assignment_jobs", { requesterLinkedinAccountId, organizationId }, undefined, {
+        operation: "getTargetLinkedInAccountIdForOnDemandJobInOrganization",
+        requesterLinkedinAccountId,
+        organizationId,
+    });
+    try {
+        const sql = `
+      SELECT 
+        la_target.id as target_linkedin_account_id
+      FROM monitoring.on_demand_mapping_jobs od
+      INNER JOIN monitoring.organization_assignment_jobs oaj 
+        ON oaj.mapping_job_id = od.mapping_job_id
+      INNER JOIN linkedin.accounts la_target 
+        ON la_target.linkedin_identifier_acoa = od.internal_identifier_acoa
+      WHERE 
+        od.requester_linkedin_account_id = $1
+        AND oaj.organization_id = $2
+        AND od.mapping_job_id IS NOT NULL
+      ORDER BY od.created_at DESC
+      LIMIT 1
+    `;
+        const result = await (0, pg_client_1.queryOne)(db, sql, [requesterLinkedinAccountId, organizationId]);
+        return result?.target_linkedin_account_id || null;
+    }
+    catch (error) {
+        console.error("Error getting target LinkedIn account ID for on-demand job:", error);
+        throw error;
+    }
+}
+async function deleteOnDemandMappingJob(requesterLinkedinAccountId, internalIdentifierAcoa) {
+    (0, db_1.debugLogDbOperation)("delete", "monitoring.on_demand_mapping_jobs", { requesterLinkedinAccountId, internalIdentifierAcoa }, undefined, {
+        operation: "deleteOnDemandMappingJob",
+        requesterLinkedinAccountId,
+        internalIdentifierAcoa,
+    });
+    try {
+        const db = await database_service_1.dbService.getDb();
+        const sql = `
+      DELETE FROM monitoring.on_demand_mapping_jobs
+      WHERE requester_linkedin_account_id = $1 AND internal_identifier_acoa = $2
+      RETURNING id
+    `;
+        const result = await (0, pg_client_1.query)(db, sql, [
+            requesterLinkedinAccountId,
+            internalIdentifierAcoa,
+        ]);
+        return result.length > 0;
+    }
+    catch (error) {
+        console.error("Error deleting on-demand mapping job:", error);
+        throw error;
+    }
+}
+/**
+ * Get relationship scores for an on-demand mapping job
+ */
+async function getRelationshipScoresForOnDemandJob(requesterLinkedinAccountId, internalIdentifierAcoa, options) {
+    const { limit = 50, minScore } = options || {};
+    (0, db_1.debugLogDbOperation)("select", "linkedin.relationships", { requesterLinkedinAccountId, internalIdentifierAcoa, limit, minScore }, undefined, {
+        operation: "getRelationshipScoresForOnDemandJob",
+        requesterLinkedinAccountId,
+        internalIdentifierAcoa,
+    });
+    try {
+        // Get the on-demand job to find the mapping job ID
+        const onDemandJob = await getOnDemandMappingJob(requesterLinkedinAccountId, internalIdentifierAcoa);
+        if (!onDemandJob || !onDemandJob.mappingJobId) {
+            return [];
+        }
+        const db = await database_service_1.dbService.getDb();
+        let sql = `
+      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
+    `;
+        const params = [onDemandJob.mappingJobId];
+        if (minScore !== undefined) {
+            sql += ` AND score >= $2`;
+            params.push(minScore);
+        }
+        sql += ` ORDER BY score DESC LIMIT $${params.length + 1}`;
+        params.push(limit);
+        const results = await (0, pg_client_1.query)(db, sql, params);
+        return results;
+    }
+    catch (error) {
+        console.error("Error getting relationship scores for on-demand job:", error);
+        throw error;
+    }
+}
+//# sourceMappingURL=on-demand-mapping-operations.js.map