integrate-sdk 0.9.54-dev.0 → 0.9.56

package/dist/database/adapters/drizzle.d.ts

@@ -0,0 +1,23 @@
+import type { DatabaseDriver, IntegrateAdapterHooks, IntegrateDatabaseAdapter } from "../types.js";
+export type DrizzleProvider = "pg" | "mysql" | "sqlite";
+export interface DrizzleIntegrateSchema {
+    providerToken: object;
+    trigger?: object;
+}
+export interface DrizzleAdapterConfig {
+    provider: DrizzleProvider;
+    schema: DrizzleIntegrateSchema;
+    hooks?: IntegrateAdapterHooks;
+    debugLogs?: boolean;
+}
+type DrizzleDb = {
+    select: (...args: any[]) => any;
+    insert: (...args: any[]) => any;
+    update: (...args: any[]) => any;
+    delete: (...args: any[]) => any;
+};
+export declare function createDrizzleDatabaseDriver(db: DrizzleDb, schema: DrizzleIntegrateSchema): DatabaseDriver;
+export declare function drizzleAdapter(db: DrizzleDb, config: DrizzleAdapterConfig): IntegrateDatabaseAdapter;
+export declare function drizzleAdapterCallbacks(db: DrizzleDb, config: DrizzleAdapterConfig): import("../types.js").IntegrateDatabaseCallbacks;
+export {};
+//# sourceMappingURL=drizzle.d.ts.map

package/dist/database/adapters/drizzle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"drizzle.d.ts","sourceRoot":"","sources":["../../../../src/database/adapters/drizzle.ts"],"names":[],"mappings":"AASA,OAAO,KAAK,EAEV,cAAc,EAGd,qBAAqB,EACrB,wBAAwB,EAMzB,MAAM,aAAa,CAAC;AAErB,MAAM,MAAM,eAAe,GACvB,IAAI,GACJ,OAAO,GACP,QAAQ,CAAC;AAEb,MAAM,WAAW,sBAAsB;IACrC,aAAa,EAAE,MAAM,CAAC;IACtB,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,WAAW,oBAAoB;IACnC,QAAQ,EAAE,eAAe,CAAC;IAC1B,MAAM,EAAE,sBAAsB,CAAC;IAC/B,KAAK,CAAC,EAAE,qBAAqB,CAAC;IAC9B,SAAS,CAAC,EAAE,OAAO,CAAC;CACrB;AAED,KAAK,SAAS,GAAG;IACf,MAAM,EAAE,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,GAAG,CAAC;IAChC,MAAM,EAAE,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,GAAG,CAAC;IAChC,MAAM,EAAE,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,GAAG,CAAC;IAChC,MAAM,EAAE,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,GAAG,CAAC;CACjC,CAAC;AAqOF,wBAAgB,2BAA2B,CACzC,EAAE,EAAE,SAAS,EACb,MAAM,EAAE,sBAAsB,GAC7B,cAAc,CAUhB;AAED,wBAAgB,cAAc,CAC5B,EAAE,EAAE,SAAS,EACb,MAAM,EAAE,oBAAoB,GAC3B,wBAAwB,CAQ1B;AAED,wBAAgB,uBAAuB,CACrC,EAAE,EAAE,SAAS,EACb,MAAM,EAAE,oBAAoB,oDAO7B"}

package/dist/database/adapters/drizzle.js

@@ -0,0 +1,646 @@
+// src/database/adapters/drizzle.ts
+import { and, count, desc, eq, ne, or } from "drizzle-orm";
+
+// 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 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 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
+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
+  });
+}
+export {
+  drizzleAdapterCallbacks,
+  drizzleAdapter,
+  createDrizzleDatabaseDriver
+};

package/dist/database/adapters/mongodb.d.ts

@@ -0,0 +1,17 @@
+import type { DatabaseDriver, IntegrateAdapterHooks, IntegrateDatabaseAdapter } from "../types.js";
+export interface MongoCollectionNames {
+    providerTokens?: string;
+    triggers?: string;
+}
+export interface MongoAdapterConfig {
+    client?: import("mongodb").MongoClient;
+    collectionNames?: MongoCollectionNames;
+    hooks?: IntegrateAdapterHooks;
+    debugLogs?: boolean;
+}
+type MongoDb = import("mongodb").Db;
+export declare function createMongoDatabaseDriver(db: MongoDb, config: MongoAdapterConfig): DatabaseDriver;
+export declare function mongodbAdapter(db: MongoDb, config?: MongoAdapterConfig): IntegrateDatabaseAdapter;
+export declare function mongodbAdapterCallbacks(db: MongoDb, config?: MongoAdapterConfig): import("../types.js").IntegrateDatabaseCallbacks;
+export {};
+//# sourceMappingURL=mongodb.d.ts.map

package/dist/database/adapters/mongodb.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mongodb.d.ts","sourceRoot":"","sources":["../../../../src/database/adapters/mongodb.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAEV,cAAc,EAGd,qBAAqB,EACrB,wBAAwB,EAMzB,MAAM,aAAa,CAAC;AAErB,MAAM,WAAW,oBAAoB;IACnC,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,kBAAkB;IACjC,MAAM,CAAC,EAAE,OAAO,SAAS,EAAE,WAAW,CAAC;IACvC,eAAe,CAAC,EAAE,oBAAoB,CAAC;IACvC,KAAK,CAAC,EAAE,qBAAqB,CAAC;IAC9B,SAAS,CAAC,EAAE,OAAO,CAAC;CACrB;AAED,KAAK,OAAO,GAAG,OAAO,SAAS,EAAE,EAAE,CAAC;AAoNpC,wBAAgB,yBAAyB,CACvC,EAAE,EAAE,OAAO,EACX,MAAM,EAAE,kBAAkB,GACzB,cAAc,CAehB;AAED,wBAAgB,cAAc,CAC5B,EAAE,EAAE,OAAO,EACX,MAAM,GAAE,kBAAuB,GAC9B,wBAAwB,CAQ1B;AAED,wBAAgB,uBAAuB,CACrC,EAAE,EAAE,OAAO,EACX,MAAM,GAAE,kBAAuB,oDAOhC"}