eggi-ai-db-schema-2 0.1.1

package/dist/utils/organization-operations.js

@@ -0,0 +1,1030 @@
+"use strict";
+/**
+ * Organization Operations
+ *
+ * Database operations for organizations and organization memberships.
+ * Provides functions for querying organization data and user memberships.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getOrganizationMembershipsForUser = getOrganizationMembershipsForUser;
+exports.getOrganizationById = getOrganizationById;
+exports.findOrganizationByLinkedInCompanyId = findOrganizationByLinkedInCompanyId;
+exports.findOrganizationByLinkedInPublicIdentifier = findOrganizationByLinkedInPublicIdentifier;
+exports.findOrganizationByDedupKey = findOrganizationByDedupKey;
+exports.getOrganizationMembers = getOrganizationMembers;
+exports.getOrganizationMembersCount = getOrganizationMembersCount;
+exports.getOrganizationContributorsCount = getOrganizationContributorsCount;
+exports.getOrganizationContributors = getOrganizationContributors;
+exports.getOrganizationMembershipForUser = getOrganizationMembershipForUser;
+exports.getOrganizationContributorByUserId = getOrganizationContributorByUserId;
+exports.findContributorPage = findContributorPage;
+exports.updateOrganizationMemberRole = updateOrganizationMemberRole;
+exports.getOrganizationMemberRelationships = getOrganizationMemberRelationships;
+exports.getOrganizationMemberRelationshipsCount = getOrganizationMemberRelationshipsCount;
+exports.createOrganization = createOrganization;
+exports.updateOrganizationLinkedInPublicIdentifier = updateOrganizationLinkedInPublicIdentifier;
+exports.findOrCreateOrganizationMember = findOrCreateOrganizationMember;
+exports.findPersonalWorkspaceForUser = findPersonalWorkspaceForUser;
+exports.getOrganizationMemberById = getOrganizationMemberById;
+exports.updateOrganizationSubscriptionTier = updateOrganizationSubscriptionTier;
+const pg_client_1 = require("../lib/pg-client");
+const db_1 = require("../lib/db");
+/**
+ * Get all organization memberships for a user with full organization details
+ *
+ * @param db - Database instance
+ * @param userId - User ID to get memberships for
+ * @returns Array of organization memberships with organization details
+ */
+async function getOrganizationMembershipsForUser(db, userId) {
+    const sql = `
+    SELECT 
+      om.id,
+      om.user_id,
+      om.organization_id,
+      om.contribution_role,
+      om.permissions_role,
+      om.created_at,
+      o.id as org_id,
+      o.name as org_name,
+      o.workspace_type as org_workspace_type,
+      o.subscription_tier as org_subscription_tier,
+      o.image_url as org_image_url,
+      o.created_at as org_created_at,
+      o.created_by_user_id as org_created_by_user_id
+    FROM public.organization_members om
+    INNER JOIN public.organizations o ON om.organization_id = o.id
+    WHERE om.user_id = $1
+    ORDER BY om.created_at
+  `;
+    const results = await (0, pg_client_1.query)(db, sql, [userId]);
+    return results.map(r => ({
+        id: r.id,
+        userId: r.user_id,
+        organizationId: r.organization_id,
+        contributionRole: r.contribution_role,
+        permissionsRole: r.permissions_role,
+        createdAt: r.created_at,
+        organization: {
+            id: r.org_id,
+            name: r.org_name,
+            workspaceType: r.org_workspace_type,
+            subscriptionTier: r.org_subscription_tier,
+            imageUrl: r.org_image_url,
+            createdAt: r.org_created_at,
+            createdByUserId: r.org_created_by_user_id,
+        },
+    }));
+}
+/**
+ * Get organization by ID
+ *
+ * @param db - Database instance
+ * @param organizationId - Organization ID
+ * @returns Organization or null if not found
+ */
+async function getOrganizationById(db, organizationId) {
+    const sql = `
+    SELECT id, name, workspace_type, subscription_tier, image_url, created_at, created_by_user_id
+    FROM public.organizations
+    WHERE id = $1
+    LIMIT 1
+  `;
+    const result = await (0, pg_client_1.queryOne)(db, sql, [organizationId]);
+    if (!result)
+        return null;
+    return {
+        id: result.id,
+        name: result.name,
+        workspaceType: result.workspace_type,
+        subscriptionTier: result.subscription_tier,
+        imageUrl: result.image_url,
+        createdAt: result.created_at,
+        createdByUserId: result.created_by_user_id,
+    };
+}
+/**
+ * Find organization by LinkedIn company ID (Forager organization ID)
+ *
+ * @param db - Database instance
+ * @param linkedinCompanyId - Forager organization ID
+ * @returns Organization or null if not found
+ */
+async function findOrganizationByLinkedInCompanyId(db, linkedinCompanyId) {
+    const sql = `
+    SELECT id, name, workspace_type, subscription_tier, image_url, created_at, created_by_user_id
+    FROM public.organizations
+    WHERE linkedin_company_id = $1
+    LIMIT 1
+  `;
+    const result = await (0, pg_client_1.queryOne)(db, sql, [linkedinCompanyId]);
+    if (!result)
+        return null;
+    return {
+        id: result.id,
+        name: result.name,
+        workspaceType: result.workspace_type,
+        subscriptionTier: result.subscription_tier,
+        imageUrl: result.image_url,
+        createdAt: result.created_at,
+        createdByUserId: result.created_by_user_id,
+    };
+}
+/**
+ * Find organization by LinkedIn public identifier
+ *
+ * @param db - Database instance
+ * @param linkedinPublicIdentifier - LinkedIn public identifier (e.g., "eggi")
+ * @returns Organization or null if not found
+ */
+async function findOrganizationByLinkedInPublicIdentifier(db, linkedinPublicIdentifier) {
+    (0, db_1.debugLogDbOperation)("select", "organizations", { linkedinPublicIdentifier });
+    const sql = `
+    SELECT 
+      id, 
+      name, 
+      workspace_type, 
+      subscription_tier, 
+      image_url, 
+      created_at, 
+      created_by_user_id,
+      linkedin_public_identifier,
+      linkedin_company_id
+    FROM public.organizations
+    WHERE linkedin_public_identifier = $1
+    LIMIT 1
+  `;
+    const result = await (0, pg_client_1.queryOne)(db, sql, [linkedinPublicIdentifier]);
+    if (!result)
+        return null;
+    return {
+        id: result.id,
+        name: result.name,
+        workspaceType: result.workspace_type,
+        subscriptionTier: result.subscription_tier,
+        imageUrl: result.image_url,
+        createdAt: result.created_at,
+        createdByUserId: result.created_by_user_id,
+        linkedinPublicIdentifier: result.linkedin_public_identifier,
+        linkedinCompanyId: result.linkedin_company_id,
+    };
+}
+/**
+ * Find organization by dedup_key (for manual organizations)
+ *
+ * @param db - Database instance
+ * @param dedupKey - Deduplication key
+ * @returns Organization or null if not found
+ */
+async function findOrganizationByDedupKey(db, dedupKey) {
+    const sql = `
+    SELECT id, name, workspace_type, subscription_tier, image_url, created_at, created_by_user_id
+    FROM public.organizations
+    WHERE dedup_key = $1
+    LIMIT 1
+  `;
+    const result = await (0, pg_client_1.queryOne)(db, sql, [dedupKey]);
+    if (!result)
+        return null;
+    return {
+        id: result.id,
+        name: result.name,
+        workspaceType: result.workspace_type,
+        subscriptionTier: result.subscription_tier,
+        imageUrl: result.image_url,
+        createdAt: result.created_at,
+        createdByUserId: result.created_by_user_id,
+    };
+}
+/**
+ * Get all members of an organization
+ *
+ * @param db - Database instance
+ * @param organizationId - Organization ID
+ * @returns Array of organization memberships
+ */
+async function getOrganizationMembers(db, organizationId) {
+    const sql = `
+    SELECT id, user_id, organization_id, contribution_role, permissions_role, created_at
+    FROM public.organization_members
+    WHERE organization_id = $1
+    ORDER BY created_at
+  `;
+    const results = await (0, pg_client_1.query)(db, sql, [organizationId]);
+    return results.map(r => ({
+        id: r.id,
+        userId: r.user_id,
+        organizationId: r.organization_id,
+        contributionRole: r.contribution_role,
+        permissionsRole: r.permissions_role,
+        createdAt: r.created_at,
+    }));
+}
+/**
+ * Get total count of organization members by contribution role
+ *
+ * @param db - Database instance
+ * @param organizationId - Organization ID
+ * @param contributionRole - Contribution role to filter by (optional)
+ * @returns Total count of members
+ */
+async function getOrganizationMembersCount(db, organizationId, contributionRole) {
+    const sql = contributionRole
+        ? `
+      SELECT COUNT(*) as count
+      FROM public.organization_members
+      WHERE organization_id = $1 AND contribution_role = $2
+    `
+        : `
+      SELECT COUNT(*) as count
+      FROM public.organization_members
+      WHERE organization_id = $1
+    `;
+    const params = contributionRole ? [organizationId, contributionRole] : [organizationId];
+    const results = await (0, pg_client_1.query)(db, sql, params);
+    return parseInt(results[0]?.count || "0", 10);
+}
+/**
+ * Get total count of contributors for an organization
+ *
+ * CRITICAL: This must use the same filtering logic as getOrganizationContributors
+ * to ensure accurate pagination. Only counts contributors with relationships_count > 0.
+ *
+ * @param db - Database instance
+ * @param organizationId - Organization ID
+ * @returns Total count of contributors with relationships
+ */
+async function getOrganizationContributorsCount(db, organizationId) {
+    const sql = `
+    WITH relationship_counts AS (
+      -- Count distinct relationships for each contributor using organization_member_id
+      -- This ensures we only count relationships assigned to the specific contributor,
+      -- not relationships where they appear as the "other person" in someone else's mapping job
+      SELECT 
+        om.user_id,
+        COUNT(DISTINCT 
+          CASE 
+            WHEN r.linkedin_account_id_a = la.id THEN r.linkedin_account_id_b
+            ELSE r.linkedin_account_id_a
+          END
+        ) as relationships_count
+      FROM public.organization_members om
+      INNER JOIN linkedin.accounts la ON la.user_id = om.user_id
+      INNER JOIN public.organization_user_relationships_assignments oura
+        ON oura.organization_member_id = om.id  -- Use organization_member_id for faster lookup
+      INNER JOIN linkedin.relationships r
+        ON r.id = oura.linkedin_relationship_id
+        AND (r.linkedin_account_id_a = la.id OR r.linkedin_account_id_b = la.id)
+      INNER JOIN monitoring.mapping_jobs mj
+        ON mj.id = r.mapping_job_id
+        AND mj.linkedin_account_id = la.id  -- CRITICAL: Only count relationships from mapping jobs that belong to this contributor
+      WHERE oura.organization_id = $1
+        AND om.organization_id = $1
+        AND om.contribution_role = 'CONTRIBUTOR'
+      GROUP BY om.user_id
+    )
+    SELECT COUNT(*) as count
+    FROM relationship_counts rc
+    WHERE rc.relationships_count > 0
+  `;
+    const results = await (0, pg_client_1.query)(db, sql, [organizationId]);
+    return parseInt(results[0]?.count || "0", 10);
+}
+/**
+ * Get contributors for an organization with pagination
+ * Sorted by:
+ * 1. LLM inference job status (descending) - completed jobs first, then pending/in-progress
+ * 2. Relationship count (descending) - most relationships first within each status group
+ * 3. Created date (ascending) - oldest first when status and relationships are equal
+ *
+ * @param db - Database instance
+ * @param organizationId - Organization ID
+ * @param limit - Maximum number of contributors to return (default: 50)
+ * @param offset - Number of contributors to skip (default: 0)
+ * @returns Array of contributor memberships
+ */
+async function getOrganizationContributors(db, organizationId, limit = 50, offset = 0) {
+    const sql = `
+    WITH relationship_counts AS (
+      -- Count distinct relationships for each contributor using organization_member_id
+      -- This ensures we only count relationships assigned to the specific contributor,
+      -- not relationships where they appear as the "other person" in someone else's mapping job
+      SELECT 
+        om.user_id,
+        COUNT(DISTINCT 
+          CASE 
+            WHEN r.linkedin_account_id_a = la.id THEN r.linkedin_account_id_b
+            ELSE r.linkedin_account_id_a
+          END
+        ) as relationships_count
+      FROM public.organization_members om
+      INNER JOIN linkedin.accounts la ON la.user_id = om.user_id
+      INNER JOIN public.organization_user_relationships_assignments oura
+        ON oura.organization_member_id = om.id  -- Use organization_member_id for faster lookup
+      INNER JOIN linkedin.relationships r
+        ON r.id = oura.linkedin_relationship_id
+        AND (r.linkedin_account_id_a = la.id OR r.linkedin_account_id_b = la.id)
+      INNER JOIN monitoring.mapping_jobs mj
+        ON mj.id = r.mapping_job_id
+        AND mj.linkedin_account_id = la.id  -- CRITICAL: Only count relationships from mapping jobs that belong to this contributor
+      WHERE oura.organization_id = $1
+        AND om.organization_id = $1
+        AND om.contribution_role = 'CONTRIBUTOR'
+      GROUP BY om.user_id
+    ),
+    llm_job_status AS (
+      -- Get LLM inference job completion status for each contributor
+      -- Only includes users who have organization_assignment_jobs
+      -- Users without assignment jobs will have NULL (treated as false)
+      SELECT DISTINCT ON (om.user_id)
+        om.user_id,
+        CASE 
+          WHEN lij.completed_at IS NOT NULL THEN true
+          ELSE false
+        END as llm_job_completed
+      FROM public.organization_members om
+      INNER JOIN monitoring.organization_assignment_jobs oaj
+        ON oaj.organization_id = om.organization_id
+      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
+      LEFT JOIN monitoring.llm_inference_jobs lij
+        ON lij.mapping_job_id = oaj.mapping_job_id
+      WHERE om.organization_id = $1
+        AND om.contribution_role = 'CONTRIBUTOR'
+        AND la.user_id = om.user_id
+      ORDER BY om.user_id, oaj.created_at DESC, lij.created_at DESC NULLS LAST
+    )
+    SELECT 
+      om.id,
+      om.user_id,
+      om.organization_id,
+      om.contribution_role,
+      om.permissions_role,
+      om.created_at,
+      COALESCE(rc.relationships_count, 0) as relationships_count,
+      COALESCE(ljs.llm_job_completed, false) as llm_job_completed
+    FROM public.organization_members om
+    INNER JOIN relationship_counts rc ON rc.user_id = om.user_id
+    LEFT JOIN llm_job_status ljs ON ljs.user_id = om.user_id
+    WHERE om.organization_id = $1 
+      AND om.contribution_role = 'CONTRIBUTOR'
+      AND rc.relationships_count > 0
+    ORDER BY 
+      -- Primary sort: LLM job completed status (descending) - completed jobs first, then pending/in-progress
+      -- true (completed) comes before false (pending/not started)
+      COALESCE(ljs.llm_job_completed, false) DESC,
+      -- Secondary sort: relationship count (descending) - most relationships first within each status group
+      COALESCE(rc.relationships_count, 0) DESC,
+      -- Tertiary sort: created_at (ascending) - oldest first when status and relationship count are equal
+      om.created_at ASC
+    LIMIT $2 OFFSET $3
+  `;
+    const results = await (0, pg_client_1.query)(db, sql, [organizationId, limit, offset]);
+    return results.map(r => ({
+        id: r.id,
+        userId: r.user_id,
+        organizationId: r.organization_id,
+        contributionRole: r.contribution_role,
+        permissionsRole: r.permissions_role,
+        createdAt: r.created_at,
+    }));
+}
+/**
+ * Get a specific organization membership for a user
+ *
+ * @param db - Database instance
+ * @param userId - User ID
+ * @param organizationId - Organization ID
+ * @returns Organization membership or null if not found
+ */
+async function getOrganizationMembershipForUser(db, userId, organizationId) {
+    const sql = `
+    SELECT id, user_id, organization_id, contribution_role, permissions_role, created_at
+    FROM public.organization_members
+    WHERE user_id = $1 AND organization_id = $2
+    LIMIT 1
+  `;
+    const result = await (0, pg_client_1.queryOne)(db, sql, [userId, organizationId]);
+    if (!result)
+        return null;
+    return {
+        id: result.id,
+        userId: result.user_id,
+        organizationId: result.organization_id,
+        contributionRole: result.contribution_role,
+        permissionsRole: result.permissions_role,
+        createdAt: result.created_at,
+    };
+}
+/**
+ * Get a specific contributor by user_id with full details
+ * Returns the same data structure as getOrganizationContributors but for a single user
+ * This is useful for direct lookups without pagination
+ *
+ * @param db - Database instance
+ * @param organizationId - Organization ID
+ * @param userId - User ID to fetch
+ * @returns Contributor data or null if not found or not a contributor with relationships
+ */
+async function getOrganizationContributorByUserId(db, organizationId, userId) {
+    // Use the same query logic as getOrganizationContributors but filter by user_id
+    // Updated to use organization_member_id for faster, more accurate lookups
+    const sql = `
+    WITH relationship_counts AS (
+      -- Count distinct relationships for each contributor using organization_member_id
+      -- This ensures we only count relationships assigned to the specific contributor,
+      -- not relationships where they appear as the "other person" in someone else's mapping job
+      SELECT 
+        om.user_id,
+        COUNT(DISTINCT 
+          CASE 
+            WHEN r.linkedin_account_id_a = la.id THEN r.linkedin_account_id_b
+            ELSE r.linkedin_account_id_a
+          END
+        ) as relationships_count
+      FROM public.organization_members om
+      INNER JOIN linkedin.accounts la ON la.user_id = om.user_id
+      INNER JOIN public.organization_user_relationships_assignments oura
+        ON oura.organization_member_id = om.id  -- Use organization_member_id for faster lookup
+      INNER JOIN linkedin.relationships r
+        ON r.id = oura.linkedin_relationship_id
+        AND (r.linkedin_account_id_a = la.id OR r.linkedin_account_id_b = la.id)
+      INNER JOIN monitoring.mapping_jobs mj
+        ON mj.id = r.mapping_job_id
+        AND mj.linkedin_account_id = la.id  -- CRITICAL: Only count relationships from mapping jobs that belong to this contributor
+      WHERE oura.organization_id = $1
+        AND om.organization_id = $1
+        AND om.contribution_role = 'CONTRIBUTOR'
+      GROUP BY om.user_id
+    ),
+    llm_job_status AS (
+      -- Get LLM inference job completion status for each contributor
+      SELECT DISTINCT ON (om.user_id)
+        om.user_id,
+        CASE 
+          WHEN lij.completed_at IS NOT NULL THEN true
+          ELSE false
+        END as llm_job_completed
+      FROM public.organization_members om
+      INNER JOIN monitoring.organization_assignment_jobs oaj
+        ON oaj.organization_id = om.organization_id
+      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
+      LEFT JOIN monitoring.llm_inference_jobs lij
+        ON lij.mapping_job_id = oaj.mapping_job_id
+      WHERE om.organization_id = $1
+        AND om.contribution_role = 'CONTRIBUTOR'
+        AND la.user_id = om.user_id
+      ORDER BY om.user_id, oaj.created_at DESC, lij.created_at DESC NULLS LAST
+    )
+    SELECT 
+      om.id,
+      om.user_id,
+      om.organization_id,
+      om.contribution_role,
+      om.permissions_role,
+      om.created_at,
+      COALESCE(rc.relationships_count, 0) as relationships_count,
+      COALESCE(ljs.llm_job_completed, false) as llm_job_completed
+    FROM public.organization_members om
+    INNER JOIN relationship_counts rc ON rc.user_id = om.user_id
+    LEFT JOIN llm_job_status ljs ON ljs.user_id = om.user_id
+    WHERE om.organization_id = $1 
+      AND om.contribution_role = 'CONTRIBUTOR'
+      AND om.user_id = $2
+      AND rc.relationships_count > 0
+    LIMIT 1
+  `;
+    const result = await (0, pg_client_1.queryOne)(db, sql, [organizationId, userId]);
+    if (!result)
+        return null;
+    return {
+        id: result.id,
+        userId: result.user_id,
+        organizationId: result.organization_id,
+        contributionRole: result.contribution_role,
+        permissionsRole: result.permissions_role,
+        createdAt: result.created_at,
+    };
+}
+/**
+ * Find which page a contributor appears on in the paginated contributors list
+ * Uses the same sorting logic as getOrganizationContributors
+ *
+ * @param db - Database instance
+ * @param organizationId - Organization ID
+ * @param userId - User ID to find
+ * @param limit - Page size (default: 50)
+ * @returns Page number (1-indexed) or null if user is not a contributor with relationships
+ */
+async function findContributorPage(db, organizationId, userId, limit = 50) {
+    const sql = `
+    WITH relationship_counts AS (
+      -- Count distinct relationships for each contributor's LinkedIn account
+      SELECT 
+        la.user_id,
+        COUNT(DISTINCT 
+          CASE 
+            WHEN r.linkedin_account_id_a = la.id THEN r.linkedin_account_id_b
+            ELSE r.linkedin_account_id_a
+          END
+        ) as relationships_count
+      FROM linkedin.accounts la
+      INNER JOIN linkedin.relationships r
+        ON (r.linkedin_account_id_a = la.id OR r.linkedin_account_id_b = la.id)
+      INNER JOIN public.organization_user_relationships_assignments oura
+        ON oura.linkedin_relationship_id = r.id
+      WHERE oura.organization_id = $1
+      GROUP BY la.user_id
+    ),
+    llm_job_status AS (
+      -- Get LLM inference job completion status for each contributor
+      SELECT DISTINCT ON (om.user_id)
+        om.user_id,
+        CASE 
+          WHEN lij.completed_at IS NOT NULL THEN true
+          ELSE false
+        END as llm_job_completed
+      FROM public.organization_members om
+      INNER JOIN monitoring.organization_assignment_jobs oaj
+        ON oaj.organization_id = om.organization_id
+      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
+      LEFT JOIN monitoring.llm_inference_jobs lij
+        ON lij.mapping_job_id = oaj.mapping_job_id
+      WHERE om.organization_id = $1
+        AND om.contribution_role = 'CONTRIBUTOR'
+        AND la.user_id = om.user_id
+      ORDER BY om.user_id, oaj.created_at DESC, lij.created_at DESC NULLS LAST
+    ),
+    ranked_contributors AS (
+      SELECT 
+        om.user_id,
+        ROW_NUMBER() OVER (
+          ORDER BY 
+            -- Primary sort: LLM job completed status (descending)
+            COALESCE(ljs.llm_job_completed, false) DESC,
+            -- Secondary sort: relationship count (descending)
+            COALESCE(rc.relationships_count, 0) DESC,
+            -- Tertiary sort: created_at (ascending)
+            om.created_at ASC
+        ) as rank
+      FROM public.organization_members om
+      INNER JOIN relationship_counts rc ON rc.user_id = om.user_id
+      LEFT JOIN llm_job_status ljs ON ljs.user_id = om.user_id
+      WHERE om.organization_id = $1 
+        AND om.contribution_role = 'CONTRIBUTOR'
+        AND rc.relationships_count > 0
+    )
+    SELECT rank
+    FROM ranked_contributors
+    WHERE user_id = $2
+  `;
+    const result = await (0, pg_client_1.queryOne)(db, sql, [
+        organizationId,
+        userId,
+    ]);
+    if (!result)
+        return null;
+    // Calculate page number (1-indexed)
+    const page = Math.ceil(result.rank / limit);
+    return page;
+}
+/**
+ * Update organization member role
+ *
+ * Updates the contribution role and/or permissions role for an existing organization member.
+ * This is useful for promoting VISITOR to CONTRIBUTOR or changing admin permissions.
+ *
+ * @param db - Database instance
+ * @param userId - User ID
+ * @param organizationId - Organization ID
+ * @param contributionRole - New contribution role (optional)
+ * @param permissionsRole - New permissions role (optional)
+ * @returns Updated organization membership or null if not found
+ */
+async function updateOrganizationMemberRole(db, userId, organizationId, params) {
+    (0, db_1.debugLogDbOperation)("update", "organization_members", { userId, organizationId, ...params }, undefined, {
+        operation: "updateOrganizationMemberRole",
+    });
+    if (!params.contributionRole && !params.permissionsRole) {
+        // Nothing to update, return existing
+        return getOrganizationMembershipForUser(db, userId, organizationId);
+    }
+    const updates = [];
+    const queryParams = [userId, organizationId];
+    let paramIndex = 3;
+    if (params.contributionRole !== undefined) {
+        updates.push(`contribution_role = $${paramIndex}`);
+        queryParams.push(params.contributionRole);
+        paramIndex++;
+    }
+    if (params.permissionsRole !== undefined) {
+        updates.push(`permissions_role = $${paramIndex}`);
+        queryParams.push(params.permissionsRole);
+        paramIndex++;
+    }
+    const sql = `
+    UPDATE public.organization_members
+    SET ${updates.join(", ")}
+    WHERE user_id = $1 AND organization_id = $2
+    RETURNING id, user_id, organization_id, contribution_role, permissions_role, created_at
+  `;
+    const result = await (0, pg_client_1.queryOne)(db, sql, queryParams);
+    if (!result)
+        return null;
+    return {
+        id: result.id,
+        userId: result.user_id,
+        organizationId: result.organization_id,
+        contributionRole: result.contribution_role,
+        permissionsRole: result.permissions_role,
+        createdAt: result.created_at,
+    };
+}
+/**
+ * Get assigned relationships for an organization member
+ *
+ * Returns relationships from organization_user_relationships_assignments
+ * where one of the LinkedIn accounts matches the target user's LinkedIn account.
+ * Deduplicates by connection person, keeping only the highest-scoring relationship
+ * for each unique connection.
+ *
+ * @param db - Database instance
+ * @param organizationId - Organization ID
+ * @param linkedinAccountId - LinkedIn account ID of the target member
+ * @param limit - Maximum number of relationships to return (default 50)
+ * @returns Array of relationships with scores, deduplicated by connection person
+ */
+async function getOrganizationMemberRelationships(db, organizationId, linkedinAccountId, limit = 50) {
+    // Updated to use organization_member_id for faster, more accurate lookups
+    // First get the organization_member_id for this user
+    const memberSql = `
+    SELECT om.id as organization_member_id
+    FROM public.organization_members om
+    INNER JOIN linkedin.accounts la ON la.user_id = om.user_id
+    WHERE om.organization_id = $1 AND la.id = $2
+    LIMIT 1
+  `;
+    const member = await (0, pg_client_1.queryOne)(db, memberSql, [organizationId, linkedinAccountId]);
+    if (!member) {
+        return [];
+    }
+    const sql = `
+    SELECT DISTINCT ON (
+      CASE 
+        WHEN r.linkedin_account_id_a = $1 THEN r.linkedin_account_id_b
+        ELSE r.linkedin_account_id_a
+      END
+    )
+      r.id,
+      r.linkedin_account_id_a,
+      r.linkedin_account_id_b,
+      r.score,
+      r.model_version,
+      r.analysis_type,
+      r.mapping_job_id,
+      r.metadata,
+      r.created_at,
+      oura.id AS organization_user_relationship_assignment_id
+    FROM linkedin.relationships r
+    INNER JOIN public.organization_user_relationships_assignments oura
+      ON oura.linkedin_relationship_id = r.id
+    WHERE 
+      oura.organization_member_id = $2
+      AND (r.linkedin_account_id_a = $1 OR r.linkedin_account_id_b = $1)
+    ORDER BY
+      CASE 
+        WHEN r.linkedin_account_id_a = $1 THEN r.linkedin_account_id_b
+        ELSE r.linkedin_account_id_a
+      END,
+      r.score DESC,
+      r.created_at DESC
+    LIMIT $3
+  `;
+    const results = await (0, pg_client_1.query)(db, sql, [linkedinAccountId, member.organization_member_id, limit]);
+    return results.map(r => ({
+        id: r.id,
+        linkedinAccountIdA: r.linkedin_account_id_a,
+        linkedinAccountIdB: r.linkedin_account_id_b,
+        score: r.score,
+        modelVersion: r.model_version,
+        analysisType: r.analysis_type,
+        mappingJobId: r.mapping_job_id,
+        metadata: r.metadata,
+        createdAt: r.created_at,
+        organizationUserRelationshipAssignmentId: r.organization_user_relationship_assignment_id,
+    }));
+}
+/**
+ * Get the count of assigned relationships for an organization member.
+ * This counts relationships from the organization_user_relationships_assignments table,
+ * which represents the actual connections assigned to the organization for this member.
+ *
+ * Counts only the top 50 relationships by score (highest first) to match
+ * the limit enforced in getOrganizationMemberRelationships.
+ *
+ * @param db - Database instance
+ * @param organizationId - Organization ID
+ * @param linkedinAccountId - LinkedIn account ID of the target member
+ * @returns Count of assigned relationships for this member in this organization (capped at 50)
+ */
+async function getOrganizationMemberRelationshipsCount(db, organizationId, linkedinAccountId) {
+    // Updated to use organization_member_id for faster, more accurate lookups
+    // First get the organization_member_id for this user
+    const memberSql = `
+    SELECT om.id as organization_member_id
+    FROM public.organization_members om
+    INNER JOIN linkedin.accounts la ON la.user_id = om.user_id
+    WHERE om.organization_id = $1 AND la.id = $2
+    LIMIT 1
+  `;
+    const member = await (0, pg_client_1.queryOne)(db, memberSql, [organizationId, linkedinAccountId]);
+    if (!member) {
+        return 0;
+    }
+    const sql = `
+    SELECT COUNT(*) as count
+    FROM (
+      SELECT DISTINCT ON (
+        CASE
+          WHEN r.linkedin_account_id_a = $1 THEN r.linkedin_account_id_b
+          ELSE r.linkedin_account_id_a
+        END
+      )
+        r.id
+      FROM linkedin.relationships r
+      INNER JOIN public.organization_user_relationships_assignments oura
+        ON oura.linkedin_relationship_id = r.id
+      WHERE 
+        oura.organization_member_id = $2
+        AND (r.linkedin_account_id_a = $1 OR r.linkedin_account_id_b = $1)
+      ORDER BY
+        CASE
+          WHEN r.linkedin_account_id_a = $1 THEN r.linkedin_account_id_b
+          ELSE r.linkedin_account_id_a
+        END,
+        r.score DESC,
+        r.created_at DESC
+      LIMIT 50
+    ) AS top_relationships
+  `;
+    const result = await (0, pg_client_1.queryOne)(db, sql, [
+        linkedinAccountId,
+        member.organization_member_id,
+    ]);
+    return result ? parseInt(result.count, 10) : 0;
+}
+/**
+ * Create a new organization
+ *
+ * @param db - Database instance
+ * @param organizationData - Organization data to create
+ * @returns Created organization
+ */
+async function createOrganization(db, organizationData) {
+    (0, db_1.debugLogDbOperation)("insert", "organizations", { organizationData });
+    // Generate deterministic dedup_key if not provided
+    // This ensures idempotency - same input = same dedup_key (no duplicates on retries)
+    // For manual orgs: dedup_key MUST be provided (used for deduplication)
+    // For LinkedIn orgs: Generate deterministic key from linkedin_company_id (not used for dedup, linkedin_company_id is)
+    // For personal workspaces: Generate deterministic key from created_by_user_id
+    let dedupKey;
+    if (organizationData.dedupKey) {
+        // Manual orgs: use provided dedup_key
+        dedupKey = organizationData.dedupKey;
+    }
+    else if (organizationData.linkedinCompanyId) {
+        // LinkedIn orgs: generate deterministic key from company_id
+        dedupKey = `linkedin-${organizationData.linkedinCompanyId}`;
+    }
+    else if (organizationData.createdByUserId) {
+        // Personal workspaces: generate deterministic key from user_id
+        dedupKey = `personal-${organizationData.createdByUserId}`;
+    }
+    else {
+        // This should never be reached:
+        // - Manual orgs: dedup_key is required
+        // - LinkedIn orgs: linkedin_company_id is always available (from Forager or provided)
+        // - Personal workspaces: created_by_user_id is always provided
+        throw new Error("Cannot generate dedup_key: missing required data. " +
+            "Manual orgs require dedup_key, LinkedIn orgs require linkedin_company_id, " +
+            "and personal workspaces require created_by_user_id.");
+    }
+    const sql = `
+    INSERT INTO public.organizations (
+      name, 
+      workspace_type, 
+      subscription_tier, 
+      created_by_user_id, 
+      image_url, 
+      linkedin_public_identifier,
+      linkedin_company_id,
+      dedup_key,
+      created_at
+    )
+    VALUES ($1, $2, $3, $4, $5, $6, $7, $8, NOW())
+    RETURNING id, name, workspace_type, subscription_tier, image_url, created_at, created_by_user_id
+  `;
+    const result = await (0, pg_client_1.queryOne)(db, sql, [
+        organizationData.name,
+        organizationData.workspaceType,
+        organizationData.subscriptionTier,
+        organizationData.createdByUserId ?? null,
+        organizationData.imageUrl || null,
+        organizationData.linkedinPublicIdentifier || null,
+        organizationData.linkedinCompanyId || null,
+        dedupKey,
+    ]);
+    if (!result) {
+        throw new Error("Failed to create organization");
+    }
+    return {
+        id: result.id,
+        name: result.name,
+        workspaceType: result.workspace_type,
+        subscriptionTier: result.subscription_tier,
+        imageUrl: result.image_url,
+        createdAt: result.created_at,
+        createdByUserId: result.created_by_user_id,
+    };
+}
+/**
+ * Update linkedin_public_identifier for an existing organization
+ *
+ * @param db - Database instance
+ * @param organizationId - Organization ID
+ * @param linkedinPublicIdentifier - LinkedIn public identifier to set
+ * @returns true if update was successful, false if no rows were updated
+ */
+async function updateOrganizationLinkedInPublicIdentifier(db, organizationId, linkedinPublicIdentifier) {
+    (0, db_1.debugLogDbOperation)("update", "organizations", { organizationId, linkedinPublicIdentifier });
+    const sql = `
+    UPDATE public.organizations 
+    SET linkedin_public_identifier = $1 
+    WHERE id = $2 AND (linkedin_public_identifier IS NULL OR linkedin_public_identifier != $1)
+    RETURNING id
+  `;
+    const result = await (0, pg_client_1.queryOne)(db, sql, [
+        linkedinPublicIdentifier,
+        organizationId,
+    ]);
+    return result !== null;
+}
+/**
+ * Find or create an organization member
+ *
+ * @param db - Database instance
+ * @param membershipData - Membership data
+ * @returns Created or existing organization member
+ */
+async function findOrCreateOrganizationMember(db, membershipData) {
+    (0, db_1.debugLogDbOperation)("select", "organization_members", { membershipData });
+    // Check if membership already exists
+    const existingSql = `
+    SELECT id, user_id, organization_id, contribution_role, permissions_role, created_at
+    FROM public.organization_members
+    WHERE organization_id = $1 AND user_id = $2
+    LIMIT 1
+  `;
+    const existing = await (0, pg_client_1.queryOne)(db, existingSql, [membershipData.organizationId, membershipData.userId]);
+    if (existing) {
+        return {
+            id: existing.id,
+            userId: existing.user_id,
+            organizationId: existing.organization_id,
+            contributionRole: existing.contribution_role,
+            permissionsRole: existing.permissions_role,
+            createdAt: existing.created_at,
+        };
+    }
+    // Create new membership
+    const insertSql = `
+    INSERT INTO public.organization_members (organization_id, user_id, contribution_role, permissions_role, created_at)
+    VALUES ($1, $2, $3, $4, NOW())
+    RETURNING id, user_id, organization_id, contribution_role, permissions_role, created_at
+  `;
+    const member = await (0, pg_client_1.queryOne)(db, insertSql, [
+        membershipData.organizationId,
+        membershipData.userId,
+        membershipData.contributionRole,
+        membershipData.permissionsRole,
+    ]);
+    if (!member) {
+        throw new Error("Failed to create organization member");
+    }
+    return {
+        id: member.id,
+        userId: member.user_id,
+        organizationId: member.organization_id,
+        contributionRole: member.contribution_role,
+        permissionsRole: member.permissions_role,
+        createdAt: member.created_at,
+    };
+}
+/**
+ * Find existing personal workspace for a user
+ * Each user can only have one personal workspace
+ *
+ * @param db - Database instance
+ * @param userId - User ID to find personal workspace for
+ * @returns Existing personal workspace or null
+ */
+async function findPersonalWorkspaceForUser(db, userId) {
+    (0, db_1.debugLogDbOperation)("select", "organizations", { userId });
+    const sql = `
+    SELECT o.id, o.name, o.workspace_type, o.subscription_tier, o.image_url, o.created_at, o.created_by_user_id
+    FROM public.organizations o
+    INNER JOIN public.organization_members om ON o.id = om.organization_id
+    WHERE o.workspace_type = 'INDIVIDUALS'
+      AND om.user_id = $1
+      AND om.contribution_role = 'CONTRIBUTOR'
+    LIMIT 1
+  `;
+    const result = await (0, pg_client_1.queryOne)(db, sql, [userId]);
+    if (!result)
+        return null;
+    return {
+        id: result.id,
+        name: result.name,
+        workspaceType: result.workspace_type,
+        subscriptionTier: result.subscription_tier,
+        imageUrl: result.image_url,
+        createdAt: result.created_at,
+        createdByUserId: result.created_by_user_id,
+    };
+}
+/**
+ * Get organization member by ID
+ *
+ * @param db - Database instance
+ * @param memberId - Organization member ID
+ * @returns Organization member or null if not found
+ */
+async function getOrganizationMemberById(db, memberId) {
+    (0, db_1.debugLogDbOperation)("select", "organization_members", { memberId });
+    const sql = `
+    SELECT 
+      id,
+      user_id,
+      organization_id,
+      contribution_role,
+      permissions_role,
+      created_at
+    FROM public.organization_members
+    WHERE id = $1
+    LIMIT 1
+  `;
+    const result = await (0, pg_client_1.queryOne)(db, sql, [memberId]);
+    if (!result) {
+        return null;
+    }
+    return {
+        id: result.id,
+        userId: result.user_id,
+        organizationId: result.organization_id,
+        contributionRole: result.contribution_role,
+        permissionsRole: result.permissions_role,
+        createdAt: result.created_at,
+    };
+}
+/**
+ * Update organization subscription tier
+ *
+ * @param db - Database instance
+ * @param organizationId - Organization ID
+ * @param subscriptionTier - New subscription tier
+ * @returns Updated organization or null if not found
+ */
+async function updateOrganizationSubscriptionTier(db, organizationId, subscriptionTier) {
+    (0, db_1.debugLogDbOperation)("update", "organizations", {
+        organizationId,
+        subscriptionTier,
+    });
+    const sql = `
+    UPDATE public.organizations
+    SET subscription_tier = $1
+    WHERE id = $2
+    RETURNING id, name, workspace_type, subscription_tier, image_url, created_at, created_by_user_id
+  `;
+    const result = await (0, pg_client_1.queryOne)(db, sql, [subscriptionTier, organizationId]);
+    if (!result) {
+        return null;
+    }
+    return {
+        id: result.id,
+        name: result.name,
+        workspaceType: result.workspace_type,
+        subscriptionTier: result.subscription_tier,
+        imageUrl: result.image_url,
+        createdAt: result.created_at,
+        createdByUserId: result.created_by_user_id,
+    };
+}
+//# sourceMappingURL=organization-operations.js.map