eggi-ai-db-schema-2 12.54.2

package/dist/utils/organization-assignment-job-operations.js

@@ -0,0 +1,881 @@
+"use strict";
+/**
+ * Organization Assignment Job Operations
+ *
+ * This module provides functions for managing organization assignment job lifecycle.
+ * These jobs track when the organization_assignments_handler Lambda processes
+ * contributor and relationship assignments to organizations.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createOrganizationAssignmentJob = createOrganizationAssignmentJob;
+exports.completeOrganizationAssignmentJob = completeOrganizationAssignmentJob;
+exports.updateOrganizationAssignmentJobMetadata = updateOrganizationAssignmentJobMetadata;
+exports.getOrganizationAssignmentJobsForMappingJob = getOrganizationAssignmentJobsForMappingJob;
+exports.getOrganizationAssignmentJobsForOrganization = getOrganizationAssignmentJobsForOrganization;
+exports.getPendingOrganizationAssignmentJobs = getPendingOrganizationAssignmentJobs;
+exports.getOrganizationAssignmentJobById = getOrganizationAssignmentJobById;
+exports.getLatestOrganizationAssignmentJob = getLatestOrganizationAssignmentJob;
+exports.getLatestOrganizationAssignmentJobForUser = getLatestOrganizationAssignmentJobForUser;
+exports.checkExportAvailability = checkExportAvailability;
+exports.checkExportAvailabilityForLinkedInAccount = checkExportAvailabilityForLinkedInAccount;
+exports.getUserExports = getUserExports;
+exports.getExportStatusByLinkedInIdentifier = getExportStatusByLinkedInIdentifier;
+exports.validateOrganizationAssignmentJobCompletion = validateOrganizationAssignmentJobCompletion;
+exports.deleteOrganizationAssignmentJob = deleteOrganizationAssignmentJob;
+const pg_client_1 = require("../lib/pg-client");
+const db_1 = require("../lib/db");
+// =============================================================================
+// CREATE OPERATIONS
+// =============================================================================
+/**
+ * Create a new organization assignment job record
+ * Called when the organization_assignments_handler Lambda starts processing
+ *
+ * @param db - Database instance
+ * @param params - Job parameters
+ * @returns The created job record
+ */
+async function createOrganizationAssignmentJob(db, params) {
+    const { mappingJobId, organizationId, jobMetadata = {} } = params;
+    (0, db_1.debugLogDbOperation)("insert", "organization_assignment_jobs", { mappingJobId, organizationId }, undefined, { operation: "createOrganizationAssignmentJob" });
+    const sql = `
+    INSERT INTO monitoring.organization_assignment_jobs (mapping_job_id, organization_id, metadata, created_at)
+    VALUES ($1, $2, $3, NOW())
+    RETURNING id, mapping_job_id, organization_id, metadata, created_at, completed_at
+  `;
+    const job = await (0, pg_client_1.queryOne)(db, sql, [mappingJobId, organizationId, JSON.stringify(jobMetadata)]);
+    if (!job) {
+        throw new Error("Failed to create organization assignment job");
+    }
+    return {
+        id: job.id,
+        mappingJobId: job.mapping_job_id,
+        organizationId: job.organization_id,
+        metadata: job.metadata,
+        createdAt: job.created_at,
+        completedAt: job.completed_at,
+    };
+}
+// =============================================================================
+// LIFECYCLE MANAGEMENT
+// =============================================================================
+/**
+ * Mark an organization assignment job as completed
+ * Updates completed_at timestamp and stores final statistics
+ *
+ * @param db - Database instance
+ * @param organizationAssignmentJobId - Job ID
+ * @param completionMetadata - Final job statistics
+ * @returns Updated job record
+ */
+async function completeOrganizationAssignmentJob(db, organizationAssignmentJobId, completionMetadata) {
+    (0, db_1.debugLogDbOperation)("update", "organization_assignment_jobs", { organizationAssignmentJobId }, undefined, { operation: "completeOrganizationAssignmentJob" });
+    const updates = ["completed_at = NOW()"];
+    const params = [organizationAssignmentJobId];
+    if (completionMetadata) {
+        updates.push("metadata = $2");
+        params.push(JSON.stringify(completionMetadata));
+    }
+    const sql = `
+    UPDATE monitoring.organization_assignment_jobs
+    SET ${updates.join(", ")}
+    WHERE id = $1
+    RETURNING id, mapping_job_id, organization_id, metadata, created_at, completed_at
+  `;
+    const job = await (0, pg_client_1.queryOne)(db, sql, params);
+    if (!job) {
+        throw new Error(`Organization assignment job ${organizationAssignmentJobId} not found`);
+    }
+    return {
+        id: job.id,
+        mappingJobId: job.mapping_job_id,
+        organizationId: job.organization_id,
+        metadata: job.metadata,
+        createdAt: job.created_at,
+        completedAt: job.completed_at,
+    };
+}
+/**
+ * Update job metadata (for incremental statistics during processing)
+ *
+ * @param db - Database instance
+ * @param organizationAssignmentJobId - Job ID
+ * @param metadata - Updated metadata
+ * @returns Updated job record
+ */
+async function updateOrganizationAssignmentJobMetadata(db, organizationAssignmentJobId, metadata) {
+    (0, db_1.debugLogDbOperation)("update", "organization_assignment_jobs", { organizationAssignmentJobId }, undefined, { operation: "updateOrganizationAssignmentJobMetadata" });
+    const sql = `
+    UPDATE monitoring.organization_assignment_jobs
+    SET metadata = $1
+    WHERE id = $2
+    RETURNING id, mapping_job_id, organization_id, metadata, created_at, completed_at
+  `;
+    const job = await (0, pg_client_1.queryOne)(db, sql, [JSON.stringify(metadata), organizationAssignmentJobId]);
+    if (!job) {
+        throw new Error(`Organization assignment job ${organizationAssignmentJobId} not found`);
+    }
+    return {
+        id: job.id,
+        mappingJobId: job.mapping_job_id,
+        organizationId: job.organization_id,
+        metadata: job.metadata,
+        createdAt: job.created_at,
+        completedAt: job.completed_at,
+    };
+}
+// =============================================================================
+// QUERY OPERATIONS
+// =============================================================================
+/**
+ * Get all organization assignment jobs for a specific mapping job
+ *
+ * @param db - Database instance
+ * @param mappingJobId - Mapping job ID
+ * @param options - Query options
+ * @returns Array of organization assignment jobs
+ */
+async function getOrganizationAssignmentJobsForMappingJob(db, mappingJobId, options = {}) {
+    const { limit = 100, onlyCompleted = false } = options;
+    (0, db_1.debugLogDbOperation)("select", "organization_assignment_jobs", { mappingJobId, limit, onlyCompleted }, undefined, { operation: "getOrganizationAssignmentJobsForMappingJob" });
+    const whereClause = onlyCompleted
+        ? "WHERE mapping_job_id = $1 AND completed_at IS NOT NULL"
+        : "WHERE mapping_job_id = $1";
+    const sql = `
+    SELECT id, mapping_job_id, organization_id, metadata, created_at, completed_at
+    FROM monitoring.organization_assignment_jobs
+    ${whereClause}
+    ORDER BY created_at DESC
+    LIMIT $2
+  `;
+    const results = await (0, pg_client_1.query)(db, sql, [mappingJobId, limit]);
+    return results.map(r => ({
+        id: r.id,
+        mappingJobId: r.mapping_job_id,
+        organizationId: r.organization_id,
+        metadata: r.metadata,
+        createdAt: r.created_at,
+        completedAt: r.completed_at,
+    }));
+}
+/**
+ * Get all organization assignment jobs for a specific organization
+ *
+ * @param db - Database instance
+ * @param organizationId - Organization ID
+ * @param options - Query options
+ * @returns Array of organization assignment jobs
+ */
+async function getOrganizationAssignmentJobsForOrganization(db, organizationId, options = {}) {
+    const { limit = 100, onlyCompleted = false } = options;
+    (0, db_1.debugLogDbOperation)("select", "organization_assignment_jobs", { organizationId, limit, onlyCompleted }, undefined, { operation: "getOrganizationAssignmentJobsForOrganization" });
+    const whereClause = onlyCompleted
+        ? "WHERE organization_id = $1 AND completed_at IS NOT NULL"
+        : "WHERE organization_id = $1";
+    const sql = `
+    SELECT id, mapping_job_id, organization_id, metadata, created_at, completed_at
+    FROM monitoring.organization_assignment_jobs
+    ${whereClause}
+    ORDER BY created_at DESC
+    LIMIT $2
+  `;
+    const results = await (0, pg_client_1.query)(db, sql, [organizationId, limit]);
+    return results.map(r => ({
+        id: r.id,
+        mappingJobId: r.mapping_job_id,
+        organizationId: r.organization_id,
+        metadata: r.metadata,
+        createdAt: r.created_at,
+        completedAt: r.completed_at,
+    }));
+}
+/**
+ * Get pending organization assignment jobs (not completed)
+ *
+ * @param db - Database instance
+ * @param options - Query options
+ * @returns Array of pending jobs
+ */
+async function getPendingOrganizationAssignmentJobs(db, options = {}) {
+    const { limit = 100 } = options;
+    (0, db_1.debugLogDbOperation)("select", "organization_assignment_jobs", { limit }, undefined, {
+        operation: "getPendingOrganizationAssignmentJobs",
+    });
+    const sql = `
+    SELECT id, mapping_job_id, organization_id, metadata, created_at, completed_at
+    FROM monitoring.organization_assignment_jobs
+    WHERE completed_at IS NULL
+    ORDER BY created_at DESC
+    LIMIT $1
+  `;
+    const results = await (0, pg_client_1.query)(db, sql, [limit]);
+    return results.map(r => ({
+        id: r.id,
+        mappingJobId: r.mapping_job_id,
+        organizationId: r.organization_id,
+        metadata: r.metadata,
+        createdAt: r.created_at,
+        completedAt: r.completed_at,
+    }));
+}
+/**
+ * Get a specific organization assignment job by ID
+ *
+ * @param db - Database instance
+ * @param organizationAssignmentJobId - Job ID
+ * @returns Job record or null if not found
+ */
+async function getOrganizationAssignmentJobById(db, organizationAssignmentJobId) {
+    (0, db_1.debugLogDbOperation)("select", "organization_assignment_jobs", { organizationAssignmentJobId }, undefined, { operation: "getOrganizationAssignmentJobById" });
+    const sql = `
+    SELECT id, mapping_job_id, organization_id, metadata, created_at, completed_at
+    FROM monitoring.organization_assignment_jobs
+    WHERE id = $1
+    LIMIT 1
+  `;
+    const job = await (0, pg_client_1.queryOne)(db, sql, [organizationAssignmentJobId]);
+    if (!job)
+        return null;
+    return {
+        id: job.id,
+        mappingJobId: job.mapping_job_id,
+        organizationId: job.organization_id,
+        metadata: job.metadata,
+        createdAt: job.created_at,
+        completedAt: job.completed_at,
+    };
+}
+/**
+ * Get the latest organization assignment job for a specific organization and mapping job
+ *
+ * @param db - Database instance
+ * @param mappingJobId - Mapping job ID
+ * @param organizationId - Organization ID
+ * @returns Latest job record or null if not found
+ */
+async function getLatestOrganizationAssignmentJob(db, mappingJobId, organizationId) {
+    (0, db_1.debugLogDbOperation)("select", "organization_assignment_jobs", { mappingJobId, organizationId }, undefined, { operation: "getLatestOrganizationAssignmentJob" });
+    const sql = `
+    SELECT id, mapping_job_id, organization_id, metadata, created_at, started_at, completed_at
+    FROM monitoring.organization_assignment_jobs
+    WHERE mapping_job_id = $1 AND organization_id = $2
+    ORDER BY created_at DESC
+    LIMIT 1
+  `;
+    const job = await (0, pg_client_1.queryOne)(db, sql, [mappingJobId, organizationId]);
+    if (!job)
+        return null;
+    return {
+        id: job.id,
+        mappingJobId: job.mapping_job_id,
+        organizationId: job.organization_id,
+        metadata: job.metadata,
+        createdAt: job.created_at,
+        completedAt: job.completed_at,
+    };
+}
+/**
+ * Get the latest organization assignment job for a user in an organization
+ *
+ * Finds the most recent organization assignment job for a user by joining
+ * through mapping_jobs and linkedin_accounts to find the user's mapping job.
+ *
+ * @param db - Database instance
+ * @param userId - User ID
+ * @param organizationId - Organization ID
+ * @returns Latest organization assignment job or null if not found
+ */
+async function getLatestOrganizationAssignmentJobForUser(db, userId, organizationId) {
+    (0, db_1.debugLogDbOperation)("select", "organization_assignment_jobs", { userId, organizationId }, undefined, { operation: "getLatestOrganizationAssignmentJobForUser" });
+    const sql = `
+    SELECT 
+      oaj.id,
+      oaj.mapping_job_id,
+      oaj.organization_id,
+      oaj.metadata,
+      oaj.created_at,
+      oaj.completed_at
+    FROM monitoring.organization_assignment_jobs oaj
+    INNER JOIN monitoring.mapping_jobs mj ON mj.id = oaj.mapping_job_id
+    INNER JOIN linkedin.accounts la ON la.id = mj.linkedin_account_id
+    WHERE la.user_id = $1 AND oaj.organization_id = $2
+    ORDER BY oaj.created_at DESC
+    LIMIT 1
+  `;
+    const job = await (0, pg_client_1.queryOne)(db, sql, [userId, organizationId]);
+    if (!job)
+        return null;
+    return {
+        id: job.id,
+        mappingJobId: job.mapping_job_id,
+        organizationId: job.organization_id,
+        metadata: job.metadata,
+        createdAt: job.created_at,
+        completedAt: job.completed_at,
+    };
+}
+async function checkExportAvailability(db, mappingJobId, organizationId) {
+    (0, db_1.debugLogDbOperation)("select", "organization_assignment_jobs", { mappingJobId, organizationId }, undefined, { operation: "checkExportAvailability" });
+    // If mapping job is not completed, export is not available
+    if (!mappingJobId) {
+        // Get organization name
+        const orgSql = `
+      SELECT name
+      FROM public.organizations
+      WHERE id = $1
+    `;
+        const org = await (0, pg_client_1.queryOne)(db, orgSql, [
+            organizationId,
+        ]).catch(() => null);
+        return {
+            can_export: false,
+            is_exported: false,
+            export_status: "not_available",
+            organization_id: organizationId,
+            organization_name: org?.name || null,
+            on_demand_mapping_job_id: null,
+        };
+    }
+    try {
+        // Get organization name
+        const orgSql = `
+      SELECT name
+      FROM public.organizations
+      WHERE id = $1
+    `;
+        const org = await (0, pg_client_1.queryOne)(db, orgSql, [
+            organizationId,
+        ]).catch(() => null);
+        const organizationName = org?.name || null;
+        const sql = `
+      SELECT 
+        oaj.id,
+        oaj.created_at,
+        oaj.started_at,
+        oaj.completed_at
+      FROM monitoring.organization_assignment_jobs oaj
+      WHERE oaj.mapping_job_id = $1
+        AND oaj.organization_id = $2
+      ORDER BY oaj.created_at DESC
+      LIMIT 1
+    `;
+        const exportJob = await (0, pg_client_1.queryOne)(db, sql, [mappingJobId, organizationId]);
+        if (exportJob) {
+            // Already exported or in progress
+            const orgAssignmentJobDetails = {
+                id: exportJob.id,
+                created_at: exportJob.created_at,
+                started_at: exportJob.started_at,
+                completed_at: exportJob.completed_at,
+            };
+            // Find the on-demand mapping job for this mapping job
+            const onDemandJobSql = `
+        SELECT odmj.id
+        FROM monitoring.on_demand_mapping_jobs odmj
+        WHERE odmj.mapping_job_id = $1
+        ORDER BY odmj.created_at DESC
+        LIMIT 1
+      `;
+            const onDemandJob = await (0, pg_client_1.queryOne)(db, onDemandJobSql, [
+                mappingJobId,
+            ]).catch(() => null);
+            if (exportJob.completed_at) {
+                return {
+                    can_export: false,
+                    is_exported: true,
+                    export_status: "exported",
+                    organization_id: organizationId,
+                    organization_name: organizationName,
+                    on_demand_mapping_job_id: onDemandJob?.id || null,
+                    org_assignment_job: orgAssignmentJobDetails,
+                };
+            }
+            else {
+                // In progress (started or queued)
+                return {
+                    can_export: false,
+                    is_exported: false,
+                    export_status: "exporting",
+                    organization_id: organizationId,
+                    organization_name: organizationName,
+                    on_demand_mapping_job_id: onDemandJob?.id || null,
+                    org_assignment_job: orgAssignmentJobDetails,
+                };
+            }
+        }
+        else {
+            // Not exported yet, can export
+            // Find the on-demand mapping job for this mapping job
+            const onDemandJobSql = `
+        SELECT odmj.id
+        FROM monitoring.on_demand_mapping_jobs odmj
+        WHERE odmj.mapping_job_id = $1
+        ORDER BY odmj.created_at DESC
+        LIMIT 1
+      `;
+            const onDemandJob = await (0, pg_client_1.queryOne)(db, onDemandJobSql, [
+                mappingJobId,
+            ]).catch(() => null);
+            // Get LinkedIn identifier (ACoA) for direct export if no on-demand job exists
+            let linkedinIdentifierAcoa = null;
+            if (!onDemandJob) {
+                const linkedinAccountSql = `
+          SELECT la.linkedin_identifier_acoa
+          FROM linkedin.accounts la
+          INNER JOIN monitoring.mapping_jobs mj ON la.id = mj.linkedin_account_id
+          WHERE mj.id = $1
+          LIMIT 1
+        `;
+                const linkedinAccount = await (0, pg_client_1.queryOne)(db, linkedinAccountSql, [mappingJobId]).catch(() => null);
+                linkedinIdentifierAcoa = linkedinAccount?.linkedin_identifier_acoa || null;
+            }
+            return {
+                can_export: true,
+                is_exported: false,
+                export_status: "not_exported",
+                organization_id: organizationId,
+                organization_name: organizationName,
+                on_demand_mapping_job_id: onDemandJob?.id || null,
+                mapping_job_id: mappingJobId, // Always include mapping job ID
+                linkedin_identifier_acoa: linkedinIdentifierAcoa, // Include ACoA for direct export
+                org_assignment_job: null,
+            };
+        }
+    }
+    catch (error) {
+        console.error("Error checking export availability:", error);
+        // On error, assume not available
+        return {
+            can_export: false,
+            is_exported: false,
+            export_status: "not_available",
+            organization_id: organizationId,
+            organization_name: null,
+            org_assignment_job: null,
+        };
+    }
+}
+/**
+ * Check export availability for a LinkedIn account to a specific organization
+ * This checks ALL mapping jobs for the account, not just the latest one
+ *
+ * @param db - Database instance
+ * @param linkedinAccountId - LinkedIn account ID
+ * @param organizationId - Organization ID to check
+ * @returns Export availability information
+ */
+async function checkExportAvailabilityForLinkedInAccount(db, linkedinAccountId, organizationId) {
+    (0, db_1.debugLogDbOperation)("select", "organization_assignment_jobs + mapping_jobs", { linkedinAccountId, organizationId }, undefined, { operation: "checkExportAvailabilityForLinkedInAccount" });
+    try {
+        // First, get the organization name
+        const orgSql = `
+      SELECT name
+      FROM public.organizations
+      WHERE id = $1
+    `;
+        const org = await (0, pg_client_1.queryOne)(db, orgSql, [organizationId]);
+        const organizationName = org?.name || null;
+        // Check if there's an organization assignment job for ANY mapping job
+        // of this LinkedIn account for this organization
+        const sql = `
+      SELECT 
+        oaj.id,
+        oaj.created_at,
+        oaj.started_at,
+        oaj.completed_at,
+        oaj.mapping_job_id
+      FROM monitoring.organization_assignment_jobs oaj
+      INNER JOIN monitoring.mapping_jobs mj ON oaj.mapping_job_id = mj.id
+      WHERE mj.linkedin_account_id = $1
+        AND oaj.organization_id = $2
+      ORDER BY oaj.created_at DESC
+      LIMIT 1
+    `;
+        const exportJob = await (0, pg_client_1.queryOne)(db, sql, [linkedinAccountId, organizationId]);
+        if (exportJob) {
+            // Already exported or in progress
+            const orgAssignmentJobDetails = {
+                id: exportJob.id,
+                created_at: exportJob.created_at,
+                started_at: exportJob.started_at,
+                completed_at: exportJob.completed_at,
+            };
+            if (exportJob.completed_at) {
+                return {
+                    can_export: false,
+                    is_exported: true,
+                    export_status: "exported",
+                    organization_id: organizationId,
+                    organization_name: organizationName,
+                    org_assignment_job: orgAssignmentJobDetails,
+                };
+            }
+            else {
+                // In progress (started or queued)
+                return {
+                    can_export: false,
+                    is_exported: false,
+                    export_status: "exporting",
+                    organization_id: organizationId,
+                    organization_name: organizationName,
+                    org_assignment_job: orgAssignmentJobDetails,
+                };
+            }
+        }
+        else {
+            // Check if there's a completed mapping job for this account
+            // If yes, export is available. If no, export is not available.
+            const completedJobSql = `
+        SELECT id
+        FROM monitoring.mapping_jobs
+        WHERE linkedin_account_id = $1
+          AND completed_at IS NOT NULL
+        ORDER BY completed_at DESC
+        LIMIT 1
+      `;
+            const completedJob = await (0, pg_client_1.queryOne)(db, completedJobSql, [linkedinAccountId]);
+            if (completedJob) {
+                // Not exported yet, but mapping is complete - can export
+                // Find the on-demand mapping job for this completed mapping job
+                const onDemandJobSql = `
+          SELECT odmj.id
+          FROM monitoring.on_demand_mapping_jobs odmj
+          WHERE odmj.mapping_job_id = $1
+          ORDER BY odmj.created_at DESC
+          LIMIT 1
+        `;
+                const onDemandJob = await (0, pg_client_1.queryOne)(db, onDemandJobSql, [completedJob.id]).catch(() => null);
+                // Get LinkedIn identifier (ACoA) for direct export if no on-demand job exists
+                let linkedinIdentifierAcoa = null;
+                if (!onDemandJob) {
+                    const linkedinAccountSql = `
+            SELECT la.linkedin_identifier_acoa
+            FROM linkedin.accounts la
+            WHERE la.id = $1
+            LIMIT 1
+          `;
+                    const linkedinAccount = await (0, pg_client_1.queryOne)(db, linkedinAccountSql, [linkedinAccountId]).catch(() => null);
+                    linkedinIdentifierAcoa = linkedinAccount?.linkedin_identifier_acoa || null;
+                }
+                return {
+                    can_export: true,
+                    is_exported: false,
+                    export_status: "not_exported",
+                    organization_id: organizationId,
+                    organization_name: organizationName,
+                    on_demand_mapping_job_id: onDemandJob?.id || null,
+                    mapping_job_id: completedJob.id, // Always include mapping job ID
+                    linkedin_identifier_acoa: linkedinIdentifierAcoa, // Include ACoA for direct export
+                    org_assignment_job: null,
+                };
+            }
+            else {
+                // No completed mapping job - export not available
+                return {
+                    can_export: false,
+                    is_exported: false,
+                    export_status: "not_available",
+                    organization_id: organizationId,
+                    organization_name: organizationName,
+                    on_demand_mapping_job_id: null,
+                    org_assignment_job: null,
+                };
+            }
+        }
+    }
+    catch (error) {
+        console.error("Error checking export availability for LinkedIn account:", error);
+        // On error, assume not available
+        return {
+            can_export: false,
+            is_exported: false,
+            export_status: "not_available",
+            organization_id: organizationId,
+            organization_name: null,
+            org_assignment_job: null,
+        };
+    }
+}
+async function getUserExports(db, requesterLinkedinAccountId, options = {}) {
+    const { page = 1, pageSize = 10, sort = "desc", organizationId, status = "all" } = options;
+    (0, db_1.debugLogDbOperation)("select", "organization_assignment_jobs + mapping_jobs + on_demand_mapping_jobs", {
+        requesterLinkedinAccountId,
+        page,
+        pageSize,
+        sort,
+        organizationId,
+        status,
+    }, undefined, { operation: "getUserExports" });
+    // Validate pagination
+    const limit = Math.min(Math.max(1, pageSize), 50); // Max 50 per page
+    const offset = (Math.max(1, page) - 1) * limit;
+    const orderBy = sort === "asc" ? "ASC" : "DESC";
+    // Build WHERE clause for status filter
+    let statusFilter = "";
+    if (status === "completed") {
+        statusFilter = "AND oaj.completed_at IS NOT NULL";
+    }
+    else if (status === "pending") {
+        statusFilter = "AND oaj.completed_at IS NULL AND oaj.started_at IS NOT NULL";
+    }
+    else if (status === "failed") {
+        // Failed status would need to be tracked in metadata or a separate field
+        // For now, we'll treat it as pending if not completed
+        statusFilter = "AND oaj.completed_at IS NULL";
+    }
+    // Build WHERE clause for organization filter
+    // If organizationId is provided, return all exports for that organization
+    // Otherwise, return only exports where the user is the requester
+    let orgFilter = "";
+    let requesterFilter = "";
+    let paramIndex = 1;
+    const countParams = [];
+    if (organizationId) {
+        // When organizationId is provided, return all exports for that organization
+        // (all members should see all exports to their organization)
+        orgFilter = `oaj.organization_id = $${paramIndex}`;
+        countParams.push(organizationId);
+        paramIndex++;
+    }
+    else {
+        // When organizationId is NOT provided, filter by requester (backward compatibility)
+        requesterFilter = `odmj.requester_linkedin_account_id = $${paramIndex}`;
+        countParams.push(requesterLinkedinAccountId);
+        paramIndex++;
+    }
+    const whereClause = [orgFilter, requesterFilter].filter(Boolean).join(" AND ");
+    const countSql = `
+    SELECT COUNT(DISTINCT oaj.id) as total
+    FROM monitoring.organization_assignment_jobs oaj
+    INNER JOIN monitoring.mapping_jobs mj ON oaj.mapping_job_id = mj.id
+    LEFT JOIN monitoring.on_demand_mapping_jobs odmj ON mj.id = odmj.mapping_job_id
+    WHERE ${whereClause}
+    ${statusFilter}
+  `;
+    const totalResult = await (0, pg_client_1.queryOne)(db, countSql, countParams);
+    const totalItems = totalResult?.total || 0;
+    const totalPages = Math.ceil(totalItems / limit);
+    // Get paginated exports with full details
+    // Note: current_company comes from work_experience table (most recent current position)
+    const sql = `
+    SELECT 
+      oaj.id,
+      oaj.created_at,
+      oaj.started_at,
+      oaj.completed_at,
+      oaj.mapping_job_id,
+      oaj.organization_id,
+      o.name as organization_name,
+      o.workspace_type,
+      CONCAT(COALESCE(la.first_name, ''), ' ', COALESCE(la.last_name, '')) as profile_name,
+      la.headline as profile_position,
+      we.company as current_company,
+      COALESCE(la.profile_image_cloudfront_url, la.profile_picture_url) as profile_image_url,
+      la.linkedin_identifier_acoa as linkedin_identifier,
+      CASE 
+        WHEN la.public_identifier IS NOT NULL 
+        THEN CONCAT('https://www.linkedin.com/in/', la.public_identifier)
+        ELSE NULL
+      END as linkedin_url
+    FROM monitoring.organization_assignment_jobs oaj
+    INNER JOIN monitoring.mapping_jobs mj ON oaj.mapping_job_id = mj.id
+    LEFT JOIN monitoring.on_demand_mapping_jobs odmj ON mj.id = odmj.mapping_job_id
+    INNER JOIN linkedin.accounts la ON mj.linkedin_account_id = la.id
+    INNER JOIN public.organizations o ON oaj.organization_id = o.id
+    LEFT JOIN LATERAL (
+      SELECT company
+      FROM linkedin.work_experience we
+      WHERE we.linkedin_account_id = la.id
+        AND we.is_current = true
+      ORDER BY we.start_date DESC NULLS LAST
+      LIMIT 1
+    ) we ON true
+    WHERE ${whereClause}
+    ${statusFilter}
+    ORDER BY oaj.created_at ${orderBy}
+    LIMIT $${paramIndex} OFFSET $${paramIndex + 1}
+  `;
+    const queryParams = [...countParams, limit, offset];
+    const results = await (0, pg_client_1.query)(db, sql, queryParams);
+    const exports = results.map(r => {
+        // Determine status based on completion
+        let exportStatus = "pending";
+        if (r.completed_at) {
+            exportStatus = "completed";
+        }
+        else if (r.started_at) {
+            exportStatus = "pending";
+        }
+        return {
+            id: r.id,
+            status: exportStatus,
+            created_at: r.created_at,
+            started_at: r.started_at,
+            completed_at: r.completed_at,
+            mapping_job_id: r.mapping_job_id,
+            organization: {
+                id: r.organization_id,
+                name: r.organization_name,
+                workspace_type: r.workspace_type,
+            },
+            profile: {
+                name: r.profile_name,
+                position: r.profile_position,
+                current_company: r.current_company,
+                profile_image_url: r.profile_image_url,
+                linkedin_identifier: r.linkedin_identifier,
+                linkedin_url: r.linkedin_url,
+            },
+        };
+    });
+    return {
+        exports,
+        pagination: {
+            page,
+            pageSize: limit,
+            totalItems,
+            totalPages,
+        },
+    };
+}
+/**
+ * Get export status for a specific LinkedIn identifier (ACoA) in an organization
+ * Returns full export details including profile and organization information
+ *
+ * @param db - Database instance
+ * @param linkedinIdentifierAcoa - LinkedIn ACoA identifier
+ * @param organizationId - Organization ID
+ * @returns Export status result
+ */
+async function getExportStatusByLinkedInIdentifier(db, linkedinIdentifierAcoa, organizationId) {
+    (0, db_1.debugLogDbOperation)("select", "organization_assignment_jobs + mapping_jobs + linkedin.accounts", { linkedinIdentifierAcoa, organizationId }, undefined, { operation: "getExportStatusByLinkedInIdentifier" });
+    try {
+        // Single query to get all export details
+        const sql = `
+      SELECT 
+        oaj.id,
+        oaj.created_at,
+        oaj.started_at,
+        oaj.completed_at,
+        oaj.mapping_job_id,
+        oaj.organization_id,
+        o.name as organization_name,
+        o.workspace_type,
+        CONCAT(COALESCE(la.first_name, ''), ' ', COALESCE(la.last_name, '')) as profile_name,
+        la.headline as profile_position,
+        we.company as current_company,
+        COALESCE(la.profile_image_cloudfront_url, la.profile_picture_url) as profile_image_url,
+        la.linkedin_identifier_acoa as linkedin_identifier,
+        CASE 
+          WHEN la.public_identifier IS NOT NULL 
+          THEN CONCAT('https://www.linkedin.com/in/', la.public_identifier)
+          ELSE NULL
+        END as linkedin_url
+      FROM monitoring.organization_assignment_jobs oaj
+      INNER JOIN monitoring.mapping_jobs mj ON oaj.mapping_job_id = mj.id
+      INNER JOIN linkedin.accounts la ON mj.linkedin_account_id = la.id
+      INNER JOIN public.organizations o ON oaj.organization_id = o.id
+      LEFT JOIN LATERAL (
+        SELECT company
+        FROM linkedin.work_experience we
+        WHERE we.linkedin_account_id = la.id
+          AND we.is_current = true
+        ORDER BY we.start_date DESC NULLS LAST
+        LIMIT 1
+      ) we ON true
+      WHERE la.linkedin_identifier_acoa = $1
+        AND oaj.organization_id = $2
+      ORDER BY oaj.created_at DESC
+      LIMIT 1
+    `;
+        const result = await (0, pg_client_1.queryOne)(db, sql, [linkedinIdentifierAcoa, organizationId]);
+        if (!result) {
+            return {
+                found: false,
+            };
+        }
+        // Determine status
+        let exportStatus = "pending";
+        if (result.completed_at) {
+            exportStatus = "completed";
+        }
+        else if (result.started_at) {
+            exportStatus = "pending";
+        }
+        return {
+            found: true,
+            export: {
+                id: result.id,
+                status: exportStatus,
+                created_at: result.created_at,
+                started_at: result.started_at,
+                completed_at: result.completed_at,
+                mapping_job_id: result.mapping_job_id,
+                organization: {
+                    id: result.organization_id,
+                    name: result.organization_name,
+                    workspace_type: result.workspace_type,
+                },
+                profile: {
+                    name: result.profile_name || "Unknown",
+                    position: result.profile_position || null,
+                    current_company: result.current_company || null,
+                    profile_image_url: result.profile_image_url || null,
+                    linkedin_identifier: result.linkedin_identifier,
+                    linkedin_url: result.linkedin_url || null,
+                },
+            },
+        };
+    }
+    catch (error) {
+        console.error("Error getting export status by LinkedIn identifier:", error);
+        throw error;
+    }
+}
+// =============================================================================
+// VALIDATION & MANAGEMENT
+// =============================================================================
+/**
+ * Validate that an organization assignment job exists and is completed
+ *
+ * @param db - Database instance
+ * @param organizationAssignmentJobId - Job ID
+ * @returns True if valid and completed, false otherwise
+ */
+async function validateOrganizationAssignmentJobCompletion(db, organizationAssignmentJobId) {
+    (0, db_1.debugLogDbOperation)("select", "organization_assignment_jobs", { organizationAssignmentJobId }, undefined, { operation: "validateOrganizationAssignmentJobCompletion" });
+    const job = await getOrganizationAssignmentJobById(db, organizationAssignmentJobId);
+    if (!job) {
+        return false;
+    }
+    return job.completedAt !== null;
+}
+/**
+ * Delete an organization assignment job
+ * Use with caution - this will cascade delete related records
+ *
+ * @param db - Database instance
+ * @param organizationAssignmentJobId - Job ID
+ * @returns Deleted job record
+ */
+async function deleteOrganizationAssignmentJob(db, organizationAssignmentJobId) {
+    (0, db_1.debugLogDbOperation)("delete", "organization_assignment_jobs", { organizationAssignmentJobId }, undefined, { operation: "deleteOrganizationAssignmentJob" });
+    const sql = `
+    DELETE FROM monitoring.organization_assignment_jobs
+    WHERE id = $1
+    RETURNING id, mapping_job_id, organization_id, metadata, created_at, completed_at
+  `;
+    const deleted = await (0, pg_client_1.queryOne)(db, sql, [organizationAssignmentJobId]);
+    if (!deleted) {
+        throw new Error(`Organization assignment job ${organizationAssignmentJobId} not found`);
+    }
+    return {
+        id: deleted.id,
+        mappingJobId: deleted.mapping_job_id,
+        organizationId: deleted.organization_id,
+        metadata: deleted.metadata,
+        createdAt: deleted.created_at,
+        completedAt: deleted.completed_at,
+    };
+}
+//# sourceMappingURL=organization-assignment-job-operations.js.map