@inkeep/agents-core 0.47.5 → 0.48.1

package/dist/data-access/runtime/scheduledTriggerInvocations.js

@@ -0,0 +1,226 @@
+import { scheduledTriggerInvocations } from "../../db/runtime/runtime-schema.js";
+import { and, asc, count, desc, eq, gte, inArray, lte, ne, sql } from "drizzle-orm";
+
+//#region src/data-access/runtime/scheduledTriggerInvocations.ts
+/**
+* Get a scheduled trigger invocation by ID (agent-scoped)
+*/
+const getScheduledTriggerInvocationById = (db) => async (params) => {
+	return await db.query.scheduledTriggerInvocations.findFirst({ where: and(eq(scheduledTriggerInvocations.tenantId, params.scopes.tenantId), eq(scheduledTriggerInvocations.projectId, params.scopes.projectId), eq(scheduledTriggerInvocations.agentId, params.scopes.agentId), eq(scheduledTriggerInvocations.scheduledTriggerId, params.scheduledTriggerId), eq(scheduledTriggerInvocations.id, params.invocationId)) });
+};
+/**
+* Get a scheduled trigger invocation by idempotency key
+* Used to check if an invocation already exists for a given schedule
+*/
+const getScheduledTriggerInvocationByIdempotencyKey = (db) => async (params) => {
+	return await db.query.scheduledTriggerInvocations.findFirst({ where: eq(scheduledTriggerInvocations.idempotencyKey, params.idempotencyKey) });
+};
+/**
+* List scheduled trigger invocations with optional filtering (agent-scoped)
+*/
+const listScheduledTriggerInvocationsPaginated = (db) => async (params) => {
+	const page = params.pagination?.page || 1;
+	const limit = Math.min(params.pagination?.limit || 10, 100);
+	const offset = (page - 1) * limit;
+	const conditions = [
+		eq(scheduledTriggerInvocations.tenantId, params.scopes.tenantId),
+		eq(scheduledTriggerInvocations.projectId, params.scopes.projectId),
+		eq(scheduledTriggerInvocations.agentId, params.scopes.agentId),
+		eq(scheduledTriggerInvocations.scheduledTriggerId, params.scheduledTriggerId)
+	];
+	if (params.filters?.status) conditions.push(eq(scheduledTriggerInvocations.status, params.filters.status));
+	if (params.filters?.from) conditions.push(gte(scheduledTriggerInvocations.scheduledFor, params.filters.from));
+	if (params.filters?.to) conditions.push(lte(scheduledTriggerInvocations.scheduledFor, params.filters.to));
+	const whereClause = and(...conditions);
+	const [data, totalResult] = await Promise.all([db.select().from(scheduledTriggerInvocations).where(whereClause).limit(limit).offset(offset).orderBy(desc(scheduledTriggerInvocations.scheduledFor)), db.select({ count: count() }).from(scheduledTriggerInvocations).where(whereClause)]);
+	const total = totalResult[0]?.count || 0;
+	return {
+		data,
+		pagination: {
+			page,
+			limit,
+			total,
+			pages: Math.ceil(total / limit)
+		}
+	};
+};
+/**
+* List pending invocations for a trigger, ordered by scheduledFor (earliest first)
+* Used by workflow to get the next invocation to execute
+*/
+const listPendingScheduledTriggerInvocations = (db) => async (params) => {
+	const maxLimit = Math.min(params.limit || 10, 100);
+	return await db.select().from(scheduledTriggerInvocations).where(and(eq(scheduledTriggerInvocations.tenantId, params.scopes.tenantId), eq(scheduledTriggerInvocations.projectId, params.scopes.projectId), eq(scheduledTriggerInvocations.agentId, params.scopes.agentId), eq(scheduledTriggerInvocations.scheduledTriggerId, params.scheduledTriggerId), eq(scheduledTriggerInvocations.status, "pending"))).orderBy(asc(scheduledTriggerInvocations.scheduledFor)).limit(maxLimit);
+};
+/**
+* Delete all pending invocations for a trigger
+* Used when cron expression changes or trigger is disabled
+*/
+const deletePendingInvocationsForTrigger = (db) => async (params) => {
+	return (await db.delete(scheduledTriggerInvocations).where(and(eq(scheduledTriggerInvocations.tenantId, params.scopes.tenantId), eq(scheduledTriggerInvocations.projectId, params.scopes.projectId), eq(scheduledTriggerInvocations.agentId, params.scopes.agentId), eq(scheduledTriggerInvocations.scheduledTriggerId, params.scheduledTriggerId), eq(scheduledTriggerInvocations.status, "pending"))).returning()).length;
+};
+/**
+* Create a new scheduled trigger invocation (agent-scoped)
+*/
+const createScheduledTriggerInvocation = (db) => async (params) => {
+	return (await db.insert(scheduledTriggerInvocations).values(params).returning())[0];
+};
+/**
+* Update scheduled trigger invocation status (agent-scoped)
+*/
+const updateScheduledTriggerInvocationStatus = (db) => async (params) => {
+	return (await db.update(scheduledTriggerInvocations).set(params.data).where(and(eq(scheduledTriggerInvocations.tenantId, params.scopes.tenantId), eq(scheduledTriggerInvocations.projectId, params.scopes.projectId), eq(scheduledTriggerInvocations.agentId, params.scopes.agentId), eq(scheduledTriggerInvocations.scheduledTriggerId, params.scheduledTriggerId), eq(scheduledTriggerInvocations.id, params.invocationId))).returning())[0];
+};
+/**
+* Mark invocation as running
+*/
+const markScheduledTriggerInvocationRunning = (db) => async (params) => {
+	const now = (/* @__PURE__ */ new Date()).toISOString();
+	return (await db.update(scheduledTriggerInvocations).set({
+		status: "running",
+		startedAt: sql`COALESCE(${scheduledTriggerInvocations.startedAt}, ${now})`
+	}).where(and(eq(scheduledTriggerInvocations.tenantId, params.scopes.tenantId), eq(scheduledTriggerInvocations.projectId, params.scopes.projectId), eq(scheduledTriggerInvocations.agentId, params.scopes.agentId), eq(scheduledTriggerInvocations.scheduledTriggerId, params.scheduledTriggerId), eq(scheduledTriggerInvocations.id, params.invocationId))).returning())[0];
+};
+/**
+* Mark invocation as completed
+* Note: Will not update if status is already 'cancelled' to respect user cancellation
+*/
+const markScheduledTriggerInvocationCompleted = (db) => async (params) => {
+	return (await db.update(scheduledTriggerInvocations).set({
+		status: "completed",
+		completedAt: (/* @__PURE__ */ new Date()).toISOString()
+	}).where(and(eq(scheduledTriggerInvocations.tenantId, params.scopes.tenantId), eq(scheduledTriggerInvocations.projectId, params.scopes.projectId), eq(scheduledTriggerInvocations.agentId, params.scopes.agentId), eq(scheduledTriggerInvocations.scheduledTriggerId, params.scheduledTriggerId), eq(scheduledTriggerInvocations.id, params.invocationId), ne(scheduledTriggerInvocations.status, "cancelled"))).returning())[0];
+};
+/**
+* Mark invocation as failed
+* Note: Will not update if status is already 'cancelled' to respect user cancellation
+*/
+const markScheduledTriggerInvocationFailed = (db) => async (params) => {
+	return (await db.update(scheduledTriggerInvocations).set({
+		status: "failed",
+		completedAt: (/* @__PURE__ */ new Date()).toISOString()
+	}).where(and(eq(scheduledTriggerInvocations.tenantId, params.scopes.tenantId), eq(scheduledTriggerInvocations.projectId, params.scopes.projectId), eq(scheduledTriggerInvocations.agentId, params.scopes.agentId), eq(scheduledTriggerInvocations.scheduledTriggerId, params.scheduledTriggerId), eq(scheduledTriggerInvocations.id, params.invocationId), ne(scheduledTriggerInvocations.status, "cancelled"))).returning())[0];
+};
+/**
+* Add a conversation ID to the invocation's conversationIds array
+* Used to track all conversations created during retries
+*/
+const addConversationIdToInvocation = (db) => async (params) => {
+	return (await db.update(scheduledTriggerInvocations).set({ conversationIds: sql`${scheduledTriggerInvocations.conversationIds} || ${JSON.stringify([params.conversationId])}::jsonb` }).where(and(eq(scheduledTriggerInvocations.tenantId, params.scopes.tenantId), eq(scheduledTriggerInvocations.projectId, params.scopes.projectId), eq(scheduledTriggerInvocations.agentId, params.scopes.agentId), eq(scheduledTriggerInvocations.scheduledTriggerId, params.scheduledTriggerId), eq(scheduledTriggerInvocations.id, params.invocationId))).returning())[0];
+};
+/**
+* Mark invocation as cancelled
+*/
+const markScheduledTriggerInvocationCancelled = (db) => async (params) => {
+	return (await db.update(scheduledTriggerInvocations).set({
+		status: "cancelled",
+		completedAt: (/* @__PURE__ */ new Date()).toISOString()
+	}).where(and(eq(scheduledTriggerInvocations.tenantId, params.scopes.tenantId), eq(scheduledTriggerInvocations.projectId, params.scopes.projectId), eq(scheduledTriggerInvocations.agentId, params.scopes.agentId), eq(scheduledTriggerInvocations.scheduledTriggerId, params.scheduledTriggerId), eq(scheduledTriggerInvocations.id, params.invocationId))).returning())[0];
+};
+/**
+* Cancel all pending invocations for a trigger
+* Used when a trigger is deleted
+*/
+const cancelPendingInvocationsForTrigger = (db) => async (params) => {
+	return (await db.update(scheduledTriggerInvocations).set({
+		status: "cancelled",
+		completedAt: (/* @__PURE__ */ new Date()).toISOString()
+	}).where(and(eq(scheduledTriggerInvocations.tenantId, params.scopes.tenantId), eq(scheduledTriggerInvocations.projectId, params.scopes.projectId), eq(scheduledTriggerInvocations.agentId, params.scopes.agentId), eq(scheduledTriggerInvocations.scheduledTriggerId, params.scheduledTriggerId), inArray(scheduledTriggerInvocations.status, ["pending", "running"]))).returning()).length;
+};
+/**
+* Cancel only PAST pending invocations for a trigger (scheduledFor <= now)
+* Used when a trigger is disabled - keeps future invocations pending
+*/
+const cancelPastPendingInvocationsForTrigger = (db) => async (params) => {
+	const now = (/* @__PURE__ */ new Date()).toISOString();
+	return (await db.update(scheduledTriggerInvocations).set({
+		status: "cancelled",
+		completedAt: now
+	}).where(and(eq(scheduledTriggerInvocations.tenantId, params.scopes.tenantId), eq(scheduledTriggerInvocations.projectId, params.scopes.projectId), eq(scheduledTriggerInvocations.agentId, params.scopes.agentId), eq(scheduledTriggerInvocations.scheduledTriggerId, params.scheduledTriggerId), inArray(scheduledTriggerInvocations.status, ["pending", "running"]), lte(scheduledTriggerInvocations.scheduledFor, now))).returning()).length;
+};
+/**
+* Get run info for multiple scheduled triggers in a single query
+* Returns last run (completed/failed) and next pending run for each trigger
+*/
+const getScheduledTriggerRunInfoBatch = (db) => async (params) => {
+	if (params.triggerIds.length === 0) return /* @__PURE__ */ new Map();
+	const { tenantId, projectId } = params.scopes;
+	const allInvocations = await db.select({
+		scheduledTriggerId: scheduledTriggerInvocations.scheduledTriggerId,
+		status: scheduledTriggerInvocations.status,
+		scheduledFor: scheduledTriggerInvocations.scheduledFor,
+		completedAt: scheduledTriggerInvocations.completedAt,
+		conversationIds: scheduledTriggerInvocations.conversationIds
+	}).from(scheduledTriggerInvocations).where(and(eq(scheduledTriggerInvocations.tenantId, tenantId), eq(scheduledTriggerInvocations.projectId, projectId), inArray(scheduledTriggerInvocations.scheduledTriggerId, params.triggerIds.map((t) => t.triggerId)))).orderBy(desc(scheduledTriggerInvocations.completedAt));
+	const result = /* @__PURE__ */ new Map();
+	for (const trigger of params.triggerIds) result.set(trigger.triggerId, {
+		lastRunAt: null,
+		lastRunStatus: null,
+		lastRunConversationIds: [],
+		nextRunAt: null
+	});
+	for (const inv of allInvocations) {
+		const triggerInfo = result.get(inv.scheduledTriggerId);
+		if (!triggerInfo) continue;
+		if (inv.status === "pending" && !triggerInfo.nextRunAt) triggerInfo.nextRunAt = inv.scheduledFor;
+		if ((inv.status === "completed" || inv.status === "failed") && !triggerInfo.lastRunAt) {
+			triggerInfo.lastRunAt = inv.completedAt;
+			triggerInfo.lastRunStatus = inv.status;
+			triggerInfo.lastRunConversationIds = inv.conversationIds || [];
+		}
+	}
+	return result;
+};
+/**
+* List upcoming invocations across ALL triggers for an agent with pagination
+* Used for the upcoming runs dashboard with full pagination support
+*/
+const listUpcomingInvocationsForAgentPaginated = (db) => async (params) => {
+	const page = params.pagination?.page || 1;
+	const limit = Math.min(params.pagination?.limit || 20, 100);
+	const offset = (page - 1) * limit;
+	const statusCondition = params.includeRunning ? inArray(scheduledTriggerInvocations.status, ["pending", "running"]) : eq(scheduledTriggerInvocations.status, "pending");
+	const whereClause = and(...[
+		eq(scheduledTriggerInvocations.tenantId, params.scopes.tenantId),
+		eq(scheduledTriggerInvocations.projectId, params.scopes.projectId),
+		eq(scheduledTriggerInvocations.agentId, params.scopes.agentId),
+		statusCondition
+	]);
+	const [data, totalResult] = await Promise.all([db.select().from(scheduledTriggerInvocations).where(whereClause).limit(limit).offset(offset).orderBy(asc(scheduledTriggerInvocations.scheduledFor)), db.select({ count: count() }).from(scheduledTriggerInvocations).where(whereClause)]);
+	const total = totalResult[0]?.count || 0;
+	return {
+		data,
+		pagination: {
+			page,
+			limit,
+			total,
+			pages: Math.ceil(total / limit)
+		}
+	};
+};
+/**
+* List all invocations across ALL triggers for a PROJECT with pagination
+* Used for the project-level invocations dashboard
+*/
+const listProjectScheduledTriggerInvocationsPaginated = (db) => async (params) => {
+	const page = params.pagination?.page || 1;
+	const limit = Math.min(params.pagination?.limit || 20, 100);
+	const offset = (page - 1) * limit;
+	const conditions = [eq(scheduledTriggerInvocations.tenantId, params.scopes.tenantId), eq(scheduledTriggerInvocations.projectId, params.scopes.projectId)];
+	if (params.filters?.status) conditions.push(eq(scheduledTriggerInvocations.status, params.filters.status));
+	const whereClause = and(...conditions);
+	const [data, totalResult] = await Promise.all([db.select().from(scheduledTriggerInvocations).where(whereClause).limit(limit).offset(offset).orderBy(desc(scheduledTriggerInvocations.createdAt)), db.select({ count: count() }).from(scheduledTriggerInvocations).where(whereClause)]);
+	const total = totalResult[0]?.count || 0;
+	return {
+		data,
+		pagination: {
+			page,
+			limit,
+			total,
+			pages: Math.ceil(total / limit)
+		}
+	};
+};
+
+//#endregion
+export { addConversationIdToInvocation, cancelPastPendingInvocationsForTrigger, cancelPendingInvocationsForTrigger, createScheduledTriggerInvocation, deletePendingInvocationsForTrigger, getScheduledTriggerInvocationById, getScheduledTriggerInvocationByIdempotencyKey, getScheduledTriggerRunInfoBatch, listPendingScheduledTriggerInvocations, listProjectScheduledTriggerInvocationsPaginated, listScheduledTriggerInvocationsPaginated, listUpcomingInvocationsForAgentPaginated, markScheduledTriggerInvocationCancelled, markScheduledTriggerInvocationCompleted, markScheduledTriggerInvocationFailed, markScheduledTriggerInvocationRunning, updateScheduledTriggerInvocationStatus };

