Skip to content

Never stop coding. Free MIT AI gateway: one endpoint, 375 providers (150+ free), 1,400+ models Kimi, Claude, GPT, Gemini, GLM, DeepSeek, MiniMax. Works with Claude Code, Codex, Cursor, OpenCode, Cline & Copilot. Quota-aware auto-fallback, RTK+Caveman compression saves 15-95% tokens, MCP/A2A, Desktop/PWA. Built by 900+ contributors

9.6 KB
Raw Blame
/**
 * Lazy-decrypting ProviderConnectionView.
 *
 * Wraps a raw (ciphertext) DB row in a JS Proxy that decrypts credential
 * fields (apiKey, accessToken, refreshToken) only on first access.
 * Non-credential reads hit the already-coerced view directly at zero cost.
 *
 * Extracted from sse/services/auth.ts for reuse across dashboard,
 * admin, and catalog callers during Phase 2/3 of the lazy-decrypt rollout.
 */

import { decryptQuiet } from "../encryption";
import { mapProviderSpecificDataSecrets } from "./providerSpecificDataSecrets";
import type { ConnectionRateLimitOverrides } from "./columns";

type JsonRecord = Record<string, unknown>;

function asRecord(value: unknown): JsonRecord {
  return value && typeof value === "object" && !Array.isArray(value) ? (value as JsonRecord) : {};
}

function toStringOrNull(value: unknown): string | null {
  return typeof value === "string" && value.trim().length > 0 ? value : null;
}

function toNumber(value: unknown, fallback = 0): number {
  if (typeof value === "number" && Number.isFinite(value)) return value;
  if (typeof value === "string" && value.trim().length > 0) {
    const parsed = Number(value);
    return Number.isFinite(parsed) ? parsed : fallback;
  }
  return fallback;
}

function toNullableNumber(value: unknown): number | null {
  if (value === null || value === undefined) return null;
  const parsed = toNumber(value, Number.NaN);
  return Number.isFinite(parsed) ? parsed : null;
}

export interface ProviderConnectionView {
  id: string;
  provider: string;
  authType: string | null;
  email: string | null;
  isActive: boolean;
  rateLimitedUntil: string | null;
  testStatus: string | null;
  apiKey: string | null;
  accessToken: string | null;
  refreshToken: string | null;
  tokenExpiresAt: string | null;
  expiresAt: string | null;
  projectId: string | null;
  defaultModel: string | null;
  providerSpecificData: JsonRecord;
  lastUsedAt: string | null;
  syncedModelsAt: string | null;
  consecutiveUseCount: number;
  priority: number;
  lastError: string | null;
  lastErrorType: string | null;
  lastErrorSource: string | null;
  errorCode: string | number | null;
  backoffLevel: number;
  maxConcurrent: number | null;
  rateLimitMaxConcurrent: number | null;
  quotaWindowThresholds: Record<string, number> | null;
  /**
   * Per-connection rate limit overrides as parsed from the JSON column.
   * Carries the optional nested `modelConcurrency` map; the chat core
   * normalizes that map (fail-open) onto credentials at selection time.
   */
  rateLimitOverrides: ConnectionRateLimitOverrides | null;
}

/**
 * Converts a raw DB row into a fully resolved ProviderConnectionView.
 * Credential fields have already been decrypted by the DB layer.
 */
export function toProviderConnection(value: unknown): ProviderConnectionView {
  const row = asRecord(value);
  const rateLimitMaxConcurrent = toNullableNumber(asRecord(row.rateLimitOverrides).maxConcurrent);
  const rawThresholds = row.quotaWindowThresholds;
  const quotaWindowThresholds: Record<string, number> | null =
    rawThresholds && typeof rawThresholds === "object" && !Array.isArray(rawThresholds)
      ? (rawThresholds as Record<string, number>)
      : null;
  const rawOverrides = row.rateLimitOverrides;
  const rateLimitOverrides: ConnectionRateLimitOverrides | null =
    rawOverrides && typeof rawOverrides === "object" && !Array.isArray(rawOverrides)
      ? (rawOverrides as ConnectionRateLimitOverrides)
      : null;
  return {
    id: toStringOrNull(row.id) || "",
    provider: toStringOrNull(row.provider) || "",
    authType: toStringOrNull(row.authType),
    email: toStringOrNull(row.email),
    isActive: row.isActive === true,
    rateLimitedUntil: toStringOrNull(row.rateLimitedUntil),
    testStatus: toStringOrNull(row.testStatus),
    apiKey: toStringOrNull(row.apiKey),
    accessToken: toStringOrNull(row.accessToken),
    refreshToken: toStringOrNull(row.refreshToken),
    tokenExpiresAt: toStringOrNull(row.tokenExpiresAt),
    expiresAt: toStringOrNull(row.expiresAt),
    projectId: toStringOrNull(row.projectId),
    defaultModel: toStringOrNull(row.defaultModel),
    providerSpecificData: asRecord(row.providerSpecificData),
    lastUsedAt: toStringOrNull(row.lastUsedAt),
    syncedModelsAt: toStringOrNull(row.syncedModelsAt),
    consecutiveUseCount: toNumber(row.consecutiveUseCount, 0),
    priority: toNumber(row.priority, 999),
    lastError: toStringOrNull(row.lastError),
    lastErrorType: toStringOrNull(row.lastErrorType),
    lastErrorSource: toStringOrNull(row.lastErrorSource),
    errorCode:
      typeof row.errorCode === "string" || typeof row.errorCode === "number" ? row.errorCode : null,
    backoffLevel: toNumber(row.backoffLevel, 0),
    maxConcurrent: toNullableNumber(row.maxConcurrent),
    rateLimitMaxConcurrent:
      rateLimitMaxConcurrent !== null && rateLimitMaxConcurrent > 0 ? rateLimitMaxConcurrent : null,
    quotaWindowThresholds,
    rateLimitOverrides,
  };
}

