antarctic 0.2.0

package/dist/providers/yahoo.js

@@ -0,0 +1,65 @@
+import { OAuth2Client } from "../client.js";
+import { decodeIdToken } from "../oidc.js";
+import { consumeOAuthState, fetchUserProfile, generateOAuthState, parseCallbackQuery, profileId, profileString, requireAuthConfig, resolveAuthConfig, resolveScopes, saveOAuthState } from "../auth.js";
+const authorizationEndpoint = "https://api.login.yahoo.com/oauth2/request_auth";
+const tokenEndpoint = "https://api.login.yahoo.com/oauth2/get_token";
+const userinfoEndpoint = "https://api.login.yahoo.com/openid/v1/userinfo";
+const envPrefix = "YAHOO";
+const defaultScopes = ["openid", "profile", "email"];
+export class Yahoo {
+    client;
+    auth = null;
+    constructor(clientIdOrOptions, clientSecret, redirectURI) {
+        if (typeof clientIdOrOptions === "object") {
+            this.auth = resolveAuthConfig(envPrefix, clientIdOrOptions, {
+                clientSecret: true,
+                redirectURI: true
+            });
+            this.client = new OAuth2Client(this.auth.clientId, this.auth.clientSecret, this.auth.redirectURI);
+        }
+        else {
+            this.client = new OAuth2Client(clientIdOrOptions, clientSecret ?? "", redirectURI ?? "");
+        }
+    }
+    createAuthorizationURL(state, scopes) {
+        const url = this.client.createAuthorizationURL(authorizationEndpoint, state, scopes);
+        return url;
+    }
+    async validateAuthorizationCode(code) {
+        const tokens = await this.client.validateAuthorizationCode(tokenEndpoint, code, null);
+        return tokens;
+    }
+    async refreshAccessToken(refreshToken) {
+        const tokens = await this.client.refreshAccessToken(tokenEndpoint, refreshToken, []);
+        return tokens;
+    }
+    async getAuthorizationURL(scopes) {
+        const auth = requireAuthConfig(this.auth);
+        const state = generateOAuthState();
+        const url = this.createAuthorizationURL(state, resolveScopes(scopes, auth, defaultScopes));
+        await saveOAuthState(auth.store, state, {});
+        return url;
+    }
+    async getUser(query) {
+        const auth = requireAuthConfig(this.auth);
+        const { code, state } = parseCallbackQuery(query);
+        await consumeOAuthState(auth.store, state);
+        const tokens = await this.validateAuthorizationCode(code);
+        let claims;
+        if ("id_token" in tokens.data) {
+            claims = decodeIdToken(tokens.idToken());
+        }
+        else {
+            claims = await fetchUserProfile(userinfoEndpoint, tokens.accessToken());
+        }
+        const givenName = profileString(claims.given_name);
+        const familyName = profileString(claims.family_name);
+        const fullName = [givenName, familyName].filter((part) => part !== null).join(" ");
+        return {
+            id: profileId(claims.sub),
+            name: profileString(claims.name) ?? (fullName !== "" ? fullName : null),
+            email: profileString(claims.email),
+            image: profileString(claims.picture)
+        };
+    }
+}

package/dist/providers/yandex.d.ts

@@ -0,0 +1,15 @@
+import type { OAuth2Tokens } from "../oauth2.js";
+import type { OAuthCallbackQuery, OAuthUser, ProviderOptions } from "../auth.js";
+export interface YandexOptions extends ProviderOptions {
+}
+export declare class Yandex {
+    private client;
+    private auth;
+    constructor(options: YandexOptions);
+    constructor(clientId: string, clientSecret: string, redirectURI: string);
+    createAuthorizationURL(state: string, scopes: string[]): URL;
+    validateAuthorizationCode(code: string): Promise<OAuth2Tokens>;
+    refreshAccessToken(refreshToken: string): Promise<OAuth2Tokens>;
+    getAuthorizationURL(scopes?: string[]): Promise<URL>;
+    getUser(query: OAuthCallbackQuery): Promise<OAuthUser>;
+}

package/dist/providers/yandex.js

