integrate-sdk 0.9.55 → 0.9.58

package/dist/database/index.js

@@ -0,0 +1,1167 @@
+// src/database/token-store.ts
+var USABLE_ACCESS_TOKEN_BUFFER_MS = 30 * 1000;
+var MIN_MEANINGFUL_EXPIRY_MS = Date.UTC(2000, 0, 1);
+function getRowUpdatedAtMs(row) {
+  return row.updatedAt instanceof Date ? row.updatedAt.getTime() : 0;
+}
+function normalizeAccountEmail(value) {
+  if (!value)
+    return null;
+  const normalized = value.trim().toLowerCase();
+  return normalized.length > 0 ? normalized : null;
+}
+function normalizeAccountEmailHint(value) {
+  const normalized = normalizeAccountEmail(value);
+  if (!normalized)
+    return null;
+  return normalized.includes("@") ? normalized : null;
+}
+function normalizeAccountIdentifier(value) {
+  return normalizeAccountEmail(value);
+}
+function normalizeAccountIdHint(value) {
+  if (!value)
+    return null;
+  const normalized = value.trim().toLowerCase();
+  return normalized.length > 0 ? normalized : null;
+}
+function normalizeProviderTokenType(value) {
+  const normalized = value?.trim();
+  return normalized && normalized.length > 0 ? normalized : "Bearer";
+}
+function hasMeaningfulExpiresAt(value) {
+  if (!value)
+    return false;
+  const ms = value.getTime();
+  return Number.isFinite(ms) && ms >= MIN_MEANINGFUL_EXPIRY_MS;
+}
+function hasUsableAccessToken(row, now = Date.now(), bufferMs = USABLE_ACCESS_TOKEN_BUFFER_MS) {
+  if (!row.accessToken)
+    return false;
+  const expiresAt = row.expiresAt;
+  if (!hasMeaningfulExpiresAt(expiresAt))
+    return true;
+  return expiresAt.getTime() > now + bufferMs;
+}
+function isLikelyUsableToken(row, now = Date.now()) {
+  return hasUsableAccessToken(row, now) || Boolean(row.refreshToken);
+}
+function parseScopes(scope) {
+  if (!scope)
+    return;
+  const scopes = scope.split(" ").map((item) => item.trim()).filter((item) => item.length > 0);
+  return scopes.length > 0 ? scopes : undefined;
+}
+function choosePreferredTokenRow(rows) {
+  if (rows.length === 0)
+    return;
+  const sorted = [...rows].sort((left, right) => getRowUpdatedAtMs(right) - getRowUpdatedAtMs(left));
+  return sorted.find((row) => hasUsableAccessToken(row)) ?? sorted.find((row) => Boolean(row.refreshToken)) ?? sorted[0];
+}
+function selectProviderTokenRow(rows, email, accountId) {
+  if (rows.length === 0) {
+    return;
+  }
+  const normalizedEmail = normalizeAccountEmailHint(email);
+  const normalizedAccountId = normalizeAccountIdHint(accountId);
+  if (normalizedAccountId && normalizedEmail) {
+    const exactBoth = rows.filter((row) => normalizeAccountIdHint(row.accountId) === normalizedAccountId && normalizeAccountEmail(row.accountEmail) === normalizedEmail);
+    if (exactBoth.length > 0) {
+      return choosePreferredTokenRow(exactBoth);
+    }
+  }
+  if (normalizedAccountId) {
+    const exactAccountId = rows.filter((row) => normalizeAccountIdHint(row.accountId) === normalizedAccountId);
+    if (exactAccountId.length > 0) {
+      return choosePreferredTokenRow(exactAccountId);
+    }
+  }
+  if (normalizedEmail) {
+    const exactEmail = rows.filter((row) => normalizeAccountEmail(row.accountEmail) === normalizedEmail);
+    if (exactEmail.length > 0) {
+      return choosePreferredTokenRow(exactEmail);
+    }
+  } else if (email) {
+    const normalizedIdentifier = normalizeAccountIdentifier(email);
+    if (normalizedIdentifier) {
+      const identifierMatches = rows.filter((row) => normalizeAccountIdHint(row.accountId) === normalizedIdentifier);
+      if (identifierMatches.length > 0) {
+        return choosePreferredTokenRow(identifierMatches);
+      }
+    }
+  }
+  if (normalizedAccountId || normalizedEmail) {
+    const legacyRows = rows.filter((row) => !normalizeAccountIdHint(row.accountId) && !normalizeAccountEmail(row.accountEmail));
+    if (legacyRows.length === 1) {
+      return choosePreferredTokenRow(legacyRows);
+    }
+    return;
+  }
+  return choosePreferredTokenRow(rows);
+}
+function providerTokenRecordToData(row) {
+  const expiresAt = hasMeaningfulExpiresAt(row.expiresAt) ? row.expiresAt : null;
+  const expiresIn = expiresAt ? Math.max(0, Math.floor((expiresAt.getTime() - Date.now()) / 1000)) : 3600;
+  return {
+    accessToken: row.accessToken,
+    refreshToken: row.refreshToken ?? undefined,
+    tokenType: normalizeProviderTokenType(row.tokenType),
+    expiresIn,
+    expiresAt: expiresAt?.toISOString(),
+    scopes: parseScopes(row.scope),
+    email: row.accountEmail ?? undefined,
+    accountId: row.accountId ?? undefined
+  };
+}
+function listConnectedProvidersFromRows(rows, configuredIntegrationIds) {
+  const allowed = configuredIntegrationIds ? new Set(configuredIntegrationIds) : undefined;
+  const rowsByProvider = new Map;
+  for (const row of rows) {
+    if (allowed && !allowed.has(row.provider))
+      continue;
+    const existing = rowsByProvider.get(row.provider);
+    if (existing) {
+      existing.push(row);
+    } else {
+      rowsByProvider.set(row.provider, [row]);
+    }
+  }
+  const connected = [];
+  for (const [provider, providerRows] of rowsByProvider.entries()) {
+    const selected = selectProviderTokenRow(providerRows);
+    if (selected && isLikelyUsableToken(selected)) {
+      connected.push(provider);
+    }
+  }
+  return connected.sort();
+}
+async function listConnectedProviders(configuredIntegrationIds, getProviderToken, context) {
+  if (!context.userId || configuredIntegrationIds.length === 0) {
+    return [];
+  }
+  const connected = [];
+  await Promise.all(configuredIntegrationIds.map(async (provider) => {
+    try {
+      const token = await getProviderToken(provider, undefined, context);
+      if (token?.accessToken || typeof token?.refreshToken === "string" && token.refreshToken.length > 0) {
+        connected.push(provider);
+      }
+    } catch {}
+  }));
+  return connected.sort();
+}
+function defaultResolveAccountIdentity(provider, tokenData, emailHint) {
+  const accountEmail = normalizeAccountEmail(emailHint ?? tokenData.email ?? null);
+  let accountId = normalizeAccountIdHint(tokenData.accountId ?? null);
+  if (!accountId && accountEmail) {
+    accountId = `${provider}:${accountEmail}`;
+  }
+  return { accountEmail, accountId };
+}
+
+// src/database/trigger-store.ts
+function toIsoString(value) {
+  if (!value)
+    return null;
+  if (value instanceof Date) {
+    return Number.isNaN(value.getTime()) ? null : value.toISOString();
+  }
+  const parsed = new Date(value);
+  return Number.isNaN(parsed.getTime()) ? null : parsed.toISOString();
+}
+function toDbSchedule(value) {
+  if (value.scheduleType && value.scheduleValue) {
+    return {
+      scheduleType: value.scheduleType,
+      scheduleValue: value.scheduleValue
+    };
+  }
+  if (value.schedule.type === "once") {
+    const runAt = toIsoString(value.schedule.runAt);
+    if (!runAt) {
+      throw new Error("Invalid trigger once schedule");
+    }
+    return {
+      scheduleType: "once",
+      scheduleValue: runAt
+    };
+  }
+  return {
+    scheduleType: "cron",
+    scheduleValue: value.schedule.expression
+  };
+}
+function toSdkSchedule(row) {
+  if (row.scheduleType === "once") {
+    return {
+      type: "once",
+      runAt: row.scheduleValue
+    };
+  }
+  return {
+    type: "cron",
+    expression: row.scheduleValue
+  };
+}
+function toSdkTrigger(row) {
+  return {
+    id: row.id,
+    userId: row.userId ?? undefined,
+    name: row.name ?? undefined,
+    description: row.description ?? undefined,
+    toolName: row.toolName,
+    toolArguments: row.toolArguments ?? {},
+    schedule: toSdkSchedule(row),
+    status: row.status,
+    provider: row.provider ?? undefined,
+    createdAt: row.createdAt.toISOString(),
+    updatedAt: row.updatedAt.toISOString(),
+    lastRunAt: toIsoString(row.lastRunAt) ?? undefined,
+    nextRunAt: toIsoString(row.nextRunAt) ?? undefined,
+    runCount: row.runCount,
+    lastError: row.lastError ?? undefined,
+    lastResult: row.lastResult ?? undefined
+  };
+}
+function toDbTriggerUpdates(updates) {
+  const dbUpdates = {
+    updatedAt: new Date
+  };
+  if (updates.name !== undefined)
+    dbUpdates.name = updates.name ?? null;
+  if (updates.description !== undefined) {
+    dbUpdates.description = updates.description ?? null;
+  }
+  if (updates.toolArguments !== undefined) {
+    dbUpdates.toolArguments = updates.toolArguments;
+  }
+  if (updates.status !== undefined)
+    dbUpdates.status = updates.status;
+  if (updates.provider !== undefined)
+    dbUpdates.provider = updates.provider ?? null;
+  if (updates.lastError !== undefined)
+    dbUpdates.lastError = updates.lastError ?? null;
+  if (updates.lastResult !== undefined) {
+    dbUpdates.lastResult = updates.lastResult ?? null;
+  }
+  if (updates.lastRunAt !== undefined) {
+    dbUpdates.lastRunAt = updates.lastRunAt ? new Date(updates.lastRunAt) : null;
+  }
+  if (updates.nextRunAt !== undefined) {
+    dbUpdates.nextRunAt = updates.nextRunAt ? new Date(updates.nextRunAt) : null;
+  }
+  if (updates.runCount !== undefined)
+    dbUpdates.runCount = updates.runCount;
+  if (updates.schedule) {
+    if (updates.schedule.type === "once") {
+      dbUpdates.scheduleType = "once";
+      dbUpdates.scheduleValue = new Date(updates.schedule.runAt).toISOString();
+    } else {
+      dbUpdates.scheduleType = "cron";
+      dbUpdates.scheduleValue = updates.schedule.expression;
+    }
+  }
+  return dbUpdates;
+}
+function flattenedTriggerToCreateInput(triggerData, contextUserId) {
+  const schedule = toDbSchedule(triggerData);
+  return {
+    id: triggerData.id,
+    userId: contextUserId ?? triggerData.userId ?? null,
+    name: triggerData.name ?? null,
+    description: triggerData.description ?? null,
+    toolName: triggerData.toolName,
+    toolArguments: triggerData.toolArguments ?? {},
+    scheduleType: schedule.scheduleType,
+    scheduleValue: schedule.scheduleValue,
+    status: triggerData.status ?? "active",
+    provider: triggerData.provider ?? null,
+    nextRunAt: triggerData.nextRunAt ? new Date(triggerData.nextRunAt) : null
+  };
+}
+
+// src/database/factory.ts
+function log(debug, message, error) {
+  if (!debug)
+    return;
+  if (error !== undefined) {
+    console.error(`[Integrate SDK] ${message}`, error);
+    return;
+  }
+  console.log(`[Integrate SDK] ${message}`);
+}
+async function authorizeTriggerRow(row, context, hooks) {
+  if (!row)
+    return null;
+  const repaired = hooks?.authorizeTrigger ? await hooks.authorizeTrigger(row, context) : row;
+  if (!repaired)
+    return null;
+  if (context?.userId && repaired.userId !== context.userId) {
+    return null;
+  }
+  return repaired;
+}
+function createDatabaseAdapterCallbacks(options) {
+  const { driver, hooks, debugLogs } = options;
+  const getProviderToken = async (provider, email, context) => {
+    const userId = context?.userId;
+    if (!userId) {
+      return;
+    }
+    const accountEmailHint = normalizeAccountEmailHint(email) ?? normalizeAccountEmailHint(typeof context?.accountEmail === "string" ? context.accountEmail : null);
+    const accountIdHint = normalizeAccountIdHint(typeof context?.accountId === "string" ? context.accountId : null);
+    try {
+      const rows = await driver.tokens.listProviderTokens(userId, provider);
+      const selectedRow = selectProviderTokenRow(rows, accountEmailHint ?? undefined, accountIdHint ?? undefined);
+      if (!selectedRow) {
+        return;
+      }
+      return providerTokenRecordToData(selectedRow);
+    } catch (error) {
+      log(debugLogs, "Error fetching provider token:", error);
+      return;
+    }
+  };
+  const setProviderToken = async (provider, tokenData, email, context) => {
+    const userId = context?.userId;
+    if (!userId) {
+      console.error("[Integrate SDK] Cannot save token: No userId in context");
+      return;
+    }
+    const accountEmail = normalizeAccountEmailHint(email) ?? normalizeAccountEmail(tokenData?.email ?? null);
+    if (tokenData === null) {
+      try {
+        await driver.tokens.deleteProviderTokens({
+          userId,
+          provider,
+          accountEmail,
+          accountId: normalizeAccountIdHint(typeof context?.accountId === "string" ? context.accountId : null)
+        });
+        await hooks?.onTokenChange?.({ userId, provider, action: "remove" });
+      } catch (error) {
+        log(debugLogs, "Error deleting provider token:", error);
+        throw error;
+      }
+      return;
+    }
+    try {
+      const resolvedIdentity = hooks?.resolveAccountIdentity ? await hooks.resolveAccountIdentity(provider, tokenData, accountEmail, context) : defaultResolveAccountIdentity(provider, tokenData, accountEmail);
+      const resolvedAccountEmail = resolvedIdentity.accountEmail;
+      const resolvedAccountId = normalizeAccountIdHint(resolvedIdentity.accountId) ?? normalizeAccountIdHint(typeof context?.accountId === "string" ? context.accountId : null) ?? null;
+      const rows = await driver.tokens.listProviderTokens(userId, provider);
+      let existing = selectProviderTokenRow(rows, resolvedAccountEmail ?? accountEmail ?? undefined, resolvedAccountId ?? undefined) ?? rows.find((row) => {
+        const sameEmail = resolvedAccountEmail && normalizeAccountEmail(row.accountEmail) === resolvedAccountEmail;
+        const sameAccountId = resolvedAccountId && normalizeAccountIdHint(row.accountId) === resolvedAccountId;
+        return Boolean(sameEmail || sameAccountId);
+      }) ?? (rows.length === 1 ? rows[0] : undefined);
+      const parsedExpiresAt = tokenData.expiresAt ? new Date(tokenData.expiresAt) : null;
+      const expiresAt = hasMeaningfulExpiresAt(parsedExpiresAt) ? parsedExpiresAt : null;
+      const scope = tokenData.scopes?.join(" ") ?? null;
+      const saved = await driver.tokens.upsertProviderToken({
+        existingId: existing?.id,
+        id: existing?.id ?? `${userId}-${provider}-${resolvedAccountEmail ?? "default"}-${Date.now()}`,
+        userId,
+        provider,
+        accountEmail: resolvedAccountEmail,
+        accountId: resolvedAccountId,
+        accessToken: tokenData.accessToken,
+        refreshToken: tokenData.refreshToken ?? null,
+        tokenType: normalizeProviderTokenType(tokenData.tokenType),
+        expiresAt,
+        scope
+      });
+      await driver.tokens.deleteDuplicateProviderTokens({
+        keepId: saved.id,
+        userId,
+        provider,
+        accountEmail: resolvedAccountEmail,
+        accountId: resolvedAccountId
+      });
+      await hooks?.onTokenChange?.({ userId, provider, action: "set" });
+    } catch (error) {
+      log(debugLogs, "Error saving provider token:", error);
+      throw error;
+    }
+  };
+  const removeProviderToken = async (provider, email, context) => {
+    const userId = context?.userId;
+    if (!userId) {
+      console.error("[Integrate SDK] Cannot delete token: No userId in context");
+      return;
+    }
+    try {
+      await driver.tokens.deleteProviderTokens({
+        userId,
+        provider,
+        accountEmail: normalizeAccountEmail(email)
+      });
+      await hooks?.onTokenChange?.({ userId, provider, action: "remove" });
+    } catch (error) {
+      log(debugLogs, "Error deleting provider token:", error);
+      throw error;
+    }
+  };
+  const callbacks = {
+    getProviderToken,
+    setProviderToken,
+    removeProviderToken
+  };
+  if (driver.triggers) {
+    const triggerDriver = driver.triggers;
+    const triggers = {
+      create: async (triggerData, context) => {
+        try {
+          const created = await triggerDriver.createTrigger(flattenedTriggerToCreateInput(triggerData, context?.userId));
+          return toSdkTrigger(created);
+        } catch (error) {
+          log(debugLogs, "Error creating trigger:", error);
+          throw error;
+        }
+      },
+      get: async (triggerId, context) => {
+        try {
+          const found = await triggerDriver.getTriggerById(triggerId);
+          const authorized = await authorizeTriggerRow(found, context, hooks);
+          return authorized ? toSdkTrigger(authorized) : null;
+        } catch (error) {
+          log(debugLogs, "Error getting trigger:", error);
+          throw error;
+        }
+      },
+      list: async (params, context) => {
+        try {
+          const { rows, total } = await triggerDriver.listTriggers({
+            userId: context?.userId,
+            status: params.status,
+            toolName: params.toolName,
+            limit: params.limit ?? 20,
+            offset: params.offset ?? 0
+          });
+          const triggers2 = [];
+          for (const row of rows) {
+            const authorized = await authorizeTriggerRow(row, context, hooks);
+            if (authorized) {
+              triggers2.push(toSdkTrigger(authorized));
+            }
+          }
+          return { triggers: triggers2, total };
+        } catch (error) {
+          log(debugLogs, "Error listing triggers:", error);
+          throw error;
+        }
+      },
+      update: async (triggerId, updates, context) => {
+        try {
+          const existing = await triggerDriver.getTriggerById(triggerId);
+          const authorized = await authorizeTriggerRow(existing, context, hooks);
+          if (!authorized) {
+            throw new Error(`Trigger not found: ${triggerId}`);
+          }
+          const updated = await triggerDriver.updateTrigger(authorized.id, toDbTriggerUpdates(updates));
+          if (!updated) {
+            throw new Error(`Trigger not found: ${triggerId}`);
+          }
+          return toSdkTrigger(updated);
+        } catch (error) {
+          log(debugLogs, "Error updating trigger:", error);
+          throw error;
+        }
+      },
+      delete: async (triggerId, context) => {
+        try {
+          const existing = await triggerDriver.getTriggerById(triggerId);
+          const authorized = await authorizeTriggerRow(existing, context, hooks);
+          if (!authorized) {
+            return;
+          }
+          await triggerDriver.deleteTrigger(authorized.id);
+        } catch (error) {
+          log(debugLogs, "Error deleting trigger:", error);
+          throw error;
+        }
+      }
+    };
+    callbacks.triggers = triggers;
+  }
+  return callbacks;
+}
+function createDatabaseAdapterFactory(createDriver, options) {
+  return () => createDatabaseAdapterCallbacks({
+    driver: createDriver(),
+    hooks: options?.hooks,
+    debugLogs: options?.debugLogs
+  });
+}
+// src/database/adapters/drizzle.ts
+import { and, count, desc, eq, ne, or } from "drizzle-orm";
+function mapProviderTokenRow(row) {
+  return {
+    id: String(row.id),
+    userId: String(row.userId),
+    provider: String(row.provider),
+    accountEmail: row.accountEmail ?? null,
+    accountId: row.accountId ?? null,
+    accessToken: String(row.accessToken),
+    refreshToken: row.refreshToken ?? null,
+    tokenType: String(row.tokenType ?? "Bearer"),
+    expiresAt: row.expiresAt ?? null,
+    scope: row.scope ?? null,
+    createdAt: row.createdAt,
+    updatedAt: row.updatedAt
+  };
+}
+function mapTriggerRow(row) {
+  return {
+    id: String(row.id),
+    userId: row.userId ?? null,
+    name: row.name ?? null,
+    description: row.description ?? null,
+    toolName: String(row.toolName),
+    toolArguments: row.toolArguments ?? {},
+    scheduleType: row.scheduleType,
+    scheduleValue: String(row.scheduleValue),
+    status: String(row.status),
+    provider: row.provider ?? null,
+    lastRunAt: row.lastRunAt ?? null,
+    nextRunAt: row.nextRunAt ?? null,
+    runCount: Number(row.runCount ?? 0),
+    lastError: row.lastError ?? null,
+    lastResult: row.lastResult ?? null,
+    createdAt: row.createdAt,
+    updatedAt: row.updatedAt
+  };
+}
+function createDrizzleTokenDriver(db, table) {
+  const t = table;
+  return {
+    async listProviderTokens(userId, provider) {
+      const rows = await db.select().from(table).where(and(eq(t.userId, userId), eq(t.provider, provider))).orderBy(desc(t.updatedAt)).limit(32);
+      return rows.map((row) => mapProviderTokenRow(row));
+    },
+    async upsertProviderToken(input) {
+      const now = new Date;
+      const values = {
+        id: input.existingId ?? input.id,
+        userId: input.userId,
+        provider: input.provider,
+        accountEmail: input.accountEmail,
+        accountId: input.accountId,
+        accessToken: input.accessToken,
+        refreshToken: input.refreshToken,
+        tokenType: input.tokenType,
+        expiresAt: input.expiresAt,
+        scope: input.scope,
+        updatedAt: now,
+        ...input.existingId ? {} : { createdAt: now }
+      };
+      if (input.existingId) {
+        const [updated] = await db.update(table).set(values).where(eq(t.id, input.existingId)).returning();
+        return mapProviderTokenRow(updated);
+      }
+      const [created] = await db.insert(table).values(values).returning();
+      return mapProviderTokenRow(created);
+    },
+    async deleteProviderTokens(input) {
+      const conditions = [
+        eq(t.userId, input.userId),
+        eq(t.provider, input.provider)
+      ];
+      if (input.accountEmail) {
+        conditions.push(eq(t.accountEmail, input.accountEmail));
+      } else if (input.accountId) {
+        conditions.push(eq(t.accountId, input.accountId));
+      }
+      await db.delete(table).where(and(...conditions));
+    },
+    async deleteDuplicateProviderTokens(input) {
+      const normalizedEmail = normalizeAccountEmail(input.accountEmail);
+      const normalizedAccountId = normalizeAccountIdHint(input.accountId);
+      if (!normalizedEmail && !normalizedAccountId) {
+        return;
+      }
+      const duplicateConditions = [
+        eq(t.userId, input.userId),
+        eq(t.provider, input.provider),
+        ne(t.id, input.keepId)
+      ];
+      const identityConditions = [];
+      if (normalizedEmail) {
+        identityConditions.push(eq(t.accountEmail, normalizedEmail));
+      }
+      if (normalizedAccountId) {
+        identityConditions.push(eq(t.accountId, normalizedAccountId));
+      }
+      if (identityConditions.length === 0) {
+        return;
+      }
+      await db.delete(table).where(and(...duplicateConditions, or(...identityConditions)));
+    }
+  };
+}
+function createDrizzleTriggerDriver(db, table) {
+  const t = table;
+  return {
+    async createTrigger(input) {
+      const now = new Date;
+      const [created] = await db.insert(table).values({
+        id: input.id,
+        userId: input.userId,
+        name: input.name ?? null,
+        description: input.description ?? null,
+        toolName: input.toolName,
+        toolArguments: input.toolArguments,
+        scheduleType: input.scheduleType,
+        scheduleValue: input.scheduleValue,
+        status: input.status,
+        provider: input.provider ?? null,
+        nextRunAt: input.nextRunAt ?? null,
+        createdAt: now,
+        updatedAt: now
+      }).returning();
+      return mapTriggerRow(created);
+    },
+    async getTriggerById(triggerId) {
+      const [found] = await db.select().from(table).where(eq(t.id, triggerId)).limit(1);
+      return found ? mapTriggerRow(found) : null;
+    },
+    async listTriggers(query) {
+      const conditions = [];
+      if (query.userId) {
+        conditions.push(eq(t.userId, query.userId));
+      }
+      if (query.status) {
+        conditions.push(eq(t.status, query.status));
+      }
+      if (query.toolName) {
+        conditions.push(eq(t.toolName, query.toolName));
+      }
+      const whereClause = conditions.length > 0 ? and(...conditions) : undefined;
+      const rows = await db.select().from(table).where(whereClause).limit(query.limit).offset(query.offset);
+      const [totalResult] = await db.select({ count: count() }).from(table).where(whereClause);
+      return {
+        rows: rows.map((row) => mapTriggerRow(row)),
+        total: Number(totalResult?.count ?? 0)
+      };
+    },
+    async updateTrigger(triggerId, updates) {
+      const [updated] = await db.update(table).set(updates).where(eq(t.id, triggerId)).returning();
+      return updated ? mapTriggerRow(updated) : null;
+    },
+    async deleteTrigger(triggerId) {
+      await db.delete(table).where(eq(t.id, triggerId));
+    }
+  };
+}
+function createDrizzleDatabaseDriver(db, schema) {
+  const driver = {
+    tokens: createDrizzleTokenDriver(db, schema.providerToken)
+  };
+  if (schema.trigger) {
+    driver.triggers = createDrizzleTriggerDriver(db, schema.trigger);
+  }
+  return driver;
+}
+function drizzleAdapter(db, config) {
+  config.provider;
+  const driver = () => createDrizzleDatabaseDriver(db, config.schema);
+  return createDatabaseAdapterFactory(driver, {
+    hooks: config.hooks,
+    debugLogs: config.debugLogs
+  });
+}
+function drizzleAdapterCallbacks(db, config) {
+  return createDatabaseAdapterCallbacks({
+    driver: createDrizzleDatabaseDriver(db, config.schema),
+    hooks: config.hooks,
+    debugLogs: config.debugLogs
+  });
+}
+// src/database/adapters/prisma.ts
+var DEFAULT_MODEL_NAMES = {
+  providerToken: "providerToken",
+  trigger: "trigger"
+};
+function getModel(client, name) {
+  const model = client[name];
+  if (!model) {
+    throw new Error(`[Integrate SDK] Prisma model "${name}" was not found on the client`);
+  }
+  return model;
+}
+function mapProviderTokenRow2(row) {
+  return {
+    id: String(row.id),
+    userId: String(row.userId),
+    provider: String(row.provider),
+    accountEmail: row.accountEmail ?? null,
+    accountId: row.accountId ?? null,
+    accessToken: String(row.accessToken),
+    refreshToken: row.refreshToken ?? null,
+    tokenType: String(row.tokenType ?? "Bearer"),
+    expiresAt: row.expiresAt ?? null,
+    scope: row.scope ?? null,
+    createdAt: row.createdAt,
+    updatedAt: row.updatedAt
+  };
+}
+function mapTriggerRow2(row) {
+  return {
+    id: String(row.id),
+    userId: row.userId ?? null,
+    name: row.name ?? null,
+    description: row.description ?? null,
+    toolName: String(row.toolName),
+    toolArguments: row.toolArguments ?? {},
+    scheduleType: row.scheduleType,
+    scheduleValue: String(row.scheduleValue),
+    status: String(row.status),
+    provider: row.provider ?? null,
+    lastRunAt: row.lastRunAt ?? null,
+    nextRunAt: row.nextRunAt ?? null,
+    runCount: Number(row.runCount ?? 0),
+    lastError: row.lastError ?? null,
+    lastResult: row.lastResult ?? null,
+    createdAt: row.createdAt,
+    updatedAt: row.updatedAt
+  };
+}
+function createPrismaTokenDriver(prisma, modelName) {
+  const model = () => getModel(prisma, modelName);
+  return {
+    async listProviderTokens(userId, provider) {
+      const rows = await model().findMany({
+        where: { userId, provider },
+        orderBy: { updatedAt: "desc" },
+        take: 32
+      });
+      return rows.map((row) => mapProviderTokenRow2(row));
+    },
+    async upsertProviderToken(input) {
+      const now = new Date;
+      const data = {
+        userId: input.userId,
+        provider: input.provider,
+        accountEmail: input.accountEmail,
+        accountId: input.accountId,
+        accessToken: input.accessToken,
+        refreshToken: input.refreshToken,
+        tokenType: input.tokenType,
+        expiresAt: input.expiresAt,
+        scope: input.scope,
+        updatedAt: now
+      };
+      if (input.existingId) {
+        const updated = await model().update({
+          where: { id: input.existingId },
+          data
+        });
+        return mapProviderTokenRow2(updated);
+      }
+      const created = await model().create({
+        data: {
+          id: input.id,
+          ...data,
+          createdAt: now
+        }
+      });
+      return mapProviderTokenRow2(created);
+    },
+    async deleteProviderTokens(input) {
+      const where = {
+        userId: input.userId,
+        provider: input.provider
+      };
+      if (input.accountEmail) {
+        where.accountEmail = input.accountEmail;
+      } else if (input.accountId) {
+        where.accountId = input.accountId;
+      }
+      await model().deleteMany({ where });
+    },
+    async deleteDuplicateProviderTokens(input) {
+      const normalizedEmail = normalizeAccountEmail(input.accountEmail);
+      const normalizedAccountId = normalizeAccountIdHint(input.accountId);
+      if (!normalizedEmail && !normalizedAccountId) {
+        return;
+      }
+      const orConditions = [];
+      if (normalizedEmail) {
+        orConditions.push({ accountEmail: normalizedEmail });
+      }
+      if (normalizedAccountId) {
+        orConditions.push({ accountId: normalizedAccountId });
+      }
+      await model().deleteMany({
+        where: {
+          userId: input.userId,
+          provider: input.provider,
+          id: { not: input.keepId },
+          OR: orConditions
+        }
+      });
+    }
+  };
+}
+function createPrismaTriggerDriver(prisma, modelName) {
+  const model = () => getModel(prisma, modelName);
+  return {
+    async createTrigger(input) {
+      const now = new Date;
+      const created = await model().create({
+        data: {
+          id: input.id,
+          userId: input.userId,
+          name: input.name ?? null,
+          description: input.description ?? null,
+          toolName: input.toolName,
+          toolArguments: input.toolArguments,
+          scheduleType: input.scheduleType,
+          scheduleValue: input.scheduleValue,
+          status: input.status,
+          provider: input.provider ?? null,
+          nextRunAt: input.nextRunAt ?? null,
+          createdAt: now,
+          updatedAt: now
+        }
+      });
+      return mapTriggerRow2(created);
+    },
+    async getTriggerById(triggerId) {
+      const found = await model().findFirst({ where: { id: triggerId } });
+      return found ? mapTriggerRow2(found) : null;
+    },
+    async listTriggers(query) {
+      const where = {};
+      if (query.userId)
+        where.userId = query.userId;
+      if (query.status)
+        where.status = query.status;
+      if (query.toolName)
+        where.toolName = query.toolName;
+      const [rows, total] = await Promise.all([
+        model().findMany({
+          where,
+          take: query.limit,
+          skip: query.offset,
+          orderBy: { updatedAt: "desc" }
+        }),
+        model().count({ where })
+      ]);
+      return {
+        rows: rows.map((row) => mapTriggerRow2(row)),
+        total
+      };
+    },
+    async updateTrigger(triggerId, updates) {
+      try {
+        const updated = await model().update({
+          where: { id: triggerId },
+          data: updates
+        });
+        return mapTriggerRow2(updated);
+      } catch {
+        return null;
+      }
+    },
+    async deleteTrigger(triggerId) {
+      await model().delete({ where: { id: triggerId } });
+    }
+  };
+}
+function createPrismaDatabaseDriver(prisma, config) {
+  const modelNames = {
+    ...DEFAULT_MODEL_NAMES,
+    ...config.modelNames
+  };
+  const driver = {
+    tokens: createPrismaTokenDriver(prisma, modelNames.providerToken)
+  };
+  if (config.modelNames?.trigger !== null) {
+    driver.triggers = createPrismaTriggerDriver(prisma, modelNames.trigger);
+  }
+  return driver;
+}
+function prismaAdapter(prisma, config) {
+  config.provider;
+  return createDatabaseAdapterFactory(() => createPrismaDatabaseDriver(prisma, config), {
+    hooks: config.hooks,
+    debugLogs: config.debugLogs
+  });
+}
+function prismaAdapterCallbacks(prisma, config) {
+  return createDatabaseAdapterCallbacks({
+    driver: createPrismaDatabaseDriver(prisma, config),
+    hooks: config.hooks,
+    debugLogs: config.debugLogs
+  });
+}
+// src/database/adapters/mongodb.ts
+var DEFAULT_COLLECTIONS = {
+  providerTokens: "provider_tokens",
+  triggers: "triggers"
+};
+function mapProviderTokenDoc(doc) {
+  return {
+    id: String(doc.id),
+    userId: String(doc.userId),
+    provider: String(doc.provider),
+    accountEmail: doc.accountEmail ?? null,
+    accountId: doc.accountId ?? null,
+    accessToken: String(doc.accessToken),
+    refreshToken: doc.refreshToken ?? null,
+    tokenType: String(doc.tokenType ?? "Bearer"),
+    expiresAt: doc.expiresAt ? new Date(doc.expiresAt) : null,
+    scope: doc.scope ?? null,
+    createdAt: new Date(doc.createdAt),
+    updatedAt: new Date(doc.updatedAt)
+  };
+}
+function mapTriggerDoc(doc) {
+  return {
+    id: String(doc.id),
+    userId: doc.userId ?? null,
+    name: doc.name ?? null,
+    description: doc.description ?? null,
+    toolName: String(doc.toolName),
+    toolArguments: doc.toolArguments ?? {},
+    scheduleType: doc.scheduleType,
+    scheduleValue: String(doc.scheduleValue),
+    status: String(doc.status),
+    provider: doc.provider ?? null,
+    lastRunAt: doc.lastRunAt ? new Date(doc.lastRunAt) : null,
+    nextRunAt: doc.nextRunAt ? new Date(doc.nextRunAt) : null,
+    runCount: Number(doc.runCount ?? 0),
+    lastError: doc.lastError ?? null,
+    lastResult: doc.lastResult ?? null,
+    createdAt: new Date(doc.createdAt),
+    updatedAt: new Date(doc.updatedAt)
+  };
+}
+function createMongoTokenDriver(db, collectionName) {
+  const collection = () => db.collection(collectionName);
+  return {
+    async listProviderTokens(userId, provider) {
+      const docs = await collection().find({ userId, provider }).sort({ updatedAt: -1 }).limit(32).toArray();
+      return docs.map((doc) => mapProviderTokenDoc(doc));
+    },
+    async upsertProviderToken(input) {
+      const now = new Date;
+      const id = input.existingId ?? input.id;
+      const doc = {
+        id,
+        userId: input.userId,
+        provider: input.provider,
+        accountEmail: input.accountEmail,
+        accountId: input.accountId,
+        accessToken: input.accessToken,
+        refreshToken: input.refreshToken,
+        tokenType: input.tokenType,
+        expiresAt: input.expiresAt,
+        scope: input.scope,
+        updatedAt: now,
+        ...input.existingId ? {} : { createdAt: now }
+      };
+      await collection().updateOne({ id }, { $set: doc }, { upsert: true });
+      const saved = await collection().findOne({ id });
+      return mapProviderTokenDoc(saved);
+    },
+    async deleteProviderTokens(input) {
+      const filter = {
+        userId: input.userId,
+        provider: input.provider
+      };
+      if (input.accountEmail) {
+        filter.accountEmail = input.accountEmail;
+      } else if (input.accountId) {
+        filter.accountId = input.accountId;
+      }
+      await collection().deleteMany(filter);
+    },
+    async deleteDuplicateProviderTokens(input) {
+      const normalizedEmail = normalizeAccountEmail(input.accountEmail);
+      const normalizedAccountId = normalizeAccountIdHint(input.accountId);
+      if (!normalizedEmail && !normalizedAccountId) {
+        return;
+      }
+      const orConditions = [];
+      if (normalizedEmail) {
+        orConditions.push({ accountEmail: normalizedEmail });
+      }
+      if (normalizedAccountId) {
+        orConditions.push({ accountId: normalizedAccountId });
+      }
+      await collection().deleteMany({
+        userId: input.userId,
+        provider: input.provider,
+        id: { $ne: input.keepId },
+        $or: orConditions
+      });
+    }
+  };
+}
+function createMongoTriggerDriver(db, collectionName) {
+  const collection = () => db.collection(collectionName);
+  return {
+    async createTrigger(input) {
+      const now = new Date;
+      const doc = {
+        id: input.id,
+        userId: input.userId,
+        name: input.name ?? null,
+        description: input.description ?? null,
+        toolName: input.toolName,
+        toolArguments: input.toolArguments,
+        scheduleType: input.scheduleType,
+        scheduleValue: input.scheduleValue,
+        status: input.status,
+        provider: input.provider ?? null,
+        nextRunAt: input.nextRunAt ?? null,
+        createdAt: now,
+        updatedAt: now
+      };
+      await collection().insertOne(doc);
+      return mapTriggerDoc(doc);
+    },
+    async getTriggerById(triggerId) {
+      const found = await collection().findOne({ id: triggerId });
+      return found ? mapTriggerDoc(found) : null;
+    },
+    async listTriggers(query) {
+      const filter = {};
+      if (query.userId)
+        filter.userId = query.userId;
+      if (query.status)
+        filter.status = query.status;
+      if (query.toolName)
+        filter.toolName = query.toolName;
+      const [docs, total] = await Promise.all([
+        collection().find(filter).sort({ updatedAt: -1 }).skip(query.offset).limit(query.limit).toArray(),
+        collection().countDocuments(filter)
+      ]);
+      return {
+        rows: docs.map((doc) => mapTriggerDoc(doc)),
+        total
+      };
+    },
+    async updateTrigger(triggerId, updates) {
+      const result = await collection().findOneAndUpdate({ id: triggerId }, { $set: updates }, { returnDocument: "after" });
+      return result ? mapTriggerDoc(result) : null;
+    },
+    async deleteTrigger(triggerId) {
+      await collection().deleteOne({ id: triggerId });
+    }
+  };
+}
+function createMongoDatabaseDriver(db, config) {
+  const names = {
+    ...DEFAULT_COLLECTIONS,
+    ...config.collectionNames
+  };
+  const driver = {
+    tokens: createMongoTokenDriver(db, names.providerTokens)
+  };
+  if (config.collectionNames?.triggers !== null) {
+    driver.triggers = createMongoTriggerDriver(db, names.triggers);
+  }
+  return driver;
+}
+function mongodbAdapter(db, config = {}) {
+  return createDatabaseAdapterFactory(() => createMongoDatabaseDriver(db, config), {
+    hooks: config.hooks,
+    debugLogs: config.debugLogs
+  });
+}
+function mongodbAdapterCallbacks(db, config = {}) {
+  return createDatabaseAdapterCallbacks({
+    driver: createMongoDatabaseDriver(db, config),
+    hooks: config.hooks,
+    debugLogs: config.debugLogs
+  });
+}
+// src/database/schemas/drizzle.ts
+import { sql } from "drizzle-orm";
+import {
+  index,
+  integer,
+  jsonb,
+  pgTable,
+  text,
+  timestamp,
+  uniqueIndex
+} from "drizzle-orm/pg-core";
+var integrateProviderToken = pgTable("provider_token", {
+  id: text("id").primaryKey(),
+  userId: text("user_id").notNull(),
+  provider: text("provider").notNull(),
+  accountEmail: text("account_email"),
+  accountId: text("account_id"),
+  accessToken: text("access_token").notNull(),
+  refreshToken: text("refresh_token"),
+  tokenType: text("token_type").notNull().default("Bearer"),
+  expiresAt: timestamp("expires_at"),
+  scope: text("scope"),
+  createdAt: timestamp("created_at", { mode: "date", precision: 3 }).default(sql`CURRENT_TIMESTAMP(3)`).notNull(),
+  updatedAt: timestamp("updated_at", { mode: "date", precision: 3 }).default(sql`CURRENT_TIMESTAMP(3)`).notNull()
+}, (table) => [
+  index("provider_token_user_id_idx").on(table.userId),
+  index("provider_token_provider_idx").on(table.provider),
+  index("provider_token_user_provider_idx").on(table.userId, table.provider),
+  uniqueIndex("provider_token_user_provider_account_email_uidx").on(table.userId, table.provider, table.accountEmail)
+]);
+var integrateTrigger = pgTable("trigger", {
+  id: text("id").primaryKey(),
+  userId: text("user_id"),
+  name: text("name"),
+  description: text("description"),
+  toolName: text("tool_name").notNull(),
+  toolArguments: jsonb("tool_arguments").notNull(),
+  scheduleType: text("schedule_type").notNull(),
+  scheduleValue: text("schedule_value").notNull(),
+  status: text("status").notNull().default("active"),
+  provider: text("provider"),
+  lastRunAt: timestamp("last_run_at", { mode: "date", precision: 3 }),
+  nextRunAt: timestamp("next_run_at", { mode: "date", precision: 3 }),
+  runCount: integer("run_count").notNull().default(0),
+  lastError: text("last_error"),
+  lastResult: jsonb("last_result"),
+  createdAt: timestamp("created_at", { mode: "date", precision: 3 }).default(sql`CURRENT_TIMESTAMP(3)`).notNull(),
+  updatedAt: timestamp("updated_at", { mode: "date", precision: 3 }).default(sql`CURRENT_TIMESTAMP(3)`).notNull()
+}, (table) => [
+  index("trigger_user_id_idx").on(table.userId),
+  index("trigger_status_idx").on(table.status),
+  index("trigger_next_run_at_idx").on(table.nextRunAt)
+]);
+export {
+  toSdkTrigger,
+  toSdkSchedule,
+  toDbTriggerUpdates,
+  toDbSchedule,
+  selectProviderTokenRow,
+  providerTokenRecordToData,
+  prismaAdapterCallbacks,
+  prismaAdapter,
+  parseScopes,
+  normalizeProviderTokenType,
+  normalizeAccountIdentifier,
+  normalizeAccountIdHint,
+  normalizeAccountEmailHint,
+  normalizeAccountEmail,
+  mongodbAdapterCallbacks,
+  mongodbAdapter,
+  listConnectedProvidersFromRows,
+  listConnectedProviders,
+  isLikelyUsableToken,
+  integrateTrigger,
+  integrateProviderToken,
+  hasUsableAccessToken,
+  hasMeaningfulExpiresAt,
+  flattenedTriggerToCreateInput,
+  drizzleAdapterCallbacks,
+  drizzleAdapter,
+  defaultResolveAccountIdentity,
+  createPrismaDatabaseDriver,
+  createMongoDatabaseDriver,
+  createDrizzleDatabaseDriver,
+  createDatabaseAdapterFactory,
+  createDatabaseAdapterCallbacks
+};