integrate-sdk 0.9.55 → 0.9.56

package/dist/server.js

@@ -21233,10 +21233,3496 @@ function zohoSprintsIntegration(config = {}) {
     }
   };
 }
+// 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 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
+  });
+}
+// node_modules/drizzle-orm/entity.js
+var entityKind = Symbol.for("drizzle:entityKind");
+var hasOwnEntityKind = Symbol.for("drizzle:hasOwnEntityKind");
+function is(value, type) {
+  if (!value || typeof value !== "object") {
+    return false;
+  }
+  if (value instanceof type) {
+    return true;
+  }
+  if (!Object.prototype.hasOwnProperty.call(type, entityKind)) {
+    throw new Error(`Class "${type.name ?? "<unknown>"}" doesn't look like a Drizzle entity. If this is incorrect and the class is provided by Drizzle, please report this as a bug.`);
+  }
+  let cls = Object.getPrototypeOf(value).constructor;
+  if (cls) {
+    while (cls) {
+      if (entityKind in cls && cls[entityKind] === type[entityKind]) {
+        return true;
+      }
+      cls = Object.getPrototypeOf(cls);
+    }
+  }
+  return false;
+}
+
+// node_modules/drizzle-orm/column.js
+class Column {
+  constructor(table, config) {
+    this.table = table;
+    this.config = config;
+    this.name = config.name;
+    this.keyAsName = config.keyAsName;
+    this.notNull = config.notNull;
+    this.default = config.default;
+    this.defaultFn = config.defaultFn;
+    this.onUpdateFn = config.onUpdateFn;
+    this.hasDefault = config.hasDefault;
+    this.primary = config.primaryKey;
+    this.isUnique = config.isUnique;
+    this.uniqueName = config.uniqueName;
+    this.uniqueType = config.uniqueType;
+    this.dataType = config.dataType;
+    this.columnType = config.columnType;
+    this.generated = config.generated;
+    this.generatedIdentity = config.generatedIdentity;
+  }
+  static [entityKind] = "Column";
+  name;
+  keyAsName;
+  primary;
+  notNull;
+  default;
+  defaultFn;
+  onUpdateFn;
+  hasDefault;
+  isUnique;
+  uniqueName;
+  uniqueType;
+  dataType;
+  columnType;
+  enumValues = undefined;
+  generated = undefined;
+  generatedIdentity = undefined;
+  config;
+  mapFromDriverValue(value) {
+    return value;
+  }
+  mapToDriverValue(value) {
+    return value;
+  }
+  shouldDisableInsert() {
+    return this.config.generated !== undefined && this.config.generated.type !== "byDefault";
+  }
+}
+
+// node_modules/drizzle-orm/column-builder.js
+class ColumnBuilder {
+  static [entityKind] = "ColumnBuilder";
+  config;
+  constructor(name, dataType, columnType) {
+    this.config = {
+      name,
+      keyAsName: name === "",
+      notNull: false,
+      default: undefined,
+      hasDefault: false,
+      primaryKey: false,
+      isUnique: false,
+      uniqueName: undefined,
+      uniqueType: undefined,
+      dataType,
+      columnType,
+      generated: undefined
+    };
+  }
+  $type() {
+    return this;
+  }
+  notNull() {
+    this.config.notNull = true;
+    return this;
+  }
+  default(value) {
+    this.config.default = value;
+    this.config.hasDefault = true;
+    return this;
+  }
+  $defaultFn(fn) {
+    this.config.defaultFn = fn;
+    this.config.hasDefault = true;
+    return this;
+  }
+  $default = this.$defaultFn;
+  $onUpdateFn(fn) {
+    this.config.onUpdateFn = fn;
+    this.config.hasDefault = true;
+    return this;
+  }
+  $onUpdate = this.$onUpdateFn;
+  primaryKey() {
+    this.config.primaryKey = true;
+    this.config.notNull = true;
+    return this;
+  }
+  setName(name) {
+    if (this.config.name !== "")
+      return;
+    this.config.name = name;
+  }
+}
+
+// node_modules/drizzle-orm/table.utils.js
+var TableName = Symbol.for("drizzle:Name");
+
+// node_modules/drizzle-orm/pg-core/foreign-keys.js
+class ForeignKeyBuilder {
+  static [entityKind] = "PgForeignKeyBuilder";
+  reference;
+  _onUpdate = "no action";
+  _onDelete = "no action";
+  constructor(config, actions) {
+    this.reference = () => {
+      const { name, columns, foreignColumns } = config();
+      return { name, columns, foreignTable: foreignColumns[0].table, foreignColumns };
+    };
+    if (actions) {
+      this._onUpdate = actions.onUpdate;
+      this._onDelete = actions.onDelete;
+    }
+  }
+  onUpdate(action) {
+    this._onUpdate = action === undefined ? "no action" : action;
+    return this;
+  }
+  onDelete(action) {
+    this._onDelete = action === undefined ? "no action" : action;
+    return this;
+  }
+  build(table) {
+    return new ForeignKey(table, this);
+  }
+}
+
+class ForeignKey {
+  constructor(table, builder) {
+    this.table = table;
+    this.reference = builder.reference;
+    this.onUpdate = builder._onUpdate;
+    this.onDelete = builder._onDelete;
+  }
+  static [entityKind] = "PgForeignKey";
+  reference;
+  onUpdate;
+  onDelete;
+  getName() {
+    const { name, columns, foreignColumns } = this.reference();
+    const columnNames = columns.map((column) => column.name);
+    const foreignColumnNames = foreignColumns.map((column) => column.name);
+    const chunks = [
+      this.table[TableName],
+      ...columnNames,
+      foreignColumns[0].table[TableName],
+      ...foreignColumnNames
+    ];
+    return name ?? `${chunks.join("_")}_fk`;
+  }
+}
+
+// node_modules/drizzle-orm/tracing-utils.js
+function iife(fn, ...args) {
+  return fn(...args);
+}
+
+// node_modules/drizzle-orm/pg-core/unique-constraint.js
+function uniqueKeyName(table, columns) {
+  return `${table[TableName]}_${columns.join("_")}_unique`;
+}
+
+// node_modules/drizzle-orm/pg-core/utils/array.js
+function parsePgArrayValue(arrayString, startFrom, inQuotes) {
+  for (let i = startFrom;i < arrayString.length; i++) {
+    const char = arrayString[i];
+    if (char === "\\") {
+      i++;
+      continue;
+    }
+    if (char === '"') {
+      return [arrayString.slice(startFrom, i).replace(/\\/g, ""), i + 1];
+    }
+    if (inQuotes) {
+      continue;
+    }
+    if (char === "," || char === "}") {
+      return [arrayString.slice(startFrom, i).replace(/\\/g, ""), i];
+    }
+  }
+  return [arrayString.slice(startFrom).replace(/\\/g, ""), arrayString.length];
+}
+function parsePgNestedArray(arrayString, startFrom = 0) {
+  const result = [];
+  let i = startFrom;
+  let lastCharIsComma = false;
+  while (i < arrayString.length) {
+    const char = arrayString[i];
+    if (char === ",") {
+      if (lastCharIsComma || i === startFrom) {
+        result.push("");
+      }
+      lastCharIsComma = true;
+      i++;
+      continue;
+    }
+    lastCharIsComma = false;
+    if (char === "\\") {
+      i += 2;
+      continue;
+    }
+    if (char === '"') {
+      const [value2, startFrom2] = parsePgArrayValue(arrayString, i + 1, true);
+      result.push(value2);
+      i = startFrom2;
+      continue;
+    }
+    if (char === "}") {
+      return [result, i + 1];
+    }
+    if (char === "{") {
+      const [value2, startFrom2] = parsePgNestedArray(arrayString, i + 1);
+      result.push(value2);
+      i = startFrom2;
+      continue;
+    }
+    const [value, newStartFrom] = parsePgArrayValue(arrayString, i, false);
+    result.push(value);
+    i = newStartFrom;
+  }
+  return [result, i];
+}
+function parsePgArray(arrayString) {
+  const [result] = parsePgNestedArray(arrayString, 1);
+  return result;
+}
+function makePgArray(array2) {
+  return `{${array2.map((item) => {
+    if (Array.isArray(item)) {
+      return makePgArray(item);
+    }
+    if (typeof item === "string") {
+      return `"${item.replace(/\\/g, "\\\\").replace(/"/g, "\\\"")}"`;
+    }
+    return `${item}`;
+  }).join(",")}}`;
+}
+
+// node_modules/drizzle-orm/pg-core/columns/common.js
+class PgColumnBuilder extends ColumnBuilder {
+  foreignKeyConfigs = [];
+  static [entityKind] = "PgColumnBuilder";
+  array(size) {
+    return new PgArrayBuilder(this.config.name, this, size);
+  }
+  references(ref, actions = {}) {
+    this.foreignKeyConfigs.push({ ref, actions });
+    return this;
+  }
+  unique(name, config) {
+    this.config.isUnique = true;
+    this.config.uniqueName = name;
+    this.config.uniqueType = config?.nulls;
+    return this;
+  }
+  generatedAlwaysAs(as) {
+    this.config.generated = {
+      as,
+      type: "always",
+      mode: "stored"
+    };
+    return this;
+  }
+  buildForeignKeys(column, table) {
+    return this.foreignKeyConfigs.map(({ ref, actions }) => {
+      return iife((ref2, actions2) => {
+        const builder = new ForeignKeyBuilder(() => {
+          const foreignColumn = ref2();
+          return { columns: [column], foreignColumns: [foreignColumn] };
+        });
+        if (actions2.onUpdate) {
+          builder.onUpdate(actions2.onUpdate);
+        }
+        if (actions2.onDelete) {
+          builder.onDelete(actions2.onDelete);
+        }
+        return builder.build(table);
+      }, ref, actions);
+    });
+  }
+  buildExtraConfigColumn(table) {
+    return new ExtraConfigColumn(table, this.config);
+  }
+}
+
+class PgColumn extends Column {
+  constructor(table, config) {
+    if (!config.uniqueName) {
+      config.uniqueName = uniqueKeyName(table, [config.name]);
+    }
+    super(table, config);
+    this.table = table;
+  }
+  static [entityKind] = "PgColumn";
+}
+
+class ExtraConfigColumn extends PgColumn {
+  static [entityKind] = "ExtraConfigColumn";
+  getSQLType() {
+    return this.getSQLType();
+  }
+  indexConfig = {
+    order: this.config.order ?? "asc",
+    nulls: this.config.nulls ?? "last",
+    opClass: this.config.opClass
+  };
+  defaultConfig = {
+    order: "asc",
+    nulls: "last",
+    opClass: undefined
+  };
+  asc() {
+    this.indexConfig.order = "asc";
+    return this;
+  }
+  desc() {
+    this.indexConfig.order = "desc";
+    return this;
+  }
+  nullsFirst() {
+    this.indexConfig.nulls = "first";
+    return this;
+  }
+  nullsLast() {
+    this.indexConfig.nulls = "last";
+    return this;
+  }
+  op(opClass) {
+    this.indexConfig.opClass = opClass;
+    return this;
+  }
+}
+
+class IndexedColumn {
+  static [entityKind] = "IndexedColumn";
+  constructor(name, keyAsName, type, indexConfig) {
+    this.name = name;
+    this.keyAsName = keyAsName;
+    this.type = type;
+    this.indexConfig = indexConfig;
+  }
+  name;
+  keyAsName;
+  type;
+  indexConfig;
+}
+
+class PgArrayBuilder extends PgColumnBuilder {
+  static [entityKind] = "PgArrayBuilder";
+  constructor(name, baseBuilder, size) {
+    super(name, "array", "PgArray");
+    this.config.baseBuilder = baseBuilder;
+    this.config.size = size;
+  }
+  build(table) {
+    const baseColumn = this.config.baseBuilder.build(table);
+    return new PgArray(table, this.config, baseColumn);
+  }
+}
+
+class PgArray extends PgColumn {
+  constructor(table, config, baseColumn, range) {
+    super(table, config);
+    this.baseColumn = baseColumn;
+    this.range = range;
+    this.size = config.size;
+  }
+  size;
+  static [entityKind] = "PgArray";
+  getSQLType() {
+    return `${this.baseColumn.getSQLType()}[${typeof this.size === "number" ? this.size : ""}]`;
+  }
+  mapFromDriverValue(value) {
+    if (typeof value === "string") {
+      value = parsePgArray(value);
+    }
+    return value.map((v) => this.baseColumn.mapFromDriverValue(v));
+  }
+  mapToDriverValue(value, isNestedArray = false) {
+    const a = value.map((v) => v === null ? null : is(this.baseColumn, PgArray) ? this.baseColumn.mapToDriverValue(v, true) : this.baseColumn.mapToDriverValue(v));
+    if (isNestedArray)
+      return a;
+    return makePgArray(a);
+  }
+}
+
+// node_modules/drizzle-orm/pg-core/columns/enum.js
+class PgEnumObjectColumn extends PgColumn {
+  static [entityKind] = "PgEnumObjectColumn";
+  enum;
+  enumValues = this.config.enum.enumValues;
+  constructor(table, config) {
+    super(table, config);
+    this.enum = config.enum;
+  }
+  getSQLType() {
+    return this.enum.enumName;
+  }
+}
+var isPgEnumSym = Symbol.for("drizzle:isPgEnum");
+function isPgEnum(obj) {
+  return !!obj && typeof obj === "function" && isPgEnumSym in obj && obj[isPgEnumSym] === true;
+}
+class PgEnumColumn extends PgColumn {
+  static [entityKind] = "PgEnumColumn";
+  enum = this.config.enum;
+  enumValues = this.config.enum.enumValues;
+  constructor(table, config) {
+    super(table, config);
+    this.enum = config.enum;
+  }
+  getSQLType() {
+    return this.enum.enumName;
+  }
+}
+
+// node_modules/drizzle-orm/subquery.js
+class Subquery {
+  static [entityKind] = "Subquery";
+  constructor(sql, fields, alias, isWith = false, usedTables = []) {
+    this._ = {
+      brand: "Subquery",
+      sql,
+      selectedFields: fields,
+      alias,
+      isWith,
+      usedTables
+    };
+  }
+}
+
+// node_modules/drizzle-orm/version.js
+var version = "0.44.7";
+
+// node_modules/drizzle-orm/tracing.js
+var otel;
+var rawTracer;
+var tracer = {
+  startActiveSpan(name, fn) {
+    if (!otel) {
+      return fn();
+    }
+    if (!rawTracer) {
+      rawTracer = otel.trace.getTracer("drizzle-orm", version);
+    }
+    return iife((otel2, rawTracer2) => rawTracer2.startActiveSpan(name, (span) => {
+      try {
+        return fn(span);
+      } catch (e) {
+        span.setStatus({
+          code: otel2.SpanStatusCode.ERROR,
+          message: e instanceof Error ? e.message : "Unknown error"
+        });
+        throw e;
+      } finally {
+        span.end();
+      }
+    }), otel, rawTracer);
+  }
+};
+
+// node_modules/drizzle-orm/view-common.js
+var ViewBaseConfig = Symbol.for("drizzle:ViewBaseConfig");
+
+// node_modules/drizzle-orm/table.js
+var Schema = Symbol.for("drizzle:Schema");
+var Columns = Symbol.for("drizzle:Columns");
+var ExtraConfigColumns = Symbol.for("drizzle:ExtraConfigColumns");
+var OriginalName = Symbol.for("drizzle:OriginalName");
+var BaseName = Symbol.for("drizzle:BaseName");
+var IsAlias = Symbol.for("drizzle:IsAlias");
+var ExtraConfigBuilder = Symbol.for("drizzle:ExtraConfigBuilder");
+var IsDrizzleTable = Symbol.for("drizzle:IsDrizzleTable");
+
+class Table {
+  static [entityKind] = "Table";
+  static Symbol = {
+    Name: TableName,
+    Schema,
+    OriginalName,
+    Columns,
+    ExtraConfigColumns,
+    BaseName,
+    IsAlias,
+    ExtraConfigBuilder
+  };
+  [TableName];
+  [OriginalName];
+  [Schema];
+  [Columns];
+  [ExtraConfigColumns];
+  [BaseName];
+  [IsAlias] = false;
+  [IsDrizzleTable] = true;
+  [ExtraConfigBuilder] = undefined;
+  constructor(name, schema, baseName) {
+    this[TableName] = this[OriginalName] = name;
+    this[Schema] = schema;
+    this[BaseName] = baseName;
+  }
+}
+
+// node_modules/drizzle-orm/sql/sql.js
+function isSQLWrapper(value) {
+  return value !== null && value !== undefined && typeof value.getSQL === "function";
+}
+function mergeQueries(queries) {
+  const result = { sql: "", params: [] };
+  for (const query of queries) {
+    result.sql += query.sql;
+    result.params.push(...query.params);
+    if (query.typings?.length) {
+      if (!result.typings) {
+        result.typings = [];
+      }
+      result.typings.push(...query.typings);
+    }
+  }
+  return result;
+}
+
+class StringChunk {
+  static [entityKind] = "StringChunk";
+  value;
+  constructor(value) {
+    this.value = Array.isArray(value) ? value : [value];
+  }
+  getSQL() {
+    return new SQL([this]);
+  }
+}
+
+class SQL {
+  constructor(queryChunks) {
+    this.queryChunks = queryChunks;
+    for (const chunk of queryChunks) {
+      if (is(chunk, Table)) {
+        const schemaName = chunk[Table.Symbol.Schema];
+        this.usedTables.push(schemaName === undefined ? chunk[Table.Symbol.Name] : schemaName + "." + chunk[Table.Symbol.Name]);
+      }
+    }
+  }
+  static [entityKind] = "SQL";
+  decoder = noopDecoder;
+  shouldInlineParams = false;
+  usedTables = [];
+  append(query) {
+    this.queryChunks.push(...query.queryChunks);
+    return this;
+  }
+  toQuery(config) {
+    return tracer.startActiveSpan("drizzle.buildSQL", (span) => {
+      const query = this.buildQueryFromSourceParams(this.queryChunks, config);
+      span?.setAttributes({
+        "drizzle.query.text": query.sql,
+        "drizzle.query.params": JSON.stringify(query.params)
+      });
+      return query;
+    });
+  }
+  buildQueryFromSourceParams(chunks, _config) {
+    const config = Object.assign({}, _config, {
+      inlineParams: _config.inlineParams || this.shouldInlineParams,
+      paramStartIndex: _config.paramStartIndex || { value: 0 }
+    });
+    const {
+      casing,
+      escapeName,
+      escapeParam,
+      prepareTyping,
+      inlineParams,
+      paramStartIndex
+    } = config;
+    return mergeQueries(chunks.map((chunk) => {
+      if (is(chunk, StringChunk)) {
+        return { sql: chunk.value.join(""), params: [] };
+      }
+      if (is(chunk, Name)) {
+        return { sql: escapeName(chunk.value), params: [] };
+      }
+      if (chunk === undefined) {
+        return { sql: "", params: [] };
+      }
+      if (Array.isArray(chunk)) {
+        const result = [new StringChunk("(")];
+        for (const [i, p] of chunk.entries()) {
+          result.push(p);
+          if (i < chunk.length - 1) {
+            result.push(new StringChunk(", "));
+          }
+        }
+        result.push(new StringChunk(")"));
+        return this.buildQueryFromSourceParams(result, config);
+      }
+      if (is(chunk, SQL)) {
+        return this.buildQueryFromSourceParams(chunk.queryChunks, {
+          ...config,
+          inlineParams: inlineParams || chunk.shouldInlineParams
+        });
+      }
+      if (is(chunk, Table)) {
+        const schemaName = chunk[Table.Symbol.Schema];
+        const tableName = chunk[Table.Symbol.Name];
+        return {
+          sql: schemaName === undefined || chunk[IsAlias] ? escapeName(tableName) : escapeName(schemaName) + "." + escapeName(tableName),
+          params: []
+        };
+      }
+      if (is(chunk, Column)) {
+        const columnName = casing.getColumnCasing(chunk);
+        if (_config.invokeSource === "indexes") {
+          return { sql: escapeName(columnName), params: [] };
+        }
+        const schemaName = chunk.table[Table.Symbol.Schema];
+        return {
+          sql: chunk.table[IsAlias] || schemaName === undefined ? escapeName(chunk.table[Table.Symbol.Name]) + "." + escapeName(columnName) : escapeName(schemaName) + "." + escapeName(chunk.table[Table.Symbol.Name]) + "." + escapeName(columnName),
+          params: []
+        };
+      }
+      if (is(chunk, View)) {
+        const schemaName = chunk[ViewBaseConfig].schema;
+        const viewName = chunk[ViewBaseConfig].name;
+        return {
+          sql: schemaName === undefined || chunk[ViewBaseConfig].isAlias ? escapeName(viewName) : escapeName(schemaName) + "." + escapeName(viewName),
+          params: []
+        };
+      }
+      if (is(chunk, Param)) {
+        if (is(chunk.value, Placeholder)) {
+          return { sql: escapeParam(paramStartIndex.value++, chunk), params: [chunk], typings: ["none"] };
+        }
+        const mappedValue = chunk.value === null ? null : chunk.encoder.mapToDriverValue(chunk.value);
+        if (is(mappedValue, SQL)) {
+          return this.buildQueryFromSourceParams([mappedValue], config);
+        }
+        if (inlineParams) {
+          return { sql: this.mapInlineParam(mappedValue, config), params: [] };
+        }
+        let typings = ["none"];
+        if (prepareTyping) {
+          typings = [prepareTyping(chunk.encoder)];
+        }
+        return { sql: escapeParam(paramStartIndex.value++, mappedValue), params: [mappedValue], typings };
+      }
+      if (is(chunk, Placeholder)) {
+        return { sql: escapeParam(paramStartIndex.value++, chunk), params: [chunk], typings: ["none"] };
+      }
+      if (is(chunk, SQL.Aliased) && chunk.fieldAlias !== undefined) {
+        return { sql: escapeName(chunk.fieldAlias), params: [] };
+      }
+      if (is(chunk, Subquery)) {
+        if (chunk._.isWith) {
+          return { sql: escapeName(chunk._.alias), params: [] };
+        }
+        return this.buildQueryFromSourceParams([
+          new StringChunk("("),
+          chunk._.sql,
+          new StringChunk(") "),
+          new Name(chunk._.alias)
+        ], config);
+      }
+      if (isPgEnum(chunk)) {
+        if (chunk.schema) {
+          return { sql: escapeName(chunk.schema) + "." + escapeName(chunk.enumName), params: [] };
+        }
+        return { sql: escapeName(chunk.enumName), params: [] };
+      }
+      if (isSQLWrapper(chunk)) {
+        if (chunk.shouldOmitSQLParens?.()) {
+          return this.buildQueryFromSourceParams([chunk.getSQL()], config);
+        }
+        return this.buildQueryFromSourceParams([
+          new StringChunk("("),
+          chunk.getSQL(),
+          new StringChunk(")")
+        ], config);
+      }
+      if (inlineParams) {
+        return { sql: this.mapInlineParam(chunk, config), params: [] };
+      }
+      return { sql: escapeParam(paramStartIndex.value++, chunk), params: [chunk], typings: ["none"] };
+    }));
+  }
+  mapInlineParam(chunk, { escapeString }) {
+    if (chunk === null) {
+      return "null";
+    }
+    if (typeof chunk === "number" || typeof chunk === "boolean") {
+      return chunk.toString();
+    }
+    if (typeof chunk === "string") {
+      return escapeString(chunk);
+    }
+    if (typeof chunk === "object") {
+      const mappedValueAsString = chunk.toString();
+      if (mappedValueAsString === "[object Object]") {
+        return escapeString(JSON.stringify(chunk));
+      }
+      return escapeString(mappedValueAsString);
+    }
+    throw new Error("Unexpected param value: " + chunk);
+  }
+  getSQL() {
+    return this;
+  }
+  as(alias) {
+    if (alias === undefined) {
+      return this;
+    }
+    return new SQL.Aliased(this, alias);
+  }
+  mapWith(decoder) {
+    this.decoder = typeof decoder === "function" ? { mapFromDriverValue: decoder } : decoder;
+    return this;
+  }
+  inlineParams() {
+    this.shouldInlineParams = true;
+    return this;
+  }
+  if(condition) {
+    return condition ? this : undefined;
+  }
+}
+
+class Name {
+  constructor(value) {
+    this.value = value;
+  }
+  static [entityKind] = "Name";
+  brand;
+  getSQL() {
+    return new SQL([this]);
+  }
+}
+function isDriverValueEncoder(value) {
+  return typeof value === "object" && value !== null && "mapToDriverValue" in value && typeof value.mapToDriverValue === "function";
+}
+var noopDecoder = {
+  mapFromDriverValue: (value) => value
+};
+var noopEncoder = {
+  mapToDriverValue: (value) => value
+};
+var noopMapper = {
+  ...noopDecoder,
+  ...noopEncoder
+};
+
+class Param {
+  constructor(value, encoder = noopEncoder) {
+    this.value = value;
+    this.encoder = encoder;
+  }
+  static [entityKind] = "Param";
+  brand;
+  getSQL() {
+    return new SQL([this]);
+  }
+}
+function sql(strings, ...params) {
+  const queryChunks = [];
+  if (params.length > 0 || strings.length > 0 && strings[0] !== "") {
+    queryChunks.push(new StringChunk(strings[0]));
+  }
+  for (const [paramIndex, param2] of params.entries()) {
+    queryChunks.push(param2, new StringChunk(strings[paramIndex + 1]));
+  }
+  return new SQL(queryChunks);
+}
+((sql2) => {
+  function empty() {
+    return new SQL([]);
+  }
+  sql2.empty = empty;
+  function fromList(list) {
+    return new SQL(list);
+  }
+  sql2.fromList = fromList;
+  function raw(str) {
+    return new SQL([new StringChunk(str)]);
+  }
+  sql2.raw = raw;
+  function join(chunks, separator) {
+    const result = [];
+    for (const [i, chunk] of chunks.entries()) {
+      if (i > 0 && separator !== undefined) {
+        result.push(separator);
+      }
+      result.push(chunk);
+    }
+    return new SQL(result);
+  }
+  sql2.join = join;
+  function identifier(value) {
+    return new Name(value);
+  }
+  sql2.identifier = identifier;
+  function placeholder2(name2) {
+    return new Placeholder(name2);
+  }
+  sql2.placeholder = placeholder2;
+  function param2(value, encoder) {
+    return new Param(value, encoder);
+  }
+  sql2.param = param2;
+})(sql || (sql = {}));
+((SQL2) => {
+
+  class Aliased {
+    constructor(sql2, fieldAlias) {
+      this.sql = sql2;
+      this.fieldAlias = fieldAlias;
+    }
+    static [entityKind] = "SQL.Aliased";
+    isSelectionField = false;
+    getSQL() {
+      return this.sql;
+    }
+    clone() {
+      return new Aliased(this.sql, this.fieldAlias);
+    }
+  }
+  SQL2.Aliased = Aliased;
+})(SQL || (SQL = {}));
+
+class Placeholder {
+  constructor(name2) {
+    this.name = name2;
+  }
+  static [entityKind] = "Placeholder";
+  getSQL() {
+    return new SQL([this]);
+  }
+}
+var IsDrizzleView = Symbol.for("drizzle:IsDrizzleView");
+
+class View {
+  static [entityKind] = "View";
+  [ViewBaseConfig];
+  [IsDrizzleView] = true;
+  constructor({ name: name2, schema, selectedFields, query }) {
+    this[ViewBaseConfig] = {
+      name: name2,
+      originalName: name2,
+      schema,
+      selectedFields,
+      query,
+      isExisting: !query,
+      isAlias: false
+    };
+  }
+  getSQL() {
+    return new SQL([this]);
+  }
+}
+Column.prototype.getSQL = function() {
+  return new SQL([this]);
+};
+Table.prototype.getSQL = function() {
+  return new SQL([this]);
+};
+Subquery.prototype.getSQL = function() {
+  return new SQL([this]);
+};
+
+// node_modules/drizzle-orm/utils.js
+function getColumnNameAndConfig(a, b) {
+  return {
+    name: typeof a === "string" && a.length > 0 ? a : "",
+    config: typeof a === "object" ? a : b
+  };
+}
+var textDecoder = typeof TextDecoder === "undefined" ? null : new TextDecoder;
+
+// node_modules/drizzle-orm/pg-core/columns/int.common.js
+class PgIntColumnBaseBuilder extends PgColumnBuilder {
+  static [entityKind] = "PgIntColumnBaseBuilder";
+  generatedAlwaysAsIdentity(sequence) {
+    if (sequence) {
+      const { name, ...options } = sequence;
+      this.config.generatedIdentity = {
+        type: "always",
+        sequenceName: name,
+        sequenceOptions: options
+      };
+    } else {
+      this.config.generatedIdentity = {
+        type: "always"
+      };
+    }
+    this.config.hasDefault = true;
+    this.config.notNull = true;
+    return this;
+  }
+  generatedByDefaultAsIdentity(sequence) {
+    if (sequence) {
+      const { name, ...options } = sequence;
+      this.config.generatedIdentity = {
+        type: "byDefault",
+        sequenceName: name,
+        sequenceOptions: options
+      };
+    } else {
+      this.config.generatedIdentity = {
+        type: "byDefault"
+      };
+    }
+    this.config.hasDefault = true;
+    this.config.notNull = true;
+    return this;
+  }
+}
+
+// node_modules/drizzle-orm/pg-core/columns/bigint.js
+class PgBigInt53Builder extends PgIntColumnBaseBuilder {
+  static [entityKind] = "PgBigInt53Builder";
+  constructor(name) {
+    super(name, "number", "PgBigInt53");
+  }
+  build(table) {
+    return new PgBigInt53(table, this.config);
+  }
+}
+
+class PgBigInt53 extends PgColumn {
+  static [entityKind] = "PgBigInt53";
+  getSQLType() {
+    return "bigint";
+  }
+  mapFromDriverValue(value) {
+    if (typeof value === "number") {
+      return value;
+    }
+    return Number(value);
+  }
+}
+
+class PgBigInt64Builder extends PgIntColumnBaseBuilder {
+  static [entityKind] = "PgBigInt64Builder";
+  constructor(name) {
+    super(name, "bigint", "PgBigInt64");
+  }
+  build(table) {
+    return new PgBigInt64(table, this.config);
+  }
+}
+
+class PgBigInt64 extends PgColumn {
+  static [entityKind] = "PgBigInt64";
+  getSQLType() {
+    return "bigint";
+  }
+  mapFromDriverValue(value) {
+    return BigInt(value);
+  }
+}
+function bigint2(a, b) {
+  const { name, config } = getColumnNameAndConfig(a, b);
+  if (config.mode === "number") {
+    return new PgBigInt53Builder(name);
+  }
+  return new PgBigInt64Builder(name);
+}
+
+// node_modules/drizzle-orm/pg-core/columns/bigserial.js
+class PgBigSerial53Builder extends PgColumnBuilder {
+  static [entityKind] = "PgBigSerial53Builder";
+  constructor(name) {
+    super(name, "number", "PgBigSerial53");
+    this.config.hasDefault = true;
+    this.config.notNull = true;
+  }
+  build(table) {
+    return new PgBigSerial53(table, this.config);
+  }
+}
+
+class PgBigSerial53 extends PgColumn {
+  static [entityKind] = "PgBigSerial53";
+  getSQLType() {
+    return "bigserial";
+  }
+  mapFromDriverValue(value) {
+    if (typeof value === "number") {
+      return value;
+    }
+    return Number(value);
+  }
+}
+
+class PgBigSerial64Builder extends PgColumnBuilder {
+  static [entityKind] = "PgBigSerial64Builder";
+  constructor(name) {
+    super(name, "bigint", "PgBigSerial64");
+    this.config.hasDefault = true;
+  }
+  build(table) {
+    return new PgBigSerial64(table, this.config);
+  }
+}
+
+class PgBigSerial64 extends PgColumn {
+  static [entityKind] = "PgBigSerial64";
+  getSQLType() {
+    return "bigserial";
+  }
+  mapFromDriverValue(value) {
+    return BigInt(value);
+  }
+}
+function bigserial(a, b) {
+  const { name, config } = getColumnNameAndConfig(a, b);
+  if (config.mode === "number") {
+    return new PgBigSerial53Builder(name);
+  }
+  return new PgBigSerial64Builder(name);
+}
+
+// node_modules/drizzle-orm/pg-core/columns/boolean.js
+class PgBooleanBuilder extends PgColumnBuilder {
+  static [entityKind] = "PgBooleanBuilder";
+  constructor(name) {
+    super(name, "boolean", "PgBoolean");
+  }
+  build(table) {
+    return new PgBoolean(table, this.config);
+  }
+}
+
+class PgBoolean extends PgColumn {
+  static [entityKind] = "PgBoolean";
+  getSQLType() {
+    return "boolean";
+  }
+}
+function boolean2(name) {
+  return new PgBooleanBuilder(name ?? "");
+}
+
+// node_modules/drizzle-orm/pg-core/columns/char.js
+class PgCharBuilder extends PgColumnBuilder {
+  static [entityKind] = "PgCharBuilder";
+  constructor(name, config) {
+    super(name, "string", "PgChar");
+    this.config.length = config.length;
+    this.config.enumValues = config.enum;
+  }
+  build(table) {
+    return new PgChar(table, this.config);
+  }
+}
+
+class PgChar extends PgColumn {
+  static [entityKind] = "PgChar";
+  length = this.config.length;
+  enumValues = this.config.enumValues;
+  getSQLType() {
+    return this.length === undefined ? `char` : `char(${this.length})`;
+  }
+}
+function char(a, b = {}) {
+  const { name, config } = getColumnNameAndConfig(a, b);
+  return new PgCharBuilder(name, config);
+}
+
+// node_modules/drizzle-orm/pg-core/columns/cidr.js
+class PgCidrBuilder extends PgColumnBuilder {
+  static [entityKind] = "PgCidrBuilder";
+  constructor(name) {
+    super(name, "string", "PgCidr");
+  }
+  build(table) {
+    return new PgCidr(table, this.config);
+  }
+}
+
+class PgCidr extends PgColumn {
+  static [entityKind] = "PgCidr";
+  getSQLType() {
+    return "cidr";
+  }
+}
+function cidr(name) {
+  return new PgCidrBuilder(name ?? "");
+}
+
+// node_modules/drizzle-orm/pg-core/columns/custom.js
+class PgCustomColumnBuilder extends PgColumnBuilder {
+  static [entityKind] = "PgCustomColumnBuilder";
+  constructor(name, fieldConfig, customTypeParams) {
+    super(name, "custom", "PgCustomColumn");
+    this.config.fieldConfig = fieldConfig;
+    this.config.customTypeParams = customTypeParams;
+  }
+  build(table) {
+    return new PgCustomColumn(table, this.config);
+  }
+}
+
+class PgCustomColumn extends PgColumn {
+  static [entityKind] = "PgCustomColumn";
+  sqlName;
+  mapTo;
+  mapFrom;
+  constructor(table, config) {
+    super(table, config);
+    this.sqlName = config.customTypeParams.dataType(config.fieldConfig);
+    this.mapTo = config.customTypeParams.toDriver;
+    this.mapFrom = config.customTypeParams.fromDriver;
+  }
+  getSQLType() {
+    return this.sqlName;
+  }
+  mapFromDriverValue(value) {
+    return typeof this.mapFrom === "function" ? this.mapFrom(value) : value;
+  }
+  mapToDriverValue(value) {
+    return typeof this.mapTo === "function" ? this.mapTo(value) : value;
+  }
+}
+function customType(customTypeParams) {
+  return (a, b) => {
+    const { name, config } = getColumnNameAndConfig(a, b);
+    return new PgCustomColumnBuilder(name, config, customTypeParams);
+  };
+}
+
+// node_modules/drizzle-orm/pg-core/columns/date.common.js
+class PgDateColumnBaseBuilder extends PgColumnBuilder {
+  static [entityKind] = "PgDateColumnBaseBuilder";
+  defaultNow() {
+    return this.default(sql`now()`);
+  }
+}
+
+// node_modules/drizzle-orm/pg-core/columns/date.js
+class PgDateBuilder extends PgDateColumnBaseBuilder {
+  static [entityKind] = "PgDateBuilder";
+  constructor(name) {
+    super(name, "date", "PgDate");
+  }
+  build(table) {
+    return new PgDate(table, this.config);
+  }
+}
+
+class PgDate extends PgColumn {
+  static [entityKind] = "PgDate";
+  getSQLType() {
+    return "date";
+  }
+  mapFromDriverValue(value) {
+    return new Date(value);
+  }
+  mapToDriverValue(value) {
+    return value.toISOString();
+  }
+}
+
+class PgDateStringBuilder extends PgDateColumnBaseBuilder {
+  static [entityKind] = "PgDateStringBuilder";
+  constructor(name) {
+    super(name, "string", "PgDateString");
+  }
+  build(table) {
+    return new PgDateString(table, this.config);
+  }
+}
+
+class PgDateString extends PgColumn {
+  static [entityKind] = "PgDateString";
+  getSQLType() {
+    return "date";
+  }
+}
+function date2(a, b) {
+  const { name, config } = getColumnNameAndConfig(a, b);
+  if (config?.mode === "date") {
+    return new PgDateBuilder(name);
+  }
+  return new PgDateStringBuilder(name);
+}
+
+// node_modules/drizzle-orm/pg-core/columns/double-precision.js
+class PgDoublePrecisionBuilder extends PgColumnBuilder {
+  static [entityKind] = "PgDoublePrecisionBuilder";
+  constructor(name) {
+    super(name, "number", "PgDoublePrecision");
+  }
+  build(table) {
+    return new PgDoublePrecision(table, this.config);
+  }
+}
+
+class PgDoublePrecision extends PgColumn {
+  static [entityKind] = "PgDoublePrecision";
+  getSQLType() {
+    return "double precision";
+  }
+  mapFromDriverValue(value) {
+    if (typeof value === "string") {
+      return Number.parseFloat(value);
+    }
+    return value;
+  }
+}
+function doublePrecision(name) {
+  return new PgDoublePrecisionBuilder(name ?? "");
+}
+
+// node_modules/drizzle-orm/pg-core/columns/inet.js
+class PgInetBuilder extends PgColumnBuilder {
+  static [entityKind] = "PgInetBuilder";
+  constructor(name) {
+    super(name, "string", "PgInet");
+  }
+  build(table) {
+    return new PgInet(table, this.config);
+  }
+}
+
+class PgInet extends PgColumn {
+  static [entityKind] = "PgInet";
+  getSQLType() {
+    return "inet";
+  }
+}
+function inet(name) {
+  return new PgInetBuilder(name ?? "");
+}
+
+// node_modules/drizzle-orm/pg-core/columns/integer.js
+class PgIntegerBuilder extends PgIntColumnBaseBuilder {
+  static [entityKind] = "PgIntegerBuilder";
+  constructor(name) {
+    super(name, "number", "PgInteger");
+  }
+  build(table) {
+    return new PgInteger(table, this.config);
+  }
+}
+
+class PgInteger extends PgColumn {
+  static [entityKind] = "PgInteger";
+  getSQLType() {
+    return "integer";
+  }
+  mapFromDriverValue(value) {
+    if (typeof value === "string") {
+      return Number.parseInt(value);
+    }
+    return value;
+  }
+}
+function integer(name) {
+  return new PgIntegerBuilder(name ?? "");
+}
+
+// node_modules/drizzle-orm/pg-core/columns/interval.js
+class PgIntervalBuilder extends PgColumnBuilder {
+  static [entityKind] = "PgIntervalBuilder";
+  constructor(name, intervalConfig) {
+    super(name, "string", "PgInterval");
+    this.config.intervalConfig = intervalConfig;
+  }
+  build(table) {
+    return new PgInterval(table, this.config);
+  }
+}
+
+class PgInterval extends PgColumn {
+  static [entityKind] = "PgInterval";
+  fields = this.config.intervalConfig.fields;
+  precision = this.config.intervalConfig.precision;
+  getSQLType() {
+    const fields = this.fields ? ` ${this.fields}` : "";
+    const precision = this.precision ? `(${this.precision})` : "";
+    return `interval${fields}${precision}`;
+  }
+}
+function interval(a, b = {}) {
+  const { name, config } = getColumnNameAndConfig(a, b);
+  return new PgIntervalBuilder(name, config);
+}
+
+// node_modules/drizzle-orm/pg-core/columns/json.js
+class PgJsonBuilder extends PgColumnBuilder {
+  static [entityKind] = "PgJsonBuilder";
+  constructor(name) {
+    super(name, "json", "PgJson");
+  }
+  build(table) {
+    return new PgJson(table, this.config);
+  }
+}
+
+class PgJson extends PgColumn {
+  static [entityKind] = "PgJson";
+  constructor(table, config) {
+    super(table, config);
+  }
+  getSQLType() {
+    return "json";
+  }
+  mapToDriverValue(value) {
+    return JSON.stringify(value);
+  }
+  mapFromDriverValue(value) {
+    if (typeof value === "string") {
+      try {
+        return JSON.parse(value);
+      } catch {
+        return value;
+      }
+    }
+    return value;
+  }
+}
+function json(name) {
+  return new PgJsonBuilder(name ?? "");
+}
+
+// node_modules/drizzle-orm/pg-core/columns/jsonb.js
+class PgJsonbBuilder extends PgColumnBuilder {
+  static [entityKind] = "PgJsonbBuilder";
+  constructor(name) {
+    super(name, "json", "PgJsonb");
+  }
+  build(table) {
+    return new PgJsonb(table, this.config);
+  }
+}
+
+class PgJsonb extends PgColumn {
+  static [entityKind] = "PgJsonb";
+  constructor(table, config) {
+    super(table, config);
+  }
+  getSQLType() {
+    return "jsonb";
+  }
+  mapToDriverValue(value) {
+    return JSON.stringify(value);
+  }
+  mapFromDriverValue(value) {
+    if (typeof value === "string") {
+      try {
+        return JSON.parse(value);
+      } catch {
+        return value;
+      }
+    }
+    return value;
+  }
+}
+function jsonb(name) {
+  return new PgJsonbBuilder(name ?? "");
+}
+
+// node_modules/drizzle-orm/pg-core/columns/line.js
+class PgLineBuilder extends PgColumnBuilder {
+  static [entityKind] = "PgLineBuilder";
+  constructor(name) {
+    super(name, "array", "PgLine");
+  }
+  build(table) {
+    return new PgLineTuple(table, this.config);
+  }
+}
+
+class PgLineTuple extends PgColumn {
+  static [entityKind] = "PgLine";
+  getSQLType() {
+    return "line";
+  }
+  mapFromDriverValue(value) {
+    const [a, b, c] = value.slice(1, -1).split(",");
+    return [Number.parseFloat(a), Number.parseFloat(b), Number.parseFloat(c)];
+  }
+  mapToDriverValue(value) {
+    return `{${value[0]},${value[1]},${value[2]}}`;
+  }
+}
+
+class PgLineABCBuilder extends PgColumnBuilder {
+  static [entityKind] = "PgLineABCBuilder";
+  constructor(name) {
+    super(name, "json", "PgLineABC");
+  }
+  build(table) {
+    return new PgLineABC(table, this.config);
+  }
+}
+
+class PgLineABC extends PgColumn {
+  static [entityKind] = "PgLineABC";
+  getSQLType() {
+    return "line";
+  }
+  mapFromDriverValue(value) {
+    const [a, b, c] = value.slice(1, -1).split(",");
+    return { a: Number.parseFloat(a), b: Number.parseFloat(b), c: Number.parseFloat(c) };
+  }
+  mapToDriverValue(value) {
+    return `{${value.a},${value.b},${value.c}}`;
+  }
+}
+function line(a, b) {
+  const { name, config } = getColumnNameAndConfig(a, b);
+  if (!config?.mode || config.mode === "tuple") {
+    return new PgLineBuilder(name);
+  }
+  return new PgLineABCBuilder(name);
+}
+
+// node_modules/drizzle-orm/pg-core/columns/macaddr.js
+class PgMacaddrBuilder extends PgColumnBuilder {
+  static [entityKind] = "PgMacaddrBuilder";
+  constructor(name) {
+    super(name, "string", "PgMacaddr");
+  }
+  build(table) {
+    return new PgMacaddr(table, this.config);
+  }
+}
+
+class PgMacaddr extends PgColumn {
+  static [entityKind] = "PgMacaddr";
+  getSQLType() {
+    return "macaddr";
+  }
+}
+function macaddr(name) {
+  return new PgMacaddrBuilder(name ?? "");
+}
+
+// node_modules/drizzle-orm/pg-core/columns/macaddr8.js
+class PgMacaddr8Builder extends PgColumnBuilder {
+  static [entityKind] = "PgMacaddr8Builder";
+  constructor(name) {
+    super(name, "string", "PgMacaddr8");
+  }
+  build(table) {
+    return new PgMacaddr8(table, this.config);
+  }
+}
+
+class PgMacaddr8 extends PgColumn {
+  static [entityKind] = "PgMacaddr8";
+  getSQLType() {
+    return "macaddr8";
+  }
+}
+function macaddr8(name) {
+  return new PgMacaddr8Builder(name ?? "");
+}
+
+// node_modules/drizzle-orm/pg-core/columns/numeric.js
+class PgNumericBuilder extends PgColumnBuilder {
+  static [entityKind] = "PgNumericBuilder";
+  constructor(name, precision, scale) {
+    super(name, "string", "PgNumeric");
+    this.config.precision = precision;
+    this.config.scale = scale;
+  }
+  build(table) {
+    return new PgNumeric(table, this.config);
+  }
+}
+
+class PgNumeric extends PgColumn {
+  static [entityKind] = "PgNumeric";
+  precision;
+  scale;
+  constructor(table, config) {
+    super(table, config);
+    this.precision = config.precision;
+    this.scale = config.scale;
+  }
+  mapFromDriverValue(value) {
+    if (typeof value === "string")
+      return value;
+    return String(value);
+  }
+  getSQLType() {
+    if (this.precision !== undefined && this.scale !== undefined) {
+      return `numeric(${this.precision}, ${this.scale})`;
+    } else if (this.precision === undefined) {
+      return "numeric";
+    } else {
+      return `numeric(${this.precision})`;
+    }
+  }
+}
+
+class PgNumericNumberBuilder extends PgColumnBuilder {
+  static [entityKind] = "PgNumericNumberBuilder";
+  constructor(name, precision, scale) {
+    super(name, "number", "PgNumericNumber");
+    this.config.precision = precision;
+    this.config.scale = scale;
+  }
+  build(table) {
+    return new PgNumericNumber(table, this.config);
+  }
+}
+
+class PgNumericNumber extends PgColumn {
+  static [entityKind] = "PgNumericNumber";
+  precision;
+  scale;
+  constructor(table, config) {
+    super(table, config);
+    this.precision = config.precision;
+    this.scale = config.scale;
+  }
+  mapFromDriverValue(value) {
+    if (typeof value === "number")
+      return value;
+    return Number(value);
+  }
+  mapToDriverValue = String;
+  getSQLType() {
+    if (this.precision !== undefined && this.scale !== undefined) {
+      return `numeric(${this.precision}, ${this.scale})`;
+    } else if (this.precision === undefined) {
+      return "numeric";
+    } else {
+      return `numeric(${this.precision})`;
+    }
+  }
+}
+
+class PgNumericBigIntBuilder extends PgColumnBuilder {
+  static [entityKind] = "PgNumericBigIntBuilder";
+  constructor(name, precision, scale) {
+    super(name, "bigint", "PgNumericBigInt");
+    this.config.precision = precision;
+    this.config.scale = scale;
+  }
+  build(table) {
+    return new PgNumericBigInt(table, this.config);
+  }
+}
+
+class PgNumericBigInt extends PgColumn {
+  static [entityKind] = "PgNumericBigInt";
+  precision;
+  scale;
+  constructor(table, config) {
+    super(table, config);
+    this.precision = config.precision;
+    this.scale = config.scale;
+  }
+  mapFromDriverValue = BigInt;
+  mapToDriverValue = String;
+  getSQLType() {
+    if (this.precision !== undefined && this.scale !== undefined) {
+      return `numeric(${this.precision}, ${this.scale})`;
+    } else if (this.precision === undefined) {
+      return "numeric";
+    } else {
+      return `numeric(${this.precision})`;
+    }
+  }
+}
+function numeric(a, b) {
+  const { name, config } = getColumnNameAndConfig(a, b);
+  const mode = config?.mode;
+  return mode === "number" ? new PgNumericNumberBuilder(name, config?.precision, config?.scale) : mode === "bigint" ? new PgNumericBigIntBuilder(name, config?.precision, config?.scale) : new PgNumericBuilder(name, config?.precision, config?.scale);
+}
+
+// node_modules/drizzle-orm/pg-core/columns/point.js
+class PgPointTupleBuilder extends PgColumnBuilder {
+  static [entityKind] = "PgPointTupleBuilder";
+  constructor(name) {
+    super(name, "array", "PgPointTuple");
+  }
+  build(table) {
+    return new PgPointTuple(table, this.config);
+  }
+}
+
+class PgPointTuple extends PgColumn {
+  static [entityKind] = "PgPointTuple";
+  getSQLType() {
+    return "point";
+  }
+  mapFromDriverValue(value) {
+    if (typeof value === "string") {
+      const [x, y] = value.slice(1, -1).split(",");
+      return [Number.parseFloat(x), Number.parseFloat(y)];
+    }
+    return [value.x, value.y];
+  }
+  mapToDriverValue(value) {
+    return `(${value[0]},${value[1]})`;
+  }
+}
+
+class PgPointObjectBuilder extends PgColumnBuilder {
+  static [entityKind] = "PgPointObjectBuilder";
+  constructor(name) {
+    super(name, "json", "PgPointObject");
+  }
+  build(table) {
+    return new PgPointObject(table, this.config);
+  }
+}
+
+class PgPointObject extends PgColumn {
+  static [entityKind] = "PgPointObject";
+  getSQLType() {
+    return "point";
+  }
+  mapFromDriverValue(value) {
+    if (typeof value === "string") {
+      const [x, y] = value.slice(1, -1).split(",");
+      return { x: Number.parseFloat(x), y: Number.parseFloat(y) };
+    }
+    return value;
+  }
+  mapToDriverValue(value) {
+    return `(${value.x},${value.y})`;
+  }
+}
+function point(a, b) {
+  const { name, config } = getColumnNameAndConfig(a, b);
+  if (!config?.mode || config.mode === "tuple") {
+    return new PgPointTupleBuilder(name);
+  }
+  return new PgPointObjectBuilder(name);
+}
+
+// node_modules/drizzle-orm/pg-core/columns/postgis_extension/utils.js
+function hexToBytes(hex) {
+  const bytes = [];
+  for (let c = 0;c < hex.length; c += 2) {
+    bytes.push(Number.parseInt(hex.slice(c, c + 2), 16));
+  }
+  return new Uint8Array(bytes);
+}
+function bytesToFloat64(bytes, offset) {
+  const buffer = new ArrayBuffer(8);
+  const view = new DataView(buffer);
+  for (let i = 0;i < 8; i++) {
+    view.setUint8(i, bytes[offset + i]);
+  }
+  return view.getFloat64(0, true);
+}
+function parseEWKB(hex) {
+  const bytes = hexToBytes(hex);
+  let offset = 0;
+  const byteOrder = bytes[offset];
+  offset += 1;
+  const view = new DataView(bytes.buffer);
+  const geomType = view.getUint32(offset, byteOrder === 1);
+  offset += 4;
+  let _srid;
+  if (geomType & 536870912) {
+    _srid = view.getUint32(offset, byteOrder === 1);
+    offset += 4;
+  }
+  if ((geomType & 65535) === 1) {
+    const x = bytesToFloat64(bytes, offset);
+    offset += 8;
+    const y = bytesToFloat64(bytes, offset);
+    offset += 8;
+    return [x, y];
+  }
+  throw new Error("Unsupported geometry type");
+}
+
+// node_modules/drizzle-orm/pg-core/columns/postgis_extension/geometry.js
+class PgGeometryBuilder extends PgColumnBuilder {
+  static [entityKind] = "PgGeometryBuilder";
+  constructor(name) {
+    super(name, "array", "PgGeometry");
+  }
+  build(table) {
+    return new PgGeometry(table, this.config);
+  }
+}
+
+class PgGeometry extends PgColumn {
+  static [entityKind] = "PgGeometry";
+  getSQLType() {
+    return "geometry(point)";
+  }
+  mapFromDriverValue(value) {
+    return parseEWKB(value);
+  }
+  mapToDriverValue(value) {
+    return `point(${value[0]} ${value[1]})`;
+  }
+}
+
+class PgGeometryObjectBuilder extends PgColumnBuilder {
+  static [entityKind] = "PgGeometryObjectBuilder";
+  constructor(name) {
+    super(name, "json", "PgGeometryObject");
+  }
+  build(table) {
+    return new PgGeometryObject(table, this.config);
+  }
+}
+
+class PgGeometryObject extends PgColumn {
+  static [entityKind] = "PgGeometryObject";
+  getSQLType() {
+    return "geometry(point)";
+  }
+  mapFromDriverValue(value) {
+    const parsed = parseEWKB(value);
+    return { x: parsed[0], y: parsed[1] };
+  }
+  mapToDriverValue(value) {
+    return `point(${value.x} ${value.y})`;
+  }
+}
+function geometry(a, b) {
+  const { name, config } = getColumnNameAndConfig(a, b);
+  if (!config?.mode || config.mode === "tuple") {
+    return new PgGeometryBuilder(name);
+  }
+  return new PgGeometryObjectBuilder(name);
+}
+
+// node_modules/drizzle-orm/pg-core/columns/real.js
+class PgRealBuilder extends PgColumnBuilder {
+  static [entityKind] = "PgRealBuilder";
+  constructor(name, length) {
+    super(name, "number", "PgReal");
+    this.config.length = length;
+  }
+  build(table) {
+    return new PgReal(table, this.config);
+  }
+}
+
+class PgReal extends PgColumn {
+  static [entityKind] = "PgReal";
+  constructor(table, config) {
+    super(table, config);
+  }
+  getSQLType() {
+    return "real";
+  }
+  mapFromDriverValue = (value) => {
+    if (typeof value === "string") {
+      return Number.parseFloat(value);
+    }
+    return value;
+  };
+}
+function real(name) {
+  return new PgRealBuilder(name ?? "");
+}
+
+// node_modules/drizzle-orm/pg-core/columns/serial.js
+class PgSerialBuilder extends PgColumnBuilder {
+  static [entityKind] = "PgSerialBuilder";
+  constructor(name) {
+    super(name, "number", "PgSerial");
+    this.config.hasDefault = true;
+    this.config.notNull = true;
+  }
+  build(table) {
+    return new PgSerial(table, this.config);
+  }
+}
+
+class PgSerial extends PgColumn {
+  static [entityKind] = "PgSerial";
+  getSQLType() {
+    return "serial";
+  }
+}
+function serial(name) {
+  return new PgSerialBuilder(name ?? "");
+}
+
+// node_modules/drizzle-orm/pg-core/columns/smallint.js
+class PgSmallIntBuilder extends PgIntColumnBaseBuilder {
+  static [entityKind] = "PgSmallIntBuilder";
+  constructor(name) {
+    super(name, "number", "PgSmallInt");
+  }
+  build(table) {
+    return new PgSmallInt(table, this.config);
+  }
+}
+
+class PgSmallInt extends PgColumn {
+  static [entityKind] = "PgSmallInt";
+  getSQLType() {
+    return "smallint";
+  }
+  mapFromDriverValue = (value) => {
+    if (typeof value === "string") {
+      return Number(value);
+    }
+    return value;
+  };
+}
+function smallint(name) {
+  return new PgSmallIntBuilder(name ?? "");
+}
+
+// node_modules/drizzle-orm/pg-core/columns/smallserial.js
+class PgSmallSerialBuilder extends PgColumnBuilder {
+  static [entityKind] = "PgSmallSerialBuilder";
+  constructor(name) {
+    super(name, "number", "PgSmallSerial");
+    this.config.hasDefault = true;
+    this.config.notNull = true;
+  }
+  build(table) {
+    return new PgSmallSerial(table, this.config);
+  }
+}
+
+class PgSmallSerial extends PgColumn {
+  static [entityKind] = "PgSmallSerial";
+  getSQLType() {
+    return "smallserial";
+  }
+}
+function smallserial(name) {
+  return new PgSmallSerialBuilder(name ?? "");
+}
+
+// node_modules/drizzle-orm/pg-core/columns/text.js
+class PgTextBuilder extends PgColumnBuilder {
+  static [entityKind] = "PgTextBuilder";
+  constructor(name, config) {
+    super(name, "string", "PgText");
+    this.config.enumValues = config.enum;
+  }
+  build(table) {
+    return new PgText(table, this.config);
+  }
+}
+
+class PgText extends PgColumn {
+  static [entityKind] = "PgText";
+  enumValues = this.config.enumValues;
+  getSQLType() {
+    return "text";
+  }
+}
+function text(a, b = {}) {
+  const { name, config } = getColumnNameAndConfig(a, b);
+  return new PgTextBuilder(name, config);
+}
+
+// node_modules/drizzle-orm/pg-core/columns/time.js
+class PgTimeBuilder extends PgDateColumnBaseBuilder {
+  constructor(name, withTimezone, precision) {
+    super(name, "string", "PgTime");
+    this.withTimezone = withTimezone;
+    this.precision = precision;
+    this.config.withTimezone = withTimezone;
+    this.config.precision = precision;
+  }
+  static [entityKind] = "PgTimeBuilder";
+  build(table) {
+    return new PgTime(table, this.config);
+  }
+}
+
+class PgTime extends PgColumn {
+  static [entityKind] = "PgTime";
+  withTimezone;
+  precision;
+  constructor(table, config) {
+    super(table, config);
+    this.withTimezone = config.withTimezone;
+    this.precision = config.precision;
+  }
+  getSQLType() {
+    const precision = this.precision === undefined ? "" : `(${this.precision})`;
+    return `time${precision}${this.withTimezone ? " with time zone" : ""}`;
+  }
+}
+function time(a, b = {}) {
+  const { name, config } = getColumnNameAndConfig(a, b);
+  return new PgTimeBuilder(name, config.withTimezone ?? false, config.precision);
+}
 
+// node_modules/drizzle-orm/pg-core/columns/timestamp.js
+class PgTimestampBuilder extends PgDateColumnBaseBuilder {
+  static [entityKind] = "PgTimestampBuilder";
+  constructor(name, withTimezone, precision) {
+    super(name, "date", "PgTimestamp");
+    this.config.withTimezone = withTimezone;
+    this.config.precision = precision;
+  }
+  build(table) {
+    return new PgTimestamp(table, this.config);
+  }
+}
+
+class PgTimestamp extends PgColumn {
+  static [entityKind] = "PgTimestamp";
+  withTimezone;
+  precision;
+  constructor(table, config) {
+    super(table, config);
+    this.withTimezone = config.withTimezone;
+    this.precision = config.precision;
+  }
+  getSQLType() {
+    const precision = this.precision === undefined ? "" : ` (${this.precision})`;
+    return `timestamp${precision}${this.withTimezone ? " with time zone" : ""}`;
+  }
+  mapFromDriverValue = (value) => {
+    return new Date(this.withTimezone ? value : value + "+0000");
+  };
+  mapToDriverValue = (value) => {
+    return value.toISOString();
+  };
+}
+
+class PgTimestampStringBuilder extends PgDateColumnBaseBuilder {
+  static [entityKind] = "PgTimestampStringBuilder";
+  constructor(name, withTimezone, precision) {
+    super(name, "string", "PgTimestampString");
+    this.config.withTimezone = withTimezone;
+    this.config.precision = precision;
+  }
+  build(table) {
+    return new PgTimestampString(table, this.config);
+  }
+}
+
+class PgTimestampString extends PgColumn {
+  static [entityKind] = "PgTimestampString";
+  withTimezone;
+  precision;
+  constructor(table, config) {
+    super(table, config);
+    this.withTimezone = config.withTimezone;
+    this.precision = config.precision;
+  }
+  getSQLType() {
+    const precision = this.precision === undefined ? "" : `(${this.precision})`;
+    return `timestamp${precision}${this.withTimezone ? " with time zone" : ""}`;
+  }
+}
+function timestamp(a, b = {}) {
+  const { name, config } = getColumnNameAndConfig(a, b);
+  if (config?.mode === "string") {
+    return new PgTimestampStringBuilder(name, config.withTimezone ?? false, config.precision);
+  }
+  return new PgTimestampBuilder(name, config?.withTimezone ?? false, config?.precision);
+}
+
+// node_modules/drizzle-orm/pg-core/columns/uuid.js
+class PgUUIDBuilder extends PgColumnBuilder {
+  static [entityKind] = "PgUUIDBuilder";
+  constructor(name) {
+    super(name, "string", "PgUUID");
+  }
+  defaultRandom() {
+    return this.default(sql`gen_random_uuid()`);
+  }
+  build(table) {
+    return new PgUUID(table, this.config);
+  }
+}
+
+class PgUUID extends PgColumn {
+  static [entityKind] = "PgUUID";
+  getSQLType() {
+    return "uuid";
+  }
+}
+function uuid(name) {
+  return new PgUUIDBuilder(name ?? "");
+}
+
+// node_modules/drizzle-orm/pg-core/columns/varchar.js
+class PgVarcharBuilder extends PgColumnBuilder {
+  static [entityKind] = "PgVarcharBuilder";
+  constructor(name, config) {
+    super(name, "string", "PgVarchar");
+    this.config.length = config.length;
+    this.config.enumValues = config.enum;
+  }
+  build(table) {
+    return new PgVarchar(table, this.config);
+  }
+}
+
+class PgVarchar extends PgColumn {
+  static [entityKind] = "PgVarchar";
+  length = this.config.length;
+  enumValues = this.config.enumValues;
+  getSQLType() {
+    return this.length === undefined ? `varchar` : `varchar(${this.length})`;
+  }
+}
+function varchar(a, b = {}) {
+  const { name, config } = getColumnNameAndConfig(a, b);
+  return new PgVarcharBuilder(name, config);
+}
+
+// node_modules/drizzle-orm/pg-core/columns/vector_extension/bit.js
+class PgBinaryVectorBuilder extends PgColumnBuilder {
+  static [entityKind] = "PgBinaryVectorBuilder";
+  constructor(name, config) {
+    super(name, "string", "PgBinaryVector");
+    this.config.dimensions = config.dimensions;
+  }
+  build(table) {
+    return new PgBinaryVector(table, this.config);
+  }
+}
+
+class PgBinaryVector extends PgColumn {
+  static [entityKind] = "PgBinaryVector";
+  dimensions = this.config.dimensions;
+  getSQLType() {
+    return `bit(${this.dimensions})`;
+  }
+}
+function bit(a, b) {
+  const { name, config } = getColumnNameAndConfig(a, b);
+  return new PgBinaryVectorBuilder(name, config);
+}
+
+// node_modules/drizzle-orm/pg-core/columns/vector_extension/halfvec.js
+class PgHalfVectorBuilder extends PgColumnBuilder {
+  static [entityKind] = "PgHalfVectorBuilder";
+  constructor(name, config) {
+    super(name, "array", "PgHalfVector");
+    this.config.dimensions = config.dimensions;
+  }
+  build(table) {
+    return new PgHalfVector(table, this.config);
+  }
+}
+
+class PgHalfVector extends PgColumn {
+  static [entityKind] = "PgHalfVector";
+  dimensions = this.config.dimensions;
+  getSQLType() {
+    return `halfvec(${this.dimensions})`;
+  }
+  mapToDriverValue(value) {
+    return JSON.stringify(value);
+  }
+  mapFromDriverValue(value) {
+    return value.slice(1, -1).split(",").map((v) => Number.parseFloat(v));
+  }
+}
+function halfvec(a, b) {
+  const { name, config } = getColumnNameAndConfig(a, b);
+  return new PgHalfVectorBuilder(name, config);
+}
+
+// node_modules/drizzle-orm/pg-core/columns/vector_extension/sparsevec.js
+class PgSparseVectorBuilder extends PgColumnBuilder {
+  static [entityKind] = "PgSparseVectorBuilder";
+  constructor(name, config) {
+    super(name, "string", "PgSparseVector");
+    this.config.dimensions = config.dimensions;
+  }
+  build(table) {
+    return new PgSparseVector(table, this.config);
+  }
+}
+
+class PgSparseVector extends PgColumn {
+  static [entityKind] = "PgSparseVector";
+  dimensions = this.config.dimensions;
+  getSQLType() {
+    return `sparsevec(${this.dimensions})`;
+  }
+}
+function sparsevec(a, b) {
+  const { name, config } = getColumnNameAndConfig(a, b);
+  return new PgSparseVectorBuilder(name, config);
+}
+
+// node_modules/drizzle-orm/pg-core/columns/vector_extension/vector.js
+class PgVectorBuilder extends PgColumnBuilder {
+  static [entityKind] = "PgVectorBuilder";
+  constructor(name, config) {
+    super(name, "array", "PgVector");
+    this.config.dimensions = config.dimensions;
+  }
+  build(table) {
+    return new PgVector(table, this.config);
+  }
+}
+
+class PgVector extends PgColumn {
+  static [entityKind] = "PgVector";
+  dimensions = this.config.dimensions;
+  getSQLType() {
+    return `vector(${this.dimensions})`;
+  }
+  mapToDriverValue(value) {
+    return JSON.stringify(value);
+  }
+  mapFromDriverValue(value) {
+    return value.slice(1, -1).split(",").map((v) => Number.parseFloat(v));
+  }
+}
+function vector(a, b) {
+  const { name, config } = getColumnNameAndConfig(a, b);
+  return new PgVectorBuilder(name, config);
+}
+
+// node_modules/drizzle-orm/pg-core/columns/all.js
+function getPgColumnBuilders() {
+  return {
+    bigint: bigint2,
+    bigserial,
+    boolean: boolean2,
+    char,
+    cidr,
+    customType,
+    date: date2,
+    doublePrecision,
+    inet,
+    integer,
+    interval,
+    json,
+    jsonb,
+    line,
+    macaddr,
+    macaddr8,
+    numeric,
+    point,
+    geometry,
+    real,
+    serial,
+    smallint,
+    smallserial,
+    text,
+    time,
+    timestamp,
+    uuid,
+    varchar,
+    bit,
+    halfvec,
+    sparsevec,
+    vector
+  };
+}
+
+// node_modules/drizzle-orm/pg-core/table.js
+var InlineForeignKeys = Symbol.for("drizzle:PgInlineForeignKeys");
+var EnableRLS = Symbol.for("drizzle:EnableRLS");
+
+class PgTable extends Table {
+  static [entityKind] = "PgTable";
+  static Symbol = Object.assign({}, Table.Symbol, {
+    InlineForeignKeys,
+    EnableRLS
+  });
+  [InlineForeignKeys] = [];
+  [EnableRLS] = false;
+  [Table.Symbol.ExtraConfigBuilder] = undefined;
+  [Table.Symbol.ExtraConfigColumns] = {};
+}
+function pgTableWithSchema(name, columns, extraConfig, schema, baseName = name) {
+  const rawTable = new PgTable(name, schema, baseName);
+  const parsedColumns = typeof columns === "function" ? columns(getPgColumnBuilders()) : columns;
+  const builtColumns = Object.fromEntries(Object.entries(parsedColumns).map(([name2, colBuilderBase]) => {
+    const colBuilder = colBuilderBase;
+    colBuilder.setName(name2);
+    const column = colBuilder.build(rawTable);
+    rawTable[InlineForeignKeys].push(...colBuilder.buildForeignKeys(column, rawTable));
+    return [name2, column];
+  }));
+  const builtColumnsForExtraConfig = Object.fromEntries(Object.entries(parsedColumns).map(([name2, colBuilderBase]) => {
+    const colBuilder = colBuilderBase;
+    colBuilder.setName(name2);
+    const column = colBuilder.buildExtraConfigColumn(rawTable);
+    return [name2, column];
+  }));
+  const table = Object.assign(rawTable, builtColumns);
+  table[Table.Symbol.Columns] = builtColumns;
+  table[Table.Symbol.ExtraConfigColumns] = builtColumnsForExtraConfig;
+  if (extraConfig) {
+    table[PgTable.Symbol.ExtraConfigBuilder] = extraConfig;
+  }
+  return Object.assign(table, {
+    enableRLS: () => {
+      table[PgTable.Symbol.EnableRLS] = true;
+      return table;
+    }
+  });
+}
+var pgTable = (name, columns, extraConfig) => {
+  return pgTableWithSchema(name, columns, extraConfig, undefined);
+};
+
+// node_modules/drizzle-orm/sql/expressions/conditions.js
+function bindIfParam(value, column) {
+  if (isDriverValueEncoder(column) && !isSQLWrapper(value) && !is(value, Param) && !is(value, Placeholder) && !is(value, Column) && !is(value, Table) && !is(value, View)) {
+    return new Param(value, column);
+  }
+  return value;
+}
+var eq = (left, right) => {
+  return sql`${left} = ${bindIfParam(right, left)}`;
+};
+var ne = (left, right) => {
+  return sql`${left} <> ${bindIfParam(right, left)}`;
+};
+function and(...unfilteredConditions) {
+  const conditions = unfilteredConditions.filter((c) => c !== undefined);
+  if (conditions.length === 0) {
+    return;
+  }
+  if (conditions.length === 1) {
+    return new SQL(conditions);
+  }
+  return new SQL([
+    new StringChunk("("),
+    sql.join(conditions, new StringChunk(" and ")),
+    new StringChunk(")")
+  ]);
+}
+function or(...unfilteredConditions) {
+  const conditions = unfilteredConditions.filter((c) => c !== undefined);
+  if (conditions.length === 0) {
+    return;
+  }
+  if (conditions.length === 1) {
+    return new SQL(conditions);
+  }
+  return new SQL([
+    new StringChunk("("),
+    sql.join(conditions, new StringChunk(" or ")),
+    new StringChunk(")")
+  ]);
+}
+
+// node_modules/drizzle-orm/sql/expressions/select.js
+function desc(column) {
+  return sql`${column} desc`;
+}
+
+// node_modules/drizzle-orm/sql/functions/aggregate.js
+function count(expression) {
+  return sql`count(${expression || sql.raw("*")})`.mapWith(Number);
+}
+
+// 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
+  });
+}
+// 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
+  });
+}
+// node_modules/drizzle-orm/pg-core/indexes.js
+class IndexBuilderOn {
+  constructor(unique, name) {
+    this.unique = unique;
+    this.name = name;
+  }
+  static [entityKind] = "PgIndexBuilderOn";
+  on(...columns) {
+    return new IndexBuilder(columns.map((it) => {
+      if (is(it, SQL)) {
+        return it;
+      }
+      it = it;
+      const clonedIndexedColumn = new IndexedColumn(it.name, !!it.keyAsName, it.columnType, it.indexConfig);
+      it.indexConfig = JSON.parse(JSON.stringify(it.defaultConfig));
+      return clonedIndexedColumn;
+    }), this.unique, false, this.name);
+  }
+  onOnly(...columns) {
+    return new IndexBuilder(columns.map((it) => {
+      if (is(it, SQL)) {
+        return it;
+      }
+      it = it;
+      const clonedIndexedColumn = new IndexedColumn(it.name, !!it.keyAsName, it.columnType, it.indexConfig);
+      it.indexConfig = it.defaultConfig;
+      return clonedIndexedColumn;
+    }), this.unique, true, this.name);
+  }
+  using(method, ...columns) {
+    return new IndexBuilder(columns.map((it) => {
+      if (is(it, SQL)) {
+        return it;
+      }
+      it = it;
+      const clonedIndexedColumn = new IndexedColumn(it.name, !!it.keyAsName, it.columnType, it.indexConfig);
+      it.indexConfig = JSON.parse(JSON.stringify(it.defaultConfig));
+      return clonedIndexedColumn;
+    }), this.unique, true, this.name, method);
+  }
+}
+
+class IndexBuilder {
+  static [entityKind] = "PgIndexBuilder";
+  config;
+  constructor(columns, unique, only, name, method = "btree") {
+    this.config = {
+      name,
+      columns,
+      unique,
+      only,
+      method
+    };
+  }
+  concurrently() {
+    this.config.concurrently = true;
+    return this;
+  }
+  with(obj) {
+    this.config.with = obj;
+    return this;
+  }
+  where(condition) {
+    this.config.where = condition;
+    return this;
+  }
+  build(table) {
+    return new Index(this.config, table);
+  }
+}
+
+class Index {
+  static [entityKind] = "PgIndex";
+  config;
+  constructor(config, table) {
+    this.config = { ...config, table };
+  }
+}
+function index(name) {
+  return new IndexBuilderOn(false, name);
+}
+function uniqueIndex(name) {
+  return new IndexBuilderOn(true, name);
+}
+
+// src/database/schemas/drizzle.ts
+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)
+]);
 // src/server.ts
 var SERVER_LOG_CONTEXT3 = "server";
 var logger203 = createLogger("MCPServer", SERVER_LOG_CONTEXT3);
+function mergeTriggerCallbacks(fromDatabase, explicit) {
+  if (!fromDatabase && !explicit) {
+    return;
+  }
+  return {
+    create: explicit?.create ?? fromDatabase.create,
+    get: explicit?.get ?? fromDatabase.get,
+    list: explicit?.list ?? fromDatabase.list,
+    update: explicit?.update ?? fromDatabase.update,
+    delete: explicit?.delete ?? fromDatabase.delete,
+    onComplete: explicit?.onComplete ?? fromDatabase?.onComplete,
+    getCallbackUrl: explicit?.getCallbackUrl ?? fromDatabase?.getCallbackUrl
+  };
+}
+function mergeDatabaseConfig(config) {
+  if (!config.database) {
+    return config;
+  }
+  const databaseCallbacks = config.database();
+  return {
+    ...config,
+    getProviderToken: config.getProviderToken ?? databaseCallbacks.getProviderToken,
+    setProviderToken: config.setProviderToken ?? databaseCallbacks.setProviderToken,
+    removeProviderToken: config.removeProviderToken ?? databaseCallbacks.removeProviderToken,
+    triggers: mergeTriggerCallbacks(databaseCallbacks.triggers, config.triggers)
+  };
+}
 async function refreshTokenIfNeeded(provider, tokenData, providers, config, context) {
   const credentials = providers[provider];
   if (!credentials || !config.serverUrl) {
@@ -21360,7 +24846,8 @@ function getDefaultRedirectUri() {
   }
   return "http://localhost:3000/api/integrate/oauth/callback";
 }
-function createMCPServer(config) {
+function createMCPServer(inputConfig) {
+  const config = mergeDatabaseConfig(inputConfig);
   setLogLevel(config.debug ? "debug" : "error", SERVER_LOG_CONTEXT3);
   if (typeof window !== "undefined") {
     throw new Error("createMCPServer() should only be called on the server-side. " + "Use createMCPClient() for client-side code.");
@@ -22313,7 +25800,11 @@ export {
   toTanStackStartHandler,
   toSvelteKitHandler,
   toSolidStartHandler,
+  toSdkTrigger,
+  toSdkSchedule,
   toNextJsHandler,
+  toDbTriggerUpdates,
+  toDbSchedule,
   tldrawIntegration,
   tinkIntegration,
   tiktokIntegration,
@@ -22340,6 +25831,7 @@ export {
   sharepointIntegration,
   sentryIntegration,
   sendWebResponse,
+  selectProviderTokenRow,
   salesforceIntegration,
   sageIntegration,
   ringIntegration,
@@ -22349,6 +25841,9 @@ export {
   rampIntegration,
   railwayIntegration,
   quickbooksIntegration,
+  providerTokenRecordToData,
+  prismaAdapterCallbacks,
+  prismaAdapter,
   powerpointIntegration,
   postmanIntegration,
   posthogIntegration,
@@ -22361,6 +25856,7 @@ export {
   philipsHueIntegration,
   phantomIntegration,
   paypalIntegration,
+  parseScopes,
   paperIntegration,
   pandadocIntegration,
   outlookIntegration,
@@ -22370,9 +25866,16 @@ export {
   onedriveIntegration,
   oktaIntegration,
   notionIntegration,
+  normalizeProviderTokenType,
+  normalizeAccountIdentifier,
+  normalizeAccountIdHint,
+  normalizeAccountEmailHint,
+  normalizeAccountEmail,
   netlifyIntegration,
   netatmoIntegration,
   neonIntegration,
+  mongodbAdapterCallbacks,
+  mongodbAdapter,
   moneybirdIntegration,
   mondayIntegration,
   miroIntegration,
@@ -22394,10 +25897,15 @@ export {
   klaviyoIntegration,
   kickIntegration,
   jiraIntegration,
+  isLikelyUsableToken,
   intercomIntegration,
+  integrateTrigger,
+  integrateProviderToken,
   instagramIntegration,
   hubspotIntegration,
   homeConnectIntegration,
+  hasUsableAccessToken,
+  hasMeaningfulExpiresAt,
   handleOpenAIResponse,
   handleAnthropicMessage,
   gtasksIntegration,
@@ -22434,6 +25942,7 @@ export {
   freshserviceIntegration,
   freeagentIntegration,
   foursquareIntegration,
+  flattenedTriggerToCreateInput,
   fitbitIntegration,
   firebaseIntegration,
   figmaIntegration,
@@ -22451,9 +25960,12 @@ export {
   ebayIntegration,
   dropboxSignIntegration,
   dropboxIntegration,
+  drizzleAdapterCallbacks,
+  drizzleAdapter,
   docusignIntegration,
   discordIntegration,
   dhlIntegration,
+  defaultResolveAccountIdentity,
   deezerIntegration,
   datadogIntegration,
   databricksIntegration,
@@ -22463,6 +25975,8 @@ export {
   createSimpleIntegration,
   createNextOAuthHandler,
   createMCPServer,
+  createDatabaseAdapterFactory,
+  createDatabaseAdapterCallbacks,
   convexIntegration,
   contentfulIntegration,
   confluenceIntegration,