@@ -0,0 +1,66 @@
+import { OAuth2Client } from "../client.js";
+import { consumeOAuthState, fetchUserProfile, generateOAuthState, parseCallbackQuery, profileId, profileString, requireAuthConfig, resolveAuthConfig, resolveScopes, saveOAuthState } from "../auth.js";
+const authorizationEndpoint = "https://oauth.yandex.com/authorize";
+const tokenEndpoint = "https://oauth.yandex.com/token";
+const userEndpoint = "https://login.yandex.ru/info?format=json";
+const envPrefix = "YANDEX";
+const defaultScopes = ["login:info", "login:email", "login:avatar"];
+export class Yandex {
+    client;
+    auth = null;
+    constructor(clientIdOrOptions, clientSecret, redirectURI) {
+        if (typeof clientIdOrOptions === "object") {
+            this.auth = resolveAuthConfig(envPrefix, clientIdOrOptions, {
+                clientSecret: true,
+                redirectURI: true
+            });
+            this.client = new OAuth2Client(this.auth.clientId, this.auth.clientSecret, this.auth.redirectURI);
+        }
+        else {
+            this.client = new OAuth2Client(clientIdOrOptions, clientSecret ?? "", redirectURI ?? "");
+        }
+    }
+    createAuthorizationURL(state, scopes) {
+        const url = this.client.createAuthorizationURL(authorizationEndpoint, state, scopes);
+        return url;
+    }
+    async validateAuthorizationCode(code) {
+        const tokens = await this.client.validateAuthorizationCode(tokenEndpoint, code, null);
+        return tokens;
+    }
+    async refreshAccessToken(refreshToken) {
+        const tokens = await this.client.refreshAccessToken(tokenEndpoint, refreshToken, []);
+        return tokens;
+    }
+    async getAuthorizationURL(scopes) {
+        const auth = requireAuthConfig(this.auth);
+        const state = generateOAuthState();
+        const url = this.createAuthorizationURL(state, resolveScopes(scopes, auth, defaultScopes));
+        await saveOAuthState(auth.store, state, {});
+        return url;
+    }
+    async getUser(query) {
+        const auth = requireAuthConfig(this.auth);
+        const { code, state } = parseCallbackQuery(query);
+        await consumeOAuthState(auth.store, state);
+        const tokens = await this.validateAuthorizationCode(code);
+        const accessToken = tokens.accessToken();
+        // Yandex expects the "OAuth" scheme instead of "Bearer".
+        const profile = await fetchUserProfile(userEndpoint, accessToken, {
+            Authorization: `OAuth ${accessToken}`
+        });
+        const avatarId = profileString(profile.default_avatar_id);
+        let image = null;
+        if (avatarId !== null && profile.is_avatar_empty !== true) {
+            image = `https://avatars.yandex.net/get-yapic/${avatarId}/islands-200`;
+        }
+        return {
+            id: profileId(profile.id),
+            name: profileString(profile.real_name) ??
+                profileString(profile.display_name) ??
+                profileString(profile.login),
+            email: profileString(profile.default_email),
+            image
+        };
+    }
+}

package/dist/providers/zoom.d.ts

@@ -0,0 +1,16 @@
+import type { OAuth2Tokens } from "../oauth2.js";
+import type { OAuthCallbackQuery, OAuthUser, ProviderOptions } from "../auth.js";
+export interface ZoomOptions extends ProviderOptions {
+}
+export declare class Zoom {
+    private client;
+    private auth;
+    constructor(options: ZoomOptions);
+    constructor(clientId: string, clientSecret: string, redirectURI: string);
+    createAuthorizationURL(state: string, codeVerifier: string, scopes: string[]): URL;
+    validateAuthorizationCode(code: string, codeVerifier: string): Promise<OAuth2Tokens>;
+    refreshAccessToken(refreshToken: string): Promise<OAuth2Tokens>;
+    revokeToken(token: string): Promise<void>;
+    getAuthorizationURL(scopes?: string[]): Promise<URL>;
+    getUser(query: OAuthCallbackQuery): Promise<OAuthUser>;
+}