package/dist/data-access/runtime/workAppSlack.d.ts

@@ -0,0 +1,55 @@
+import { workAppSlackChannelAgentConfigs, workAppSlackUserMappings, workAppSlackWorkspaces } from "../../db/runtime/runtime-schema.js";
+import { AgentsRunDatabaseClient } from "../../db/runtime/runtime-client.js";
+
+//#region src/data-access/runtime/workAppSlack.d.ts
+type WorkAppSlackWorkspaceInsert = typeof workAppSlackWorkspaces.$inferInsert;
+type WorkAppSlackWorkspaceSelect = typeof workAppSlackWorkspaces.$inferSelect;
+type WorkAppSlackUserMappingInsert = typeof workAppSlackUserMappings.$inferInsert;
+type WorkAppSlackUserMappingSelect = typeof workAppSlackUserMappings.$inferSelect;
+type WorkAppSlackChannelAgentConfigInsert = typeof workAppSlackChannelAgentConfigs.$inferInsert;
+type WorkAppSlackChannelAgentConfigSelect = typeof workAppSlackChannelAgentConfigs.$inferSelect;
+declare const createWorkAppSlackWorkspace: (db: AgentsRunDatabaseClient) => (data: Omit<WorkAppSlackWorkspaceInsert, "id" | "createdAt" | "updatedAt">) => Promise<WorkAppSlackWorkspaceSelect>;
+declare const findWorkAppSlackWorkspaceByTeamId: (db: AgentsRunDatabaseClient) => (tenantId: string, slackTeamId: string) => Promise<WorkAppSlackWorkspaceSelect | null>;
+/**
+ * Find a workspace by Slack team ID only (without tenant filter).
+ * Slack team IDs are globally unique, so this is safe for resolving
+ * the tenant from an incoming Slack event where tenant is unknown.
+ */
+declare const findWorkAppSlackWorkspaceBySlackTeamId: (db: AgentsRunDatabaseClient) => (slackTeamId: string) => Promise<WorkAppSlackWorkspaceSelect | null>;
+/**
+ * Find a workspace by its Nango connection ID.
+ *
+ * One Nango connection = one OAuth token = one Slack workspace.
+ * The nangoConnectionId should be globally unique (not per-tenant).
+ * The schema has a unique constraint on nangoConnectionId ensuring this.
+ */
+declare const findWorkAppSlackWorkspaceByNangoConnectionId: (db: AgentsRunDatabaseClient) => (nangoConnectionId: string) => Promise<WorkAppSlackWorkspaceSelect | null>;
+declare const listWorkAppSlackWorkspacesByTenant: (db: AgentsRunDatabaseClient) => (tenantId: string) => Promise<WorkAppSlackWorkspaceSelect[]>;
+declare const updateWorkAppSlackWorkspace: (db: AgentsRunDatabaseClient) => (id: string, data: Partial<Pick<WorkAppSlackWorkspaceInsert, "status" | "slackTeamName">>) => Promise<WorkAppSlackWorkspaceSelect | null>;
+declare const deleteWorkAppSlackWorkspace: (db: AgentsRunDatabaseClient) => (id: string) => Promise<boolean>;
+declare const deleteWorkAppSlackWorkspaceByNangoConnectionId: (db: AgentsRunDatabaseClient) => (nangoConnectionId: string) => Promise<boolean>;
+declare const findWorkAppSlackUserMapping: (db: AgentsRunDatabaseClient) => (tenantId: string, slackUserId: string, slackTeamId: string, clientId?: string) => Promise<WorkAppSlackUserMappingSelect | null>;
+declare const findWorkAppSlackUserMappingByInkeepUserId: (db: AgentsRunDatabaseClient) => (inkeepUserId: string) => Promise<WorkAppSlackUserMappingSelect[]>;
+/**
+ * Find a user mapping by Slack user ID and team ID only (ignores tenant).
+ * Use this when you need to find the user's tenant from their mapping.
+ */
+declare const findWorkAppSlackUserMappingBySlackUser: (db: AgentsRunDatabaseClient) => (slackUserId: string, slackTeamId: string, clientId?: string) => Promise<WorkAppSlackUserMappingSelect | null>;
+declare const listWorkAppSlackUserMappingsByTeam: (db: AgentsRunDatabaseClient) => (tenantId: string, slackTeamId: string) => Promise<WorkAppSlackUserMappingSelect[]>;
+declare const createWorkAppSlackUserMapping: (db: AgentsRunDatabaseClient) => (data: Omit<WorkAppSlackUserMappingInsert, "id" | "clientId" | "createdAt" | "updatedAt"> & {
+  clientId?: string;
+}) => Promise<WorkAppSlackUserMappingSelect>;
+declare const deleteWorkAppSlackUserMapping: (db: AgentsRunDatabaseClient) => (tenantId: string, slackUserId: string, slackTeamId: string, clientId?: string) => Promise<boolean>;
+declare const deleteAllWorkAppSlackUserMappingsByTeam: (db: AgentsRunDatabaseClient) => (tenantId: string, slackTeamId: string, clientId?: string) => Promise<number>;
+declare const createWorkAppSlackChannelAgentConfig: (db: AgentsRunDatabaseClient) => (data: Omit<WorkAppSlackChannelAgentConfigInsert, "id" | "createdAt" | "updatedAt">) => Promise<WorkAppSlackChannelAgentConfigSelect>;
+declare const findWorkAppSlackChannelAgentConfig: (db: AgentsRunDatabaseClient) => (tenantId: string, slackTeamId: string, slackChannelId: string) => Promise<WorkAppSlackChannelAgentConfigSelect | null>;
+declare const listWorkAppSlackChannelAgentConfigsByTeam: (db: AgentsRunDatabaseClient) => (tenantId: string, slackTeamId: string) => Promise<WorkAppSlackChannelAgentConfigSelect[]>;
+/**
+ * Atomic upsert using onConflictDoUpdate to avoid TOCTOU race conditions.
+ * Uses the unique constraint on (tenantId, slackTeamId, slackChannelId).
+ */
+declare const upsertWorkAppSlackChannelAgentConfig: (db: AgentsRunDatabaseClient) => (data: Omit<WorkAppSlackChannelAgentConfigInsert, "id" | "createdAt" | "updatedAt">) => Promise<WorkAppSlackChannelAgentConfigSelect>;
+declare const deleteWorkAppSlackChannelAgentConfig: (db: AgentsRunDatabaseClient) => (tenantId: string, slackTeamId: string, slackChannelId: string) => Promise<boolean>;
+declare const deleteAllWorkAppSlackChannelAgentConfigsByTeam: (db: AgentsRunDatabaseClient) => (tenantId: string, slackTeamId: string) => Promise<number>;
+//#endregion
+export { WorkAppSlackChannelAgentConfigInsert, WorkAppSlackChannelAgentConfigSelect, WorkAppSlackUserMappingInsert, WorkAppSlackUserMappingSelect, WorkAppSlackWorkspaceInsert, WorkAppSlackWorkspaceSelect, createWorkAppSlackChannelAgentConfig, createWorkAppSlackUserMapping, createWorkAppSlackWorkspace, deleteAllWorkAppSlackChannelAgentConfigsByTeam, deleteAllWorkAppSlackUserMappingsByTeam, deleteWorkAppSlackChannelAgentConfig, deleteWorkAppSlackUserMapping, deleteWorkAppSlackWorkspace, deleteWorkAppSlackWorkspaceByNangoConnectionId, findWorkAppSlackChannelAgentConfig, findWorkAppSlackUserMapping, findWorkAppSlackUserMappingByInkeepUserId, findWorkAppSlackUserMappingBySlackUser, findWorkAppSlackWorkspaceByNangoConnectionId, findWorkAppSlackWorkspaceBySlackTeamId, findWorkAppSlackWorkspaceByTeamId, listWorkAppSlackChannelAgentConfigsByTeam, listWorkAppSlackUserMappingsByTeam, listWorkAppSlackWorkspacesByTenant, updateWorkAppSlackWorkspace, upsertWorkAppSlackChannelAgentConfig };

