altair-graphql-core 6.4.2 → 7.0.1

package/build/authorization/providers/oauth2.d.ts

@@ -0,0 +1,10 @@
+import { AccessTokenResponse } from '../../oauth2';
+import { AuthorizationResult } from '../../types/state/authorization.interface';
+import { AuthorizationProvider, AuthorizationProviderExecuteOptions } from '../authorization-provider';
+export interface OAuth2AuthorizationProviderData {
+    accessTokenResponse: AccessTokenResponse;
+}
+export default class OAuth2AuthorizationProvider extends AuthorizationProvider<OAuth2AuthorizationProviderData> {
+    execute(options: AuthorizationProviderExecuteOptions<OAuth2AuthorizationProviderData>): Promise<AuthorizationResult>;
+}
+//# sourceMappingURL=oauth2.d.ts.map

package/build/authorization/providers/oauth2.js

@@ -0,0 +1,11 @@
+import { AuthorizationProvider, } from '../authorization-provider';
+export default class OAuth2AuthorizationProvider extends AuthorizationProvider {
+    async execute(options) {
+        return {
+            headers: {
+                Authorization: `Bearer ${this.hydrate(options.data.accessTokenResponse.access_token)}`,
+            },
+        };
+    }
+}
+//# sourceMappingURL=oauth2.js.map

package/build/cjs/authorization/providers/oauth2.d.ts

@@ -0,0 +1,10 @@
+import { AccessTokenResponse } from '../../oauth2';
+import { AuthorizationResult } from '../../types/state/authorization.interface';
+import { AuthorizationProvider, AuthorizationProviderExecuteOptions } from '../authorization-provider';
+export interface OAuth2AuthorizationProviderData {
+    accessTokenResponse: AccessTokenResponse;
+}
+export default class OAuth2AuthorizationProvider extends AuthorizationProvider<OAuth2AuthorizationProviderData> {
+    execute(options: AuthorizationProviderExecuteOptions<OAuth2AuthorizationProviderData>): Promise<AuthorizationResult>;
+}
+//# sourceMappingURL=oauth2.d.ts.map

package/build/cjs/authorization/providers/oauth2.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const authorization_provider_1 = require("../authorization-provider");
+class OAuth2AuthorizationProvider extends authorization_provider_1.AuthorizationProvider {
+    async execute(options) {
+        return {
+            headers: {
+                Authorization: `Bearer ${this.hydrate(options.data.accessTokenResponse.access_token)}`,
+            },
+        };
+    }
+}
+exports.default = OAuth2AuthorizationProvider;
+//# sourceMappingURL=oauth2.js.map

package/build/cjs/config.d.ts