package/dist/providers/zoom.js

@@ -0,0 +1,66 @@
+import { OAuth2Client, CodeChallengeMethod } from "../client.js";
+import { consumeOAuthState, fetchUserProfile, generateOAuthCodeVerifier, generateOAuthState, InvalidOAuthCallbackError, parseCallbackQuery, profileId, profileString, requireAuthConfig, resolveAuthConfig, resolveScopes, saveOAuthState } from "../auth.js";
+const authorizationEndpoint = "https://zoom.us/oauth/authorize";
+const tokenEndpoint = "https://zoom.us/oauth/token";
+const tokenRevocationEndpoint = "https://zoom.us/oauth/revoke";
+const userEndpoint = "https://api.zoom.us/v2/users/me";
+const envPrefix = "ZOOM";
+const defaultScopes = ["user:read:user"];
+export class Zoom {
+    client;
+    auth = null;
+    constructor(clientIdOrOptions, clientSecret, redirectURI) {
+        if (typeof clientIdOrOptions === "object") {
+            this.auth = resolveAuthConfig(envPrefix, clientIdOrOptions, {
+                clientSecret: true,
+                redirectURI: true
+            });
+            this.client = new OAuth2Client(this.auth.clientId, this.auth.clientSecret, this.auth.redirectURI);
+        }
+        else {
+            this.client = new OAuth2Client(clientIdOrOptions, clientSecret ?? "", redirectURI ?? "");
+        }
+    }
+    createAuthorizationURL(state, codeVerifier, scopes) {
+        const url = this.client.createAuthorizationURLWithPKCE(authorizationEndpoint, state, CodeChallengeMethod.S256, codeVerifier, scopes);
+        return url;
+    }
+    async validateAuthorizationCode(code, codeVerifier) {
+        const tokens = await this.client.validateAuthorizationCode(tokenEndpoint, code, codeVerifier);
+        return tokens;
+    }
+    async refreshAccessToken(refreshToken) {
+        const tokens = await this.client.refreshAccessToken(tokenEndpoint, refreshToken, []);
+        return tokens;
+    }
+    async revokeToken(token) {
+        await this.client.revokeToken(tokenRevocationEndpoint, token);
+    }
+    async getAuthorizationURL(scopes) {
+        const auth = requireAuthConfig(this.auth);
+        const state = generateOAuthState();
+        const codeVerifier = generateOAuthCodeVerifier();
+        const url = this.createAuthorizationURL(state, codeVerifier, resolveScopes(scopes, auth, defaultScopes));
+        await saveOAuthState(auth.store, state, { codeVerifier });
+        return url;
+    }
+    async getUser(query) {
+        const auth = requireAuthConfig(this.auth);
+        const { code, state } = parseCallbackQuery(query);
+        const stored = await consumeOAuthState(auth.store, state);
+        if (typeof stored.codeVerifier !== "string") {
+            throw new InvalidOAuthCallbackError("Missing PKCE code verifier for OAuth state");
+        }
+        const tokens = await this.validateAuthorizationCode(code, stored.codeVerifier);
+        const profile = await fetchUserProfile(userEndpoint, tokens.accessToken());
+        const firstName = profileString(profile.first_name);
+        const lastName = profileString(profile.last_name);
+        const fullName = [firstName, lastName].filter((part) => part !== null).join(" ");
+        return {
+            id: profileId(profile.id),
+            name: profileString(profile.display_name) ?? (fullName !== "" ? fullName : null),
+            email: profileString(profile.email),
+            image: profileString(profile.pic_url)
+        };
+    }
+}

package/dist/request.d.ts

