@equilateral_ai/mindmeld 3.3.1 → 3.5.0

package/src/handlers/admin/adminSetup.js

@@ -0,0 +1,216 @@
+/**
+ * Admin Setup Handler
+ * One-time setup for enterprise clients via Lambda invocation
+ *
+ * Invoke via AWS CLI:
+ *   aws lambda invoke --function-name rapport-api-prod-AdminSetup \
+ *     --payload '{"action":"setup-equilateral"}' \
+ *     --profile production-sso response.json
+ */
+
+const { wrapHandler, executeQuery, createSuccessResponse, createErrorResponse, handleError } = require('../helpers');
+
+const SETUP_CONFIGS = {
+    'setup-equilateral': {
+        client: {
+            client_id: 'EQUILATERAL_MAIN',
+            client_name: 'Equilateral AI',
+            client_type: 'ENTERPRISE',
+            subscription_tier: 'enterprise',
+            seat_count: 25,
+            billing_type: 'internal'
+        },
+        company: {
+            company_id: 'EQUILATERAL_MAIN',
+            company_name: 'Equilateral AI'
+        },
+        admin_email: 'james.ford@happyhippo.ai',
+        invitations: [
+            { email: 'adeel@equilateral.ai', name: 'Adeel', role: 'member' },
+            { email: 'satish@equilateral.ai', name: 'Satish', role: 'member' }
+        ]
+    }
+};
+
+async function adminSetup({ body }) {
+    try {
+        const action = body?.action;
+
+        // Special action: list-tables
+        if (action === 'list-tables') {
+            const result = await executeQuery(`
+                SELECT table_name
+                FROM information_schema.tables
+                WHERE table_schema = 'rapport'
+                ORDER BY table_name
+            `);
+            return createSuccessResponse({
+                tables: result.rows.map(r => r.table_name)
+            }, `Found ${result.rows.length} tables`);
+        }
+
+        // Special action: run-sql (for migrations)
+        if (action === 'run-sql') {
+            const sql = body?.sql;
+            if (!sql) {
+                return createErrorResponse(400, 'sql parameter required');
+            }
+            try {
+                await executeQuery(sql);
+                return createSuccessResponse({ executed: true }, 'SQL executed successfully');
+            } catch (err) {
+                return createErrorResponse(500, `SQL error: ${err.message}`);
+            }
+        }
+
+        // Special action: query (returns results)
+        if (action === 'query') {
+            const sql = body?.sql;
+            if (!sql) {
+                return createErrorResponse(400, 'sql parameter required');
+            }
+            try {
+                const result = await executeQuery(sql);
+                return createSuccessResponse({ rows: result.rows, rowCount: result.rowCount }, `Query returned ${result.rowCount} rows`);
+            } catch (err) {
+                return createErrorResponse(500, `Query error: ${err.message}`);
+            }
+        }
+
+        if (!action || !SETUP_CONFIGS[action]) {
+            return createErrorResponse(400, `Invalid action. Available: ${Object.keys(SETUP_CONFIGS).join(', ')}, list-tables, run-sql`);
+        }
+
+        const config = SETUP_CONFIGS[action];
+        const results = [];
+
+        // 1. Create client
+        const existingClient = await executeQuery(
+            'SELECT client_id FROM rapport.clients WHERE client_id = $1',
+            [config.client.client_id]
+        );
+
+        if (existingClient.rows.length > 0) {
+            results.push({ step: 'client', status: 'exists', client_id: config.client.client_id });
+        } else {
+            await executeQuery(`
+                INSERT INTO rapport.clients (
+                    client_id, client_name, client_type, client_status, active,
+                    subscription_tier, subscription_status, billing_type, seat_count
+                )
+                VALUES ($1, $2, $3, 'Active', true, $4, 'active', $5, $6)
+            `, [
+                config.client.client_id,
+                config.client.client_name,
+                config.client.client_type,
+                config.client.subscription_tier,
+                config.client.billing_type,
+                config.client.seat_count
+            ]);
+            results.push({ step: 'client', status: 'created', client_id: config.client.client_id });
+        }
+
+        // 2. Create company
+        const existingCompany = await executeQuery(
+            'SELECT company_id FROM rapport.companies WHERE company_id = $1',
+            [config.company.company_id]
+        );
+
+        if (existingCompany.rows.length > 0) {
+            results.push({ step: 'company', status: 'exists', company_id: config.company.company_id });
+        } else {
+            await executeQuery(`
+                INSERT INTO rapport.companies (
+                    company_id, client_id, company_name, company_status
+                )
+                VALUES ($1, $2, $3, 'Active')
+            `, [config.company.company_id, config.client.client_id, config.company.company_name]);
+            results.push({ step: 'company', status: 'created', company_id: config.company.company_id });
+        }
+
+        // 3. Create admin entitlement
+        const existingEntitlement = await executeQuery(
+            'SELECT * FROM rapport.user_entitlements WHERE email_address = $1 AND company_id = $2',
+            [config.admin_email, config.company.company_id]
+        );
+
+        if (existingEntitlement.rows.length > 0) {
+            results.push({ step: 'admin_entitlement', status: 'exists', email: config.admin_email });
+        } else {
+            await executeQuery(`
+                INSERT INTO rapport.user_entitlements (
+                    email_address, client_id, company_id, admin, member
+                )
+                VALUES ($1, $2, $3, true, true)
+            `, [config.admin_email, config.client.client_id, config.company.company_id]);
+            results.push({ step: 'admin_entitlement', status: 'created', email: config.admin_email });
+        }
+
+        // 4. Create invitations (skip if table doesn't exist)
+        let invitationsSkipped = false;
+        for (const inv of config.invitations) {
+            if (invitationsSkipped) {
+                results.push({ step: 'invitation', status: 'skipped', email: inv.email, reason: 'table not found' });
+                continue;
+            }
+            try {
+                await executeQuery(`
+                    INSERT INTO rapport.enterprise_invitations
+                        (client_id, company_id, email, role, invited_by, status, created_at)
+                    VALUES ($1, $2, $3, $4, $5, 'pending', NOW())
+                    ON CONFLICT (company_id, email) DO UPDATE SET
+                        role = EXCLUDED.role,
+                        invited_by = EXCLUDED.invited_by,
+                        status = 'pending',
+                        created_at = NOW()
+                `, [config.client.client_id, config.company.company_id, inv.email.toLowerCase(), inv.role, config.admin_email]);
+                results.push({ step: 'invitation', status: 'created', email: inv.email, role: inv.role });
+            } catch (err) {
+                if (err.code === '42P01') { // relation does not exist
+                    invitationsSkipped = true;
+                    results.push({ step: 'invitation', status: 'skipped', email: inv.email, reason: 'enterprise_invitations table not found' });
+                } else {
+                    results.push({ step: 'invitation', status: 'error', email: inv.email, error: err.message });
+                }
+            }
+        }
+
+        // 5. Get final state
+        const clientInfo = await executeQuery(
+            'SELECT client_id, client_name, subscription_tier, seat_count FROM rapport.clients WHERE client_id = $1',
+            [config.client.client_id]
+        );
+
+        const entitlements = await executeQuery(
+            'SELECT email_address, admin, member FROM rapport.user_entitlements WHERE company_id = $1',
+            [config.company.company_id]
+        );
+
+        let invitationsList = [];
+        try {
+            const invitations = await executeQuery(
+                'SELECT email, role, status FROM rapport.enterprise_invitations WHERE company_id = $1',
+                [config.company.company_id]
+            );
+            invitationsList = invitations.rows;
+        } catch (err) {
+            if (err.code !== '42P01') throw err; // rethrow if not "relation does not exist"
+        }
+
+        return createSuccessResponse({
+            action,
+            results,
+            final_state: {
+                client: clientInfo.rows[0],
+                entitlements: entitlements.rows,
+                invitations: invitationsList
+            }
+        }, 'Setup complete');
+
+    } catch (error) {
+        console.error('Admin setup error:', error);
+        return handleError(error);
+    }
+}
+
+exports.handler = wrapHandler(adminSetup);

