@opengeni/db 0.17.1 → 0.18.1

package/src/index.ts

@@ -153,6 +153,7 @@ import {
   asc,
   desc,
   eq,
+  getTableColumns,
   gt,
   gte,
   inArray,
@@ -3381,10 +3382,31 @@ export type CreateSocialConnectionInput = {
   status: SocialConnectionStatus;
   scopes?: string[];
   credentialRef?: string | null;
+  credentialEncrypted?: string | null;
   tokenMetadata?: Record<string, unknown>;
   metadata?: Record<string, unknown>;
 };
 
+export type UpsertSocialOAuthConnectionInput = {
+  accountId: string;
+  workspaceId: string;
+  provider: SocialProvider;
+  accountHandle: string;
+  accountName?: string | null;
+  externalAccountId?: string | null;
+  scopes: string[];
+  credentialEncrypted: string;
+  tokenMetadata?: Record<string, unknown>;
+};
+
+export type UpdateSocialConnectionCredentialInput = {
+  workspaceId: string;
+  connectionId: string;
+  credentialEncrypted?: string | null;
+  status?: SocialConnectionStatus;
+  tokenMetadata?: Record<string, unknown>;
+};
+
 export type CreateSocialPostInput = {
   accountId: string;
   workspaceId: string;
@@ -5085,6 +5107,21 @@ function connectionExactSubject(subjectId?: string | null): SQL {
     : isNull(schema.connections.subjectId);
 }
 
+function personalSlackCanonicalConnectionOrder(): SQL[] {
+  return [
+    sql`case ${schema.connections.status}
+      when 'active' then 0
+      when 'needs_reauth' then 1
+      when 'error' then 2
+      when 'revoked' then 3
+      else 4
+    end`,
+    desc(schema.connections.updatedAt),
+    desc(schema.connections.createdAt),
+    desc(schema.connections.id),
+  ];
+}
+
 async function withConnectionSubjectRls<T>(
   db: Database,
   workspaceId: string,
@@ -5345,6 +5382,7 @@ export type SlackInteractionInboxEntry = {
   claimHolderId: string | null;
   claimExpiresAt: Date | null;
   attemptCount: number;
+  retryAt: Date | null;
   lastErrorCode: string | null;
   processedAt: Date | null;
   createdAt: Date;
@@ -5368,6 +5406,9 @@ export type SlackInteraction = {
   lastDeliveredSessionEventSequence: number;
   deliveryClaimHolderId: string | null;
   deliveryClaimExpiresAt: Date | null;
+  deliveryAttemptCount: number;
+  deliveryRetryAt: Date | null;
+  deliveryLastErrorCode: string | null;
   ackSlackMessageTs: string | null;
   progressCount: number;
   terminalDeliveryState: "open" | "completed" | "failed" | "cancelled" | "blocked";
@@ -5486,6 +5527,7 @@ export async function enqueueSlackInteractionInbox(
     | "claimHolderId"
     | "claimExpiresAt"
     | "attemptCount"
+    | "retryAt"
     | "lastErrorCode"
     | "processedAt"
     | "createdAt"
@@ -5548,6 +5590,7 @@ export async function settleSlackInteractionInbox(
         status: input.outcome,
         claimHolderId: null,
         claimExpiresAt: null,
+        retryAt: null,
         processedAt: sql`now()`,
         lastErrorCode: input.errorCode ?? null,
         updatedAt: sql`now()`,
@@ -5570,6 +5613,7 @@ export async function releaseSlackInteractionInbox(
     entry: Pick<SlackInteractionInboxEntry, "id" | "accountId" | "workspaceId">;
     claimHolderId: string;
     errorCode: string;
+    retryAt: Date;
   },
 ): Promise<boolean> {
   return await withRlsContext(db, input.entry, async (scopedDb) => {
@@ -5579,6 +5623,7 @@ export async function releaseSlackInteractionInbox(
         status: "pending",
         claimHolderId: null,
         claimExpiresAt: null,
+        retryAt: input.retryAt,
         lastErrorCode: input.errorCode,
         updatedAt: sql`now()`,
       })
@@ -5604,6 +5649,9 @@ export async function getOrCreateSlackInteraction(
     | "lastDeliveredSessionEventSequence"
     | "deliveryClaimHolderId"
     | "deliveryClaimExpiresAt"
+    | "deliveryAttemptCount"
+    | "deliveryRetryAt"
+    | "deliveryLastErrorCode"
     | "ackSlackMessageTs"
     | "progressCount"
     | "terminalDeliveryState"
@@ -5943,7 +5991,13 @@ export async function reopenSlackInteractionDelivery(
   return await withRlsContext(db, input, async (scopedDb) => {
     const rows = await scopedDb
       .update(schema.slackInteractions)
-      .set({ terminalDeliveryState: "open", updatedAt: sql`now()` })
+      .set({
+        terminalDeliveryState: "open",
+        deliveryAttemptCount: 0,
+        deliveryRetryAt: null,
+        deliveryLastErrorCode: null,
+        updatedAt: sql`now()`,
+      })
       .where(eq(schema.slackInteractions.id, input.id))
       .returning({ id: schema.slackInteractions.id });
     return rows.length === 1;
@@ -5966,6 +6020,9 @@ export async function advanceSlackInteractionDelivery(
         ...(input.ackSlackMessageTs !== undefined
           ? { ackSlackMessageTs: input.ackSlackMessageTs }
           : {}),
+        deliveryAttemptCount: 0,
+        deliveryRetryAt: null,
+        deliveryLastErrorCode: null,
         updatedAt: sql`now()`,
       })
       .where(
@@ -6005,12 +6062,42 @@ export async function releaseSlackInteractionDelivery(
   });
 }
 
+export async function deferSlackInteractionDelivery(
+  db: Database,
+  input: Pick<SlackInteraction, "id" | "accountId" | "workspaceId"> & {
+    claimHolderId: string;
+    retryAt: Date;
+    errorCode: string;
+  },
+): Promise<boolean> {
+  return await withRlsContext(db, input, async (scopedDb) => {
+    const rows = await scopedDb
+      .update(schema.slackInteractions)
+      .set({
+        deliveryClaimHolderId: null,
+        deliveryClaimExpiresAt: null,
+        deliveryRetryAt: input.retryAt,
+        deliveryLastErrorCode: input.errorCode.slice(0, 128),
+        updatedAt: sql`now()`,
+      })
+      .where(
+        and(
+          eq(schema.slackInteractions.id, input.id),
+          eq(schema.slackInteractions.deliveryClaimHolderId, input.claimHolderId),
+        ),
+      )
+      .returning({ id: schema.slackInteractions.id });
+    return rows.length === 1;
+  });
+}
+
 export async function closeSlackInteractionDelivery(
   db: Database,
   input: Pick<SlackInteraction, "id" | "accountId" | "workspaceId"> & {
     claimHolderId: string;
     sequence: number;
     state: Exclude<SlackInteraction["terminalDeliveryState"], "open">;
+    errorCode?: string | null;
   },
 ): Promise<boolean> {
   return await withRlsContext(db, input, async (scopedDb) => {
@@ -6021,6 +6108,8 @@ export async function closeSlackInteractionDelivery(
         terminalDeliveryState: input.state,
         deliveryClaimHolderId: null,
         deliveryClaimExpiresAt: null,
+        deliveryRetryAt: null,
+        deliveryLastErrorCode: input.errorCode?.slice(0, 128) ?? null,
         updatedAt: sql`now()`,
       })
       .where(
@@ -6059,6 +6148,7 @@ function mapSlackInteractionInbox(
     claimHolderId: slackRowNullableString(row, "claimHolderId", "claim_holder_id"),
     claimExpiresAt: slackRowNullableDate(row, "claimExpiresAt", "claim_expires_at"),
     attemptCount: slackRowNumber(row, "attemptCount", "attempt_count"),
+    retryAt: slackRowNullableDate(row, "retryAt", "retry_at"),
     lastErrorCode: slackRowNullableString(row, "lastErrorCode", "last_error_code"),
     processedAt: slackRowNullableDate(row, "processedAt", "processed_at"),
     createdAt: slackRowDate(row, "createdAt", "created_at"),
@@ -6102,6 +6192,13 @@ function mapSlackInteraction(
       "deliveryClaimExpiresAt",
       "delivery_claim_expires_at",
     ),
+    deliveryAttemptCount: slackRowNumber(row, "deliveryAttemptCount", "delivery_attempt_count"),
+    deliveryRetryAt: slackRowNullableDate(row, "deliveryRetryAt", "delivery_retry_at"),
+    deliveryLastErrorCode: slackRowNullableString(
+      row,
+      "deliveryLastErrorCode",
+      "delivery_last_error_code",
+    ),
     ackSlackMessageTs: slackRowNullableString(row, "ackSlackMessageTs", "ack_slack_message_ts"),
     progressCount: slackRowNumber(row, "progressCount", "progress_count"),
     terminalDeliveryState: slackRowString(
@@ -7058,13 +7155,25 @@ export async function loadConnectionCredentialForBroker(
     async (scopedDb) => {
       // Prefer active rows: a revoke bumps updatedAt, so recency alone would let a
       // freshly revoked connection shadow an active replacement for the provider.
+      // UUID-free Personal Slack lookup additionally mirrors the UI/reconnect
+      // canonical rule through createdAt and immutable UUID tie-breakers. Migration
+      // 0132 can stamp legacy duplicates with the same updatedAt in one transaction.
+      const personalSlackSubjectLookup =
+        !input.connectionId &&
+        input.allowSubjectOwned === true &&
+        input.providerDomain === "slack.com" &&
+        input.kind === "oauth2";
       const [row] = await scopedDb
         .select()
         .from(schema.connections)
         .where(and(...conditions))
         .orderBy(
-          desc(sql`(${schema.connections.status} = 'active')`),
-          desc(schema.connections.updatedAt),
+          ...(personalSlackSubjectLookup
+            ? personalSlackCanonicalConnectionOrder()
+            : [
+                desc(sql`(${schema.connections.status} = 'active')`),
+                desc(schema.connections.updatedAt),
+              ]),
         )
         .limit(1);
       if (!row) {
@@ -8594,6 +8703,7 @@ export async function createSocialConnection(
           status: input.status,
           scopes: input.scopes ?? [],
           credentialRef: input.credentialRef ?? null,
+          credentialEncrypted: input.credentialEncrypted ?? null,
           tokenMetadata: input.tokenMetadata ?? {},
           metadata: input.metadata ?? {},
         })
@@ -8606,6 +8716,118 @@ export async function createSocialConnection(
   );
 }
 
+/**
+ * OAuth-callback persistence: reconnecting the same provider account replaces
+ * the stored credential and revives the connection instead of failing on the
+ * (workspace, provider, handle) unique index.
+ */
+export async function upsertSocialOAuthConnection(
+  db: Database,
+  input: UpsertSocialOAuthConnectionInput,
+): Promise<SocialConnection> {
+  return await withRlsContext(
+    db,
+    { accountId: input.accountId, workspaceId: input.workspaceId },
+    async (scopedDb) => {
+      const [row] = await scopedDb
+        .insert(schema.socialConnections)
+        .values({
+          accountId: input.accountId,
+          workspaceId: input.workspaceId,
+          provider: input.provider,
+          accountHandle: input.accountHandle,
+          accountName: input.accountName ?? null,
+          externalAccountId: input.externalAccountId ?? null,
+          status: "connected",
+          scopes: input.scopes,
+          credentialEncrypted: input.credentialEncrypted,
+          tokenMetadata: input.tokenMetadata ?? {},
+        })
+        .onConflictDoUpdate({
+          target: [
+            schema.socialConnections.workspaceId,
+            schema.socialConnections.provider,
+            schema.socialConnections.accountHandle,
+          ],
+          set: {
+            accountName: input.accountName ?? null,
+            externalAccountId: input.externalAccountId ?? null,
+            status: "connected",
+            scopes: input.scopes,
+            credentialEncrypted: input.credentialEncrypted,
+            tokenMetadata: input.tokenMetadata ?? {},
+            updatedAt: new Date(),
+          },
+        })
+        .returning();
+      if (!row) {
+        throw new Error("Failed to upsert social connection");
+      }
+      return mapSocialConnection(row);
+    },
+  );
+}
+
+/**
+ * Host-side credential read for the social API client. Deliberately not part
+ * of mapSocialConnection so the encrypted bundle never rides along on list or
+ * MCP responses.
+ */
+export async function loadSocialConnectionCredential(
+  db: Database,
+  workspaceId: string,
+  connectionId: string,
+): Promise<{ connection: SocialConnection; credentialEncrypted: string | null } | null> {
+  return await withWorkspaceRls(db, workspaceId, async (scopedDb) => {
+    const [row] = await scopedDb
+      .select()
+      .from(schema.socialConnections)
+      .where(
+        and(
+          eq(schema.socialConnections.workspaceId, workspaceId),
+          eq(schema.socialConnections.id, connectionId),
+        ),
+      )
+      .limit(1);
+    if (!row) {
+      return null;
+    }
+    return { connection: mapSocialConnection(row), credentialEncrypted: row.credentialEncrypted };
+  });
+}
+
+export async function updateSocialConnectionCredential(
+  db: Database,
+  input: UpdateSocialConnectionCredentialInput,
+): Promise<SocialConnection | null> {
+  return await withWorkspaceRls(db, input.workspaceId, async (scopedDb) => {
+    const [row] = await scopedDb
+      .update(schema.socialConnections)
+      .set({
+        ...(input.credentialEncrypted !== undefined
+          ? { credentialEncrypted: input.credentialEncrypted }
+          : {}),
+        ...(input.status !== undefined ? { status: input.status } : {}),
+        ...(input.tokenMetadata !== undefined ? { tokenMetadata: input.tokenMetadata } : {}),
+        updatedAt: new Date(),
+      })
+      .where(
+        and(
+          eq(schema.socialConnections.workspaceId, input.workspaceId),
+          eq(schema.socialConnections.id, input.connectionId),
+        ),
+      )
+      .returning();
+    return row ? mapSocialConnection(row) : null;
+  });
+}
+
+// List/get never select credential_encrypted (same posture as the broker
+// `connections` helpers): the ciphertext must not ride into API-process memory
+// on every list, where one added debug log or row spread would expose it.
+const { credentialEncrypted: _socialCredentialColumn, ...socialConnectionPublicColumns } =
+  getTableColumns(schema.socialConnections);
+
 export async function listSocialConnections(
   db: Database,
   workspaceId: string,
@@ -8613,7 +8835,7 @@ export async function listSocialConnections(
 ): Promise<SocialConnection[]> {
   return await withWorkspaceRls(db, workspaceId, async (scopedDb) => {
     const rows = await scopedDb
-      .select()
+      .select(socialConnectionPublicColumns)
       .from(schema.socialConnections)
       .where(eq(schema.socialConnections.workspaceId, workspaceId))
       .orderBy(desc(schema.socialConnections.createdAt))
@@ -8629,7 +8851,7 @@ export async function getSocialConnection(
 ): Promise<SocialConnection | null> {
   return await withWorkspaceRls(db, workspaceId, async (scopedDb) => {
     const [row] = await scopedDb
-      .select()
+      .select(socialConnectionPublicColumns)
       .from(schema.socialConnections)
       .where(
         and(
@@ -8691,6 +8913,70 @@ export async function createSocialPost(
   );
 }
 
+/**
+ * Idempotent bulk ingest for provider sync: rows already present under the
+ * (workspace, connection, external post id) unique index are skipped, so a
+ * scheduled re-sync never duplicates or fails.
+ */
+export async function recordSyncedSocialPosts(
+  db: Database,
+  input: {
+    accountId: string;
+    workspaceId: string;
+    connectionId: string;
+    posts: Array<{
+      externalPostId: string;
+      url?: string | null;
+      authorHandle?: string | null;
+      text: string;
+      publishedAt: Date;
+      metrics?: Record<string, number>;
+      raw?: Record<string, unknown>;
+    }>;
+  },
+): Promise<{ inserted: number; skipped: number }> {
+  if (input.posts.length === 0) {
+    return { inserted: 0, skipped: 0 };
+  }
+  return await withRlsContext(
+    db,
+    { accountId: input.accountId, workspaceId: input.workspaceId },
+    async (scopedDb) => {
+      const connection = await requireSocialConnection(
+        scopedDb,
+        input.workspaceId,
+        input.connectionId,
+      );
+      const rows = await scopedDb
+        .insert(schema.socialPosts)
+        .values(
+          input.posts.map((post) => ({
+            accountId: input.accountId,
+            workspaceId: input.workspaceId,
+            connectionId: input.connectionId,
+            provider: connection.provider,
+            externalPostId: post.externalPostId,
+            url: post.url ?? null,
+            authorHandle: post.authorHandle ?? connection.accountHandle,
+            text: post.text,
+            publishedAt: post.publishedAt,
+            metrics: post.metrics ?? {},
+            raw: post.raw ?? {},
+          })),
+        )
+        .onConflictDoNothing({
+          target: [
+            schema.socialPosts.workspaceId,
+            schema.socialPosts.connectionId,
+            schema.socialPosts.externalPostId,
+          ],
+        })
+        .returning({ id: schema.socialPosts.id });
+      return { inserted: rows.length, skipped: input.posts.length - rows.length };
+    },
+  );
+}
+
 export async function listSocialPosts(
   db: Database,
   options: {
@@ -42139,7 +42425,9 @@ function mapKnowledgeMemory(row: typeof schema.knowledgeMemories.$inferSelect):
   };
 }
 
-function mapSocialConnection(row: typeof schema.socialConnections.$inferSelect): SocialConnection {
+function mapSocialConnection(
+  row: Omit<typeof schema.socialConnections.$inferSelect, "credentialEncrypted">,
+): SocialConnection {
   return {
     id: row.id,
     accountId: row.accountId,

package/src/schema.ts

@@ -776,6 +776,7 @@ export const slackInteractionInbox = pgTable(
     claimHolderId: uuid("claim_holder_id"),
     claimExpiresAt: timestamp("claim_expires_at", { withTimezone: true }),
     attemptCount: integer("attempt_count").notNull().default(0),
+    retryAt: timestamp("retry_at", { withTimezone: true }),
     lastErrorCode: text("last_error_code"),
     processedAt: timestamp("processed_at", { withTimezone: true }),
     createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
@@ -792,6 +793,7 @@ export const slackInteractionInbox = pgTable(
     ),
     pending: index("slack_interaction_inbox_pending_idx").on(
       table.status,
+      table.retryAt,
       table.createdAt,
       table.id,
     ),
@@ -829,6 +831,9 @@ export const slackInteractions = pgTable(
     deliveryClaimExpiresAt: timestamp("delivery_claim_expires_at", {
       withTimezone: true,
     }),
+    deliveryAttemptCount: integer("delivery_attempt_count").notNull().default(0),
+    deliveryRetryAt: timestamp("delivery_retry_at", { withTimezone: true }),
+    deliveryLastErrorCode: text("delivery_last_error_code"),
     ackSlackMessageTs: text("ack_slack_message_ts"),
     progressCount: integer("progress_count").notNull().default(0),
     terminalDeliveryState: text("terminal_delivery_state")
@@ -854,6 +859,7 @@ export const slackInteractions = pgTable(
       .where(sql`${table.sessionId} is not null`),
     delivery: index("slack_interactions_delivery_idx").on(
       table.terminalDeliveryState,
+      table.deliveryRetryAt,
       table.updatedAt,
       table.id,
     ),
@@ -5119,6 +5125,10 @@ export const socialConnections = pgTable(
     status: text("status").notNull().default("connected"),
     scopes: jsonb("scopes").$type<string[]>().notNull().default([]),
     credentialRef: text("credential_ref"),
+    // AES-256-GCM envelope (environment-crypto v1 format) holding the OAuth
+    // token bundle. Never exposed through contracts or MCP tools; only the
+    // host-side social API client decrypts it.
+    credentialEncrypted: text("credential_encrypted"),
     tokenMetadata: jsonb("token_metadata").$type<Record<string, unknown>>().notNull().default({}),
     metadata: jsonb("metadata").$type<Record<string, unknown>>().notNull().default({}),
     createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),