@vercel/connect 0.0.5-alpha.1 → 0.1.1

package/dist/token.js

@@ -1,20 +1,34 @@
-import { getVercelOidcToken } from "@vercel/oidc";
-export class NoValidTokenError extends Error {
-    constructor(message) {
+import { getVercelOidcToken } from '@vercel/oidc';
+export class ConnectError extends Error {
+    code;
+    status;
+    statusText;
+    vendor;
+    constructor(message, options = {}) {
         super(message);
-        this.name = "NoValidTokenError";
+        this.name = 'ConnectError';
+        this.code = options.code;
+        this.status = options.status;
+        this.statusText = options.statusText;
+        this.vendor = options.vendor;
     }
 }
-export class UserAuthorizationRequiredError extends Error {
-    constructor(message) {
-        super(message);
-        this.name = "UserAuthorizationRequiredError";
+export class NoValidTokenError extends ConnectError {
+    constructor(message, options) {
+        super(message, options);
+        this.name = 'NoValidTokenError';
     }
 }
-export class ConnectorInstallationRequiredError extends Error {
-    constructor(message) {
-        super(message);
-        this.name = "ConnectorInstallationRequiredError";
+export class UserAuthorizationRequiredError extends ConnectError {
+    constructor(message, options) {
+        super(message, options);
+        this.name = 'UserAuthorizationRequiredError';
+    }
+}
+export class ConnectorInstallationRequiredError extends ConnectError {
+    constructor(message, options) {
+        super(message, options);
+        this.name = 'ConnectorInstallationRequiredError';
     }
 }
 export async function getToken(connector, params, options) {
@@ -36,46 +50,16 @@ export async function getTokenResponse(connector, params, options) {
     const vercelToken = options?.vercelToken ?? (await getVercelOidcToken());
     const endpoint = `https://api.vercel.com/v1/connect/token/${encodeURIComponent(connector)}`;
     const response = await fetch(endpoint, {
-        method: "POST",
+        method: 'POST',
         headers: {
-            Accept: "application/json",
-            "Content-Type": "application/json",
+            Accept: 'application/json',
+            'Content-Type': 'application/json',
             Authorization: `Bearer ${vercelToken}`,
         },
         body: JSON.stringify(params),
     });
     if (!response.ok) {
-        let errorText;
-        let errorObject;
-        try {
-            errorText = await response.text();
-            const errorJson = JSON.parse(errorText);
-            if (typeof errorJson === "object" && errorJson !== null) {
-                errorObject = errorJson;
-            }
-        }
-        catch { }
-        const code = errorObject?.error?.code;
-        const message = errorObject?.error?.message;
-        if (code === "no_token") {
-            throw new NoValidTokenError(message || errorText || "No valid token available");
-        }
-        if (code === "user_authorization_required") {
-            throw new UserAuthorizationRequiredError(message || errorText || "User authorization is required");
-        }
-        if (code === "client_installation_required" ||
-            code === "connector_installation_required") {
-            throw new ConnectorInstallationRequiredError(message || errorText || "Connector installation is required");
-        }
-        throw new Error([
-            "Failed to get token:",
-            `${response.status}`,
-            response.statusText,
-            code ? ` - ${code}` : "",
-            errorText ? ` - ${errorText}` : "",
-        ]
-            .filter(Boolean)
-            .join(" "));
+        throw await createConnectErrorFromResponse(response, 'Failed to get token');
     }
     const data = await response.json();
     if (cache.size >= MAX_CACHE_SIZE) {
@@ -100,3 +84,89 @@ function evictLru() {
         cache.delete(oldestKey);
     }
 }
+export async function createConnectErrorFromResponse(response, fallbackMessage) {
+    const parsedError = await readConnectErrorResponse(response);
+    return createConnectError(response, parsedError, fallbackMessage);
+}
+function createConnectError(response, parsedError, fallbackMessage) {
+    const { code, message, bodyText } = parsedError;
+    const errorOptions = connectErrorOptions(response, parsedError);
+    if (code === 'no_token') {
+        return new NoValidTokenError(message || bodyText || 'No valid token available', errorOptions);
+    }
+    if (code === 'user_authorization_required') {
+        return new UserAuthorizationRequiredError(message || bodyText || 'User authorization is required', errorOptions);
+    }
+    if (code === 'client_installation_required' ||
+        code === 'connector_installation_required') {
+        return new ConnectorInstallationRequiredError(message || bodyText || 'Connector installation is required', errorOptions);
+    }
+    return new ConnectError(buildConnectResponseErrorMessage(response, parsedError, fallbackMessage), errorOptions);
+}
+async function readConnectErrorResponse(response) {
+    let bodyText;
+    try {
+        bodyText = await response.text();
+    }
+    catch { }
+    if (!bodyText) {
+        return {};
+    }
+    try {
+        const body = JSON.parse(bodyText);
+        if (!isRecord(body)) {
+            return { bodyText };
+        }
+        const error = isRecord(body.error)
+            ? body.error
+            : isRecord(body.err)
+                ? body.err
+                : undefined;
+        if (!error) {
+            return { bodyText, vendor: vendorPayload(body) };
+        }
+        return {
+            bodyText,
+            code: typeof error.code === 'string' ? error.code : undefined,
+            message: typeof error.message === 'string' ? error.message : undefined,
+            vendor: vendorPayload(error) ?? vendorPayload(body),
+        };
+    }
+    catch {
+        return { bodyText };
+    }
+}
+function connectErrorOptions(response, parsedError) {
+    return {
+        code: parsedError.code,
+        status: response.status,
+        statusText: response.statusText,
+        vendor: parsedError.vendor,
+    };
+}
+function buildConnectResponseErrorMessage(response, parsedError, fallbackMessage) {
+    if (parsedError.message) {
+        return parsedError.message;
+    }
+    return [
+        `${fallbackMessage}:`,
+        `${response.status}`,
+        response.statusText,
+        parsedError.code ? ` - ${parsedError.code}` : '',
+        parsedError.bodyText ? ` - ${parsedError.bodyText}` : '',
+    ]
+        .filter(Boolean)
+        .join(' ');
+}
+function vendorPayload(error) {
+    if (isRecord(error.vendor)) {
+        return error.vendor;
+    }
+    if (isRecord(error.meta) && isRecord(error.meta.vendor)) {
+        return error.meta.vendor;
+    }
+    return undefined;
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}

package/package.json

@@ -1,8 +1,13 @@
 {
   "name": "@vercel/connect",
-  "version": "0.0.5-alpha.1",
+  "version": "0.1.1",
   "license": "Apache-2.0",
   "type": "module",
+  "repository": {
+    "directory": "packages/connect",
+    "type": "git",
+    "url": "git+https://github.com/vercel/vercel.git"
+  },
   "exports": {
     ".": {
       "types": "./dist/index.d.ts",
@@ -25,7 +30,7 @@
     "dist"
   ],
   "dependencies": {
-    "@vercel/oidc": "*"
+    "@vercel/oidc": "3.5.0"
   },
   "peerDependencies": {
     "@auth/core": ">=0.37.0",
@@ -46,7 +51,7 @@
   "devDependencies": {
     "@auth/core": "0.37.4",
     "better-auth": "1.5.5",
-    "experimental-ash": "0.3.0-alpha.29",
+    "experimental-ash": "0.31.0",
     "typescript": "^5"
   },
   "private": false,