eggi-ai-db-schema-2 0.1.1

package/dist/utils/sales-pipeline-operations.js

@@ -0,0 +1,725 @@
+"use strict";
+/**
+ * Sales Pipeline Operations
+ *
+ * Database operations for sales pipelines and user assignments.
+ * Organization-scoped pipelines shared by all users in the organization.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createOrGetSalesPipeline = createOrGetSalesPipeline;
+exports.getOrCreateOrganizationRelationshipAssignment = getOrCreateOrganizationRelationshipAssignment;
+exports.createOrUpdateSalesPipelineAssignment = createOrUpdateSalesPipelineAssignment;
+exports.getSalesPipelineAssignmentWithValidation = getSalesPipelineAssignmentWithValidation;
+exports.addToSalesPipeline = addToSalesPipeline;
+exports.addToSalesPipelineByAssignmentId = addToSalesPipelineByAssignmentId;
+exports.getSalesPipelineById = getSalesPipelineById;
+exports.getSalesPipelineForOrganization = getSalesPipelineForOrganization;
+exports.updateSalesPipelineAssignmentStage = updateSalesPipelineAssignmentStage;
+const pg_client_1 = require("../lib/pg-client");
+const db_1 = require("../lib/db");
+/**
+ * Create or get a sales pipeline entry for an organization
+ * Checks for existing entry via organization_user_relationship_assignment_id
+ * If the pipeline entry already exists, returns the existing one
+ *
+ * @param db - Database instance
+ * @param organizationId - Organization ID
+ * @param organizationUserRelationshipAssignmentId - Organization relationship assignment ID
+ * @param addedByOrganizationMemberId - Organization member who added this to the pipeline
+ * @returns Sales pipeline entry
+ */
+async function createOrGetSalesPipeline(db, organizationId, organizationUserRelationshipAssignmentId, addedByOrganizationMemberId // Mandatory - must be provided
+) {
+    (0, db_1.debugLogDbOperation)("createOrGetSalesPipeline", "sales_pipelines", {
+        organizationId,
+        organizationUserRelationshipAssignmentId,
+        addedByOrganizationMemberId,
+    });
+    // Try to get existing pipeline entry via assignment
+    const existingSql = `
+    SELECT sp.id, sp.organization_id, sp.added_by_organization_member_id, sp.created_at
+    FROM public.sales_pipelines sp
+    INNER JOIN public.sales_pipeline_assignments spa ON spa.sales_pipeline_id = sp.id
+    WHERE sp.organization_id = $1 
+      AND spa.organization_user_relationship_assignment_id = $2
+    LIMIT 1
+  `;
+    const existing = await (0, pg_client_1.queryOne)(db, existingSql, [
+        organizationId,
+        organizationUserRelationshipAssignmentId,
+    ]);
+    if (existing) {
+        return {
+            id: existing.id,
+            organizationId: existing.organization_id,
+            addedByOrganizationMemberId: existing.added_by_organization_member_id,
+            createdAt: existing.created_at,
+        };
+    }
+    // Create new pipeline entry
+    const insertSql = `
+    INSERT INTO public.sales_pipelines (organization_id, added_by_organization_member_id)
+    VALUES ($1, $2)
+    RETURNING id, organization_id, added_by_organization_member_id, created_at
+  `;
+    const result = await (0, pg_client_1.queryOne)(db, insertSql, [organizationId, addedByOrganizationMemberId]);
+    if (!result) {
+        throw new Error("Failed to create sales pipeline entry");
+    }
+    return {
+        id: result.id,
+        organizationId: result.organization_id,
+        addedByOrganizationMemberId: result.added_by_organization_member_id,
+        createdAt: result.created_at,
+    };
+}
+/**
+ * Get or create an organization_user_relationships_assignments entry
+ *
+ * @param db - Database instance
+ * @param organizationId - Organization ID
+ * @param linkedinRelationshipId - LinkedIn relationship ID
+ * @param organizationMemberId - Organization member ID (the member whose LinkedIn account is part of the relationship)
+ * @returns Organization relationship assignment ID
+ */
+async function getOrCreateOrganizationRelationshipAssignment(db, organizationId, linkedinRelationshipId, organizationMemberId) {
+    // Try to get existing assignment for this specific organization member
+    const existingSql = `
+    SELECT id
+    FROM public.organization_user_relationships_assignments
+    WHERE organization_id = $1 
+      AND linkedin_relationship_id = $2
+      AND organization_member_id = $3
+    LIMIT 1
+  `;
+    const existing = await (0, pg_client_1.queryOne)(db, existingSql, [
+        organizationId,
+        linkedinRelationshipId,
+        organizationMemberId,
+    ]);
+    if (existing) {
+        return existing.id;
+    }
+    // Create new assignment
+    const insertSql = `
+    INSERT INTO public.organization_user_relationships_assignments (organization_id, linkedin_relationship_id, organization_member_id, created_at)
+    VALUES ($1, $2, $3, NOW())
+    RETURNING id
+  `;
+    const result = await (0, pg_client_1.queryOne)(db, insertSql, [
+        organizationId,
+        linkedinRelationshipId,
+        organizationMemberId,
+    ]);
+    if (!result) {
+        throw new Error("Failed to create organization relationship assignment");
+    }
+    return result.id;
+}
+/**
+ * Create or update a sales pipeline assignment
+ * If assignment exists, updates the stage; otherwise creates new assignment with default stage 'prospect'
+ *
+ * @param db - Database instance
+ * @param salesPipelineId - Sales pipeline ID
+ * @param organizationUserRelationshipAssignmentId - Organization relationship assignment ID
+ * @param stage - Sales stage (default: 'prospect')
+ * @returns Sales pipeline assignment
+ */
+async function createOrUpdateSalesPipelineAssignment(db, salesPipelineId, organizationUserRelationshipAssignmentId, stage = "prospect") {
+    (0, db_1.debugLogDbOperation)("createOrUpdateSalesPipelineAssignment", "sales_pipeline_assignments", {
+        salesPipelineId,
+        organizationUserRelationshipAssignmentId,
+        stage,
+    });
+    // Try to get existing assignment
+    const existingSql = `
+    SELECT id, sales_pipeline_id, organization_user_relationship_assignment_id, stage, created_at, updated_at
+    FROM public.sales_pipeline_assignments
+    WHERE sales_pipeline_id = $1 AND organization_user_relationship_assignment_id = $2
+    LIMIT 1
+  `;
+    const existing = await (0, pg_client_1.queryOne)(db, existingSql, [
+        salesPipelineId,
+        organizationUserRelationshipAssignmentId,
+    ]);
+    if (existing) {
+        // Update existing assignment if stage changed
+        if (existing.stage !== stage) {
+            const updateSql = `
+        UPDATE public.sales_pipeline_assignments
+        SET stage = $1, updated_at = now()
+        WHERE id = $2
+        RETURNING id, sales_pipeline_id, organization_user_relationship_assignment_id, stage, created_at, updated_at
+      `;
+            const updated = await (0, pg_client_1.queryOne)(db, updateSql, [stage, existing.id]);
+            if (!updated) {
+                throw new Error("Failed to update sales pipeline assignment");
+            }
+            return {
+                id: updated.id,
+                salesPipelineId: updated.sales_pipeline_id,
+                organizationUserRelationshipAssignmentId: updated.organization_user_relationship_assignment_id,
+                stage: updated.stage,
+                createdAt: updated.created_at,
+                updatedAt: updated.updated_at,
+            };
+        }
+        // Return existing assignment if stage unchanged
+        return {
+            id: existing.id,
+            salesPipelineId: existing.sales_pipeline_id,
+            organizationUserRelationshipAssignmentId: existing.organization_user_relationship_assignment_id,
+            stage: existing.stage,
+            createdAt: existing.created_at,
+            updatedAt: existing.updated_at,
+        };
+    }
+    // Create new assignment
+    const insertSql = `
+    INSERT INTO public.sales_pipeline_assignments (sales_pipeline_id, organization_user_relationship_assignment_id, stage)
+    VALUES ($1, $2, $3)
+    RETURNING id, sales_pipeline_id, organization_user_relationship_assignment_id, stage, created_at, updated_at
+  `;
+    const result = await (0, pg_client_1.queryOne)(db, insertSql, [
+        salesPipelineId,
+        organizationUserRelationshipAssignmentId,
+        stage,
+    ]);
+    if (!result) {
+        throw new Error("Failed to create sales pipeline assignment");
+    }
+    return {
+        id: result.id,
+        salesPipelineId: result.sales_pipeline_id,
+        organizationUserRelationshipAssignmentId: result.organization_user_relationship_assignment_id,
+        stage: result.stage,
+        createdAt: result.created_at,
+        updatedAt: result.updated_at,
+    };
+}
+/**
+ * Get a sales pipeline assignment by ID and validate it belongs to an organization
+ *
+ * @param db - Database instance
+ * @param assignmentId - Sales pipeline assignment ID
+ * @param organizationId - Organization ID to validate against
+ * @returns Sales pipeline assignment with pipeline info, or null if not found or doesn't belong to org
+ */
+async function getSalesPipelineAssignmentWithValidation(db, assignmentId, organizationId) {
+    (0, db_1.debugLogDbOperation)("getSalesPipelineAssignmentWithValidation", "sales_pipeline_assignments", {
+        assignmentId,
+        organizationId,
+    });
+    const sql = `
+    SELECT 
+      spa.id,
+      spa.sales_pipeline_id,
+      spa.organization_user_relationship_assignment_id,
+      spa.stage,
+      spa.created_at as assignment_created_at,
+      spa.updated_at as assignment_updated_at,
+      sp.id as pipeline_id,
+      sp.organization_id,
+      sp.added_by_organization_member_id,
+      sp.created_at as pipeline_created_at
+    FROM public.sales_pipeline_assignments spa
+    INNER JOIN public.sales_pipelines sp ON sp.id = spa.sales_pipeline_id
+    INNER JOIN public.organization_user_relationships_assignments oura ON oura.id = spa.organization_user_relationship_assignment_id
+    WHERE spa.id = $1 AND sp.organization_id = $2 AND oura.organization_id = $2
+    LIMIT 1
+  `;
+    const result = await (0, pg_client_1.queryOne)(db, sql, [assignmentId, organizationId]);
+    if (!result) {
+        return null;
+    }
+    return {
+        assignment: {
+            id: result.id,
+            salesPipelineId: result.sales_pipeline_id,
+            organizationUserRelationshipAssignmentId: result.organization_user_relationship_assignment_id,
+            stage: result.stage,
+            createdAt: result.assignment_created_at,
+            updatedAt: result.assignment_updated_at,
+        },
+        pipeline: {
+            id: result.pipeline_id,
+            organizationId: result.organization_id,
+            addedByOrganizationMemberId: result.added_by_organization_member_id,
+            createdAt: result.pipeline_created_at,
+        },
+    };
+}
+/**
+ * Add a relationship to the sales pipeline
+ * Creates or gets the pipeline entry and organization relationship assignment, then creates/updates the pipeline assignment with default stage 'prospect'
+ *
+ * @param db - Database instance
+ * @param organizationId - Organization ID
+ * @param linkedinRelationshipId - LinkedIn relationship ID
+ * @returns Sales pipeline assignment
+ */
+async function addToSalesPipeline(db, organizationId, linkedinRelationshipId, addedByOrganizationMemberId // Mandatory - must be provided
+) {
+    (0, db_1.debugLogDbOperation)("addToSalesPipeline", "sales_pipeline_assignments", {
+        organizationId,
+        linkedinRelationshipId,
+        addedByOrganizationMemberId,
+    });
+    // Find the organization member whose LinkedIn account is part of this relationship
+    // The relationship assignment should belong to the member who owns the relationship
+    const findOrgMemberSql = `
+    SELECT om.id
+    FROM linkedin.relationships r
+    INNER JOIN linkedin.accounts la ON (la.id = r.linkedin_account_id_a OR la.id = r.linkedin_account_id_b)
+    INNER JOIN public.organization_members om ON om.user_id = la.user_id
+    WHERE r.id = $1 
+      AND om.organization_id = $2
+      AND om.id = $3
+    LIMIT 1
+  `;
+    const relationshipOwner = await (0, pg_client_1.queryOne)(db, findOrgMemberSql, [linkedinRelationshipId, organizationId, addedByOrganizationMemberId]);
+    // If the person adding to pipeline is not the relationship owner, try to find the actual owner
+    let organizationMemberId = addedByOrganizationMemberId;
+    if (!relationshipOwner) {
+        const findAnyOwnerSql = `
+      SELECT om.id
+      FROM linkedin.relationships r
+      INNER JOIN linkedin.accounts la ON (la.id = r.linkedin_account_id_a OR la.id = r.linkedin_account_id_b)
+      INNER JOIN public.organization_members om ON om.user_id = la.user_id
+      WHERE r.id = $1 
+        AND om.organization_id = $2
+      LIMIT 1
+    `;
+        const actualOwner = await (0, pg_client_1.queryOne)(db, findAnyOwnerSql, [
+            linkedinRelationshipId,
+            organizationId,
+        ]);
+        if (actualOwner) {
+            organizationMemberId = actualOwner.id;
+        }
+        // If no owner found, fall back to addedByOrganizationMemberId
+    }
+    // Get or create the organization relationship assignment first
+    const orgRelAssignmentId = await getOrCreateOrganizationRelationshipAssignment(db, organizationId, linkedinRelationshipId, organizationMemberId);
+    // Create or get the pipeline entry (checking via assignment)
+    const pipeline = await createOrGetSalesPipeline(db, organizationId, orgRelAssignmentId, addedByOrganizationMemberId);
+    // Create or update the pipeline assignment with default stage 'prospect'
+    const assignment = await createOrUpdateSalesPipelineAssignment(db, pipeline.id, orgRelAssignmentId, "prospect");
+    return assignment;
+}
+/**
+ * Add a relationship to the sales pipeline using organization relationship assignment ID
+ * This is more efficient as it already contains the organization and relationship context
+ *
+ * @param db - Database instance
+ * @param organizationUserRelationshipAssignmentId - Organization relationship assignment ID
+ * @param addedByOrganizationMemberId - Organization member who added this entry
+ * @returns Sales pipeline assignment
+ */
+async function addToSalesPipelineByAssignmentId(db, organizationUserRelationshipAssignmentId, addedByOrganizationMemberId) {
+    (0, db_1.debugLogDbOperation)("addToSalesPipelineByAssignmentId", "sales_pipeline_assignments", {
+        organizationUserRelationshipAssignmentId,
+        addedByOrganizationMemberId,
+    });
+    // First, get the organization relationship assignment to extract org_id
+    const getAssignmentSql = `
+    SELECT organization_id, linkedin_relationship_id, organization_member_id
+    FROM public.organization_user_relationships_assignments
+    WHERE id = $1
+    LIMIT 1
+  `;
+    const assignment = await (0, pg_client_1.queryOne)(db, getAssignmentSql, [organizationUserRelationshipAssignmentId]);
+    if (!assignment) {
+        throw new Error(`Organization relationship assignment not found: ${organizationUserRelationshipAssignmentId}`);
+    }
+    const organizationId = assignment.organization_id;
+    // Create or get the pipeline entry (checking via assignment)
+    const pipeline = await createOrGetSalesPipeline(db, organizationId, organizationUserRelationshipAssignmentId, addedByOrganizationMemberId);
+    // Create or update the pipeline assignment with default stage 'prospect'
+    const pipelineAssignment = await createOrUpdateSalesPipelineAssignment(db, pipeline.id, organizationUserRelationshipAssignmentId, "prospect");
+    return pipelineAssignment;
+}
+/**
+ * Get a sales pipeline entry by ID
+ *
+ * @param db - Database instance
+ * @param salesPipelineId - Sales pipeline ID
+ * @returns Sales pipeline entry or null if not found
+ */
+async function getSalesPipelineById(db, salesPipelineId) {
+    (0, db_1.debugLogDbOperation)("getSalesPipelineById", "sales_pipelines", {
+        salesPipelineId,
+    });
+    const sql = `
+    SELECT id, organization_id, added_by_organization_member_id, created_at
+    FROM public.sales_pipelines
+    WHERE id = $1
+    LIMIT 1
+  `;
+    const result = await (0, pg_client_1.queryOne)(db, sql, [salesPipelineId]);
+    if (!result) {
+        return null;
+    }
+    return {
+        id: result.id,
+        organizationId: result.organization_id,
+        addedByOrganizationMemberId: result.added_by_organization_member_id,
+        createdAt: result.created_at,
+    };
+}
+/**
+ * Get all sales pipeline entries for an organization with profile data
+ * Returns all pipeline assignments, with full relationship and profile information
+ *
+ * @param db - Database instance
+ * @param organizationId - Organization ID
+ * @param linkedinAccountId - Optional: filter by specific LinkedIn account's relationships
+ * @returns Array of sales pipeline entries with profile data
+ */
+async function getSalesPipelineForOrganization(db, organizationId, linkedinAccountId) {
+    (0, db_1.debugLogDbOperation)("getSalesPipelineForOrganization", "sales_pipeline_assignments", {
+        organizationId,
+        linkedinAccountId,
+    });
+    const sql = `
+    WITH org_member_accounts AS (
+      -- Get all LinkedIn account IDs for organization members
+      SELECT DISTINCT la.id as linkedin_account_id
+      FROM public.organization_members om
+      INNER JOIN linkedin.accounts la ON la.user_id = om.user_id
+      WHERE om.organization_id = $1
+    ),
+    pipeline_assignments AS (
+      -- Get all assignments for pipelines in this organization
+      SELECT 
+        spa.id as assignment_id,
+        spa.sales_pipeline_id,
+        spa.organization_user_relationship_assignment_id,
+        spa.stage,
+        spa.created_at as assignment_created_at,
+        spa.updated_at as assignment_updated_at,
+        oura.linkedin_relationship_id,
+        sp.added_by_organization_member_id
+      FROM public.sales_pipeline_assignments spa
+      INNER JOIN public.sales_pipelines sp ON sp.id = spa.sales_pipeline_id
+      INNER JOIN public.organization_user_relationships_assignments oura ON oura.id = spa.organization_user_relationship_assignment_id
+      INNER JOIN linkedin.relationships r ON r.id = oura.linkedin_relationship_id
+      WHERE sp.organization_id = $1 AND oura.organization_id = $1
+        ${linkedinAccountId ? "AND (r.linkedin_account_id_a = $2 OR r.linkedin_account_id_b = $2)" : ""}
+    )
+    SELECT 
+      pa.assignment_id,
+      pa.sales_pipeline_id,
+      pa.organization_user_relationship_assignment_id,
+      pa.stage,
+      pa.assignment_created_at,
+      pa.assignment_updated_at,
+      pa.linkedin_relationship_id,
+      -- Get the contributor/introducer's LinkedIn account (the one whose mapping job created the relationship)
+      -- The contributor is the one who can make the intro
+      CASE 
+        WHEN mj.linkedin_account_id = r.linkedin_account_id_a THEN r.linkedin_account_id_a
+        WHEN mj.linkedin_account_id = r.linkedin_account_id_b THEN r.linkedin_account_id_b
+        -- Fallback: if mapping job info not available, use org member logic
+        WHEN oma_a.linkedin_account_id IS NOT NULL THEN r.linkedin_account_id_a
+        WHEN oma_b.linkedin_account_id IS NOT NULL THEN r.linkedin_account_id_b
+        ELSE NULL
+      END as introducer_linkedin_account_id,
+      -- Get the connection's LinkedIn account (the "other" side - the person we want to reach)
+      CASE 
+        WHEN mj.linkedin_account_id = r.linkedin_account_id_a THEN r.linkedin_account_id_b
+        WHEN mj.linkedin_account_id = r.linkedin_account_id_b THEN r.linkedin_account_id_a
+        -- Fallback: if mapping job info not available, use org member logic
+        WHEN oma_a.linkedin_account_id IS NOT NULL THEN r.linkedin_account_id_b
+        ELSE r.linkedin_account_id_a
+      END as connection_id,
+      -- Connection profile data (the person we want to reach)
+      COALESCE(
+        CASE 
+          WHEN mj.linkedin_account_id = r.linkedin_account_id_a THEN la_b.first_name || ' ' || la_b.last_name
+          WHEN mj.linkedin_account_id = r.linkedin_account_id_b THEN la_a.first_name || ' ' || la_a.last_name
+          WHEN oma_a.linkedin_account_id IS NOT NULL THEN la_b.first_name || ' ' || la_b.last_name
+          ELSE la_a.first_name || ' ' || la_a.last_name
+        END,
+        CASE 
+          WHEN mj.linkedin_account_id = r.linkedin_account_id_a THEN la_b.first_name
+          WHEN mj.linkedin_account_id = r.linkedin_account_id_b THEN la_a.first_name
+          WHEN oma_a.linkedin_account_id IS NOT NULL THEN la_b.first_name
+          ELSE la_a.first_name
+        END
+      ) as full_name,
+      CASE 
+        WHEN mj.linkedin_account_id = r.linkedin_account_id_a THEN la_b.first_name
+        WHEN mj.linkedin_account_id = r.linkedin_account_id_b THEN la_a.first_name
+        WHEN oma_a.linkedin_account_id IS NOT NULL THEN la_b.first_name
+        ELSE la_a.first_name
+      END as first_name,
+      CASE 
+        WHEN mj.linkedin_account_id = r.linkedin_account_id_a THEN la_b.last_name
+        WHEN mj.linkedin_account_id = r.linkedin_account_id_b THEN la_a.last_name
+        WHEN oma_a.linkedin_account_id IS NOT NULL THEN la_b.last_name
+        ELSE la_a.last_name
+      END as last_name,
+      CASE 
+        WHEN mj.linkedin_account_id = r.linkedin_account_id_a THEN la_b.headline
+        WHEN mj.linkedin_account_id = r.linkedin_account_id_b THEN la_a.headline
+        WHEN oma_a.linkedin_account_id IS NOT NULL THEN la_b.headline
+        ELSE la_a.headline
+      END as headline,
+      CASE 
+        WHEN mj.linkedin_account_id = r.linkedin_account_id_a THEN la_b.summary
+        WHEN mj.linkedin_account_id = r.linkedin_account_id_b THEN la_a.summary
+        WHEN oma_a.linkedin_account_id IS NOT NULL THEN la_b.summary
+        ELSE la_a.summary
+      END as summary,
+      CASE 
+        WHEN mj.linkedin_account_id = r.linkedin_account_id_a THEN la_b.location
+        WHEN mj.linkedin_account_id = r.linkedin_account_id_b THEN la_a.location
+        WHEN oma_a.linkedin_account_id IS NOT NULL THEN la_b.location
+        ELSE la_a.location
+      END as location,
+      COALESCE(
+        CASE 
+          WHEN mj.linkedin_account_id = r.linkedin_account_id_a THEN la_b.profile_image_cloudfront_url
+          WHEN mj.linkedin_account_id = r.linkedin_account_id_b THEN la_a.profile_image_cloudfront_url
+          WHEN oma_a.linkedin_account_id IS NOT NULL THEN la_b.profile_image_cloudfront_url
+          ELSE la_a.profile_image_cloudfront_url
+        END,
+        CASE 
+          WHEN mj.linkedin_account_id = r.linkedin_account_id_a THEN la_b.profile_picture_url
+          WHEN mj.linkedin_account_id = r.linkedin_account_id_b THEN la_a.profile_picture_url
+          WHEN oma_a.linkedin_account_id IS NOT NULL THEN la_b.profile_picture_url
+          ELSE la_a.profile_picture_url
+        END
+      ) as profile_image_url,
+      CASE 
+        WHEN mj.linkedin_account_id = r.linkedin_account_id_a THEN la_b.public_identifier
+        WHEN mj.linkedin_account_id = r.linkedin_account_id_b THEN la_a.public_identifier
+        WHEN oma_a.linkedin_account_id IS NOT NULL THEN la_b.public_identifier
+        ELSE la_a.public_identifier
+      END as linkedin_public_identifier,
+      CASE 
+        WHEN mj.linkedin_account_id = r.linkedin_account_id_a THEN la_b.linkedin_identifier_acoa
+        WHEN mj.linkedin_account_id = r.linkedin_account_id_b THEN la_a.linkedin_identifier_acoa
+        WHEN oma_a.linkedin_account_id IS NOT NULL THEN la_b.linkedin_identifier_acoa
+        ELSE la_a.linkedin_identifier_acoa
+      END as linkedin_identifier_acoa,
+      -- Connection user data (if the connection is a registered user)
+      CASE 
+        WHEN mj.linkedin_account_id = r.linkedin_account_id_a THEN la_b.user_id
+        WHEN mj.linkedin_account_id = r.linkedin_account_id_b THEN la_a.user_id
+        WHEN oma_a.linkedin_account_id IS NOT NULL THEN la_b.user_id
+        ELSE la_a.user_id
+      END as connection_user_id,
+      CASE 
+        WHEN mj.linkedin_account_id = r.linkedin_account_id_a THEN u_b.given_name
+        WHEN mj.linkedin_account_id = r.linkedin_account_id_b THEN u_a.given_name
+        WHEN oma_a.linkedin_account_id IS NOT NULL THEN u_b.given_name
+        ELSE u_a.given_name
+      END as connection_user_given_name,
+      CASE 
+        WHEN mj.linkedin_account_id = r.linkedin_account_id_a THEN u_b.family_name
+        WHEN mj.linkedin_account_id = r.linkedin_account_id_b THEN u_a.family_name
+        WHEN oma_a.linkedin_account_id IS NOT NULL THEN u_b.family_name
+        ELSE u_a.family_name
+      END as connection_user_family_name,
+      -- Introducer/Contributor data (the person who can do the intro - the one whose mapping job created the relationship)
+      COALESCE(
+        CASE 
+          WHEN mj.linkedin_account_id = r.linkedin_account_id_a THEN la_a.first_name || ' ' || la_a.last_name
+          WHEN mj.linkedin_account_id = r.linkedin_account_id_b THEN la_b.first_name || ' ' || la_b.last_name
+          WHEN oma_a.linkedin_account_id IS NOT NULL THEN la_a.first_name || ' ' || la_a.last_name
+          WHEN oma_b.linkedin_account_id IS NOT NULL THEN la_b.first_name || ' ' || la_b.last_name
+          ELSE NULL
+        END,
+        CASE 
+          WHEN mj.linkedin_account_id = r.linkedin_account_id_a THEN la_a.first_name
+          WHEN mj.linkedin_account_id = r.linkedin_account_id_b THEN la_b.first_name
+          WHEN oma_a.linkedin_account_id IS NOT NULL THEN la_a.first_name
+          WHEN oma_b.linkedin_account_id IS NOT NULL THEN la_b.first_name
+          ELSE NULL
+        END
+      ) as introducer_full_name,
+      CASE 
+        WHEN mj.linkedin_account_id = r.linkedin_account_id_a THEN la_a.first_name
+        WHEN mj.linkedin_account_id = r.linkedin_account_id_b THEN la_b.first_name
+        WHEN oma_a.linkedin_account_id IS NOT NULL THEN la_a.first_name
+        WHEN oma_b.linkedin_account_id IS NOT NULL THEN la_b.first_name
+        ELSE NULL
+      END as introducer_first_name,
+      CASE 
+        WHEN mj.linkedin_account_id = r.linkedin_account_id_a THEN la_a.last_name
+        WHEN mj.linkedin_account_id = r.linkedin_account_id_b THEN la_b.last_name
+        WHEN oma_a.linkedin_account_id IS NOT NULL THEN la_a.last_name
+        WHEN oma_b.linkedin_account_id IS NOT NULL THEN la_b.last_name
+        ELSE NULL
+      END as introducer_last_name,
+      CASE 
+        WHEN mj.linkedin_account_id = r.linkedin_account_id_a THEN la_a.headline
+        WHEN mj.linkedin_account_id = r.linkedin_account_id_b THEN la_b.headline
+        WHEN oma_a.linkedin_account_id IS NOT NULL THEN la_a.headline
+        WHEN oma_b.linkedin_account_id IS NOT NULL THEN la_b.headline
+        ELSE NULL
+      END as introducer_headline,
+      COALESCE(
+        CASE 
+          WHEN mj.linkedin_account_id = r.linkedin_account_id_a THEN la_a.profile_image_cloudfront_url
+          WHEN mj.linkedin_account_id = r.linkedin_account_id_b THEN la_b.profile_image_cloudfront_url
+          WHEN oma_a.linkedin_account_id IS NOT NULL THEN la_a.profile_image_cloudfront_url
+          WHEN oma_b.linkedin_account_id IS NOT NULL THEN la_b.profile_image_cloudfront_url
+          ELSE NULL
+        END,
+        CASE 
+          WHEN mj.linkedin_account_id = r.linkedin_account_id_a THEN la_a.profile_picture_url
+          WHEN mj.linkedin_account_id = r.linkedin_account_id_b THEN la_b.profile_picture_url
+          WHEN oma_a.linkedin_account_id IS NOT NULL THEN la_a.profile_picture_url
+          WHEN oma_b.linkedin_account_id IS NOT NULL THEN la_b.profile_picture_url
+          ELSE NULL
+        END
+      ) as introducer_profile_image_url,
+      CASE 
+        WHEN mj.linkedin_account_id = r.linkedin_account_id_a THEN la_a.public_identifier
+        WHEN mj.linkedin_account_id = r.linkedin_account_id_b THEN la_b.public_identifier
+        WHEN oma_a.linkedin_account_id IS NOT NULL THEN la_a.public_identifier
+        WHEN oma_b.linkedin_account_id IS NOT NULL THEN la_b.public_identifier
+        ELSE NULL
+      END as introducer_linkedin_public_identifier,
+      CASE 
+        WHEN mj.linkedin_account_id = r.linkedin_account_id_a THEN la_a.linkedin_identifier_acoa
+        WHEN mj.linkedin_account_id = r.linkedin_account_id_b THEN la_b.linkedin_identifier_acoa
+        WHEN oma_a.linkedin_account_id IS NOT NULL THEN la_a.linkedin_identifier_acoa
+        WHEN oma_b.linkedin_account_id IS NOT NULL THEN la_b.linkedin_identifier_acoa
+        ELSE NULL
+      END as introducer_linkedin_identifier_acoa,
+      CASE 
+        WHEN mj.linkedin_account_id = r.linkedin_account_id_a THEN la_a.user_id
+        WHEN mj.linkedin_account_id = r.linkedin_account_id_b THEN la_b.user_id
+        WHEN oma_a.linkedin_account_id IS NOT NULL THEN la_a.user_id
+        WHEN oma_b.linkedin_account_id IS NOT NULL THEN la_b.user_id
+        ELSE NULL
+      END as introducer_user_id,
+      CASE 
+        WHEN mj.linkedin_account_id = r.linkedin_account_id_a THEN u_a.given_name
+        WHEN mj.linkedin_account_id = r.linkedin_account_id_b THEN u_b.given_name
+        WHEN oma_a.linkedin_account_id IS NOT NULL THEN u_a.given_name
+        WHEN oma_b.linkedin_account_id IS NOT NULL THEN u_b.given_name
+        ELSE NULL
+      END as introducer_user_given_name,
+      CASE 
+        WHEN mj.linkedin_account_id = r.linkedin_account_id_a THEN u_a.family_name
+        WHEN mj.linkedin_account_id = r.linkedin_account_id_b THEN u_b.family_name
+        WHEN oma_a.linkedin_account_id IS NOT NULL THEN u_a.family_name
+        WHEN oma_b.linkedin_account_id IS NOT NULL THEN u_b.family_name
+        ELSE NULL
+      END as introducer_user_family_name,
+      -- Added by information (who added this entry to the sales pipeline)
+      pa.added_by_organization_member_id,
+      added_by_om.user_id as added_by_user_id,
+      COALESCE(
+        added_by_user.given_name || ' ' || added_by_user.family_name,
+        added_by_user.given_name,
+        added_by_user.family_name,
+        'Unknown'
+      ) as added_by_full_name,
+      added_by_user.given_name as added_by_given_name,
+      added_by_user.family_name as added_by_family_name,
+      COALESCE(
+        added_by_la.profile_image_cloudfront_url,
+        added_by_la.profile_picture_url
+      ) as added_by_profile_image_url
+    FROM pipeline_assignments pa
+    INNER JOIN linkedin.relationships r ON r.id = pa.linkedin_relationship_id
+    -- Get mapping job to determine which account is the contributor (the one whose mapping job created the relationship)
+    LEFT JOIN monitoring.mapping_jobs mj ON mj.id = r.mapping_job_id
+    -- Check if account A is an org member (fallback if mapping job info not available)
+    LEFT JOIN org_member_accounts oma_a ON oma_a.linkedin_account_id = r.linkedin_account_id_a
+    -- Check if account B is an org member (fallback if mapping job info not available)
+    LEFT JOIN org_member_accounts oma_b ON oma_b.linkedin_account_id = r.linkedin_account_id_b
+    -- Get LinkedIn account A data
+    INNER JOIN linkedin.accounts la_a ON la_a.id = r.linkedin_account_id_a
+    LEFT JOIN public.users u_a ON u_a.id = la_a.user_id
+    -- Get LinkedIn account B data
+    INNER JOIN linkedin.accounts la_b ON la_b.id = r.linkedin_account_id_b
+    LEFT JOIN public.users u_b ON u_b.id = la_b.user_id
+    -- Get added_by organization member and user data
+    LEFT JOIN public.organization_members added_by_om ON added_by_om.id = pa.added_by_organization_member_id
+    LEFT JOIN public.users added_by_user ON added_by_user.id = added_by_om.user_id
+    LEFT JOIN linkedin.accounts added_by_la ON added_by_la.user_id = added_by_om.user_id
+    ORDER BY pa.assignment_updated_at DESC, pa.assignment_created_at DESC
+  `;
+    const params = linkedinAccountId ? [organizationId, linkedinAccountId] : [organizationId];
+    const results = await (0, pg_client_1.query)(db, sql, params);
+    return results.map(r => ({
+        assignment_id: r.assignment_id,
+        sales_pipeline_id: r.sales_pipeline_id,
+        organization_user_relationship_assignment_id: r.organization_user_relationship_assignment_id,
+        stage: r.stage,
+        assignment_created_at: r.assignment_created_at,
+        assignment_updated_at: r.assignment_updated_at,
+        linkedin_relationship_id: r.linkedin_relationship_id,
+        connection_id: r.connection_id,
+        full_name: r.full_name,
+        first_name: r.first_name,
+        last_name: r.last_name,
+        headline: r.headline,
+        summary: r.summary,
+        location: r.location,
+        profile_image_url: r.profile_image_url,
+        linkedin_public_identifier: r.linkedin_public_identifier,
+        linkedin_identifier_acoa: r.linkedin_identifier_acoa,
+        connection_user_id: r.connection_user_id,
+        connection_user_given_name: r.connection_user_given_name,
+        connection_user_family_name: r.connection_user_family_name,
+        introducer_linkedin_account_id: r.introducer_linkedin_account_id,
+        introducer_full_name: r.introducer_full_name,
+        introducer_first_name: r.introducer_first_name,
+        introducer_last_name: r.introducer_last_name,
+        introducer_headline: r.introducer_headline,
+        introducer_profile_image_url: r.introducer_profile_image_url,
+        introducer_linkedin_public_identifier: r.introducer_linkedin_public_identifier,
+        introducer_linkedin_identifier_acoa: r.introducer_linkedin_identifier_acoa,
+        introducer_user_id: r.introducer_user_id,
+        introducer_user_given_name: r.introducer_user_given_name,
+        introducer_user_family_name: r.introducer_user_family_name,
+        added_by_organization_member_id: r.added_by_organization_member_id,
+        added_by_user_id: r.added_by_user_id,
+        added_by_full_name: r.added_by_full_name,
+        added_by_given_name: r.added_by_given_name,
+        added_by_family_name: r.added_by_family_name,
+        added_by_profile_image_url: r.added_by_profile_image_url,
+    }));
+}
+/**
+ * Update the stage of a sales pipeline assignment
+ *
+ * @param db - Database instance
+ * @param assignmentId - Sales pipeline assignment ID
+ * @param newStage - New sales stage
+ * @returns Updated sales pipeline assignment
+ */
+async function updateSalesPipelineAssignmentStage(db, assignmentId, newStage) {
+    (0, db_1.debugLogDbOperation)("updateSalesPipelineAssignmentStage", "sales_pipeline_assignments", {
+        assignmentId,
+        newStage,
+    });
+    const updateSql = `
+    UPDATE public.sales_pipeline_assignments
+    SET stage = $1, updated_at = now()
+    WHERE id = $2
+    RETURNING id, sales_pipeline_id, organization_user_relationship_assignment_id, stage, created_at, updated_at
+  `;
+    const updated = await (0, pg_client_1.queryOne)(db, updateSql, [newStage, assignmentId]);
+    if (!updated) {
+        throw new Error("Failed to update sales pipeline assignment stage - assignment not found");
+    }
+    return {
+        id: updated.id,
+        salesPipelineId: updated.sales_pipeline_id,
+        organizationUserRelationshipAssignmentId: updated.organization_user_relationship_assignment_id,
+        stage: updated.stage,
+        createdAt: updated.created_at,
+        updatedAt: updated.updated_at,
+    };
+}
+//# sourceMappingURL=sales-pipeline-operations.js.map