package/src/handlers/alerts/alertsAcknowledge.js

@@ -24,10 +24,10 @@ exports.handler = wrapHandler(async ({ requestContext, body }) => {
 
     // Check user role
     const userCheck = await executeQuery(`
-        SELECT ue."Company_ID", ue."Manager", ue."Admin", u."Super_Admin"
-        FROM "UserEntitlements" ue
-        JOIN "Users" u ON ue."Email_Address" = u."Email_Address"
-        WHERE ue."Email_Address" = $1
+        SELECT ue.company_id, ue.manager, ue.admin, u.super_admin
+        FROM rapport.user_entitlements ue
+        JOIN rapport.users u ON ue.email_address = u.email_address
+        WHERE ue.email_address = $1
     `, [email]);
 
     if (userCheck.rowCount === 0) {
@@ -35,7 +35,7 @@ exports.handler = wrapHandler(async ({ requestContext, body }) => {
     }
 
     const userRole = userCheck.rows[0];
-    const isManager = userRole.Manager || userRole.Admin || userRole.Super_Admin;
+    const isManager = userRole.manager || userRole.admin || userRole.super_admin;
 
     if (!isManager) {
         return createErrorResponse(403, 'Manager or Admin access required');
@@ -55,7 +55,7 @@ exports.handler = wrapHandler(async ({ requestContext, body }) => {
     }
 
     const alert = alertCheck.rows[0];
-    if (alert.company_id !== userRole.Company_ID && !userRole.Super_Admin) {
+    if (alert.company_id !== userRole.company_id && !userRole.super_admin) {
         return createErrorResponse(403, 'Access denied to this alert');
     }
 

package/src/handlers/alerts/alertsGet.js

@@ -24,13 +24,13 @@ exports.handler = wrapHandler(async ({ requestContext, queryStringParameters })
     // Check user role
     const userCheck = await executeQuery(`
         SELECT
-            ue."Company_ID",
-            ue."Manager",
-            ue."Admin",
-            u."Super_Admin"
-        FROM "UserEntitlements" ue
-        JOIN "Users" u ON ue."Email_Address" = u."Email_Address"
-        WHERE ue."Email_Address" = $1
+            ue.company_id,
+            ue.manager,
+            ue.admin,
+            u.super_admin
+        FROM rapport.user_entitlements ue
+        JOIN rapport.users u ON ue.email_address = u.email_address
+        WHERE ue.email_address = $1
     `, [email]);
 
     if (userCheck.rowCount === 0) {
@@ -38,8 +38,8 @@ exports.handler = wrapHandler(async ({ requestContext, queryStringParameters })
     }
 
     const userRole = userCheck.rows[0];
-    const isManager = userRole.Manager || userRole.Admin || userRole.Super_Admin;
-    const companyId = userRole.Company_ID;
+    const isManager = userRole.manager || userRole.admin || userRole.super_admin;
+    const companyId = userRole.company_id;
 
     // Parse query parameters
     const status = queryStringParameters?.status || 'active';
@@ -54,7 +54,7 @@ exports.handler = wrapHandler(async ({ requestContext, queryStringParameters })
             SELECT
                 aa.alert_id,
                 aa.email_address,
-                u."User_Display_Name" as user_name,
+                CONCAT(u.first_name, ' ', u.last_name) as user_name,
                 aa.alert_type,
                 aa.severity,
                 aa.details,
@@ -64,7 +64,7 @@ exports.handler = wrapHandler(async ({ requestContext, queryStringParameters })
                 aa.expires_at,
                 aa.created_at
             FROM rapport.attention_alerts aa
-            JOIN "Users" u ON aa.email_address = u."Email_Address"
+            JOIN rapport.users u ON aa.email_address = u.email_address
             WHERE aa.company_id = $1
         `;
 

package/src/handlers/analytics/activitySummaryGet.js

@@ -25,9 +25,9 @@ async function getActivitySummary({ requestContext, queryStringParameters }) {
 
     // Verify user access
     const userCheck = await executeQuery(`
-        SELECT ue."Company_ID"
-        FROM "UserEntitlements" ue
-        WHERE ue."Email_Address" = $1
+        SELECT ue.company_id
+        FROM rapport.user_entitlements ue
+        WHERE ue.email_address = $1
         LIMIT 1
     `, [email]);
 
@@ -35,7 +35,7 @@ async function getActivitySummary({ requestContext, queryStringParameters }) {
         return createErrorResponse(403, 'Access denied');
     }
 
-    const companyId = userCheck.rows[0].Company_ID;
+    const companyId = userCheck.rows[0].company_id;
     const params = queryStringParameters || {};
     const projectId = params.project_id || null;
     const period = params.period || '7d';
@@ -58,8 +58,8 @@ async function getActivitySummary({ requestContext, queryStringParameters }) {
                 DATE(p.created_at) as date,
                 COUNT(*) as count
             FROM rapport.patterns p
-            JOIN "UserEntitlements" ue ON p.created_by = ue."Email_Address"
-            WHERE ue."Company_ID" = $1
+            JOIN rapport.user_entitlements ue ON p.created_by = ue.email_address
+            WHERE ue.company_id = $1
             AND p.created_at >= $2
             ${projectId ? 'AND p.project_id = $3' : ''}
             GROUP BY DATE(p.created_at)
@@ -76,20 +76,20 @@ async function getActivitySummary({ requestContext, queryStringParameters }) {
         console.log('[ActivitySummary] Harvests query failed:', err.message);
     }
 
-    // Injections: standards_injected events from audit_trail
+    // Injections: count from session_standards joined through sessions
     let injections = { total: 0, by_day: [] };
     try {
         const injectionResult = await executeQuery(`
             SELECT
-                DATE(at.created_at) as date,
+                DATE(ss.created_at) as date,
                 COUNT(*) as count
-            FROM rapport.audit_trail at
-            JOIN "UserEntitlements" ue ON at.email_address = ue."Email_Address"
-            WHERE ue."Company_ID" = $1
-            AND at.action = 'standards_injected'
-            AND at.created_at >= $2
-            ${projectFilter}
-            GROUP BY DATE(at.created_at)
+            FROM rapport.session_standards ss
+            JOIN rapport.sessions s ON s.session_id = ss.session_id
+            JOIN rapport.user_entitlements ue ON s.email_address = ue.email_address
+            WHERE ue.company_id = $1
+            AND ss.created_at >= $2
+            ${projectId ? 'AND s.project_id = $3' : ''}
+            GROUP BY DATE(ss.created_at)
             ORDER BY date
         `, baseParams);
 
@@ -109,8 +109,8 @@ async function getActivitySummary({ requestContext, queryStringParameters }) {
         const promotionResult = await executeQuery(`
             SELECT COUNT(*) as count
             FROM rapport.audit_trail at
-            JOIN "UserEntitlements" ue ON at.email_address = ue."Email_Address"
-            WHERE ue."Company_ID" = $1
+            JOIN rapport.user_entitlements ue ON at.email_address = ue.email_address
+            WHERE ue.company_id = $1
             AND at.action = 'standard_promoted'
             AND at.created_at >= $2
             ${projectFilter}
@@ -124,8 +124,8 @@ async function getActivitySummary({ requestContext, queryStringParameters }) {
                 p.status,
                 COUNT(*) as count
             FROM rapport.patterns p
-            JOIN "UserEntitlements" ue ON p.created_by = ue."Email_Address"
-            WHERE ue."Company_ID" = $1
+            JOIN rapport.user_entitlements ue ON p.created_by = ue.email_address
+            WHERE ue.company_id = $1
             AND p.status IN ('proposed', 'active')
             ${projectId ? 'AND p.project_id = $3' : ''}
             GROUP BY p.status
@@ -150,8 +150,8 @@ async function getActivitySummary({ requestContext, queryStringParameters }) {
                 COALESCE(at.details->>'category', 'uncategorized') as category,
                 COUNT(*) as count
             FROM rapport.audit_trail at
-            JOIN "UserEntitlements" ue ON at.email_address = ue."Email_Address"
-            WHERE ue."Company_ID" = $1
+            JOIN rapport.user_entitlements ue ON at.email_address = ue.email_address
+            WHERE ue.company_id = $1
             AND at.action = 'violation_detected'
             AND at.created_at >= $2
             ${projectFilter}
@@ -169,28 +169,27 @@ async function getActivitySummary({ requestContext, queryStringParameters }) {
         console.log('[ActivitySummary] Violations query failed:', err.message);
     }
 
-    // Top standards by usage count
+    // Top standards by usage count from session_standards
     let topStandards = [];
     try {
         const standardsResult = await executeQuery(`
             SELECT
-                at.resource_id as name,
-                COUNT(*) as usage_count
-            FROM rapport.audit_trail at
-            JOIN "UserEntitlements" ue ON at.email_address = ue."Email_Address"
-            WHERE ue."Company_ID" = $1
-            AND at.action = 'standards_injected'
-            AND at.created_at >= $2
-            AND at.resource_id IS NOT NULL
-            ${projectFilter}
-            GROUP BY at.resource_id
-            ORDER BY usage_count DESC
+                ss.standard_name,
+                COUNT(*) as count
+            FROM rapport.session_standards ss
+            JOIN rapport.sessions s ON s.session_id = ss.session_id
+            JOIN rapport.user_entitlements ue ON s.email_address = ue.email_address
+            WHERE ue.company_id = $1
+            AND ss.created_at >= $2
+            ${projectId ? 'AND s.project_id = $3' : ''}
+            GROUP BY ss.standard_name
+            ORDER BY count DESC
             LIMIT 10
         `, baseParams);
 
         topStandards = standardsResult.rows.map(row => ({
-            name: row.name,
-            usage_count: parseInt(row.usage_count, 10)
+            standard_name: row.standard_name,
+            count: parseInt(row.count, 10)
         }));
     } catch (err) {
         console.log('[ActivitySummary] Top standards query failed:', err.message);

package/src/handlers/analytics/coachingGet.js

@@ -43,12 +43,12 @@ async function getCoachingRecommendations({ requestContext, queryStringParameter
 
     if (!isSelf) {
         const accessCheck = await executeQuery(`
-            SELECT ue."Company_ID"
-            FROM "UserEntitlements" ue
-            JOIN rapport.projects p ON p."Company_ID" = ue."Company_ID"
-            WHERE ue."Email_Address" = $1
+            SELECT ue.company_id
+            FROM rapport.user_entitlements ue
+            JOIN rapport.projects p ON p.company_id = ue.company_id
+            WHERE ue.email_address = $1
             AND p.project_id = $2
-            AND (ue."Admin" = true OR ue."Manager" = true)
+            AND (ue.admin = true OR ue.manager = true)
             LIMIT 1
         `, [email, projectId]);
 
@@ -60,12 +60,12 @@ async function getCoachingRecommendations({ requestContext, queryStringParameter
     // Verify target user exists and belongs to the project's company
     const userResult = await executeQuery(`
         SELECT
-            u."Email_Address" as user_email,
-            u."User_Display_Name" as display_name
-        FROM "Users" u
-        JOIN "UserEntitlements" ue ON ue."Email_Address" = u."Email_Address"
-        JOIN rapport.projects p ON p."Company_ID" = ue."Company_ID"
-        WHERE u."Email_Address" = $1
+            u.email_address as user_email,
+            CONCAT(u.first_name, ' ', u.last_name) as display_name
+        FROM rapport.users u
+        JOIN rapport.user_entitlements ue ON ue.email_address = u.email_address
+        JOIN rapport.projects p ON p.company_id = ue.company_id
+        WHERE u.email_address = $1
         AND p.project_id = $2
         LIMIT 1
     `, [targetUserId, projectId]);