@@ -0,0 +1,26 @@
+import { OAuth2Tokens } from "./oauth2.js";
+export declare function joinURIAndPath(base: string, ...path: string[]): string;
+export declare function createOAuth2Request(endpoint: string, body: URLSearchParams): Request;
+export declare function encodeBasicCredentials(username: string, password: string): string;
+export declare function sendTokenRequest(request: Request): Promise<OAuth2Tokens>;
+export declare function sendTokenRevocationRequest(request: Request): Promise<void>;
+export declare function createOAuth2RequestError(result: object): OAuth2RequestError;
+export declare class ArcticFetchError extends Error {
+    constructor(cause: unknown);
+}
+export declare class OAuth2RequestError extends Error {
+    code: string;
+    description: string | null;
+    uri: string | null;
+    state: string | null;
+    constructor(code: string, description: string | null, uri: string | null, state: string | null);
+}
+export declare class UnexpectedResponseError extends Error {
+    status: number;
+    constructor(responseStatus: number);
+}
+export declare class UnexpectedErrorResponseBodyError extends Error {
+    status: number;
+    data: unknown;
+    constructor(status: number, data: unknown);
+}

package/dist/request.js

@@ -0,0 +1,182 @@
+import * as encoding from "@oslojs/encoding";
+import { OAuth2Tokens } from "./oauth2.js";
+import { trimLeft, trimRight } from "./utils.js";
+export function joinURIAndPath(base, ...path) {
+    let joined = trimRight(base, "/");
+    for (const part of path) {
+        joined = trimRight(joined, "/") + "/" + trimLeft(part, "/");
+    }
+    return joined;
+}
+export function createOAuth2Request(endpoint, body) {
+    const bodyBytes = new TextEncoder().encode(body.toString());
+    const request = new Request(endpoint, {
+        method: "POST",
+        body: bodyBytes
+    });
+    request.headers.set("Content-Type", "application/x-www-form-urlencoded");
+    request.headers.set("Accept", "application/json");
+    // Required by GitHub, and probably by others as well
+    request.headers.set("User-Agent", "arctic");
+    // Required by Reddit
+    request.headers.set("Content-Length", bodyBytes.byteLength.toString());
+    return request;
+}
+export function encodeBasicCredentials(username, password) {
+    const bytes = new TextEncoder().encode(`${username}:${password}`);
+    return encoding.encodeBase64(bytes);
+}
+export async function sendTokenRequest(request) {
+    let response;
+    try {
+        response = await fetch(request);
+    }
+    catch (e) {
+        throw new ArcticFetchError(e);
+    }
+    if (response.status === 400 || response.status === 401) {
+        let data;
+        try {
+            data = await response.json();
+        }
+        catch {
+            throw new UnexpectedResponseError(response.status);
+        }
+        if (typeof data !== "object" || data === null) {
+            throw new UnexpectedErrorResponseBodyError(response.status, data);
+        }
+        let error;
+        try {
+            error = createOAuth2RequestError(data);
+        }
+        catch {
+            throw new UnexpectedErrorResponseBodyError(response.status, data);
+        }
+        throw error;
+    }
+    if (response.status === 200) {
+        let data;
+        try {
+            data = await response.json();
+        }
+        catch {
+            throw new UnexpectedResponseError(response.status);
+        }
+        if (typeof data !== "object" || data === null) {
+            throw new UnexpectedErrorResponseBodyError(response.status, data);
+        }
+        const tokens = new OAuth2Tokens(data);
+        return tokens;
+    }
+    if (response.body !== null) {
+        await response.body.cancel();
+    }
+    throw new UnexpectedResponseError(response.status);
+}
+export async function sendTokenRevocationRequest(request) {
+    let response;
+    try {
+        response = await fetch(request);
+    }
+    catch (e) {
+        throw new ArcticFetchError(e);
+    }
+    if (response.status === 400 || response.status === 401) {
+        let data;
+        try {
+            data = await response.json();
+        }
+        catch {
+            throw new UnexpectedErrorResponseBodyError(response.status, null);
+        }
+        if (typeof data !== "object" || data === null) {
+            throw new UnexpectedErrorResponseBodyError(response.status, data);
+        }
+        let error;
+        try {
+            error = createOAuth2RequestError(data);
+        }
+        catch {
+            throw new UnexpectedErrorResponseBodyError(response.status, data);
+        }
+        throw error;
+    }
+    if (response.status === 200) {
+        if (response.body !== null) {
+            await response.body.cancel();
+        }
+        return;
+    }
+    if (response.body !== null) {
+        await response.body.cancel();
+    }
+    throw new UnexpectedResponseError(response.status);
+}
+export function createOAuth2RequestError(result) {
+    let code;
+    if ("error" in result && typeof result.error === "string") {
+        code = result.error;
+    }
+    else {
+        throw new Error("Invalid error response");
+    }
+    let description = null;
+    let uri = null;
+    let state = null;
+    if ("error_description" in result) {
+        if (typeof result.error_description !== "string") {
+            throw new Error("Invalid data");
+        }
+        description = result.error_description;
+    }
+    if ("error_uri" in result) {
+        if (typeof result.error_uri !== "string") {
+            throw new Error("Invalid data");
+        }
+        uri = result.error_uri;
+    }
+    if ("state" in result) {
+        if (typeof result.state !== "string") {
+            throw new Error("Invalid data");
+        }
+        state = result.state;
+    }
+    const error = new OAuth2RequestError(code, description, uri, state);
+    return error;
+}
+export class ArcticFetchError extends Error {
+    constructor(cause) {
+        super("Failed to send request", {
+            cause
+        });
+    }
+}
+export class OAuth2RequestError extends Error {
+    code;
+    description;
+    uri;
+    state;
+    constructor(code, description, uri, state) {
+        super(`OAuth request error: ${code}`);
+        this.code = code;
+        this.description = description;
+        this.uri = uri;
+        this.state = state;
+    }
+}
+export class UnexpectedResponseError extends Error {
+    status;
+    constructor(responseStatus) {
+        super("Unexpected error response");
+        this.status = responseStatus;
+    }
+}
+export class UnexpectedErrorResponseBodyError extends Error {
+    status;
+    data;
+    constructor(status, data) {
+        super("Unexpected error response body");
+        this.status = status;
+        this.data = data;
+    }
+}

