eggi-ai-db-schema-2 0.1.1

package/dist/lib/database-service.js

@@ -0,0 +1,1394 @@
+"use strict";
+/**
+ * =============================================================================
+ * DATABASE SERVICE - Clean Object-Oriented Database Management
+ * =============================================================================
+ *
+ * Provides a singleton database service that accepts connection parameters
+ * directly. No environment variables, no AWS dependencies - just clean
+ * database operations with provided connection info.
+ *
+ * @author Eggi.ai Team
+ * @version 3.0.0 - Clean architecture with input-based connections
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DatabaseService = exports.dbService = void 0;
+const pg_1 = require("pg");
+// Import ALL database operations from utility files
+const mapping_job_operations_1 = require("../utils/mapping-job-operations");
+const llm_inference_job_operations_1 = require("../utils/llm-inference-job-operations");
+const invitation_operations_1 = require("../utils/invitation-operations");
+const organization_assignment_job_operations_1 = require("../utils/organization-assignment-job-operations");
+const on_demand_mapping_operations_1 = require("../utils/on-demand-mapping-operations");
+const linkedin_account_operations_1 = require("../utils/linkedin-account-operations");
+const linkedin_data_operations_1 = require("../utils/linkedin-data-operations");
+const forager_linkedin_operations_1 = require("../utils/forager-linkedin-operations");
+const ghost_genius_linkedin_operations_1 = require("../utils/ghost-genius-linkedin-operations");
+const linkedin_profile_cache_1 = require("../utils/linkedin-profile-cache");
+const user_industry_operations_1 = require("../utils/user-industry-operations");
+const authenticated_user_operations_1 = require("../utils/authenticated-user-operations");
+const contact_operations_1 = require("../utils/contact-operations");
+const user_operations_1 = require("../utils/user-operations");
+const unipile_account_operations_1 = require("../utils/unipile-account-operations");
+const linkedin_account_relationship_operations_1 = require("../utils/linkedin-account-relationship-operations");
+const relationship_operations_1 = require("../utils/relationship-operations");
+const minimal_connections_1 = require("../queries/minimal-connections");
+const authentication_operations_1 = require("../utils/authentication-operations");
+const skills_operations_1 = require("../utils/skills-operations");
+const organization_operations_1 = require("../utils/organization-operations");
+const mapping_operations_1 = require("../utils/mapping-operations");
+const introduction_request_operations_1 = require("../utils/introduction-request-operations");
+const onboarding_operations_1 = require("../utils/onboarding-operations");
+const quota_operations_1 = require("../utils/quota-operations");
+/**
+ * Singleton Database Service Class
+ * Manages database connections and provides type-safe query methods
+ */
+class DatabaseService {
+    constructor() {
+        this.dbPromise = null;
+        this.isInitialized = false;
+    }
+    /**
+     * Get singleton instance of DatabaseService
+     */
+    static getInstance() {
+        if (!DatabaseService.instance) {
+            DatabaseService.instance = new DatabaseService();
+        }
+        return DatabaseService.instance;
+    }
+    /**
+     * Build database URL from provided connection configuration
+     */
+    buildDatabaseUrl(connectionConfig) {
+        // If complete URL is provided, use it directly
+        if (connectionConfig.databaseUrl) {
+            return connectionConfig.databaseUrl;
+        }
+        // Build URL from individual components
+        const { host = "localhost", port = 5432, database = "postgres", username = "postgres", password = "", ssl = true, } = connectionConfig;
+        // URL encode password to handle special characters
+        const encodedPassword = encodeURIComponent(password);
+        // Build connection string
+        const sslParam = ssl ? "?ssl=true&sslmode=require" : "?ssl=false";
+        const databaseUrl = `postgresql://${username}:${encodedPassword}@${host}:${port}/${database}${sslParam}&connect_timeout=30&application_name=eggi-db-service`;
+        return databaseUrl;
+    }
+    /**
+     * Initialize database connection with configuration
+     * REQUIRED: Must provide connection configuration
+     */
+    async initialize(config) {
+        if (!this.dbPromise) {
+            console.log("🚀 DatabaseService: Starting initialization");
+            if (!config.connection) {
+                throw new Error("DatabaseService: connection configuration is required");
+            }
+            // Default pool configuration
+            const defaultPoolConfig = {
+                max: 5,
+                idleTimeoutMillis: 120000,
+                connectionTimeoutMillis: 30000,
+            };
+            // Merge pool config
+            const poolConfig = {
+                ...defaultPoolConfig,
+                ...config.poolConfig,
+            };
+            console.log("🔧 DatabaseService: Connection configuration", {
+                host: config.connection.host || "provided in URL",
+                poolConfig,
+            });
+            let pgPoolConfig;
+            // If connection parameters are provided directly, use them (avoids URL encoding issues)
+            if (config.connection.host && config.connection.database) {
+                console.log("🔧 Using direct connection parameters (no URL encoding)");
+                pgPoolConfig = {
+                    host: config.connection.host,
+                    port: config.connection.port || 5432,
+                    database: config.connection.database,
+                    user: config.connection.username,
+                    password: config.connection.password,
+                    ssl: config.connection.ssl === false ? false : { rejectUnauthorized: false },
+                    ...poolConfig,
+                };
+            }
+            else {
+                // Fallback: Parse DATABASE_URL if provided
+                console.log("🔧 Using DATABASE_URL (with URL encoding)");
+                const databaseUrl = this.buildDatabaseUrl(config.connection);
+                const url = new URL(databaseUrl);
+                pgPoolConfig = {
+                    host: url.hostname,
+                    port: parseInt(url.port) || 5432,
+                    database: url.pathname.slice(1), // Remove leading '/'
+                    user: url.username,
+                    password: url.password,
+                    ssl: url.searchParams.get("sslmode") === "disable" || url.searchParams.get("ssl") === "false"
+                        ? false
+                        : { rejectUnauthorized: false },
+                    ...poolConfig,
+                };
+            }
+            // Initialize connection pool
+            const pool = new pg_1.Pool(pgPoolConfig);
+            this.dbPromise = Promise.resolve(pool);
+            await this.dbPromise;
+            this.isInitialized = true;
+            console.log("✅ DatabaseService: Initialization completed successfully");
+        }
+    }
+    /**
+     * Get database instance
+     * Throws error if not initialized
+     */
+    async getDb() {
+        if (!this.dbPromise) {
+            throw new Error("DatabaseService not initialized. Call initialize() with connection config first.");
+        }
+        return this.dbPromise;
+    }
+    /**
+     * Check if database is initialized
+     */
+    isReady() {
+        return this.isInitialized;
+    }
+    // =============================================================================
+    // COMPREHENSIVE DATABASE OPERATIONS - ALL RDS SCHEMA FUNCTIONS
+    // =============================================================================
+    // ============================================
+    // MAPPING JOB OPERATIONS
+    // ============================================
+    async createMappingJobForLinkedInAccount(params) {
+        const db = await this.getDb();
+        return (0, mapping_job_operations_1.createMappingJobForLinkedInAccount)(db, params);
+    }
+    async createMappingJobWithLinkedInAccounts(accountsData) {
+        const db = await this.getDb();
+        return (0, mapping_job_operations_1.createMappingJobsForLinkedInAccounts)(db, accountsData);
+    }
+    async startMappingJob(mappingJobId, metadata) {
+        const db = await this.getDb();
+        return (0, mapping_job_operations_1.startMappingJob)(db, mappingJobId, metadata);
+    }
+    async completeMappingJob(mappingJobId, metadata) {
+        const db = await this.getDb();
+        return (0, mapping_job_operations_1.completeMappingJob)(db, mappingJobId, metadata);
+    }
+    async validateMappingJobCompletion(mappingJobId) {
+        const db = await this.getDb();
+        return (0, mapping_job_operations_1.validateMappingJobCompletion)(db, mappingJobId);
+    }
+    async createLlmInferenceJob(params) {
+        const db = await this.getDb();
+        return (0, llm_inference_job_operations_1.createLlmInferenceJob)(db, params);
+    }
+    async createOrganizationAssignmentJob(params) {
+        const db = await this.getDb();
+        return (0, organization_assignment_job_operations_1.createOrganizationAssignmentJob)(db, params);
+    }
+    async completeOrganizationAssignmentJob(organizationAssignmentJobId, completionMetadata) {
+        const db = await this.getDb();
+        return (0, organization_assignment_job_operations_1.completeOrganizationAssignmentJob)(db, organizationAssignmentJobId, completionMetadata);
+    }
+    async getOrganizationAssignmentJobById(organizationAssignmentJobId) {
+        const db = await this.getDb();
+        return (0, organization_assignment_job_operations_1.getOrganizationAssignmentJobById)(db, organizationAssignmentJobId);
+    }
+    async checkExportAvailability(mappingJobId, organizationId) {
+        const db = await this.getDb();
+        return (0, organization_assignment_job_operations_1.checkExportAvailability)(db, mappingJobId, organizationId);
+    }
+    async checkExportAvailabilityForLinkedInAccount(linkedinAccountId, organizationId) {
+        const db = await this.getDb();
+        return (0, organization_assignment_job_operations_1.checkExportAvailabilityForLinkedInAccount)(db, linkedinAccountId, organizationId);
+    }
+    async getExportStatusByLinkedInIdentifier(linkedinIdentifierAcoa, organizationId) {
+        const db = await this.getDb();
+        return (0, organization_assignment_job_operations_1.getExportStatusByLinkedInIdentifier)(db, linkedinIdentifierAcoa, organizationId);
+    }
+    /**
+     * Get paginated exports for a user (requester)
+     * @param requesterLinkedinAccountId - LinkedIn account ID of the requester
+     * @param options - Query options (page, pageSize, sort, organizationId, status)
+     * @returns Paginated list of exports with profile and organization details
+     */
+    async getUserExports(requesterLinkedinAccountId, options = {}) {
+        const db = await this.getDb();
+        return (0, organization_assignment_job_operations_1.getUserExports)(db, requesterLinkedinAccountId, options);
+    }
+    async getLatestOrganizationAssignmentJobForUser(userId, organizationId) {
+        const db = await this.getDb();
+        return (0, organization_assignment_job_operations_1.getLatestOrganizationAssignmentJobForUser)(db, userId, organizationId);
+    }
+    async getLatestOrganizationAssignmentJob(mappingJobId, organizationId) {
+        const db = await this.getDb();
+        return (0, organization_assignment_job_operations_1.getLatestOrganizationAssignmentJob)(db, mappingJobId, organizationId);
+    }
+    async updateOrganizationAssignmentJobMetadata(organizationAssignmentJobId, metadata) {
+        const db = await this.getDb();
+        return (0, organization_assignment_job_operations_1.updateOrganizationAssignmentJobMetadata)(db, organizationAssignmentJobId, metadata);
+    }
+    async getRelationshipScoresForMappingJob(mappingJobId, options) {
+        const db = await this.getDb();
+        return (0, mapping_job_operations_1.getRelationshipScoresForMappingJob)(db, mappingJobId, options);
+    }
+    async getEnrichedRelationshipScoresForMappingJob(mappingJobId, mainLinkedinAccountId, options) {
+        const db = await this.getDb();
+        return (0, mapping_job_operations_1.getEnrichedRelationshipScoresForMappingJob)(db, mappingJobId, mainLinkedinAccountId, options);
+    }
+    async getRelationshipScoresForAccount(linkedinAccountId, options) {
+        const db = await this.getDb();
+        return (0, relationship_operations_1.getRelationshipScoresForAccount)(db, linkedinAccountId, options);
+    }
+    async getMappingJobWithLinkedInAccount(mappingJobId) {
+        const db = await this.getDb();
+        return (0, mapping_job_operations_1.getMappingJobWithLinkedInAccount)(db, mappingJobId);
+    }
+    // ============================================
+    // ONBOARDING OPERATIONS
+    // ============================================
+    async createOnboardingJob(data) {
+        const db = await this.getDb();
+        return (0, onboarding_operations_1.createOnboardingJob)(db, data);
+    }
+    async updateOnboardingJob(onboardingJobId, updates) {
+        const db = await this.getDb();
+        return (0, onboarding_operations_1.updateOnboardingJob)(db, onboardingJobId, updates);
+    }
+    async updateOnboardingJobStep(onboardingJobId, currentStep, nextStep, metadata) {
+        const db = await this.getDb();
+        return (0, onboarding_operations_1.updateOnboardingJobStep)(db, onboardingJobId, currentStep, nextStep, metadata);
+    }
+    async completeOnboardingJob(onboardingJobId, completionMetadata) {
+        const db = await this.getDb();
+        return (0, onboarding_operations_1.completeOnboardingJob)(db, onboardingJobId, completionMetadata);
+    }
+    async getOnboardingJobByUserId(userId) {
+        const db = await this.getDb();
+        return (0, onboarding_operations_1.getOnboardingJobByUserId)(db, userId);
+    }
+    async getOnboardingJobById(onboardingJobId) {
+        const db = await this.getDb();
+        return (0, onboarding_operations_1.getOnboardingJobById)(db, onboardingJobId);
+    }
+    // ============================================
+    // ON-DEMAND MAPPING OPERATIONS
+    // ============================================
+    async createOnDemandMappingJob(data) {
+        const db = await this.getDb();
+        return (0, on_demand_mapping_operations_1.createOnDemandMappingJob)(data);
+    }
+    /**
+     * Check and increment quota for a mapping job request
+     * Returns whether the operation is allowed based on quota limits
+     */
+    async checkAndIncrementMappingJobQuota(authenticatedUserId, organizationId, period = "daily") {
+        const db = await this.getDb();
+        return (0, quota_operations_1.checkAndIncrementQuota)(db, authenticatedUserId, organizationId, period);
+    }
+    /**
+     * Get current quota status without incrementing
+     */
+    async getMappingJobQuotaStatus(authenticatedUserId, organizationId, period = "daily") {
+        const db = await this.getDb();
+        return (0, quota_operations_1.getQuotaStatus)(db, authenticatedUserId, organizationId, period);
+    }
+    /**
+     * Get all quotas for a user across all organizations
+     * Returns quotas for all quota types (currently only mapping_jobs, but extensible)
+     */
+    async getAllQuotasForUser(authenticatedUserId) {
+        const db = await this.getDb();
+        return (0, quota_operations_1.getAllQuotasForUser)(db, authenticatedUserId);
+    }
+    /**
+     * Initialize quota records for all organization members when subscription is activated
+     * Creates daily and monthly quota records with appropriate limits based on subscription tier
+     */
+    async initializeQuotasForOrganization(organizationId) {
+        const db = await this.getDb();
+        return (0, quota_operations_1.initializeQuotasForOrganization)(db, organizationId);
+    }
+    async getAllOnDemandMappingJobsForUserMinimal(requesterLinkedinAccountId, limit, offset) {
+        const db = await this.getDb();
+        return (0, on_demand_mapping_operations_1.getOnDemandMappingJobsMinimal)(db, requesterLinkedinAccountId, limit || 50, offset || 0);
+    }
+    async checkMappingAvailability(targetLinkedInIdentifier) {
+        const db = await this.getDb();
+        return (0, mapping_job_operations_1.checkMappingAvailability)(db, targetLinkedInIdentifier);
+    }
+    async getOnDemandMappingJobById(jobId) {
+        return (0, on_demand_mapping_operations_1.getOnDemandMappingJobById)(jobId);
+    }
+    async getMappingJobById(mappingJobId) {
+        const db = await this.getDb();
+        return (0, mapping_job_operations_1.getMappingJobById)(db, mappingJobId);
+    }
+    async getTargetLinkedInAccountIdForOnDemandJobInOrganization(requesterLinkedinAccountId, organizationId) {
+        const db = await this.getDb();
+        return (0, on_demand_mapping_operations_1.getTargetLinkedInAccountIdForOnDemandJobInOrganization)(db, requesterLinkedinAccountId, organizationId);
+    }
+    async checkOnDemandMappingJobExists(requesterLinkedInAccountId, targetLinkedInIdentifier) {
+        return (0, on_demand_mapping_operations_1.checkOnDemandMappingJobExists)(requesterLinkedInAccountId, targetLinkedInIdentifier);
+    }
+    async updateOnDemandMappingJobId(requesterLinkedinAccountId, internalIdentifierAcoa, mappingJobId) {
+        return (0, on_demand_mapping_operations_1.updateOnDemandMappingJobId)(requesterLinkedinAccountId, internalIdentifierAcoa, mappingJobId);
+    }
+    // ============================================
+    // LINKEDIN ACCOUNT OPERATIONS (Forager-based)
+    // ============================================
+    async getLinkedInAccountsForUser(userId) {
+        const db = await this.getDb();
+        return (0, linkedin_account_operations_1.getLinkedInAccountsForUser)(db, userId);
+    }
+    // ============================================
+    // USER OPERATIONS
+    // ============================================
+    // User operations moved to dedicated user-operations.ts file
+    async getAuthenticatedUserByCognitoId(cognitoUserId) {
+        const db = await this.getDb();
+        return (0, user_operations_1.getAuthenticatedUserByCognitoId)(db, cognitoUserId);
+    }
+    async getAuthenticatedUserByUserId(userId) {
+        const db = await this.getDb();
+        return (0, user_operations_1.getAuthenticatedUserByUserId)(db, userId);
+    }
+    async getAuthenticatedUserByEmail(email) {
+        const db = await this.getDb();
+        return (0, user_operations_1.getAuthenticatedUserByEmail)(db, email);
+    }
+    async getUserByCognitoId(cognitoUserId) {
+        const db = await this.getDb();
+        return (0, user_operations_1.getUserByCognitoId)(db, cognitoUserId);
+    }
+    async getExistingUnipileAccount(cognitoUserId, platformType) {
+        const db = await this.getDb();
+        return (0, user_operations_1.getExistingUnipileAccount)(db, cognitoUserId, platformType);
+    }
+    // DEPRECATED: upsertLinkedAccount removed - use Forager-based operations instead
+    // ============================================
+    // AUTHENTICATED USER OPERATIONS
+    // ============================================
+    async findAuthenticatedUserByCognitoId(cognitoUserId) {
+        const db = await this.getDb();
+        return (0, authenticated_user_operations_1.findAuthenticatedUserByCognitoId)(db, cognitoUserId);
+    }
+    async findAuthenticatedUserById(authenticatedUserId) {
+        const db = await this.getDb();
+        return (0, authenticated_user_operations_1.findAuthenticatedUserById)(db, authenticatedUserId);
+    }
+    async findAuthenticatedUserByUserId(userId) {
+        const db = await this.getDb();
+        return (0, authenticated_user_operations_1.findAuthenticatedUserByUserId)(db, userId);
+    }
+    async updateAuthenticatedUserAdminStatus(cognitoUserId, isAdmin) {
+        const db = await this.getDb();
+        return (0, authenticated_user_operations_1.updateAuthenticatedUserAdminStatus)(db, cognitoUserId, isAdmin);
+    }
+    async getAllAdminUsers() {
+        const db = await this.getDb();
+        return (0, authenticated_user_operations_1.getAllAdminUsers)(db);
+    }
+    // ============================================
+    // LINKEDIN DATA OPERATIONS (Forager-based)
+    // ============================================
+    // ============================================
+    // LINKEDIN PROFILE CACHE OPERATIONS
+    // ============================================
+    async getCachedLinkedinProfiles(acoIdentifiers) {
+        const db = await this.getDb();
+        return (0, linkedin_profile_cache_1.getCachedLinkedInProfiles)(db, acoIdentifiers);
+    }
+    async getComprehensiveLinkedinProfile(identifier) {
+        const db = await this.getDb();
+        return (0, linkedin_profile_cache_1.getCachedLinkedInProfile)(db, identifier);
+    }
+    async getComprehensiveLinkedinProfileById(linkedinAccountId) {
+        const db = await this.getDb();
+        return (0, linkedin_profile_cache_1.getCachedLinkedInProfileById)(db, linkedinAccountId);
+    }
+    // ============================================
+    // CONTACT OPERATIONS
+    // ============================================
+    async createContactInfo(data) {
+        const db = await this.getDb();
+        return (0, contact_operations_1.createContactInfo)(db, data);
+    }
+    async upsertContactInfo(data) {
+        const db = await this.getDb();
+        return (0, contact_operations_1.upsertContactInfo)(db, data);
+    }
+    async batchCreateContactInfos(contactInfosData) {
+        const db = await this.getDb();
+        return (0, contact_operations_1.batchCreateContactInfos)(db, contactInfosData);
+    }
+    async batchUpsertContactInfos(contactInfosData) {
+        const db = await this.getDb();
+        return (0, contact_operations_1.batchUpsertContactInfos)(db, contactInfosData);
+    }
+    async getBatchUserEmails(userIds) {
+        const db = await this.getDb();
+        return (0, contact_operations_1.getBatchUserEmails)(db, userIds);
+    }
+    // ============================================
+    // UNIPILE ACCOUNT OPERATIONS
+    // ============================================
+    async createUnipileAccount(data) {
+        const db = await this.getDb();
+        return (0, unipile_account_operations_1.createUnipileAccount)(db, data);
+    }
+    async upsertUnipileAccount(data) {
+        const db = await this.getDb();
+        return (0, unipile_account_operations_1.upsertUnipileAccount)(db, data);
+    }
+    async getUserLinkedAccountStatus(cognitoUserId, activeOnly) {
+        const db = await this.getDb();
+        return (0, unipile_account_operations_1.getUserLinkedAccountStatus)(db, cognitoUserId, activeOnly);
+    }
+    async batchMarkAccountsAsSynced(accountIds, syncTime) {
+        const db = await this.getDb();
+        return (0, unipile_account_operations_1.batchMarkAccountsAsSynced)(db, accountIds, syncTime);
+    }
+    async checkAcoaAlreadyConnectedToDifferentUser(linkedinIdentifierAcoa, currentUserId) {
+        const db = await this.getDb();
+        return (0, unipile_account_operations_1.checkAcoaAlreadyConnectedToDifferentUser)(db, linkedinIdentifierAcoa, currentUserId);
+    }
+    // ============================================
+    // SOCIAL ACCOUNT RELATIONSHIP OPERATIONS
+    // ============================================
+    async upsertLinkedInAccountRelationshipScore(data) {
+        const db = await this.getDb();
+        return (0, linkedin_account_relationship_operations_1.upsertLinkedInAccountRelationshipScore)(db, data);
+    }
+    async getLinkedInAccountRelationshipScore(linkedinAccountIdA, linkedinAccountIdB, modelVersion, analysisType) {
+        const db = await this.getDb();
+        return (0, linkedin_account_relationship_operations_1.getLinkedInAccountRelationshipScore)(db, linkedinAccountIdA, linkedinAccountIdB, modelVersion, analysisType);
+    }
+    async getLinkedInRelationshipByIdWithAccountsAndUsers(relationshipId) {
+        const db = await this.getDb();
+        return (0, linkedin_account_relationship_operations_1.getLinkedInRelationshipByIdWithAccountsAndUsers)(db, relationshipId);
+    }
+    // ============================================
+    // RELATIONSHIP OPERATIONS
+    // ============================================
+    async getTopClosestConnections(cognitoUserId, modelVersion, limit, sortOrder) {
+        const db = await this.getDb();
+        return (0, relationship_operations_1.getTopClosestConnections)(db, cognitoUserId, modelVersion, limit, sortOrder);
+    }
+    // ============================================
+    // QUERY OPERATIONS
+    // ============================================
+    async getConnectionsForChromeExtension(identifier, identifierType) {
+        const db = await this.getDb();
+        return (0, minimal_connections_1.getConnectionsForChromeExtension)(db, identifier, identifierType);
+    }
+    // ============================================
+    // AUTHENTICATION OPERATIONS (Forager-based)
+    // ============================================
+    async handlePostAuthentication(cognitoUserId, userId, signupEmail) {
+        const db = await this.getDb();
+        return (0, authentication_operations_1.handlePostAuthentication)(db, cognitoUserId, userId, signupEmail);
+    }
+    // ============================================
+    // SKILLS OPERATIONS
+    // ============================================
+    async findOrCreateSkill(skillName, category) {
+        const db = await this.getDb();
+        return (0, skills_operations_1.findOrCreateSkill)(db, skillName, category);
+    }
+    async findOrCreateSkills(skillInputs) {
+        const db = await this.getDb();
+        return (0, skills_operations_1.findOrCreateSkills)(db, skillInputs);
+    }
+    async addProfileSkills(profileId, skillInputs) {
+        const db = await this.getDb();
+        return (0, skills_operations_1.addProfileSkills)(db, profileId, skillInputs);
+    }
+    async getProfileSkills(profileId) {
+        const db = await this.getDb();
+        return (0, skills_operations_1.getProfileSkills)(db, profileId);
+    }
+    async addWorkExperienceSkills(workExperienceId, skillInputs) {
+        const db = await this.getDb();
+        return (0, skills_operations_1.addWorkExperienceSkills)(db, workExperienceId, skillInputs);
+    }
+    async addEducationSkills(educationId, skillInputs) {
+        const db = await this.getDb();
+        return (0, skills_operations_1.addEducationSkills)(db, educationId, skillInputs);
+    }
+    async getEducationSkills(educationId) {
+        const db = await this.getDb();
+        return (0, skills_operations_1.getEducationSkills)(db, educationId);
+    }
+    async getWorkExperienceSkills(workExperienceId) {
+        const db = await this.getDb();
+        return (0, skills_operations_1.getWorkExperienceSkills)(db, workExperienceId);
+    }
+    async getPopularSkills(limit) {
+        const db = await this.getDb();
+        return (0, skills_operations_1.getPopularSkills)(db, limit);
+    }
+    // LinkedIn Account Operations (Forager-based - Primary)
+    async findLinkedInAccountByForagerId(foragerId) {
+        const db = await this.getDb();
+        return (0, forager_linkedin_operations_1.findLinkedInAccountByForagerId)(db, foragerId);
+    }
+    async findLinkedInAccountByPublicIdentifier(publicIdentifier) {
+        const db = await this.getDb();
+        return (0, forager_linkedin_operations_1.findLinkedInAccountByPublicIdentifier)(db, publicIdentifier);
+    }
+    async findLinkedInAccountByAnyIdentifier(identifier) {
+        const db = await this.getDb();
+        return (0, forager_linkedin_operations_1.findLinkedInAccountByAnyIdentifier)(db, identifier);
+    }
+    async findLinkedInAccountByAcoa(linkedinIdentifierAcoa) {
+        const db = await this.getDb();
+        return (0, ghost_genius_linkedin_operations_1.findLinkedInAccountByAcoa)(db, linkedinIdentifierAcoa);
+    }
+    async findOrCreateLinkedInAccountByAcoa(linkedinIdentifierAcoa, publicIdentifier, userId) {
+        const db = await this.getDb();
+        return (0, ghost_genius_linkedin_operations_1.findOrCreateLinkedInAccountByAcoa)(db, linkedinIdentifierAcoa, publicIdentifier, userId);
+    }
+    async findOrCreateLinkedInAccountByForagerId(foragerId, publicIdentifier, linkedinIdentifierAcoa, userId) {
+        const db = await this.getDb();
+        return (0, forager_linkedin_operations_1.findOrCreateLinkedInAccountByForagerId)(db, foragerId, publicIdentifier, linkedinIdentifierAcoa, userId);
+    }
+    async storeCompleteLinkedInProfileByForagerId(foragerId, profileData, userId, userWasCreated = false) {
+        const db = await this.getDb();
+        return (0, linkedin_data_operations_1.storeCompleteLinkedInProfileByForagerId)(db, foragerId, profileData, userId, userWasCreated);
+    }
+    /**
+     * Store complete LinkedIn profile using ACoA identifier (for Ghost Genius profiles)
+     */
+    async storeCompleteLinkedInProfileByAcoa(linkedinIdentifierAcoa, profileData, userId, userWasCreated = false) {
+        const db = await this.getDb();
+        return (0, linkedin_data_operations_1.storeCompleteLinkedInProfileByAcoa)(db, linkedinIdentifierAcoa, profileData, userId, userWasCreated);
+    }
+    async updateLinkedInAccountAcoaIdentifierByForagerId(foragerId, linkedinIdentifierAcoa) {
+        const db = await this.getDb();
+        const { updateLinkedInAccountAcoaIdentifierByForagerId } = await Promise.resolve().then(() => __importStar(require("../utils/forager-linkedin-operations")));
+        return updateLinkedInAccountAcoaIdentifierByForagerId(db, foragerId, linkedinIdentifierAcoa);
+    }
+    async updateLinkedInAccountAcoaIdentifierByForagerIdWithChangeDetection(foragerId, linkedinIdentifierAcoa) {
+        const db = await this.getDb();
+        const { updateLinkedInAccountAcoaIdentifierByForagerIdWithChangeDetection } = await Promise.resolve().then(() => __importStar(require("../utils/forager-linkedin-operations")));
+        return updateLinkedInAccountAcoaIdentifierByForagerIdWithChangeDetection(db, foragerId, linkedinIdentifierAcoa);
+    }
+    async updateLinkedInAccountProfilePictureUrl(linkedinAccountId, profilePictureUrl, profileImageHash) {
+        const db = await this.getDb();
+        const sql = profileImageHash
+            ? `
+        UPDATE linkedin.accounts
+        SET profile_image_cloudfront_url = $1,
+            profile_image_hash = $2
+        WHERE id = $3
+        RETURNING id, user_id, linkedin_identifier_acoa, public_identifier, forager_id,
+                  first_name, last_name, headline, summary, location,
+                  profile_picture_url, profile_image_cloudfront_url, profile_image_hash,
+                  follower_count, connections_count, profiles_updated_at, created_at
+      `
+            : `
+        UPDATE linkedin.accounts
+        SET profile_image_cloudfront_url = $1
+        WHERE id = $2
+        RETURNING id, user_id, linkedin_identifier_acoa, public_identifier, forager_id,
+                  first_name, last_name, headline, summary, location,
+                  profile_picture_url, profile_image_cloudfront_url, profile_image_hash,
+                  follower_count, connections_count, profiles_updated_at, created_at
+      `;
+        const params = profileImageHash
+            ? [profilePictureUrl, profileImageHash, linkedinAccountId]
+            : [profilePictureUrl, linkedinAccountId];
+        const result = await db.query(sql, params);
+        return result.rows[0];
+    }
+    async getLinkedInAccountProfileImageHash(linkedinAccountId) {
+        const db = await this.getDb();
+        const sql = `
+      SELECT profile_image_hash
+      FROM linkedin.accounts
+      WHERE id = $1
+      LIMIT 1
+    `;
+        const result = await db.query(sql, [linkedinAccountId]);
+        return result.rows[0]?.profile_image_hash || null;
+    }
+    async refreshCompleteLinkedInProfileByForagerId(foragerId, profileData, userId) {
+        const db = await this.getDb();
+        const { refreshCompleteLinkedInProfileByForagerId } = await Promise.resolve().then(() => __importStar(require("../utils/linkedin-data-operations")));
+        return refreshCompleteLinkedInProfileByForagerId(db, foragerId, profileData, userId);
+    }
+    // Authenticated User Operations (Forager-based)
+    async findAuthenticatedUserByForagerId(foragerId) {
+        const db = await this.getDb();
+        const { findAuthenticatedUserByForagerId } = await Promise.resolve().then(() => __importStar(require("../utils/authenticated-user-operations")));
+        return findAuthenticatedUserByForagerId(db, foragerId);
+    }
+    async findAuthenticatedUserByPublicIdentifier(publicIdentifier) {
+        const db = await this.getDb();
+        const { findAuthenticatedUserByPublicIdentifier } = await Promise.resolve().then(() => __importStar(require("../utils/authenticated-user-operations")));
+        return findAuthenticatedUserByPublicIdentifier(db, publicIdentifier);
+    }
+    async findAuthenticatedUserByAnyIdentifier(identifier) {
+        const db = await this.getDb();
+        const { findAuthenticatedUserByAnyIdentifier } = await Promise.resolve().then(() => __importStar(require("../utils/authenticated-user-operations")));
+        return findAuthenticatedUserByAnyIdentifier(db, identifier);
+    }
+    // Authentication Operations (Forager-based)
+    async handleLinkedInProfileFetchByForagerId(foragerId, publicIdentifier, profileData, linkedinIdentifierAcoa, providerAccountId) {
+        const db = await this.getDb();
+        const { handleLinkedInProfileFetchByForagerId } = await Promise.resolve().then(() => __importStar(require("../utils/authentication-operations")));
+        return handleLinkedInProfileFetchByForagerId(db, foragerId, publicIdentifier, profileData, linkedinIdentifierAcoa, providerAccountId);
+    }
+    async getMostRecentWorkExperience(linkedinAccountId) {
+        const db = await this.getDb();
+        return (0, linkedin_account_operations_1.getMostRecentWorkExperience)(db, linkedinAccountId);
+    }
+    // ============================================
+    // ORGANIZATION OPERATIONS
+    // ============================================
+    async getOrganizationMembershipsForUser(userId) {
+        const db = await this.getDb();
+        return (0, organization_operations_1.getOrganizationMembershipsForUser)(db, userId);
+    }
+    async getOrganizationById(organizationId) {
+        const db = await this.getDb();
+        return (0, organization_operations_1.getOrganizationById)(db, organizationId);
+    }
+    async findOrganizationByLinkedInCompanyId(linkedinCompanyId) {
+        const db = await this.getDb();
+        const { findOrganizationByLinkedInCompanyId } = await Promise.resolve().then(() => __importStar(require("../utils/organization-operations")));
+        return findOrganizationByLinkedInCompanyId(db, linkedinCompanyId);
+    }
+    async findOrganizationByLinkedInPublicIdentifier(linkedinPublicIdentifier) {
+        const db = await this.getDb();
+        const { findOrganizationByLinkedInPublicIdentifier } = await Promise.resolve().then(() => __importStar(require("../utils/organization-operations")));
+        return findOrganizationByLinkedInPublicIdentifier(db, linkedinPublicIdentifier);
+    }
+    async findOrganizationByDedupKey(dedupKey) {
+        const db = await this.getDb();
+        const { findOrganizationByDedupKey } = await Promise.resolve().then(() => __importStar(require("../utils/organization-operations")));
+        return findOrganizationByDedupKey(db, dedupKey);
+    }
+    async updateOrganizationLinkedInPublicIdentifier(organizationId, linkedinPublicIdentifier) {
+        const db = await this.getDb();
+        const { updateOrganizationLinkedInPublicIdentifier } = await Promise.resolve().then(() => __importStar(require("../utils/organization-operations")));
+        return updateOrganizationLinkedInPublicIdentifier(db, organizationId, linkedinPublicIdentifier);
+    }
+    async createCompanyMappingJob(options) {
+        const db = await this.getDb();
+        const { createCompanyMappingJob } = await Promise.resolve().then(() => __importStar(require("../utils/company-mapping-job-operations")));
+        return createCompanyMappingJob(db, options);
+    }
+    async updateCompanyMappingJobLinkedInId(companyMappingJobId, linkedinCompanyId) {
+        const db = await this.getDb();
+        const { updateCompanyMappingJobLinkedInId } = await Promise.resolve().then(() => __importStar(require("../utils/company-mapping-job-operations")));
+        return updateCompanyMappingJobLinkedInId(db, companyMappingJobId, linkedinCompanyId);
+    }
+    async updateCompanyMappingJobS3Path(companyMappingJobId, s3FilePath) {
+        const db = await this.getDb();
+        const { updateCompanyMappingJobS3Path } = await Promise.resolve().then(() => __importStar(require("../utils/company-mapping-job-operations")));
+        return updateCompanyMappingJobS3Path(db, companyMappingJobId, s3FilePath);
+    }
+    async updateCompanyMappingJobQueued(companyMappingJobId, employeesCount) {
+        const db = await this.getDb();
+        const { updateCompanyMappingJobQueued } = await Promise.resolve().then(() => __importStar(require("../utils/company-mapping-job-operations")));
+        return updateCompanyMappingJobQueued(db, companyMappingJobId, employeesCount);
+    }
+    async updateCompanyMappingJobStarted(companyMappingJobId) {
+        const db = await this.getDb();
+        const { updateCompanyMappingJobStarted } = await Promise.resolve().then(() => __importStar(require("../utils/company-mapping-job-operations")));
+        return updateCompanyMappingJobStarted(db, companyMappingJobId);
+    }
+    async updateCompanyMappingJobCompleted(companyMappingJobId, employeesCount) {
+        const db = await this.getDb();
+        const { updateCompanyMappingJobCompleted } = await Promise.resolve().then(() => __importStar(require("../utils/company-mapping-job-operations")));
+        return updateCompanyMappingJobCompleted(db, companyMappingJobId, employeesCount);
+    }
+    async getCompanyMappingJobById(companyMappingJobId) {
+        const db = await this.getDb();
+        const { getCompanyMappingJobById } = await Promise.resolve().then(() => __importStar(require("../utils/company-mapping-job-operations")));
+        return getCompanyMappingJobById(db, companyMappingJobId);
+    }
+    async updateCompanyMappingJobOrganizationId(companyMappingJobId, organizationId) {
+        const db = await this.getDb();
+        const { updateCompanyMappingJobOrganizationId } = await Promise.resolve().then(() => __importStar(require("../utils/company-mapping-job-operations")));
+        return updateCompanyMappingJobOrganizationId(db, companyMappingJobId, organizationId);
+    }
+    // =============================================================================
+    // RECURSIVE MAPPING JOB OPERATIONS
+    // =============================================================================
+    async createRecursiveMappingJob(options) {
+        const db = await this.getDb();
+        const { createRecursiveMappingJob } = await Promise.resolve().then(() => __importStar(require("../utils/recursive-mapping-job-operations")));
+        return createRecursiveMappingJob(db, options);
+    }
+    async getRecursiveMappingJobById(recursiveMappingJobId) {
+        const db = await this.getDb();
+        const { getRecursiveMappingJobById } = await Promise.resolve().then(() => __importStar(require("../utils/recursive-mapping-job-operations")));
+        return getRecursiveMappingJobById(db, recursiveMappingJobId);
+    }
+    async updateRecursiveMappingJobStarted(recursiveMappingJobId) {
+        const db = await this.getDb();
+        const { updateRecursiveMappingJobStarted } = await Promise.resolve().then(() => __importStar(require("../utils/recursive-mapping-job-operations")));
+        return updateRecursiveMappingJobStarted(db, recursiveMappingJobId);
+    }
+    async updateRecursiveMappingJobCompleted(recursiveMappingJobId, downstreamJobsCount) {
+        const db = await this.getDb();
+        const { updateRecursiveMappingJobCompleted } = await Promise.resolve().then(() => __importStar(require("../utils/recursive-mapping-job-operations")));
+        return updateRecursiveMappingJobCompleted(db, recursiveMappingJobId, downstreamJobsCount);
+    }
+    async updateOrganizationSubscriptionTier(organizationId, subscriptionTier) {
+        const db = await this.getDb();
+        const { updateOrganizationSubscriptionTier } = await Promise.resolve().then(() => __importStar(require("../utils/organization-operations")));
+        return updateOrganizationSubscriptionTier(db, organizationId, subscriptionTier);
+    }
+    // =============================================================================
+    // SUBSCRIPTION OPERATIONS
+    // =============================================================================
+    async upsertSubscription(subscriptionData) {
+        const db = await this.getDb();
+        const { upsertSubscription } = await Promise.resolve().then(() => __importStar(require("../utils/subscription-operations")));
+        return upsertSubscription(db, subscriptionData);
+    }
+    async getSubscriptionByStripeId(stripeSubscriptionId) {
+        const db = await this.getDb();
+        const { getSubscriptionByStripeId } = await Promise.resolve().then(() => __importStar(require("../utils/subscription-operations")));
+        return getSubscriptionByStripeId(db, stripeSubscriptionId);
+    }
+    async getSubscriptionByOrganizationId(organizationId) {
+        const db = await this.getDb();
+        const { getSubscriptionByOrganizationId } = await Promise.resolve().then(() => __importStar(require("../utils/subscription-operations")));
+        return getSubscriptionByOrganizationId(db, organizationId);
+    }
+    async hasOrganizationUsedFreeTrial(organizationId) {
+        const db = await this.getDb();
+        const { hasOrganizationUsedFreeTrial } = await Promise.resolve().then(() => __importStar(require("../utils/subscription-operations")));
+        return hasOrganizationUsedFreeTrial(db, organizationId);
+    }
+    async hasUserUsedFreeTrial(userId) {
+        const db = await this.getDb();
+        const { hasUserUsedFreeTrial } = await Promise.resolve().then(() => __importStar(require("../utils/subscription-operations")));
+        return hasUserUsedFreeTrial(db, userId);
+    }
+    async isStripeEventProcessed(stripeEventId) {
+        const db = await this.getDb();
+        const { isStripeEventProcessed } = await Promise.resolve().then(() => __importStar(require("../utils/subscription-operations")));
+        return isStripeEventProcessed(db, stripeEventId);
+    }
+    async updateSubscription(stripeSubscriptionId, updateData) {
+        const db = await this.getDb();
+        const { updateSubscription } = await Promise.resolve().then(() => __importStar(require("../utils/subscription-operations")));
+        return updateSubscription(db, stripeSubscriptionId, updateData);
+    }
+    async getOrganizationMembers(organizationId) {
+        const db = await this.getDb();
+        return (0, organization_operations_1.getOrganizationMembers)(db, organizationId);
+    }
+    async getOrganizationContributors(organizationId, limit = 50, offset = 0) {
+        const db = await this.getDb();
+        return (0, organization_operations_1.getOrganizationContributors)(db, organizationId, limit, offset);
+    }
+    async getOrganizationContributorsCount(organizationId) {
+        const db = await this.getDb();
+        return (0, organization_operations_1.getOrganizationContributorsCount)(db, organizationId);
+    }
+    async getOrganizationMembersCount(organizationId, contributionRole) {
+        const db = await this.getDb();
+        return (0, organization_operations_1.getOrganizationMembersCount)(db, organizationId, contributionRole);
+    }
+    async getOrganizationMembershipForUser(userId, organizationId) {
+        const db = await this.getDb();
+        return (0, organization_operations_1.getOrganizationMembershipForUser)(db, userId, organizationId);
+    }
+    /**
+     * Get organization member by ID
+     */
+    async getOrganizationMemberById(memberId) {
+        const db = await this.getDb();
+        const { getOrganizationMemberById } = await Promise.resolve().then(() => __importStar(require("../utils/organization-operations")));
+        return getOrganizationMemberById(db, memberId);
+    }
+    async getOrganizationContributorByUserId(organizationId, userId) {
+        const db = await this.getDb();
+        return (0, organization_operations_1.getOrganizationContributorByUserId)(db, organizationId, userId);
+    }
+    async findContributorPage(organizationId, userId, limit = 50) {
+        const db = await this.getDb();
+        return (0, organization_operations_1.findContributorPage)(db, organizationId, userId, limit);
+    }
+    async updateOrganizationMemberRole(userId, organizationId, params) {
+        const db = await this.getDb();
+        return (0, organization_operations_1.updateOrganizationMemberRole)(db, userId, organizationId, params);
+    }
+    async getOrganizationMemberRelationships(organizationId, linkedinAccountId, limit = 50) {
+        const db = await this.getDb();
+        return (0, organization_operations_1.getOrganizationMemberRelationships)(db, organizationId, linkedinAccountId, limit);
+    }
+    async getOrganizationMemberRelationshipsCount(organizationId, linkedinAccountId) {
+        const db = await this.getDb();
+        const { getOrganizationMemberRelationshipsCount } = await Promise.resolve().then(() => __importStar(require("../utils/organization-operations")));
+        return getOrganizationMemberRelationshipsCount(db, organizationId, linkedinAccountId);
+    }
+    async createOrganization(organizationData) {
+        const db = await this.getDb();
+        return (0, organization_operations_1.createOrganization)(db, organizationData);
+    }
+    async findOrCreateOrganizationMember(membershipData) {
+        const db = await this.getDb();
+        return (0, organization_operations_1.findOrCreateOrganizationMember)(db, membershipData);
+    }
+    async findPersonalWorkspaceForUser(userId) {
+        const db = await this.getDb();
+        return (0, organization_operations_1.findPersonalWorkspaceForUser)(db, userId);
+    }
+    async findOrCreateOrganizationMemberLegacy(params) {
+        const db = await this.getDb();
+        // Try to find existing member
+        const selectSql = `
+      SELECT id, organization_id, user_id, contribution_role, permissions_role, created_at
+      FROM public.organization_members
+      WHERE organization_id = $1 AND user_id = $2
+      LIMIT 1
+    `;
+        const existing = await db.query(selectSql, [params.organizationId, params.userId]);
+        if (existing.rows.length > 0) {
+            return existing.rows[0];
+        }
+        // Create new member
+        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, organization_id, user_id, contribution_role, permissions_role, created_at
+    `;
+        const result = await db.query(insertSql, [
+            params.organizationId,
+            params.userId,
+            params.contributionRole,
+            params.permissionsRole,
+        ]);
+        return result.rows[0];
+    }
+    async createOrganizationUserRelationshipAssignment(params) {
+        const db = await this.getDb();
+        const sql = `
+      INSERT INTO public.organization_user_relationships_assignments (organization_id, linkedin_relationship_id, created_at)
+      VALUES ($1, $2, NOW())
+      ON CONFLICT (organization_id, linkedin_relationship_id) DO NOTHING
+      RETURNING id, organization_id, linkedin_relationship_id, created_at
+    `;
+        const result = await db.query(sql, [params.organizationId, params.linkedinRelationshipId]);
+        // If no row was returned, it means the assignment already exists (ON CONFLICT DO NOTHING)
+        // This is not an error - it's idempotent behavior
+        if (!result.rows || result.rows.length === 0) {
+            // Return null to indicate the assignment already existed
+            return null;
+        }
+        return result.rows[0];
+    }
+    /**
+     * Bulk create organization user relationship assignments
+     * This is more efficient and atomic than individual inserts
+     *
+     * @param params - Parameters for bulk creation
+     * @returns Object with counts of created and skipped assignments
+     */
+    async bulkCreateOrganizationUserRelationshipAssignments(params) {
+        const db = await this.getDb();
+        if (params.linkedinRelationshipIds.length === 0) {
+            return { created: 0, skipped: 0 };
+        }
+        // Build VALUES clause for bulk insert
+        const values = [];
+        const sqlParams = [params.organizationId];
+        let paramIndex = 2;
+        params.linkedinRelationshipIds.forEach(relationshipId => {
+            values.push(`($1, $${paramIndex}, NOW())`);
+            sqlParams.push(relationshipId);
+            paramIndex++;
+        });
+        const sql = `
+      INSERT INTO public.organization_user_relationships_assignments (organization_id, linkedin_relationship_id, created_at)
+      VALUES ${values.join(", ")}
+      ON CONFLICT (organization_id, linkedin_relationship_id) DO NOTHING
+      RETURNING id, organization_id, linkedin_relationship_id, created_at
+    `;
+        const result = await db.query(sql, sqlParams);
+        const created = result.rows.length;
+        const skipped = params.linkedinRelationshipIds.length - created;
+        return { created, skipped };
+    }
+    async deleteOrganizationUserRelationshipAssignmentsByLinkedInAccount(params) {
+        const db = await this.getDb();
+        // Import the function from organization-relationship-operations
+        const { deleteOrganizationUserRelationshipAssignmentsByLinkedInAccount } = await Promise.resolve().then(() => __importStar(require("../utils/organization-relationship-operations")));
+        return deleteOrganizationUserRelationshipAssignmentsByLinkedInAccount(db, params);
+    }
+    /**
+     * Get organization relationship assignment by ID
+     * @param assignmentId - Organization relationship assignment ID
+     * @returns Assignment data or null if not found
+     */
+    async getOrganizationRelationshipAssignmentById(assignmentId) {
+        const db = await this.getDb();
+        const { getOrganizationRelationshipAssignmentById } = await Promise.resolve().then(() => __importStar(require("../utils/organization-relationship-operations")));
+        return getOrganizationRelationshipAssignmentById(db, assignmentId);
+    }
+    /**
+     * Find organization member for a relationship
+     * @param organizationId - Organization ID
+     * @param linkedinRelationshipId - LinkedIn relationship ID
+     * @returns Organization member ID or null if not found
+     */
+    async findOrganizationMemberForRelationship(organizationId, linkedinRelationshipId) {
+        const db = await this.getDb();
+        const { findOrganizationMemberForRelationship } = await Promise.resolve().then(() => __importStar(require("../utils/organization-relationship-operations")));
+        return findOrganizationMemberForRelationship(db, {
+            linkedinRelationshipId,
+            organizationId,
+        });
+    }
+    /**
+     * Delete all relationship assignments for an organization member
+     * Uses organization_member_id for faster, more accurate lookups
+     * @param organizationMemberId - Organization member ID
+     * @param client - Optional transaction client (if provided, uses it instead of getting new connection)
+     */
+    async deleteAssignmentsByOrganizationMember(organizationMemberId, client) {
+        const db = client || (await this.getDb());
+        const { deleteAssignmentsByOrganizationMember } = await Promise.resolve().then(() => __importStar(require("../utils/organization-assignment-operations")));
+        return deleteAssignmentsByOrganizationMember(db, organizationMemberId);
+    }
+    /**
+     * Bulk insert relationship assignments for an organization member
+     * Uses organization_member_id for faster, more accurate lookups
+     * @param params - Parameters for bulk insert
+     * @param client - Optional transaction client (if provided, uses it instead of getting new connection)
+     */
+    async bulkInsertAssignmentsForOrganizationMember(params, client) {
+        const db = client || (await this.getDb());
+        const { bulkInsertAssignmentsForOrganizationMember } = await Promise.resolve().then(() => __importStar(require("../utils/organization-assignment-operations")));
+        return bulkInsertAssignmentsForOrganizationMember(db, params);
+    }
+    /**
+     * Verify relationship assignments for an organization member after commit
+     * Uses organization_member_id for faster, more accurate lookups
+     */
+    async verifyAssignmentsForOrganizationMember(params) {
+        const db = await this.getDb();
+        const { verifyAssignmentsForOrganizationMember } = await Promise.resolve().then(() => __importStar(require("../utils/organization-assignment-operations")));
+        return verifyAssignmentsForOrganizationMember(db, params);
+    }
+    async findOrCreatePersonalWorkspace(params) {
+        const db = await this.getDb();
+        // Try to find existing personal workspace for this user
+        // Updated to use workspace_type instead of subscription_tier (migration 0039)
+        const selectSql = `
+      SELECT id, name, workspace_type, subscription_tier, created_by_user_id, image_url, created_at
+      FROM public.organizations
+      WHERE created_by_user_id = $1 AND workspace_type = 'INDIVIDUALS'
+      LIMIT 1
+    `;
+        const existing = await db.query(selectSql, [params.userId]);
+        if (existing.rows.length > 0) {
+            return existing.rows[0];
+        }
+        // Create new personal workspace with custom name or default
+        // Updated to use workspace_type and subscription_tier (migration 0039)
+        // New INDIVIDUALS workspaces default to WAITING_FOR_SUBSCRIPTION_SELECTION (not FREE_TIER)
+        const workspaceName = params.workspaceName || "Personal Workspace";
+        const insertOrgSql = `
+      INSERT INTO public.organizations (name, workspace_type, subscription_tier, created_by_user_id, image_url, created_at)
+      VALUES ($1, 'INDIVIDUALS', 'WAITING_FOR_SUBSCRIPTION_SELECTION', $2, NULL, NOW())
+      RETURNING id, name, workspace_type, subscription_tier, created_by_user_id, image_url, created_at
+    `;
+        const orgResult = await db.query(insertOrgSql, [workspaceName, params.userId]);
+        // Note: Personal workspaces always have a created_by_user_id (the user who created them)
+        const newOrg = orgResult.rows[0];
+        if (!newOrg) {
+            throw new Error("Failed to create personal workspace");
+        }
+        // Automatically assign the user as CONTRIBUTOR + ADMIN
+        const insertMemberSql = `
+      INSERT INTO public.organization_members (organization_id, user_id, contribution_role, permissions_role, created_at)
+      VALUES ($1, $2, 'CONTRIBUTOR', 'ADMIN', NOW())
+    `;
+        await db.query(insertMemberSql, [newOrg.id, params.userId]);
+        return newOrg;
+    }
+    /**
+     * Get user's personal workspace by finding the organization they are a member of with workspace_type INDIVIDUALS
+     * Every authenticated user should have exactly one personal workspace
+     * @param userId - The user's ID
+     * @returns The personal workspace organization or null if not found
+     */
+    async getUserPersonalWorkspace(userId) {
+        const db = await this.getDb();
+        // Find personal workspace by joining organization_members with organizations
+        // Updated to use workspace_type instead of subscription_tier (migration 0039)
+        const sql = `
+      SELECT o.id, o.name, o.workspace_type, o.subscription_tier, o.created_by_user_id, o.image_url, o.created_at
+      FROM public.organization_members om
+      INNER JOIN public.organizations o ON om.organization_id = o.id
+      WHERE om.user_id = $1 AND o.workspace_type = 'INDIVIDUALS'
+      LIMIT 1
+    `;
+        const result = await db.query(sql, [userId]);
+        if (result.rows.length === 0) {
+            return null;
+        }
+        return result.rows[0];
+    }
+    // =============================================================================
+    // USER OPERATIONS
+    // =============================================================================
+    async getUserById(userId) {
+        const db = await this.getDb();
+        return (0, user_operations_1.getUserById)(db, userId);
+    }
+    // =============================================================================
+    // MAPPING OPERATIONS
+    // =============================================================================
+    async getLatestCompletedMappingJobForUser(userId) {
+        const db = await this.getDb();
+        return (0, mapping_operations_1.getLatestCompletedMappingJobForUser)(db, userId);
+    }
+    async getLatestCompletedMappingJobForLinkedInAccount(linkedinAccountId) {
+        const db = await this.getDb();
+        const completedJobs = await (0, mapping_job_operations_1.getCompletedMappingJobs)(db, {
+            limit: 1,
+            linkedinAccountId,
+        });
+        return completedJobs.length > 0 ? completedJobs[0] : null;
+    }
+    async getRelationshipsForMappingJob(jobId, maxCount = 50) {
+        const db = await this.getDb();
+        return (0, mapping_operations_1.getRelationshipsForMappingJob)(db, jobId, maxCount);
+    }
+    async getAllRelationshipsForMappingJob(jobId, maxCount = null) {
+        const db = await this.getDb();
+        return (0, mapping_operations_1.getAllRelationshipsForMappingJob)(db, jobId, maxCount);
+    }
+    async getRelationshipCountForMappingJob(jobId) {
+        const db = await this.getDb();
+        return (0, mapping_operations_1.getRelationshipCountForMappingJob)(db, jobId);
+    }
+    async getLinkedInAccountByUserId(userId) {
+        const db = await this.getDb();
+        return (0, mapping_operations_1.getLinkedInAccountByUserId)(db, userId);
+    }
+    async getUserByLinkedInAccountId(linkedinAccountId) {
+        const db = await this.getDb();
+        return (0, mapping_operations_1.getUserByLinkedInAccountId)(db, linkedinAccountId);
+    }
+    async getLinkedInAccountWithUserByForagerId(foragerId) {
+        const db = await this.getDb();
+        return (0, forager_linkedin_operations_1.findLinkedInAccountWithUserByForagerId)(db, foragerId);
+    }
+    // =============================================================================
+    // LLM INFERENCE JOB OPERATIONS
+    // =============================================================================
+    async getLlmInferenceJobStatusForContributor(params) {
+        const db = await this.getDb();
+        return (0, llm_inference_job_operations_1.getLlmInferenceJobStatusForContributor)(db, params);
+    }
+    async getLlmInferenceJobStatusForMappingJob(mappingJobId) {
+        const db = await this.getDb();
+        return (0, llm_inference_job_operations_1.getLlmInferenceJobStatusForMappingJob)(db, mappingJobId);
+    }
+    async getAllLlmInferenceJobStatusesForOrganization(organizationId) {
+        const db = await this.getDb();
+        return (0, llm_inference_job_operations_1.getAllLlmInferenceJobStatusesForOrganization)(db, organizationId);
+    }
+    async getLinkedInAccountById(linkedinAccountId) {
+        const db = await this.getDb();
+        return (0, mapping_operations_1.getLinkedInAccountById)(db, linkedinAccountId);
+    }
+    // =============================================================================
+    // USER INDUSTRY OPERATIONS (Normalized)
+    // =============================================================================
+    /**
+     * Get all industries for a user
+     * @param userId - User ID
+     * @returns Array of industry names (lowercase)
+     */
+    async getUserIndustries(userId) {
+        const db = await this.getDb();
+        return (0, user_industry_operations_1.getUserIndustries)(db, userId);
+    }
+    /**
+     * Get industries for multiple users (batch query - optimized)
+     * @param userIds - Array of user IDs
+     * @returns Map of userId -> industry names array
+     */
+    async getBatchUserIndustries(userIds) {
+        const db = await this.getDb();
+        return (0, user_industry_operations_1.getBatchUserIndustries)(db, userIds);
+    }
+    /**
+     * Find or create an industry by name (always lowercase)
+     * @param industryName - Industry name
+     * @returns Industry ID
+     */
+    async findOrCreateIndustry(industryName) {
+        const db = await this.getDb();
+        return (0, user_industry_operations_1.findOrCreateIndustry)(db, industryName);
+    }
+    /**
+     * Set industries for a user (replaces existing)
+     * @param userId - User ID
+     * @param industryNames - Array of industry names
+     */
+    async setUserIndustries(userId, industryNames) {
+        const db = await this.getDb();
+        return (0, user_industry_operations_1.setUserIndustries)(db, userId, industryNames);
+    }
+    /**
+     * Add industries to a user (keeps existing)
+     * @param userId - User ID
+     * @param industryNames - Array of industry names to add
+     */
+    async addUserIndustries(userId, industryNames) {
+        const db = await this.getDb();
+        return (0, user_industry_operations_1.addUserIndustries)(db, userId, industryNames);
+    }
+    /**
+     * Remove specific industries from a user
+     * @param userId - User ID
+     * @param industryNames - Array of industry names to remove
+     */
+    async removeUserIndustries(userId, industryNames) {
+        const db = await this.getDb();
+        return (0, user_industry_operations_1.removeUserIndustries)(db, userId, industryNames);
+    }
+    /**
+     * Remove all industries from a user
+     * @param userId - User ID
+     */
+    async clearUserIndustries(userId) {
+        const db = await this.getDb();
+        return (0, user_industry_operations_1.clearUserIndustries)(db, userId);
+    }
+    /**
+     * Check if a user has a specific industry
+     * @param userId - User ID
+     * @param industryName - Industry name to check
+     * @returns True if user has the industry
+     */
+    async userHasIndustry(userId, industryName) {
+        const db = await this.getDb();
+        return (0, user_industry_operations_1.userHasIndustry)(db, userId, industryName);
+    }
+    /**
+     * Get all unique industries in the system
+     * @param limit - Optional limit (default: 1000)
+     * @returns Array of industry names
+     */
+    async getAllIndustries(limit) {
+        const db = await this.getDb();
+        return (0, user_industry_operations_1.getAllIndustries)(db, limit);
+    }
+    /**
+     * Search industries by partial name match
+     * @param searchTerm - Search term (case-insensitive)
+     * @param limit - Optional limit (default: 20)
+     * @returns Array of matching industry names
+     */
+    async searchIndustries(searchTerm, limit) {
+        const db = await this.getDb();
+        return (0, user_industry_operations_1.searchIndustries)(db, searchTerm, limit);
+    }
+    // =============================================================================
+    // INVITATION OPERATIONS
+    // =============================================================================
+    async createInvitation(email, invitedByUserId, shadowUserId, organizationId, invitationMessage, invitedUserPermissionsRole, expiresInDays) {
+        const db = await this.getDb();
+        return (0, invitation_operations_1.createInvitation)(db, {
+            email,
+            invitedByUserId,
+            shadowUserId,
+            organizationId,
+            ...(invitationMessage !== undefined && { invitationMessage }),
+            ...(invitedUserPermissionsRole !== undefined && { invitedUserPermissionsRole }),
+            ...(expiresInDays !== undefined && { expiresInDays }),
+        });
+    }
+    async validateInvitationToken(token) {
+        const db = await this.getDb();
+        return (0, invitation_operations_1.validateInvitationToken)(db, token);
+    }
+    async validateInvitationEligibility(email) {
+        const db = await this.getDb();
+        return (0, invitation_operations_1.validateInvitationEligibility)(db, email);
+    }
+    async markInvitationAsUsed(token) {
+        const db = await this.getDb();
+        return (0, invitation_operations_1.markInvitationAsUsed)(db, token);
+    }
+    async revokeInvitation(invitationId) {
+        const db = await this.getDb();
+        return (0, invitation_operations_1.revokeInvitation)(db, invitationId);
+    }
+    async getInvitationById(invitationId) {
+        const db = await this.getDb();
+        return (0, invitation_operations_1.getInvitationById)(db, invitationId);
+    }
+    async getInvitationsSentByUser(invitedByUserId) {
+        const db = await this.getDb();
+        return (0, invitation_operations_1.getInvitationsSentByUser)(db, invitedByUserId);
+    }
+    async getPendingInvitationsByOrganization(organizationId) {
+        const db = await this.getDb();
+        return (0, invitation_operations_1.getPendingInvitationsByOrganization)(db, organizationId);
+    }
+    async getAllInvitationsByOrganization(organizationId) {
+        const db = await this.getDb();
+        return (0, invitation_operations_1.getAllInvitationsByOrganization)(db, organizationId);
+    }
+    async hasPendingInvitation(email, organizationId) {
+        const db = await this.getDb();
+        return (0, invitation_operations_1.hasPendingInvitation)(db, email, organizationId);
+    }
+    async hasActiveInvitationByEmail(email) {
+        const db = await this.getDb();
+        const { hasActiveInvitationByEmail } = await Promise.resolve().then(() => __importStar(require("../utils/invitation-operations")));
+        return hasActiveInvitationByEmail(db, email);
+    }
+    async hasActiveInvitationByEmailForOrg(email, organizationId) {
+        const db = await this.getDb();
+        const { hasActiveInvitationByEmailForOrg } = await Promise.resolve().then(() => __importStar(require("../utils/invitation-operations")));
+        return hasActiveInvitationByEmailForOrg(db, email, organizationId);
+    }
+    async isEmailUsedByAuthenticatedUser(email) {
+        const db = await this.getDb();
+        const { isEmailUsedByAuthenticatedUser } = await Promise.resolve().then(() => __importStar(require("../utils/invitation-operations")));
+        return isEmailUsedByAuthenticatedUser(db, email);
+    }
+    async isEmailReservedByContactInfo(email) {
+        const db = await this.getDb();
+        const { isEmailReservedByContactInfo } = await Promise.resolve().then(() => __importStar(require("../utils/invitation-operations")));
+        return isEmailReservedByContactInfo(db, email);
+    }
+    async cleanupExpiredInvitations(olderThanDays = 90) {
+        const db = await this.getDb();
+        return (0, invitation_operations_1.cleanupExpiredInvitations)(db, olderThanDays);
+    }
+    // =============================================================================
+    // INTRODUCTION REQUEST OPERATIONS
+    // =============================================================================
+    async createIntroductionRequest(params) {
+        const db = await this.getDb();
+        return (0, introduction_request_operations_1.createIntroductionRequest)(db, params);
+    }
+    async getIntroductionRequestsByUser(userId, limit) {
+        const db = await this.getDb();
+        return (0, introduction_request_operations_1.getIntroductionRequestsByUser)(db, userId, limit);
+    }
+    async getIntroductionRequestById(requestId) {
+        const db = await this.getDb();
+        return (0, introduction_request_operations_1.getIntroductionRequestById)(db, requestId);
+    }
+    async hasExistingIntroductionRequest(byUserId, toRelationshipId) {
+        const db = await this.getDb();
+        return (0, introduction_request_operations_1.hasExistingIntroductionRequest)(db, byUserId, toRelationshipId);
+    }
+    async updateIntroductionRequestStatus(requestId, status) {
+        const db = await this.getDb();
+        return (0, introduction_request_operations_1.updateIntroductionRequestStatus)(db, requestId, status);
+    }
+    async markIntroductionRequestAsSeen(requestId) {
+        const db = await this.getDb();
+        return (0, introduction_request_operations_1.markIntroductionRequestAsSeen)(db, requestId);
+    }
+    async getReceivedIntroductionRequests(userId, organizationId) {
+        const db = await this.getDb();
+        return (0, introduction_request_operations_1.getReceivedIntroductionRequests)(db, userId, organizationId);
+    }
+    async getSentIntroductionRequests(userId, organizationId) {
+        const db = await this.getDb();
+        return (0, introduction_request_operations_1.getSentIntroductionRequests)(db, userId, organizationId);
+    }
+    async markReceivedIntroductionRequestsAsSeen(userId, organizationId) {
+        const db = await this.getDb();
+        return (0, introduction_request_operations_1.markReceivedIntroductionRequestsAsSeen)(db, userId, organizationId);
+    }
+    // ============================================
+    // USER OPERATIONS
+    // ============================================
+    async createUser(params) {
+        const db = await this.getDb();
+        const sql = `
+      INSERT INTO public.users (given_name, family_name, created_at)
+      VALUES ($1, $2, NOW())
+      RETURNING id, given_name, family_name, summary, embedding_summary, embedding, created_at
+    `;
+        const result = await db.query(sql, [params.givenName, params.familyName]);
+        return result.rows[0];
+    }
+    // ============================================
+    // AUTHENTICATED USER OPERATIONS
+    // ============================================
+    async createAuthenticatedUser(params) {
+        const db = await this.getDb();
+        return (0, authenticated_user_operations_1.createAuthenticatedUser)(db, params);
+    }
+    // ============================================
+    // Company Sheet Upload Operations
+    // ============================================
+    async createCompanySheetUpload(data) {
+        const db = await this.getDb();
+        const { createCompanySheetUpload } = await Promise.resolve().then(() => __importStar(require("../utils/company-sheet-upload-operations")));
+        return createCompanySheetUpload(db, data);
+    }
+    async getCompanySheetUploadById(sheetUploadId) {
+        const db = await this.getDb();
+        const { getCompanySheetUploadById } = await Promise.resolve().then(() => __importStar(require("../utils/company-sheet-upload-operations")));
+        return getCompanySheetUploadById(db, sheetUploadId);
+    }
+    async updateCompanySheetUploadJobId(sheetUploadId, companyMappingJobId) {
+        const db = await this.getDb();
+        const { updateCompanySheetUploadJobId } = await Promise.resolve().then(() => __importStar(require("../utils/company-sheet-upload-operations")));
+        return updateCompanySheetUploadJobId(db, sheetUploadId, companyMappingJobId);
+    }
+}
+exports.DatabaseService = DatabaseService;
+DatabaseService.instance = null;
+// Export singleton instance
+exports.dbService = DatabaseService.getInstance();
+//# sourceMappingURL=database-service.js.map