/**
 * Creates a lazy-decrypting ProviderConnectionView from a raw (ciphertext)
 * DB row. First calls toProviderConnection for full type coercion (isActive
 * boolean, providerSpecificData object, etc.), then proxies credential
 * fields (apiKey, accessToken, refreshToken) to decrypt-only-on-first-access.
 *
 * Non-credential reads hit the already-coerced view directly at zero cost.
 */
export function createLazyConnectionView(row: Record<string, unknown>): ProviderConnectionView {
  const base = toProviderConnection(row);
  let decrypted: Record<string, null | string> | undefined;
  let providerData: Record<string, unknown> | undefined;

  const ensureDecrypted = () => {
    if (!decrypted) {
      const connectionId = base.id;
      const provider = base.provider;
      decrypted = {
        apiKey: toStringOrNull(
          decryptQuiet(base.apiKey, { connectionId, provider, field: "apiKey" })
        ),
        accessToken: toStringOrNull(
          decryptQuiet(base.accessToken, { connectionId, provider, field: "accessToken" })
        ),
        refreshToken: toStringOrNull(
          decryptQuiet(base.refreshToken, { connectionId, provider, field: "refreshToken" })
        ),
      };
    }
    return decrypted;
  };

  return new Proxy(base, {
    get: (_target, prop: string | symbol) => {
      if (prop === "apiKey" || prop === "accessToken" || prop === "refreshToken") {
        return ensureDecrypted()[prop];
      }
      if (prop === "providerSpecificData") {
        providerData ??= mapProviderSpecificDataSecrets(base.providerSpecificData, (value, field) =>
          decryptQuiet(value, { connectionId: base.id, provider: base.provider, field })
        ) as Record<string, unknown>;
        return providerData;
      }
      return Reflect.get(_target, prop);
    },
  });
}

const CREDENTIAL_FIELDS = new Set(["apiKey", "accessToken", "refreshToken", "idToken"]);

/**
 * Wraps a raw (ciphertext) DB row in a JS Proxy that decrypts credential
 * fields only on first access. Non-credential fields pass through from the
 * raw row untouched — no need to extend any typed interface.
 *
 * Returns Record<string, unknown> so it can replace getProviderConnections
 * without any caller changes. The typed createLazyConnectionView remains
 * available for new code that wants a structured view.
 */
export function createLazyRowProxy(row: Record<string, unknown>): Record<string, unknown> {
  let decrypted: Record<string, string | null | undefined> | undefined;
  let providerData: unknown;
  let providerDataLoaded = false;
  const readProviderData = () => {
    if (!providerDataLoaded) {
      providerDataLoaded = true;
      providerData = mapProviderSpecificDataSecrets(row.providerSpecificData, (value, field) =>
        decryptQuiet(value, {
          connectionId: typeof row.id === "string" ? row.id : "",
          provider: typeof row.provider === "string" ? row.provider : "unknown",
          field,
        })
      );
    }
    return providerData;
  };

  const ensureDecrypted = () => {
    if (!decrypted) {
      const connectionId = typeof row.id === "string" ? row.id : "";
      const provider = typeof row.provider === "string" ? row.provider : "unknown";
      decrypted = {
        apiKey: lazyDecrypt(row.apiKey, { connectionId, provider, field: "apiKey" }),
        accessToken: lazyDecrypt(row.accessToken, { connectionId, provider, field: "accessToken" }),
        refreshToken: lazyDecrypt(row.refreshToken, {
          connectionId,
          provider,
          field: "refreshToken",
        }),
        idToken: lazyDecrypt(row.idToken, { connectionId, provider, field: "idToken" }),
      };
    }
    return decrypted;
  };

  return new Proxy(row, {
    get(target, prop) {
      if (typeof prop === "string" && CREDENTIAL_FIELDS.has(prop)) {
        return ensureDecrypted()[prop];
      }
      if (prop === "providerSpecificData") return readProviderData();
      if (prop === "toJSON") {
        return () => {
          const result: Record<string, unknown> = {};
          for (const key of Object.keys(target)) {
            result[key] = CREDENTIAL_FIELDS.has(key)
              ? ensureDecrypted()[key]
              : key === "providerSpecificData"
                ? readProviderData()
                : target[key];
          }
          return result;
        };
      }
      return Reflect.get(target, prop);
    },
    ownKeys(target) {
      return Reflect.ownKeys(target);
    },
    getOwnPropertyDescriptor(target, prop) {
      return Reflect.getOwnPropertyDescriptor(target, prop);
    },
  });
}

function lazyDecrypt(
  value: unknown,
  meta: { connectionId: string; provider: string; field: string }
): string | null | undefined {
  if (typeof value !== "string") return undefined;
  return decryptQuiet(value, meta);
}