package/dist/utils.d.ts

@@ -0,0 +1,2 @@
+export declare function trimLeft(s: string, character: string): string;
+export declare function trimRight(s: string, character: string): string;

package/dist/utils.js

@@ -0,0 +1,20 @@
+export function trimLeft(s, character) {
+    if (character.length !== 1) {
+        throw new TypeError("Invalid character string");
+    }
+    let start = 0;
+    while (start < s.length && s[start] === character) {
+        start++;
+    }
+    return s.slice(start);
+}
+export function trimRight(s, character) {
+    if (character.length !== 1) {
+        throw new TypeError("Invalid character string");
+    }
+    let end = s.length;
+    while (end > 0 && s[end - 1] === character) {
+        end--;
+    }
+    return s.slice(0, end);
+}

package/package.json

@@ -0,0 +1,42 @@
+{
+	"name": "antarctic",
+	"version": "0.2.0",
+	"description": "High-level OAuth 2.0 clients for popular providers, forked from Arctic",
+	"type": "module",
+	"main": "dist/index.js",
+	"types": "dist/index.d.ts",
+	"module": "dist/index.js",
+	"scripts": {
+		"build": "rm -rf dist/* && tsc",
+		"format": "prettier -w .",
+		"lint": "eslint src",
+		"test": "vitest run --sequence.concurrent"
+	},
+	"files": [
+		"/dist/"
+	],
+	"author": "Francisco Presencia",
+	"contributors": [
+		"pilcrowOnPaper (author of Arctic, which Antarctic is a fork of)"
+	],
+	"license": "MIT",
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/franciscop/antarctic.git"
+	},
+	"devDependencies": {
+		"@types/node": "^20.8.6",
+		"@typescript-eslint/eslint-plugin": "^6.7.5",
+		"@typescript-eslint/parser": "^6.7.5",
+		"auri": "^3.1.0",
+		"eslint": "^8.51.0",
+		"prettier": "^3.0.3",
+		"typescript": "^5.2.2",
+		"vitest": "1.6.0"
+	},
+	"dependencies": {
+		"@oslojs/crypto": "1.0.1",
+		"@oslojs/encoding": "1.1.0",
+		"@oslojs/jwt": "0.2.0"
+	}
+}