integrate-sdk 0.9.54-dev.0 → 0.9.56

package/dist/database/adapters/mongodb.js

@@ -0,0 +1,643 @@
+// 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/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
+  });
+}
+export {
+  mongodbAdapterCallbacks,
+  mongodbAdapter,
+  createMongoDatabaseDriver
+};

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

@@ -0,0 +1,18 @@
+import type { DatabaseDriver, IntegrateAdapterHooks, IntegrateDatabaseAdapter } from "../types.js";
+export type PrismaProvider = "sqlite" | "postgresql" | "mysql" | "sqlserver" | "cockroachdb" | "mongodb";
+export interface PrismaIntegrateModelNames {
+    providerToken?: string;
+    trigger?: string;
+}
+export interface PrismaAdapterConfig {
+    provider: PrismaProvider;
+    modelNames?: PrismaIntegrateModelNames;
+    hooks?: IntegrateAdapterHooks;
+    debugLogs?: boolean;
+}
+type PrismaClientLike = Record<string, any>;
+export declare function createPrismaDatabaseDriver(prisma: PrismaClientLike, config: PrismaAdapterConfig): DatabaseDriver;
+export declare function prismaAdapter(prisma: PrismaClientLike, config: PrismaAdapterConfig): IntegrateDatabaseAdapter;
+export declare function prismaAdapterCallbacks(prisma: PrismaClientLike, config: PrismaAdapterConfig): import("../types.js").IntegrateDatabaseCallbacks;
+export {};
+//# sourceMappingURL=prisma.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"prisma.d.ts","sourceRoot":"","sources":["../../../../src/database/adapters/prisma.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAEV,cAAc,EAGd,qBAAqB,EACrB,wBAAwB,EAMzB,MAAM,aAAa,CAAC;AAErB,MAAM,MAAM,cAAc,GACtB,QAAQ,GACR,YAAY,GACZ,OAAO,GACP,WAAW,GACX,aAAa,GACb,SAAS,CAAC;AAEd,MAAM,WAAW,yBAAyB;IACxC,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,WAAW,mBAAmB;IAClC,QAAQ,EAAE,cAAc,CAAC;IACzB,UAAU,CAAC,EAAE,yBAAyB,CAAC;IACvC,KAAK,CAAC,EAAE,qBAAqB,CAAC;IAC9B,SAAS,CAAC,EAAE,OAAO,CAAC;CACrB;AAED,KAAK,gBAAgB,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;AAiO5C,wBAAgB,0BAA0B,CACxC,MAAM,EAAE,gBAAgB,EACxB,MAAM,EAAE,mBAAmB,GAC1B,cAAc,CAehB;AAED,wBAAgB,aAAa,CAC3B,MAAM,EAAE,gBAAgB,EACxB,MAAM,EAAE,mBAAmB,GAC1B,wBAAwB,CAS1B;AAED,wBAAgB,sBAAsB,CACpC,MAAM,EAAE,gBAAgB,EACxB,MAAM,EAAE,mBAAmB,oDAO5B"}