@kubun/provider-google 0.17.0 → 0.18.0

package/lib/api.d.ts

@@ -0,0 +1,32 @@
+export type GoogleErrorBody = {
+    message: string;
+    status?: string;
+};
+export type GoogleAPIFailure = {
+    httpStatus: number;
+    message: string;
+    googleStatus?: string;
+};
+export type GoogleAPIClientConfig = {
+    api: string;
+    accessToken: string;
+    fetch?: typeof globalThis.fetch;
+    toError: (failure: GoogleAPIFailure) => Error;
+};
+export type GoogleAPIGetOptions = {
+    signal?: AbortSignal;
+};
+export type GoogleAPISendOptions = {
+    method: string;
+    body?: unknown;
+    headers?: Record<string, string>;
+    signal?: AbortSignal;
+};
+export type GoogleAPIClient = {
+    get<T>(url: string, options?: GoogleAPIGetOptions): Promise<T>;
+    send<T>(url: string, options: GoogleAPISendOptions): Promise<T>;
+    request(url: string, options?: GoogleAPISendOptions): Promise<Response>;
+    fail(response: Response): Promise<never>;
+};
+export declare function parseGoogleErrorBody(response: Response): Promise<GoogleErrorBody>;
+export declare function createGoogleAPIClient(config: GoogleAPIClientConfig): GoogleAPIClient;

package/lib/api.js

@@ -0,0 +1,61 @@
+export async function parseGoogleErrorBody(response) {
+    try {
+        const body = await response.json();
+        return {
+            message: body.error?.message ?? `${response.status} ${response.statusText}`,
+            status: body.error?.status
+        };
+    } catch  {
+        return {
+            message: `${response.status} ${response.statusText}`
+        };
+    }
+}
+export function createGoogleAPIClient(config) {
+    const fetchFn = config.fetch ?? globalThis.fetch;
+    async function request(url, options) {
+        return fetchFn(url, {
+            ...options?.method != null ? {
+                method: options.method
+            } : {},
+            headers: {
+                Authorization: `Bearer ${config.accessToken}`,
+                ...options?.body !== undefined ? {
+                    'Content-Type': 'application/json'
+                } : {},
+                ...options?.headers
+            },
+            ...options?.body !== undefined ? {
+                body: JSON.stringify(options.body)
+            } : {},
+            signal: options?.signal
+        });
+    }
+    async function fail(response) {
+        const detail = await parseGoogleErrorBody(response);
+        throw config.toError({
+            httpStatus: response.status,
+            message: `${config.api} error: ${detail.message}`,
+            googleStatus: detail.status
+        });
+    }
+    async function get(url, options) {
+        const response = await request(url, {
+            method: 'GET',
+            signal: options?.signal
+        });
+        if (!response.ok) return fail(response);
+        return await response.json();
+    }
+    async function send(url, options) {
+        const response = await request(url, options);
+        if (!response.ok) return fail(response);
+        return await response.json();
+    }
+    return {
+        get,
+        send,
+        request,
+        fail
+    };
+}

package/lib/index.d.ts

@@ -1,5 +1,11 @@
 import type { OAuthProviderDefinition } from '@kokuin/oauth';
+export { createGoogleAPIClient, type GoogleAPIClient, type GoogleAPIClientConfig, type GoogleAPIFailure, type GoogleAPIGetOptions, type GoogleAPISendOptions, type GoogleErrorBody, parseGoogleErrorBody, } from './api.js';
 export declare const googleAuthorizationParams: Record<string, string>;
+type GoogleExistingCredential = {
+    accessToken: string;
+    scopes: Array<string>;
+    metadata?: Record<string, unknown>;
+};
 type CreateGoogleProviderParams = {
     mode: 'confidential';
     clientID: string;
@@ -11,5 +17,5 @@ type CreateGoogleProviderParams = {
 };
 export declare function createGoogleProvider(params: CreateGoogleProviderParams): OAuthProviderDefinition & {
     authorizationParams?: Record<string, string>;
+    incrementalAuthorizationParams?: (existing: GoogleExistingCredential) => Record<string, string>;
 };
-export {};

package/lib/index.js

@@ -1,3 +1,4 @@
+export { createGoogleAPIClient, parseGoogleErrorBody } from './api.js';
 export const googleAuthorizationParams = {
     // Offline access requests a refresh token (issuance stays provider-dependent);
     // consent keeps that guarantee for repeat authorizations. select_account forces
@@ -21,7 +22,14 @@ export function createGoogleProvider(params) {
             'profile',
             'email'
         ],
-        authorizationParams: googleAuthorizationParams
+        authorizationParams: googleAuthorizationParams,
+        incrementalAuthorizationParams: (existing)=>({
+                include_granted_scopes: 'true',
+                prompt: 'consent',
+                ...typeof existing.metadata?.googleAccountEmail === 'string' ? {
+                    login_hint: existing.metadata.googleAccountEmail
+                } : {}
+            })
     };
     return params.mode === 'confidential' ? {
         ...base,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kubun/provider-google",
-  "version": "0.17.0",
+  "version": "0.18.0",
   "keywords": [],
   "license": "see LICENSE.md",
   "sideEffects": false,
@@ -15,7 +15,7 @@
     "LICENSE.md"
   ],
   "dependencies": {
-    "@kokuin/oauth": "^0.1.0"
+    "@kokuin/oauth": "^0.1.1"
   },
   "publishConfig": {
     "access": "public"