@@ -99,6 +99,10 @@ export interface AltairConfigOptions extends AltairWindowOptions {
      * List of options for windows to be loaded
      */
     initialWindows?: AltairWindowOptions[];
+    /**
+     * Persisted settings for the app. The settings will be merged with the app settings.
+     */
+    persistedSettings?: Partial<SettingsState>;
     /**
      * Disable the account and remote syncing functionality
      */
@@ -150,6 +154,7 @@ export declare class AltairConfig {
         postRequestScript: string;
         instanceStorageNamespace: string;
         settings: Partial<SettingsState> | undefined;
+        persistedSettings: Partial<SettingsState> | undefined;
         initialSubscriptionsProvider: SubscriptionProviderIds | undefined;
         initialSubscriptionsPayload: IDictionary;
         initialHttpMethod: "POST" | "GET" | "PUT" | "DELETE";
@@ -157,7 +162,7 @@ export declare class AltairConfig {
         windows: AltairWindowOptions[];
         disableAccount: boolean;
     };
-    constructor({ endpointURL, subscriptionsEndpoint, subscriptionsProtocol, initialQuery, initialHeaders, initialEnvironments, initialVariables, initialPreRequestScript, initialPostRequestScript, instanceStorageNamespace, initialSettings, initialSubscriptionsProvider, initialSubscriptionsPayload, initialHttpMethod, preserveState, initialWindows, disableAccount, }?: AltairConfigOptions);
+    constructor({ endpointURL, subscriptionsEndpoint, subscriptionsProtocol, initialQuery, initialHeaders, initialEnvironments, initialVariables, initialPreRequestScript, initialPostRequestScript, instanceStorageNamespace, initialSettings, persistedSettings, initialSubscriptionsProvider, initialSubscriptionsPayload, initialHttpMethod, preserveState, initialWindows, disableAccount, }?: AltairConfigOptions);
 }
 export declare const setAltairConfig: (_config: AltairConfig) => void;
 export declare const getAltairConfig: () => AltairConfig;

package/build/cjs/config.js

@@ -8,7 +8,7 @@ const subscriptions_1 = require("./subscriptions");
 const is_electron_1 = __importDefault(require("./utils/is_electron"));
 const isTranslateMode = window.__ALTAIR_TRANSLATE__;
 class AltairConfig {
-    constructor({ endpointURL, subscriptionsEndpoint, subscriptionsProtocol, initialQuery, initialHeaders, initialEnvironments, initialVariables, initialPreRequestScript, initialPostRequestScript = '', instanceStorageNamespace, initialSettings, initialSubscriptionsProvider = subscriptions_1.WEBSOCKET_PROVIDER_ID, initialSubscriptionsPayload = {}, initialHttpMethod = 'POST', preserveState = true, initialWindows = [], disableAccount = false, } = {}) {
+    constructor({ endpointURL, subscriptionsEndpoint, subscriptionsProtocol, initialQuery, initialHeaders, initialEnvironments, initialVariables, initialPreRequestScript, initialPostRequestScript = '', instanceStorageNamespace, initialSettings, persistedSettings, initialSubscriptionsProvider = subscriptions_1.WEBSOCKET_PROVIDER_ID, initialSubscriptionsPayload = {}, initialHttpMethod = 'POST', preserveState = true, initialWindows = [], disableAccount = false, } = {}) {
         this.donation = {
             url: 'https://opencollective.com/altair/donate',
             action_count_threshold: 50,
@@ -55,6 +55,7 @@ class AltairConfig {
             postRequestScript: '',
             instanceStorageNamespace: 'altair_',
             settings: undefined,
+            persistedSettings: undefined,
             initialSubscriptionsProvider: undefined,
             initialSubscriptionsPayload: {},
             initialHttpMethod: 'POST',
@@ -63,29 +64,30 @@ class AltairConfig {
             disableAccount: false,
         };
         this.initialData.url =
-            window.__ALTAIR_ENDPOINT_URL__ || endpointURL || '';
+            window.__ALTAIR_ENDPOINT_URL__ ?? endpointURL ?? '';
         this.initialData.subscriptionsEndpoint =
-            window.__ALTAIR_SUBSCRIPTIONS_ENDPOINT__ ||
-                subscriptionsEndpoint ||
+            window.__ALTAIR_SUBSCRIPTIONS_ENDPOINT__ ??
+                subscriptionsEndpoint ??
                 '';
-        this.initialData.subscriptionsProtocol = subscriptionsProtocol || '';
+        this.initialData.subscriptionsProtocol = subscriptionsProtocol ?? '';
         this.initialData.query =
-            window.__ALTAIR_INITIAL_QUERY__ || initialQuery || '';
+            window.__ALTAIR_INITIAL_QUERY__ ?? initialQuery ?? '';
         this.initialData.variables =
-            window.__ALTAIR_INITIAL_VARIABLES__ || initialVariables || '';
+            window.__ALTAIR_INITIAL_VARIABLES__ ?? initialVariables ?? '';
         this.initialData.headers =
-            window.__ALTAIR_INITIAL_HEADERS__ || initialHeaders || '';
-        this.initialData.environments = initialEnvironments || {};
+            window.__ALTAIR_INITIAL_HEADERS__ ?? initialHeaders ?? '';
+        this.initialData.environments = initialEnvironments ?? {};
         this.initialData.preRequestScript =
-            window.__ALTAIR_INITIAL_PRE_REQUEST_SCRIPT__ ||
-                initialPreRequestScript ||
+            window.__ALTAIR_INITIAL_PRE_REQUEST_SCRIPT__ ??
+                initialPreRequestScript ??
                 '';
         this.initialData.postRequestScript = initialPostRequestScript;
         this.initialData.instanceStorageNamespace =
-            window.__ALTAIR_INSTANCE_STORAGE_NAMESPACE__ ||
-                instanceStorageNamespace ||
+            window.__ALTAIR_INSTANCE_STORAGE_NAMESPACE__ ??
+                instanceStorageNamespace ??
                 'altair_';
         this.initialData.settings = initialSettings;
+        this.initialData.persistedSettings = persistedSettings;
         this.initialData.initialSubscriptionsProvider = initialSubscriptionsProvider;
         this.initialData.initialSubscriptionsPayload = initialSubscriptionsPayload;
         this.initialData.initialHttpMethod = initialHttpMethod;

package/build/cjs/oauth2/client.d.ts

@@ -0,0 +1,34 @@
+import { AccessTokenErrorResponse, AccessTokenResponse, AuthorizationRedirectErrorResponse, AuthorizationRedirectResponse, OAuth2Type } from './types';
+interface CommonOAuth2ClientOptions {
+    clientId: string;
+    redirectUri: string;
+    scopes: string[];
+    /**
+     * An opaque string used to store request-specific data and/or prevent CSRF attacks by verifying the value of state later
+     */
+    state: string;
+}
+interface AuthorizationCode_OAuth2ClientOptions extends CommonOAuth2ClientOptions {
+    type: OAuth2Type.AUTHORIZATION_CODE;
+    clientSecret: string;
+    authorizationEndpoint: string;
+    tokenEndpoint: string;
+}
+interface AuthorizationCodePKCE_OAuth2ClientOptions extends Omit<AuthorizationCode_OAuth2ClientOptions, 'type'> {
+    type: OAuth2Type.AUTHORIZATION_CODE_PKCE;
+    /**
+     * A cryptographically random string between 43 and 128 characters long that will be used to verify the authorization code
+     * using the character set [A-Z, a-z, 0-9, "-", ".", "_", "~"]
+     */
+    codeVerifier: string;
+}
+export type OAuth2ClientOptions = AuthorizationCode_OAuth2ClientOptions | AuthorizationCodePKCE_OAuth2ClientOptions;
+export declare class OAuth2Client {
+    private options;
+    constructor(options: OAuth2ClientOptions);
+    getAuthorizationUrl(): Promise<string>;
+    getAuthorizationRedirectResponse(): Promise<AuthorizationRedirectResponse | AuthorizationRedirectErrorResponse | undefined>;
+    getAccessTokenFromCode(code: string): Promise<AccessTokenResponse | AccessTokenErrorResponse>;
+}
+export {};
+//# sourceMappingURL=client.d.ts.map

package/build/cjs/oauth2/client.js

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OAuth2Client = void 0;
+const helpers_1 = require("./helpers");
+class OAuth2Client {
+    constructor(options) {
+        this.options = options;
+    }
+    async getAuthorizationUrl() {
+        const params = {
+            response_type: 'code',
+            client_id: this.options.clientId,
+            redirect_uri: this.options.redirectUri,
+            state: this.options.state,
+            scope: this.options.scopes.join(' '),
+            ...(this.options.type === 'auth_code_pkce'
+                ? {
+                    code_challenge: await (0, helpers_1.getCodeChallenge)(this.options.codeVerifier),
+                    code_challenge_method: 'S256',
+                }
+                : {}),
+        };
+        const urlParams = new URLSearchParams(params);
+        const u = new URL(this.options.authorizationEndpoint);
+        const url = new URL(`${u.origin}${u.pathname}?${urlParams.toString()}`);
+        return url.toString();
+    }
+    async getAuthorizationRedirectResponse() {
+        // Get params from url
+        const url = new URL(window.location.href);
+        const obj = Object.fromEntries(url.searchParams.entries());
+        if (obj.error) {
+            return {
+                error: obj.error,
+                state: obj.state ?? '',
+                error_description: obj.error_description,
+                error_uri: obj.error_uri,
+            };
+        }
+        // Validate params
+        if (!obj.code || !obj.state) {
+            return;
+        }
+        // verify state is the same as the one generated
+        if (obj.state !== this.options.state) {
+            return {
+                error: 'invalid_state',
+                state: obj.state,
+                error_description: 'The state is invalid',
+            };
+        }
+        // Return params
+        return { code: obj.code, state: obj.state };
+    }
+    // Since this will be a CORS request, we only support it in the desktop app for now
+    async getAccessTokenFromCode(code) {
+        const params = {
+            grant_type: 'authorization_code',
+            code,
+            redirect_uri: this.options.redirectUri,
+            client_id: this.options.clientId,
+            client_secret: this.options.clientSecret,
+            ...(this.options.type === 'auth_code_pkce'
+                ? { code_verifier: this.options.codeVerifier }
+                : {}),
+        };
+        const response = await fetch(this.options.tokenEndpoint, {
+            method: 'POST',
+            headers: {
+                Accept: 'application/json',
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify(params),
+        });
+        const data = await response.json();
+        return data;
+    }
+}
+exports.OAuth2Client = OAuth2Client;
+/*
+in app:
+listen for ready message from auth window
+send [options + action] to the auth window
+listen for authorization code from auth window
+close auth window
+exchange code for access token
+
+in auth window:
+send ready message to app
+listen for options message from app
+- redirect to authorization url
+- get code from url
+- send code to app
+*/
+//# sourceMappingURL=client.js.map

package/build/cjs/oauth2/client.spec.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=client.spec.d.ts.map

package/build/cjs/oauth2/client.spec.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const globals_1 = require("@jest/globals");
+const client_1 = require("./client");
+const types_1 = require("./types");
+(0, globals_1.describe)('oauth2 client', () => {
+    (0, globals_1.describe)('getAuthorizationUrl', () => {
+        (0, globals_1.it)('should return the authorization url', async () => {
+            const client = new client_1.OAuth2Client({
+                type: types_1.OAuth2Type.AUTHORIZATION_CODE_PKCE,
+                authorizationEndpoint: 'https://auth-server.com/oauth/authorize',
+                tokenEndpoint: 'https://auth-server.com/oauth/token',
+                clientId: 'clientId',
+                clientSecret: 'clientSecret',
+                redirectUri: 'redirectUri',
+                scopes: ['scope1', 'scope2'],
+                codeVerifier: 'codeVerifier',
+                state: 'random-state',
+            });
+            const url = await client.getAuthorizationUrl();
+            (0, globals_1.expect)(url).toBe('https://auth-server.com/oauth/authorize?response_type=code&client_id=clientId&redirect_uri=redirectUri&state=random-state&scope=scope1+scope2&code_challenge=N1E4yRMD7xixn_oFyO_W3htYN3rY7-HMDKJe6z6r928&code_challenge_method=S256');
+        });
+    });
+});
+//# sourceMappingURL=client.spec.js.map

package/build/cjs/oauth2/events.d.ts

@@ -0,0 +1,6 @@
+export declare const EVENT_TYPES: {
+    FRAME_READY: string;
+    ACTION: string;
+    AUTHORIZATION_CODE: string;
+};
+//# sourceMappingURL=events.d.ts.map

package/build/cjs/oauth2/events.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EVENT_TYPES = void 0;
+exports.EVENT_TYPES = {
+    FRAME_READY: 'frame-ready',
+    ACTION: 'action',
+    AUTHORIZATION_CODE: 'authorization-code',
+};
+//# sourceMappingURL=events.js.map

package/build/cjs/oauth2/helpers.d.ts

@@ -0,0 +1,6 @@
+export declare const secureRandomString: (length?: number) => string;
+export declare const base64UrlEncode: (buffer: ArrayBuffer) => string;
+export declare const sha256: (str: string) => Promise<ArrayBuffer>;
+export declare const hex: (buffer: ArrayBuffer) => string;
+export declare const getCodeChallenge: (codeVerifier: string) => Promise<string>;
+//# sourceMappingURL=helpers.d.ts.map

package/build/cjs/oauth2/helpers.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCodeChallenge = exports.hex = exports.sha256 = exports.base64UrlEncode = exports.secureRandomString = void 0;
+const secureRandomString = (length = 16) => {
+    const charset = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-._~';
+    const randomValues = new Uint32Array(length);
+    window.crypto.getRandomValues(randomValues);
+    return Array.from(randomValues)
+        .map((x) => charset[x % charset.length])
+        .join('');
+};
+exports.secureRandomString = secureRandomString;
+// https://thewoods.blog/base64url/
+const base64UrlEncode = (buffer) => {
+    return btoa(Array.from(new Uint8Array(buffer), (b) => String.fromCharCode(b)).join(''))
+        .replace(/\+/g, '-')
+        .replace(/\//g, '_')
+        .replace(/={1,4}$/, '');
+};
+exports.base64UrlEncode = base64UrlEncode;
+const sha256 = async (str) => {
+    const buffer = new TextEncoder().encode(str);
+    const hashBuffer = await window.crypto.subtle.digest('SHA-256', buffer);
+    return hashBuffer;
+};
+exports.sha256 = sha256;
+const hex = (buffer) => {
+    const hexCodes = [];
+    const view = new DataView(buffer);
+    for (let i = 0; i < view.byteLength; i += 4) {
+        const value = view.getUint32(i);
+        const stringValue = value.toString(16);
+        const padding = '00000000';
+        const paddedValue = (padding + stringValue).slice(-padding.length);
+        hexCodes.push(paddedValue);
+    }
+    return hexCodes.join('');
+};
+exports.hex = hex;
+const getCodeChallenge = async (codeVerifier) => {
+    return (0, exports.base64UrlEncode)(await (0, exports.sha256)(codeVerifier));
+};
+exports.getCodeChallenge = getCodeChallenge;
+//# sourceMappingURL=helpers.js.map

package/build/cjs/oauth2/helpers.spec.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=helpers.spec.d.ts.map

package/build/cjs/oauth2/helpers.spec.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const globals_1 = require("@jest/globals");
+const helpers_1 = require("./helpers");
+(0, globals_1.describe)('oauth2 helpers', () => {
+    (0, globals_1.describe)('secureRandomString', () => {
+        (0, globals_1.it)('should generate a random string', () => {
+            const out = (0, helpers_1.secureRandomString)(64);
+            (0, globals_1.expect)(out).toHaveLength(64);
+        });
+        (0, globals_1.it)('should generate a code verifier spec compliant string', () => {
+            const out = (0, helpers_1.secureRandomString)(128);
+            (0, globals_1.expect)(out).toMatch(/^[A-Za-z0-9\-._~]{43,128}$/);
+        });
+    });
+    (0, globals_1.describe)('base64UrlEncode', () => {
+        (0, globals_1.it)('should encode a string to base64url', () => {
+            const out = (0, helpers_1.base64UrlEncode)(new TextEncoder().encode('hello world'));
+            (0, globals_1.expect)(out).toBe('aGVsbG8gd29ybGQ');
+        });
+    });
+    (0, globals_1.describe)('sha256', () => {
+        (0, globals_1.it)('should hash a string using SHA-256', async () => {
+            const str = JSON.stringify({ a: 'a', b: [1, 2, 3, 4], foo: { c: 'bar' } });
+            const out = await (0, helpers_1.sha256)(str);
+            const hexed = (0, helpers_1.hex)(out);
+            (0, globals_1.expect)(hexed).toBe('04aa106279f5977f59f9067fa9712afc4aedc6f5862a8defc34552d8c7206393');
+        });
+    });
+    (0, globals_1.describe)('getCodeChallenge', () => {
+        globals_1.it.each([
+            // random samples from https://example-app.com/pkce
+            [
+                '075f4a07eb8e645d4857f9c8debd85fc867e963da49a7f76583ed453',
+                'boifgebQR7BmZyyNRkG-Q8B-f-Ex8VGD3hRK1tTfmic',
+            ],
+            [
+                'd874bb0fcb35b0a7b52af7c3f3fc5180667fe427ba3dedbfa0dadd5b',
+                'I8r8ci9TjlPpOvU6Vm32Ya3sLXIS4XVQwZ4_hrFWIz8',
+            ],
+            [
+                '63a4b655ae5a4e2204d984f516c8c36b628b040fbd1840fb546e943a',
+                'CiU3jN5rx9NMCmgFG-PETaoPTlBjkhT9U6bH68CoUdk',
+            ],
+            [
+                'bWrd3MfgGswVQXR54T3nnXY7lGgnIDrpcFEL5cSqxrdQpZCP30Ls5UKuviRS2R6kwtbOUyFjtKjthuZe6MucVdZtXZFrr9v2BkydYvGbAB7FOx6_-_whBvhF1XNpC9il',
+                'entSJG70NsTQypzbSNd6Koq6Zv2hBT6aXpHncJ5AX8M',
+            ],
+        ])('should encode a string to base64url', async (str, expected) => {
+            const out = await (0, helpers_1.getCodeChallenge)(str);
+            (0, globals_1.expect)(out).toBe(expected);
+        });
+    });
+});
+//# sourceMappingURL=helpers.spec.js.map

package/build/cjs/oauth2/index.d.ts

@@ -0,0 +1,5 @@
+export * from './client';
+export * from './helpers';
+export * from './types';
+export * from './events';
+//# sourceMappingURL=index.d.ts.map

package/build/cjs/oauth2/index.js

@@ -0,0 +1,21 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./client"), exports);
+__exportStar(require("./helpers"), exports);
+__exportStar(require("./types"), exports);
+__exportStar(require("./events"), exports);
+//# sourceMappingURL=index.js.map

package/build/cjs/oauth2/types.d.ts

@@ -0,0 +1,89 @@
+export declare enum OAuth2Type {
+    AUTHORIZATION_CODE = "auth_code",
+    AUTHORIZATION_CODE_PKCE = "auth_code_pkce"
+}
+export interface SimpleAuthorizationRequestParams extends Record<string, string> {
+    response_type: 'code';
+    /**
+     * The client ID of your application
+     */
+    client_id: string;
+    /**
+     * The URL in your app where users will be sent after authorization
+     */
+    redirect_uri: string;
+    /**
+     * A random string generated by your application, which you'll verify later
+     */
+    state: string;
+    /**
+     * A space-separated list of scopes
+     */
+    scope: string;
+}
+export interface CodeChallengeAuthorizationRequestParams extends SimpleAuthorizationRequestParams {
+    code_challenge: string;
+    code_challenge_method: 'S256';
+}
+export type AuthorizationRequestParams = SimpleAuthorizationRequestParams | CodeChallengeAuthorizationRequestParams;
+export interface AuthorizationRedirectResponse {
+    /**
+     * The authorization code received from the authorization server
+     */
+    code: string;
+    /**
+     * The exact value of the state parameter passed by the client in the authorization request
+     */
+    state: string;
+}
+export interface AuthorizationRedirectErrorResponse {
+    error: string;
+    state: string;
+    error_description?: string;
+    error_uri?: string;
+}
+export interface AuthorizationCode_AccessTokenRequest {
+    grant_type: 'authorization_code';
+    /**
+     * The authorization code received from the authorization server
+     */
+    code: string;
+    /**
+     * The redirect URI used in the initial request
+     */
+    redirect_uri: string;
+    client_id: string;
+    client_secret: string;
+}
+export interface AuthorizationCodePKCE_AccessTokenRequest extends AuthorizationCode_AccessTokenRequest {
+    code_verifier: string;
+}
+export type AccessTokenRequest = AuthorizationCode_AccessTokenRequest | AuthorizationCodePKCE_AccessTokenRequest;
+export interface AccessTokenResponse {
+    /**
+     * The access token issued by the authorization server
+     */
+    access_token: string;
+    /**
+     * The type of the token issued
+     */
+    token_type: string;
+    /**
+     * The exact value of the state parameter passed by the client in the authorization request
+     */
+    state: string;
+    /**
+     * The lifetime in seconds of the access token
+     */
+    expires_in?: number;
+    refresh_token?: string;
+    id_token?: string;
+    scope?: string;
+}
+export interface AccessTokenErrorResponse {
+    error: string;
+    state: string;
+    error_description?: string;
+    error_uri?: string;
+}
+//# sourceMappingURL=types.d.ts.map

package/build/cjs/oauth2/types.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OAuth2Type = void 0;
+var OAuth2Type;
+(function (OAuth2Type) {
+    OAuth2Type["AUTHORIZATION_CODE"] = "auth_code";
+    OAuth2Type["AUTHORIZATION_CODE_PKCE"] = "auth_code_pkce";
+})(OAuth2Type || (exports.OAuth2Type = OAuth2Type = {}));
+//# sourceMappingURL=types.js.map

package/build/cjs/origins.d.ts

@@ -0,0 +1,2 @@
+export declare const validOrigins: string[];
+//# sourceMappingURL=origins.d.ts.map

package/build/cjs/origins.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validOrigins = void 0;
+exports.validOrigins = [
+    'chrome-extension://flnheeellpciglgpaodhkhmapeljopja',
+    'chrome-extension://aiopipphfnlndegenpkclffgaiillbdd',
+    'moz-extension://567d7e27-43b8-994e-ab50-e770fa7eab4b',
+    'http://localhost:4200',
+    'https://dash.altairgraphql.dev',
+    'https://altair-gql.sirmuel.design',
+    'https://web.altairgraphql.dev',
+    'altair://-',
+];
+//# sourceMappingURL=origins.js.map

package/build/cjs/script/context.d.ts

@@ -0,0 +1,6 @@
+import { GlobalContextBuilderHandlers, GlobalHelperContext, ModuleImportsMap, ScriptContextData, ScriptContextResponse } from './types';
+export declare const ModuleImports: ModuleImportsMap;
+export declare const buildContextResponse: (data: ScriptContextData) => ScriptContextResponse | undefined;
+export declare const importModuleHelper: (moduleName: string) => Promise<any>;
+export declare const getGlobalContext: (data: ScriptContextData, handlers: GlobalContextBuilderHandlers) => GlobalHelperContext;
+//# sourceMappingURL=context.d.ts.map