eggi-ai-db-schema-2 12.54.2

package/dist/utils/forager-linkedin-operations.js

@@ -0,0 +1,778 @@
+"use strict";
+/**
+ * Forager-based LinkedIn Account Operations
+ *
+ * Migrated to native PostgreSQL queries for better performance and flexibility.
+ * All functions maintain the same interface for backward compatibility.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findLinkedInAccountByForagerId = findLinkedInAccountByForagerId;
+exports.findLinkedInAccountByPublicIdentifier = findLinkedInAccountByPublicIdentifier;
+exports.findLinkedInAccountByAnyIdentifier = findLinkedInAccountByAnyIdentifier;
+exports.findOrCreateLinkedInAccountByForagerId = findOrCreateLinkedInAccountByForagerId;
+exports.findLinkedInAccountWithUserByForagerId = findLinkedInAccountWithUserByForagerId;
+exports.updateLinkedInAccountProfileByForagerId = updateLinkedInAccountProfileByForagerId;
+exports.updateLinkedInAccountAcoaIdentifierByForagerId = updateLinkedInAccountAcoaIdentifierByForagerId;
+exports.updateLinkedInAccountAcoaIdentifierByForagerIdWithChangeDetection = updateLinkedInAccountAcoaIdentifierByForagerIdWithChangeDetection;
+const pg_client_1 = require("../lib/pg-client");
+const db_1 = require("../lib/db");
+/**
+ * Maps database row (snake_case) to User interface (camelCase)
+ */
+function mapToUser(row) {
+    return {
+        id: row.id,
+        givenName: row.given_name,
+        familyName: row.family_name,
+        summary: row.summary,
+        embeddingSummary: row.embedding_summary,
+        embedding: row.embedding,
+        createdAt: row.created_at,
+    };
+}
+// Simple logger for this module
+const logger = {
+    info: (message, data) => console.log(`[INFO] ${message}`, data ? JSON.stringify(data, null, 2) : ""),
+    error: (message, data) => console.error(`[ERROR] ${message}`, data ? JSON.stringify(data, null, 2) : ""),
+};
+// =============================================================================
+// HELPER FUNCTIONS
+// =============================================================================
+/**
+ * Convert database row to LinkedInAccountResult with computed profilePictureUrl
+ */
+function mapToLinkedInAccountResult(row) {
+    return {
+        id: row.id,
+        user_id: row.user_id,
+        forager_id: row.forager_id,
+        public_identifier: row.public_identifier,
+        linkedin_identifier_acoa: row.linkedin_identifier_acoa,
+        first_name: row.first_name,
+        last_name: row.last_name,
+        headline: row.headline,
+        summary: row.summary,
+        location: row.location,
+        profile_picture_url: row.profile_picture_url, // Already computed via COALESCE in SQL
+        profile_image_cloudfront_url: null, // Always hidden
+        profile_image_hash: row.profile_image_hash || null,
+        follower_count: row.follower_count,
+        connections_count: row.connections_count,
+        profiles_updated_at: row.profiles_updated_at,
+        created_at: row.created_at,
+    };
+}
+// =============================================================================
+// FORAGER-BASED LINKEDIN ACCOUNT OPERATIONS
+// =============================================================================
+/**
+ * Find LinkedIn account by Forager ID (primary matching method)
+ */
+async function findLinkedInAccountByForagerId(db, foragerId) {
+    (0, db_1.debugLogDbOperation)("select", "linkedin.accounts", { foragerId }, undefined, {
+        operation: "findLinkedInAccountByForagerId",
+        foragerId,
+    });
+    try {
+        const sql = `
+      SELECT 
+        id,
+        user_id,
+        forager_id,
+        public_identifier,
+        linkedin_identifier_acoa,
+        first_name,
+        last_name,
+        headline,
+        summary,
+        location,
+        COALESCE(profile_image_cloudfront_url, profile_picture_url) AS profile_picture_url,
+        follower_count,
+        connections_count,
+        profiles_updated_at,
+        created_at
+      FROM linkedin.accounts
+      WHERE forager_id = $1
+      LIMIT 1
+    `;
+        const result = await (0, pg_client_1.queryOne)(db, sql, [foragerId]);
+        return result ? mapToLinkedInAccountResult(result) : null;
+    }
+    catch (error) {
+        console.error("Error finding LinkedIn account by Forager ID:", error);
+        throw error;
+    }
+}
+/**
+ * Find LinkedIn account by public identifier (fallback method)
+ */
+async function findLinkedInAccountByPublicIdentifier(db, publicIdentifier) {
+    (0, db_1.debugLogDbOperation)("select", "linkedin.accounts", { publicIdentifier }, undefined, {
+        operation: "findLinkedInAccountByPublicIdentifier",
+        publicIdentifier,
+    });
+    try {
+        const sql = `
+      SELECT 
+        id,
+        user_id,
+        forager_id,
+        public_identifier,
+        linkedin_identifier_acoa,
+        first_name,
+        last_name,
+        headline,
+        summary,
+        location,
+        COALESCE(profile_image_cloudfront_url, profile_picture_url) AS profile_picture_url,
+        follower_count,
+        connections_count,
+        profiles_updated_at,
+        created_at
+      FROM linkedin.accounts
+      WHERE public_identifier = $1
+      LIMIT 1
+    `;
+        const result = await (0, pg_client_1.queryOne)(db, sql, [publicIdentifier]);
+        return result ? mapToLinkedInAccountResult(result) : null;
+    }
+    catch (error) {
+        console.error("Error finding LinkedIn account by public identifier:", error);
+        throw error;
+    }
+}
+/**
+ * Find LinkedIn account by any identifier (Forager ID, public identifier, or ACoA)
+ * Priority: forager_id > public_identifier > linkedin_identifier_acoa
+ */
+async function findLinkedInAccountByAnyIdentifier(db, identifier) {
+    (0, db_1.debugLogDbOperation)("select", "linkedin.accounts", { identifier }, undefined, {
+        operation: "findLinkedInAccountByAnyIdentifier",
+        identifier,
+    });
+    try {
+        // Try Forager ID first if it's a number
+        if (typeof identifier === "number") {
+            const foragerResult = await findLinkedInAccountByForagerId(db, identifier);
+            if (foragerResult)
+                return foragerResult;
+        }
+        // Try public identifier
+        if (typeof identifier === "string") {
+            const publicResult = await findLinkedInAccountByPublicIdentifier(db, identifier);
+            if (publicResult)
+                return publicResult;
+        }
+        // Try ACoA identifier as last resort
+        if (typeof identifier === "string" && identifier.startsWith("ACoA")) {
+            const sql = `
+        SELECT 
+          id,
+          user_id,
+          forager_id,
+          public_identifier,
+          linkedin_identifier_acoa,
+          first_name,
+          last_name,
+          headline,
+          summary,
+          location,
+          COALESCE(profile_image_cloudfront_url, profile_picture_url) AS profile_picture_url,
+          follower_count,
+          connections_count,
+          profiles_updated_at,
+          created_at
+        FROM linkedin.accounts
+        WHERE linkedin_identifier_acoa = $1
+        LIMIT 1
+      `;
+            const result = await (0, pg_client_1.queryOne)(db, sql, [identifier]);
+            return result ? mapToLinkedInAccountResult(result) : null;
+        }
+        return null;
+    }
+    catch (error) {
+        console.error("Error finding LinkedIn account by any identifier:", error);
+        throw error;
+    }
+}
+/**
+ * Find or create LinkedIn account by Forager ID
+ */
+async function findOrCreateLinkedInAccountByForagerId(db, foragerId, publicIdentifier, linkedinIdentifierAcoa, userId) {
+    (0, db_1.debugLogDbOperation)("upsert", "linkedin.accounts", {
+        foragerId,
+        publicIdentifier,
+        linkedinIdentifierAcoa,
+        userId,
+    }, undefined, {
+        operation: "findOrCreateLinkedInAccountByForagerId",
+        foragerId,
+    });
+    try {
+        // First, check if a record already exists with the same foragerId
+        const existingByForagerIdSql = `
+      SELECT id, forager_id 
+      FROM linkedin.accounts 
+      WHERE forager_id = $1 
+      LIMIT 1
+    `;
+        const existingByForagerId = await (0, pg_client_1.queryOne)(db, existingByForagerIdSql, [foragerId]);
+        if (existingByForagerId) {
+            // Record already exists - update it
+            // First, check current values to determine if update will change data
+            const currentValuesSql = `
+        SELECT 
+          public_identifier,
+          linkedin_identifier_acoa,
+          user_id
+        FROM linkedin.accounts
+        WHERE id = $1
+      `;
+            const currentValues = await (0, pg_client_1.queryOne)(db, currentValuesSql, [existingByForagerId.id]);
+            if (!currentValues) {
+                throw new Error(`LinkedIn account not found for id: ${existingByForagerId.id}`);
+            }
+            // Determine if update will actually change data
+            const willUpdatePublicIdentifier = publicIdentifier !== null &&
+                publicIdentifier !== undefined &&
+                currentValues.public_identifier !== publicIdentifier;
+            const willUpdateAcoa = linkedinIdentifierAcoa !== null &&
+                linkedinIdentifierAcoa !== undefined &&
+                currentValues.linkedin_identifier_acoa !== linkedinIdentifierAcoa;
+            const willUpdateUserId = userId !== undefined && userId !== null && currentValues.user_id !== userId;
+            const willUpdate = willUpdatePublicIdentifier || willUpdateAcoa || willUpdateUserId;
+            // Log the decision-making process for tracking
+            logger.info("LinkedIn account update decision", {
+                foragerId,
+                accountId: existingByForagerId.id,
+                willUpdate,
+                willUpdatePublicIdentifier,
+                willUpdateAcoa,
+                willUpdateUserId,
+                currentPublicIdentifier: currentValues.public_identifier,
+                newPublicIdentifier: publicIdentifier,
+                currentAcoa: currentValues.linkedin_identifier_acoa,
+                newAcoa: linkedinIdentifierAcoa,
+                currentUserId: currentValues.user_id,
+                newUserId: userId,
+            });
+            // Perform update if there are changes
+            if (willUpdate) {
+                const updateSql = `
+          UPDATE linkedin.accounts
+          SET 
+            public_identifier = COALESCE($2, public_identifier),
+            linkedin_identifier_acoa = COALESCE($3, linkedin_identifier_acoa)
+            ${userId !== undefined ? ", user_id = $4" : ""}
+          WHERE id = $1
+          RETURNING id
+        `;
+                const updateParams = userId !== undefined
+                    ? [existingByForagerId.id, publicIdentifier, linkedinIdentifierAcoa, userId]
+                    : [existingByForagerId.id, publicIdentifier, linkedinIdentifierAcoa];
+                await (0, pg_client_1.queryOne)(db, updateSql, updateParams);
+                logger.info("LinkedIn account updated successfully", {
+                    foragerId,
+                    accountId: existingByForagerId.id,
+                    wasUpdated: true,
+                });
+            }
+            else {
+                logger.info("LinkedIn account exists but no changes needed", {
+                    foragerId,
+                    accountId: existingByForagerId.id,
+                    wasUpdated: false,
+                });
+            }
+            return {
+                id: existingByForagerId.id,
+                wasNewlyCreated: false,
+                wasUpdated: willUpdate,
+            };
+        }
+        // Check if a record exists with the same ACoA identifier (different foragerId)
+        if (linkedinIdentifierAcoa) {
+            const existingByAcoaSql = `
+        SELECT id, forager_id 
+        FROM linkedin.accounts 
+        WHERE linkedin_identifier_acoa = $1 
+        LIMIT 1
+      `;
+            const existingByAcoa = await (0, pg_client_1.queryOne)(db, existingByAcoaSql, [linkedinIdentifierAcoa]);
+            if (existingByAcoa) {
+                // Update existing record with new foragerId
+                // First, check current values to determine if update will change data
+                const currentValuesSql = `
+          SELECT 
+            forager_id,
+            public_identifier,
+            user_id
+          FROM linkedin.accounts
+          WHERE id = $1
+        `;
+                const currentValues = await (0, pg_client_1.queryOne)(db, currentValuesSql, [existingByAcoa.id]);
+                if (!currentValues) {
+                    throw new Error(`LinkedIn account not found for id: ${existingByAcoa.id}`);
+                }
+                // Determine if update will actually change data
+                const willUpdateForagerId = currentValues.forager_id !== foragerId;
+                const willUpdatePublicIdentifier = publicIdentifier !== null &&
+                    publicIdentifier !== undefined &&
+                    currentValues.public_identifier !== publicIdentifier;
+                const willUpdateUserId = userId !== undefined && userId !== null && currentValues.user_id !== userId;
+                const willUpdate = willUpdateForagerId || willUpdatePublicIdentifier || willUpdateUserId;
+                // Log the decision-making process for tracking (ACoA match)
+                logger.info("LinkedIn account update decision (ACoA match)", {
+                    foragerId,
+                    accountId: existingByAcoa.id,
+                    willUpdate,
+                    willUpdateForagerId,
+                    willUpdatePublicIdentifier,
+                    willUpdateUserId,
+                    currentForagerId: currentValues.forager_id,
+                    newForagerId: foragerId,
+                    currentPublicIdentifier: currentValues.public_identifier,
+                    newPublicIdentifier: publicIdentifier,
+                    currentUserId: currentValues.user_id,
+                    newUserId: userId,
+                });
+                // Perform update if there are changes
+                if (willUpdate) {
+                    const updateSql = `
+            UPDATE linkedin.accounts
+            SET 
+              forager_id = $2,
+              public_identifier = COALESCE($3, public_identifier)
+              ${userId !== undefined ? ", user_id = $4" : ""}
+            WHERE id = $1
+            RETURNING id
+          `;
+                    const updateParams = userId !== undefined
+                        ? [existingByAcoa.id, foragerId, publicIdentifier, userId]
+                        : [existingByAcoa.id, foragerId, publicIdentifier];
+                    await (0, pg_client_1.queryOne)(db, updateSql, updateParams);
+                    logger.info("LinkedIn account updated successfully (ACoA match)", {
+                        foragerId,
+                        accountId: existingByAcoa.id,
+                        wasUpdated: true,
+                    });
+                }
+                else {
+                    logger.info("LinkedIn account exists but no changes needed (ACoA match)", {
+                        foragerId,
+                        accountId: existingByAcoa.id,
+                        wasUpdated: false,
+                    });
+                }
+                return {
+                    id: existingByAcoa.id,
+                    wasNewlyCreated: false,
+                    wasUpdated: willUpdate,
+                };
+            }
+        }
+        // No existing record found - create new one
+        const insertSql = `
+      INSERT INTO linkedin.accounts (
+        forager_id,
+        public_identifier,
+        linkedin_identifier_acoa,
+        user_id,
+        created_at
+      ) VALUES ($1, $2, $3, $4, NOW())
+      RETURNING id
+    `;
+        const result = await (0, pg_client_1.queryOne)(db, insertSql, [
+            foragerId,
+            publicIdentifier || null,
+            linkedinIdentifierAcoa || null,
+            userId || null,
+        ]);
+        if (!result) {
+            throw new Error("Failed to create LinkedIn account");
+        }
+        logger.info("LinkedIn account created successfully", {
+            foragerId,
+            accountId: result.id,
+            publicIdentifier,
+            linkedinIdentifierAcoa,
+            userId,
+            wasNewlyCreated: true,
+            wasUpdated: false,
+        });
+        return {
+            id: result.id,
+            wasNewlyCreated: true,
+            wasUpdated: false, // New record, not an update
+        };
+    }
+    catch (error) {
+        // If it's a duplicate key constraint violation on linkedin_identifier_acoa,
+        // try to find the existing record instead of failing
+        if (error instanceof Error &&
+            error.message.includes('duplicate key value violates unique constraint "accounts_linkedin_identifier_acoa_unique"')) {
+            logger.info("Found existing LinkedIn account with same ACoA identifier, updating it", {
+                foragerId,
+                linkedinIdentifierAcoa,
+                publicIdentifier,
+                userId,
+            });
+            // Find the existing record by ACoA identifier
+            const existingByAcoaSql = `
+        SELECT id, forager_id 
+        FROM linkedin.accounts 
+        WHERE linkedin_identifier_acoa = $1 
+        LIMIT 1
+      `;
+            const existingByAcoa = await (0, pg_client_1.queryOne)(db, existingByAcoaSql, [linkedinIdentifierAcoa]);
+            if (existingByAcoa) {
+                // Update the existing record with new foragerId and userId if provided
+                // First, check current values to determine if update will change data
+                const currentValuesSql = `
+          SELECT 
+            forager_id,
+            public_identifier,
+            user_id
+          FROM linkedin.accounts
+          WHERE id = $1
+        `;
+                const currentValues = await (0, pg_client_1.queryOne)(db, currentValuesSql, [existingByAcoa.id]);
+                if (!currentValues) {
+                    throw new Error(`LinkedIn account not found for id: ${existingByAcoa.id}`);
+                }
+                // Determine if update will actually change data
+                const willUpdateForagerId = currentValues.forager_id !== foragerId;
+                const willUpdatePublicIdentifier = publicIdentifier !== null &&
+                    publicIdentifier !== undefined &&
+                    currentValues.public_identifier !== publicIdentifier;
+                const willUpdateUserId = userId !== undefined && userId !== null && currentValues.user_id !== userId;
+                const willUpdate = willUpdateForagerId || willUpdatePublicIdentifier || willUpdateUserId;
+                // Log the decision-making process for tracking (duplicate key recovery)
+                logger.info("LinkedIn account update decision (duplicate key recovery)", {
+                    foragerId,
+                    accountId: existingByAcoa.id,
+                    willUpdate,
+                    willUpdateForagerId,
+                    willUpdatePublicIdentifier,
+                    willUpdateUserId,
+                    currentForagerId: currentValues.forager_id,
+                    newForagerId: foragerId,
+                    currentPublicIdentifier: currentValues.public_identifier,
+                    newPublicIdentifier: publicIdentifier,
+                    currentUserId: currentValues.user_id,
+                    newUserId: userId,
+                });
+                // Perform update if there are changes
+                if (willUpdate) {
+                    const updateSql = `
+            UPDATE linkedin.accounts
+            SET 
+              forager_id = $2,
+              public_identifier = COALESCE($3, public_identifier)
+              ${userId !== undefined ? ", user_id = $4" : ""}
+            WHERE id = $1
+            RETURNING id
+          `;
+                    const updateParams = userId !== undefined
+                        ? [existingByAcoa.id, foragerId, publicIdentifier, userId]
+                        : [existingByAcoa.id, foragerId, publicIdentifier];
+                    await (0, pg_client_1.queryOne)(db, updateSql, updateParams);
+                    logger.info("LinkedIn account updated successfully (duplicate key recovery)", {
+                        foragerId,
+                        accountId: existingByAcoa.id,
+                        wasUpdated: true,
+                    });
+                }
+                else {
+                    logger.info("LinkedIn account exists but no changes needed (duplicate key recovery)", {
+                        foragerId,
+                        accountId: existingByAcoa.id,
+                        wasUpdated: false,
+                    });
+                }
+                return {
+                    id: existingByAcoa.id,
+                    wasNewlyCreated: false,
+                    wasUpdated: willUpdate,
+                };
+            }
+            // If existingByAcoa is null, fall through to error handling
+        }
+        console.error("Error in findOrCreateLinkedInAccountByForagerId:", error);
+        throw error;
+    }
+}
+/**
+ * Find LinkedIn account with associated user by Forager ID
+ */
+async function findLinkedInAccountWithUserByForagerId(db, foragerId) {
+    (0, db_1.debugLogDbOperation)("select", "linkedin.accounts + users", { foragerId }, undefined, {
+        operation: "findLinkedInAccountWithUserByForagerId",
+        foragerId,
+    });
+    try {
+        const sql = `
+      SELECT 
+        la.id,
+        la.user_id,
+        la.forager_id,
+        la.public_identifier,
+        la.linkedin_identifier_acoa,
+        la.first_name,
+        la.last_name,
+        la.headline,
+        la.summary,
+        la.location,
+        COALESCE(la.profile_image_cloudfront_url, la.profile_picture_url) AS profile_picture_url,
+        la.follower_count,
+        la.connections_count,
+        la.profiles_updated_at,
+        la.created_at,
+        u.id AS user_id_joined,
+        u.given_name AS user_given_name,
+        u.family_name AS user_family_name,
+        u.created_at AS user_created_at
+      FROM linkedin.accounts la
+      LEFT JOIN public.users u ON la.user_id = u.id
+      WHERE la.forager_id = $1
+      LIMIT 1
+    `;
+        const result = await (0, pg_client_1.queryOne)(db, sql, [foragerId]);
+        if (!result) {
+            return null;
+        }
+        return {
+            account: mapToLinkedInAccountResult(result),
+            user: result.user_id_joined
+                ? mapToUser({
+                    id: result.user_id_joined,
+                    given_name: result.user_given_name,
+                    family_name: result.user_family_name,
+                    summary: null,
+                    embedding_summary: null,
+                    embedding: null,
+                    created_at: result.user_created_at,
+                })
+                : null,
+        };
+    }
+    catch (error) {
+        console.error("Error finding LinkedIn account with user by Forager ID:", error);
+        throw error;
+    }
+}
+/**
+ * Update LinkedIn account profile data by Forager ID
+ */
+async function updateLinkedInAccountProfileByForagerId(db, foragerId, profileData) {
+    (0, db_1.debugLogDbOperation)("update", "linkedin.accounts", { foragerId, ...profileData }, undefined, {
+        operation: "updateLinkedInAccountProfileByForagerId",
+        foragerId,
+    });
+    try {
+        // Build dynamic SET clause
+        const updates = [];
+        const params = [foragerId];
+        let paramIndex = 2;
+        if (profileData.firstName !== undefined) {
+            updates.push(`first_name = $${paramIndex++}`);
+            params.push(profileData.firstName);
+        }
+        if (profileData.lastName !== undefined) {
+            updates.push(`last_name = $${paramIndex++}`);
+            params.push(profileData.lastName);
+        }
+        if (profileData.headline !== undefined) {
+            updates.push(`headline = $${paramIndex++}`);
+            params.push(profileData.headline);
+        }
+        if (profileData.summary !== undefined) {
+            updates.push(`summary = $${paramIndex++}`);
+            params.push(profileData.summary);
+        }
+        if (profileData.location !== undefined) {
+            updates.push(`location = $${paramIndex++}`);
+            params.push(profileData.location);
+        }
+        if (profileData.profilePictureUrl !== undefined) {
+            updates.push(`profile_picture_url = $${paramIndex++}`);
+            params.push(profileData.profilePictureUrl);
+        }
+        if (profileData.followerCount !== undefined) {
+            updates.push(`follower_count = $${paramIndex++}`);
+            params.push(profileData.followerCount);
+        }
+        if (profileData.connectionsCount !== undefined) {
+            updates.push(`connections_count = $${paramIndex++}`);
+            params.push(profileData.connectionsCount);
+        }
+        // Always update profiles_updated_at
+        updates.push(`profiles_updated_at = NOW()`);
+        const sql = `
+      UPDATE linkedin.accounts
+      SET ${updates.join(", ")}
+      WHERE forager_id = $1
+      RETURNING 
+        id,
+        user_id,
+        forager_id,
+        public_identifier,
+        linkedin_identifier_acoa,
+        first_name,
+        last_name,
+        headline,
+        summary,
+        location,
+        COALESCE(profile_image_cloudfront_url, profile_picture_url) AS profile_picture_url,
+        follower_count,
+        connections_count,
+        profiles_updated_at,
+        created_at
+    `;
+        const result = await (0, pg_client_1.queryOne)(db, sql, params);
+        if (!result) {
+            throw new Error(`LinkedIn account with Forager ID ${foragerId} not found`);
+        }
+        return mapToLinkedInAccountResult(result);
+    }
+    catch (error) {
+        console.error("Error updating LinkedIn account profile by Forager ID:", error);
+        throw error;
+    }
+}
+/**
+ * Update LinkedIn account ACoA identifier by Forager ID
+ */
+async function updateLinkedInAccountAcoaIdentifierByForagerId(db, foragerId, linkedinIdentifierAcoa) {
+    (0, db_1.debugLogDbOperation)("update", "linkedin.accounts", { foragerId, linkedinIdentifierAcoa }, undefined, {
+        operation: "updateLinkedInAccountAcoaIdentifierByForagerId",
+        foragerId,
+    });
+    try {
+        const sql = `
+      UPDATE linkedin.accounts
+      SET 
+        linkedin_identifier_acoa = $2,
+        profiles_updated_at = NOW()
+      WHERE forager_id = $1
+      RETURNING 
+        id,
+        user_id,
+        forager_id,
+        public_identifier,
+        linkedin_identifier_acoa,
+        first_name,
+        last_name,
+        headline,
+        summary,
+        location,
+        profile_picture_url,
+        profile_image_cloudfront_url,
+        follower_count,
+        connections_count,
+        profiles_updated_at,
+        created_at
+    `;
+        const result = await (0, pg_client_1.queryOne)(db, sql, [foragerId, linkedinIdentifierAcoa]);
+        if (!result) {
+            throw new Error(`LinkedIn account with Forager ID ${foragerId} not found`);
+        }
+        return {
+            ...mapToLinkedInAccountResult(result),
+            profile_image_cloudfront_url: null,
+        };
+    }
+    catch (error) {
+        console.error("Error updating LinkedIn account ACoA identifier by Forager ID:", error);
+        throw error;
+    }
+}
+/**
+ * Update LinkedIn account ACoA identifier by Forager ID with change detection
+ * Returns whether the value actually changed
+ */
+async function updateLinkedInAccountAcoaIdentifierByForagerIdWithChangeDetection(db, foragerId, linkedinIdentifierAcoa) {
+    (0, db_1.debugLogDbOperation)("update", "linkedin.accounts", { foragerId, linkedinIdentifierAcoa }, undefined, {
+        operation: "updateLinkedInAccountAcoaIdentifierByForagerIdWithChangeDetection",
+        foragerId,
+    });
+    try {
+        // Use a single query with RETURNING to get both old and new values
+        const sql = `
+      UPDATE linkedin.accounts
+      SET 
+        linkedin_identifier_acoa = $2,
+        profiles_updated_at = NOW()
+      WHERE forager_id = $1
+      RETURNING 
+        id,
+        user_id,
+        forager_id,
+        public_identifier,
+        linkedin_identifier_acoa AS new_acoa,
+        (SELECT linkedin_identifier_acoa FROM linkedin.accounts WHERE forager_id = $1 FOR UPDATE) AS old_acoa,
+        first_name,
+        last_name,
+        headline,
+        summary,
+        location,
+        profile_picture_url,
+        profile_image_cloudfront_url,
+        follower_count,
+        connections_count,
+        profiles_updated_at,
+        created_at
+    `;
+        // Better approach: two queries in transaction for clarity
+        const currentSql = `SELECT linkedin_identifier_acoa FROM linkedin.accounts WHERE forager_id = $1`;
+        const currentResult = await (0, pg_client_1.queryOne)(db, currentSql, [foragerId]);
+        if (!currentResult) {
+            throw new Error(`LinkedIn account with Forager ID ${foragerId} not found`);
+        }
+        const oldValue = currentResult.linkedin_identifier_acoa;
+        const wasChanged = oldValue !== linkedinIdentifierAcoa;
+        // Update the account
+        const updateSql = `
+      UPDATE linkedin.accounts
+      SET 
+        linkedin_identifier_acoa = $2,
+        profiles_updated_at = NOW()
+      WHERE forager_id = $1
+      RETURNING 
+        id,
+        user_id,
+        forager_id,
+        public_identifier,
+        linkedin_identifier_acoa,
+        first_name,
+        last_name,
+        headline,
+        summary,
+        location,
+        profile_picture_url,
+        profile_image_cloudfront_url,
+        follower_count,
+        connections_count,
+        profiles_updated_at,
+        created_at
+    `;
+        const updatedAccount = await (0, pg_client_1.queryOne)(db, updateSql, [foragerId, linkedinIdentifierAcoa]);
+        if (!updatedAccount) {
+            throw new Error(`Failed to update LinkedIn account with Forager ID ${foragerId}`);
+        }
+        return {
+            account: {
+                ...mapToLinkedInAccountResult(updatedAccount),
+                profile_image_cloudfront_url: null,
+            },
+            wasChanged,
+            oldValue,
+        };
+    }
+    catch (error) {
+        console.error("Error updating LinkedIn account ACoA identifier by Forager ID with change detection:", error);
+        throw error;
+    }
+}
+//# sourceMappingURL=forager-linkedin-operations.js.map