package/dist/data-access/runtime/workAppSlack.js

@@ -0,0 +1,146 @@
+import { workAppSlackChannelAgentConfigs, workAppSlackUserMappings, workAppSlackWorkspaces } from "../../db/runtime/runtime-schema.js";
+import { and, eq } from "drizzle-orm";
+import { nanoid } from "nanoid";
+
+//#region src/data-access/runtime/workAppSlack.ts
+const DEFAULT_CLIENT_ID = "work-apps-slack";
+const createWorkAppSlackWorkspace = (db) => async (data) => {
+	const id = `wsw_${nanoid(21)}`;
+	const now = (/* @__PURE__ */ new Date()).toISOString();
+	const [result] = await db.insert(workAppSlackWorkspaces).values({
+		id,
+		...data,
+		createdAt: now,
+		updatedAt: now
+	}).returning();
+	return result;
+};
+const findWorkAppSlackWorkspaceByTeamId = (db) => async (tenantId, slackTeamId) => {
+	return (await db.select().from(workAppSlackWorkspaces).where(and(eq(workAppSlackWorkspaces.tenantId, tenantId), eq(workAppSlackWorkspaces.slackTeamId, slackTeamId))).limit(1))[0] || null;
+};
+/**
+* Find a workspace by Slack team ID only (without tenant filter).
+* Slack team IDs are globally unique, so this is safe for resolving
+* the tenant from an incoming Slack event where tenant is unknown.
+*/
+const findWorkAppSlackWorkspaceBySlackTeamId = (db) => async (slackTeamId) => {
+	return (await db.select().from(workAppSlackWorkspaces).where(eq(workAppSlackWorkspaces.slackTeamId, slackTeamId)).limit(1))[0] || null;
+};
+/**
+* Find a workspace by its Nango connection ID.
+*
+* One Nango connection = one OAuth token = one Slack workspace.
+* The nangoConnectionId should be globally unique (not per-tenant).
+* The schema has a unique constraint on nangoConnectionId ensuring this.
+*/
+const findWorkAppSlackWorkspaceByNangoConnectionId = (db) => async (nangoConnectionId) => {
+	return (await db.select().from(workAppSlackWorkspaces).where(eq(workAppSlackWorkspaces.nangoConnectionId, nangoConnectionId)))[0] || null;
+};
+const listWorkAppSlackWorkspacesByTenant = (db) => async (tenantId) => {
+	return db.select().from(workAppSlackWorkspaces).where(eq(workAppSlackWorkspaces.tenantId, tenantId));
+};
+const updateWorkAppSlackWorkspace = (db) => async (id, data) => {
+	const [result] = await db.update(workAppSlackWorkspaces).set({
+		...data,
+		updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+	}).where(eq(workAppSlackWorkspaces.id, id)).returning();
+	return result || null;
+};
+const deleteWorkAppSlackWorkspace = (db) => async (id) => {
+	return (await db.delete(workAppSlackWorkspaces).where(eq(workAppSlackWorkspaces.id, id)).returning()).length > 0;
+};
+const deleteWorkAppSlackWorkspaceByNangoConnectionId = (db) => async (nangoConnectionId) => {
+	return (await db.delete(workAppSlackWorkspaces).where(eq(workAppSlackWorkspaces.nangoConnectionId, nangoConnectionId)).returning()).length > 0;
+};
+const findWorkAppSlackUserMapping = (db) => async (tenantId, slackUserId, slackTeamId, clientId = DEFAULT_CLIENT_ID) => {
+	return (await db.select().from(workAppSlackUserMappings).where(and(eq(workAppSlackUserMappings.tenantId, tenantId), eq(workAppSlackUserMappings.clientId, clientId), eq(workAppSlackUserMappings.slackUserId, slackUserId), eq(workAppSlackUserMappings.slackTeamId, slackTeamId))).limit(1))[0] || null;
+};
+const findWorkAppSlackUserMappingByInkeepUserId = (db) => async (inkeepUserId) => {
+	return db.select().from(workAppSlackUserMappings).where(eq(workAppSlackUserMappings.inkeepUserId, inkeepUserId));
+};
+/**
+* Find a user mapping by Slack user ID and team ID only (ignores tenant).
+* Use this when you need to find the user's tenant from their mapping.
+*/
+const findWorkAppSlackUserMappingBySlackUser = (db) => async (slackUserId, slackTeamId, clientId = DEFAULT_CLIENT_ID) => {
+	return (await db.select().from(workAppSlackUserMappings).where(and(eq(workAppSlackUserMappings.clientId, clientId), eq(workAppSlackUserMappings.slackUserId, slackUserId), eq(workAppSlackUserMappings.slackTeamId, slackTeamId))).limit(1))[0] || null;
+};
+const listWorkAppSlackUserMappingsByTeam = (db) => async (tenantId, slackTeamId) => {
+	return db.select().from(workAppSlackUserMappings).where(and(eq(workAppSlackUserMappings.tenantId, tenantId), eq(workAppSlackUserMappings.slackTeamId, slackTeamId)));
+};
+const createWorkAppSlackUserMapping = (db) => async (data) => {
+	const id = `wsum_${nanoid(21)}`;
+	const now = (/* @__PURE__ */ new Date()).toISOString();
+	const [result] = await db.insert(workAppSlackUserMappings).values({
+		id,
+		clientId: data.clientId || DEFAULT_CLIENT_ID,
+		...data,
+		linkedAt: now,
+		createdAt: now,
+		updatedAt: now
+	}).returning();
+	return result;
+};
+const deleteWorkAppSlackUserMapping = (db) => async (tenantId, slackUserId, slackTeamId, clientId = DEFAULT_CLIENT_ID) => {
+	return (await db.delete(workAppSlackUserMappings).where(and(eq(workAppSlackUserMappings.tenantId, tenantId), eq(workAppSlackUserMappings.clientId, clientId), eq(workAppSlackUserMappings.slackUserId, slackUserId), eq(workAppSlackUserMappings.slackTeamId, slackTeamId))).returning()).length > 0;
+};
+const deleteAllWorkAppSlackUserMappingsByTeam = (db) => async (tenantId, slackTeamId, clientId = DEFAULT_CLIENT_ID) => {
+	return (await db.delete(workAppSlackUserMappings).where(and(eq(workAppSlackUserMappings.tenantId, tenantId), eq(workAppSlackUserMappings.clientId, clientId), eq(workAppSlackUserMappings.slackTeamId, slackTeamId))).returning()).length;
+};
+const createWorkAppSlackChannelAgentConfig = (db) => async (data) => {
+	const id = `wscac_${nanoid(21)}`;
+	const now = (/* @__PURE__ */ new Date()).toISOString();
+	const [result] = await db.insert(workAppSlackChannelAgentConfigs).values({
+		id,
+		...data,
+		createdAt: now,
+		updatedAt: now
+	}).returning();
+	return result;
+};
+const findWorkAppSlackChannelAgentConfig = (db) => async (tenantId, slackTeamId, slackChannelId) => {
+	return (await db.select().from(workAppSlackChannelAgentConfigs).where(and(eq(workAppSlackChannelAgentConfigs.tenantId, tenantId), eq(workAppSlackChannelAgentConfigs.slackTeamId, slackTeamId), eq(workAppSlackChannelAgentConfigs.slackChannelId, slackChannelId))).limit(1))[0] || null;
+};
+const listWorkAppSlackChannelAgentConfigsByTeam = (db) => async (tenantId, slackTeamId) => {
+	return db.select().from(workAppSlackChannelAgentConfigs).where(and(eq(workAppSlackChannelAgentConfigs.tenantId, tenantId), eq(workAppSlackChannelAgentConfigs.slackTeamId, slackTeamId)));
+};
+/**
+* Atomic upsert using onConflictDoUpdate to avoid TOCTOU race conditions.
+* Uses the unique constraint on (tenantId, slackTeamId, slackChannelId).
+*/
+const upsertWorkAppSlackChannelAgentConfig = (db) => async (data) => {
+	const id = `wscac_${nanoid(21)}`;
+	const now = (/* @__PURE__ */ new Date()).toISOString();
+	const [result] = await db.insert(workAppSlackChannelAgentConfigs).values({
+		id,
+		...data,
+		createdAt: now,
+		updatedAt: now
+	}).onConflictDoUpdate({
+		target: [
+			workAppSlackChannelAgentConfigs.tenantId,
+			workAppSlackChannelAgentConfigs.slackTeamId,
+			workAppSlackChannelAgentConfigs.slackChannelId
+		],
+		set: {
+			projectId: data.projectId,
+			agentId: data.agentId,
+			agentName: data.agentName,
+			slackChannelName: data.slackChannelName,
+			slackChannelType: data.slackChannelType,
+			enabled: data.enabled,
+			configuredByUserId: data.configuredByUserId,
+			updatedAt: now
+		}
+	}).returning();
+	return result;
+};
+const deleteWorkAppSlackChannelAgentConfig = (db) => async (tenantId, slackTeamId, slackChannelId) => {
+	return (await db.delete(workAppSlackChannelAgentConfigs).where(and(eq(workAppSlackChannelAgentConfigs.tenantId, tenantId), eq(workAppSlackChannelAgentConfigs.slackTeamId, slackTeamId), eq(workAppSlackChannelAgentConfigs.slackChannelId, slackChannelId))).returning()).length > 0;
+};
+const deleteAllWorkAppSlackChannelAgentConfigsByTeam = (db) => async (tenantId, slackTeamId) => {
+	return (await db.delete(workAppSlackChannelAgentConfigs).where(and(eq(workAppSlackChannelAgentConfigs.tenantId, tenantId), eq(workAppSlackChannelAgentConfigs.slackTeamId, slackTeamId))).returning()).length;
+};
+
+//#endregion
+export { createWorkAppSlackChannelAgentConfig, createWorkAppSlackUserMapping, createWorkAppSlackWorkspace, deleteAllWorkAppSlackChannelAgentConfigsByTeam, deleteAllWorkAppSlackUserMappingsByTeam, deleteWorkAppSlackChannelAgentConfig, deleteWorkAppSlackUserMapping, deleteWorkAppSlackWorkspace, deleteWorkAppSlackWorkspaceByNangoConnectionId, findWorkAppSlackChannelAgentConfig, findWorkAppSlackUserMapping, findWorkAppSlackUserMappingByInkeepUserId, findWorkAppSlackUserMappingBySlackUser, findWorkAppSlackWorkspaceByNangoConnectionId, findWorkAppSlackWorkspaceBySlackTeamId, findWorkAppSlackWorkspaceByTeamId, listWorkAppSlackChannelAgentConfigsByTeam, listWorkAppSlackUserMappingsByTeam, listWorkAppSlackWorkspacesByTenant, updateWorkAppSlackWorkspace, upsertWorkAppSlackChannelAgentConfig };