// Start OAuth for the current app user
const redirectUrl = await base44.connectors.connectAppUser("abc123def");
window.location.href = redirectUrl;

// Disconnect the app user's connection
await base44.connectors.disconnectAppUser("abc123def");

// Backend function only
export default async function (req) {
  const base44 = createClientFromRequest(req);

  const { accessToken, connectionConfig } = await base44.asServiceRole.connectors.getConnection("slack");

  const response = await fetch("https://slack.com/api/chat.postMessage", {
    method: "POST",
    headers: {
      "Authorization": `Bearer ${accessToken}`,
      "Content-Type": "application/json"
    },
    body: JSON.stringify({ channel: "#general", text: "Hello from Base44!" })
  });

  return Response.json(await response.json());
}

// Using connectionConfig (for services that need extra params, e.g. a subdomain)
const { accessToken, connectionConfig } = await base44.asServiceRole.connectors.getConnection("myservice");
const subdomain = connectionConfig?.subdomain;
const response = await fetch(`https://${subdomain}.example.com/api/v1/data`, {
  headers: { "Authorization": `Bearer ${accessToken}` }
});

// Google Calendar example
const { accessToken } = await base44.asServiceRole.connectors.getConnection("googlecalendar");

const events = await fetch(
  "https://www.googleapis.com/calendar/v3/calendars/primary/events?" +
  new URLSearchParams({ maxResults: "10", orderBy: "startTime", singleEvents: "true", timeMin: new Date().toISOString() }),
  { headers: { "Authorization": `Bearer ${accessToken}` } }
).then(r => r.json());

// Snowflake: retrieve the shared token and run a statement
const { accessToken, connectionConfig } = await base44.asServiceRole.connectors.getWorkspaceConnection("abc123def");

const response = await fetch(
  `https://${connectionConfig?.subdomain}.snowflakecomputing.com/api/v2/statements`,
  { headers: { Authorization: `Bearer ${accessToken}` } }
);

const { accessToken } = await base44.asServiceRole.connectors.getCurrentAppUserConnection("abc123def");

const response = await fetch("https://www.googleapis.com/calendar/v3/calendars/primary/events", {
  headers: { Authorization: `Bearer ${accessToken}` }
});

// Post to X
const res = await base44.asServiceRole.connectors.callApi("x", {
  method: "POST",
  path: "/2/tweets",
  body: { text: "Shipped!" },
});

if (!res.success) {
  console.error("X rejected the post", res.status, res.data);
}

// Search and check the cost
const res = await base44.asServiceRole.connectors.callApi("x", {
  path: "/2/tweets/search/recent",
  query: { query: "base44", max_results: 10 },
});

console.log(`${res.creditsCharged} credits`, res.data);

/**
 * The type of external integration/connector (for service role connectors).
 * Examples: 'googlecalendar', 'slack', 'github', 'notion', etc.
 */
type ConnectorIntegrationType = string;

/** Connection details returned by getConnection() / getWorkspaceConnection(). */
interface ConnectorConnectionResponse {
  /** The OAuth access token for the external service. */
  accessToken: string;
  /** Key-value configuration for the connection, or null if not needed. */
  connectionConfig: Record<string, string> | null;
}

/** Connection details returned by getCurrentAppUserConnection(). */
interface AppUserConnectorConnectionResponse {
  accessToken: string;
  connectionConfig: Record<string, string> | null;
}

/** How far a metered connector call progressed through the Base44 proxy. */
type ConnectorApiResponsePhase = "not_sent" | "responded" | "timed_out" | "sent_unconfirmed";

/** A request to forward to a metered connector's API. */
interface ConnectorApiRequest {
  method?: "GET" | "POST" | "PUT" | "PATCH" | "DELETE" | "HEAD";
  host?: string;
  /** Relative to the connector's API root, starting with '/'. Not an absolute URL. */
  path: string;
  query?: Record<string, string | number | boolean | Array<string | number>>;
  headers?: Record<string, string>;
  body?: unknown;
}

/** The upstream API's response, via the Base44 connector proxy. */
interface ConnectorApiResponse<T = unknown> {
  /** Whether the upstream API returned a 2xx status. */
  success: boolean;
  phase: ConnectorApiResponsePhase;
  status: number | null;
  /** Parsed response body, or null when the response is binary (see dataBase64). */
  data: T | null;
  /** Base64-encoded body for binary media types. Set instead of data. */
  dataBase64: string | null;
  contentType: string | null;
  /** Subset of upstream response headers the connector exposes, typically rate-limit counters. */
  headers: Record<string, string>;
  /** Credits charged to the workspace for this call. */
  creditsCharged: number;
}

/** Service role connectors module (app-scoped OAuth + metered calls). Backend only. */
interface ConnectorsModule {
  getConnection(integrationType: ConnectorIntegrationType): Promise<ConnectorConnectionResponse>;
  getWorkspaceConnection(connectorId: string): Promise<ConnectorConnectionResponse>;
  getCurrentAppUserConnection(connectorId: string): Promise<AppUserConnectorConnectionResponse>;
  callApi<T = unknown>(
    integrationType: ConnectorIntegrationType,
    request: ConnectorApiRequest
  ): Promise<ConnectorApiResponse<T>>;

  /** @deprecated Use getConnection() instead. */
  getAccessToken(integrationType: ConnectorIntegrationType): Promise<string>;
}

/** User-scoped connectors module for app user OAuth flows. Available via base44.connectors. */
interface UserConnectorsModule {
  /** Starts the OAuth flow for an app user connector; returns a redirect URL. */
  connectAppUser(connectorId: string): Promise<string>;
  /** Disconnects the current app user's connection for an app user connector. */
  disconnectAppUser(connectorId: string): Promise<void>;
}