integrate-sdk 0.9.55 → 0.9.58

package/dist/database/adapters/prisma.js

@@ -0,0 +1,679 @@
+// 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/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 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 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) => mapProviderTokenRow(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 mapProviderTokenRow(updated);
+      }
+      const created = await model().create({
+        data: {
+          id: input.id,
+          ...data,
+          createdAt: now
+        }
+      });
+      return mapProviderTokenRow(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 mapTriggerRow(created);
+    },
+    async getTriggerById(triggerId) {
+      const found = await model().findFirst({ where: { id: triggerId } });
+      return found ? mapTriggerRow(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) => mapTriggerRow(row)),
+        total
+      };
+    },
+    async updateTrigger(triggerId, updates) {
+      try {
+        const updated = await model().update({
+          where: { id: triggerId },
+          data: updates
+        });
+        return mapTriggerRow(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
+  });
+}
+export {
+  prismaAdapterCallbacks,
+  prismaAdapter,
+  createPrismaDatabaseDriver
+};

package/dist/database/index.d.ts

@@ -0,0 +1,9 @@
+export type { AccountIdentity, CreateTriggerInput, DatabaseDriver, DeleteDuplicateProviderTokensInput, DeleteProviderTokensInput, FlattenedTrigger, IntegrateAdapterHooks, IntegrateDatabaseAdapter, IntegrateDatabaseCallbacks, ListTriggersQuery, ProviderTokenRecord, TokenChangeEvent, TokenDatabaseDriver, TriggerDatabaseDriver, TriggerRecord, UpsertProviderTokenInput, } from "./types.js";
+export { createDatabaseAdapterCallbacks, createDatabaseAdapterFactory, } from "./factory.js";
+export { defaultResolveAccountIdentity, hasMeaningfulExpiresAt, hasUsableAccessToken, isLikelyUsableToken, normalizeAccountEmail, normalizeAccountEmailHint, normalizeAccountIdHint, normalizeAccountIdentifier, normalizeProviderTokenType, parseScopes, providerTokenRecordToData, selectProviderTokenRow, listConnectedProviders, listConnectedProvidersFromRows, } from "./token-store.js";
+export { flattenedTriggerToCreateInput, toDbSchedule, toDbTriggerUpdates, toSdkSchedule, toSdkTrigger, } from "./trigger-store.js";
+export { drizzleAdapter, drizzleAdapterCallbacks, createDrizzleDatabaseDriver, type DrizzleAdapterConfig, type DrizzleIntegrateSchema, type DrizzleProvider, } from "./adapters/drizzle.js";
+export { prismaAdapter, prismaAdapterCallbacks, createPrismaDatabaseDriver, type PrismaAdapterConfig, type PrismaIntegrateModelNames, type PrismaProvider, } from "./adapters/prisma.js";
+export { mongodbAdapter, mongodbAdapterCallbacks, createMongoDatabaseDriver, type MongoAdapterConfig, type MongoCollectionNames, } from "./adapters/mongodb.js";
+export { integrateProviderToken, integrateTrigger, } from "./schemas/drizzle.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/database/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/database/index.ts"],"names":[],"mappings":"AAAA,YAAY,EACV,eAAe,EACf,kBAAkB,EAClB,cAAc,EACd,kCAAkC,EAClC,yBAAyB,EACzB,gBAAgB,EAChB,qBAAqB,EACrB,wBAAwB,EACxB,0BAA0B,EAC1B,iBAAiB,EACjB,mBAAmB,EACnB,gBAAgB,EAChB,mBAAmB,EACnB,qBAAqB,EACrB,aAAa,EACb,wBAAwB,GACzB,MAAM,YAAY,CAAC;AAEpB,OAAO,EACL,8BAA8B,EAC9B,4BAA4B,GAC7B,MAAM,cAAc,CAAC;AAEtB,OAAO,EACL,6BAA6B,EAC7B,sBAAsB,EACtB,oBAAoB,EACpB,mBAAmB,EACnB,qBAAqB,EACrB,yBAAyB,EACzB,sBAAsB,EACtB,0BAA0B,EAC1B,0BAA0B,EAC1B,WAAW,EACX,yBAAyB,EACzB,sBAAsB,EACtB,sBAAsB,EACtB,8BAA8B,GAC/B,MAAM,kBAAkB,CAAC;AAE1B,OAAO,EACL,6BAA6B,EAC7B,YAAY,EACZ,kBAAkB,EAClB,aAAa,EACb,YAAY,GACb,MAAM,oBAAoB,CAAC;AAE5B,OAAO,EACL,cAAc,EACd,uBAAuB,EACvB,2BAA2B,EAC3B,KAAK,oBAAoB,EACzB,KAAK,sBAAsB,EAC3B,KAAK,eAAe,GACrB,MAAM,uBAAuB,CAAC;AAE/B,OAAO,EACL,aAAa,EACb,sBAAsB,EACtB,0BAA0B,EAC1B,KAAK,mBAAmB,EACxB,KAAK,yBAAyB,EAC9B,KAAK,cAAc,GACpB,MAAM,sBAAsB,CAAC;AAE9B,OAAO,EACL,cAAc,EACd,uBAAuB,EACvB,yBAAyB,EACzB,KAAK,kBAAkB,EACvB,KAAK,oBAAoB,GAC1B,MAAM,uBAAuB,CAAC;AAE/B,OAAO,EACL,sBAAsB,EACtB,gBAAgB,GACjB,MAAM,sBAAsB,CAAC"}