@react-native-kakao/user 3.0.0-next.3 → 3.1.0-next.0

package/src/index.web.ts

@@ -1,21 +1,22 @@
 import { camelCaseObject, filterNonNullishKeys, is } from '@mj-studio/js-util';
 import { kFetch, kFetchFormUrlEncoded, kGlobalStorage, kRunWebAPI } from '@react-native-kakao/core';
-import * as querystring from 'querystring';
 
 import {
   type KakaoLoginToken,
   type KakaoScopeInfo,
-  type KakaoServiceTerms,
   type KakaoShippingAddressResult,
-  type KakaoUser,
+  type KakaoUser as KakaoUserProfile,
   type KakaoUserAPI,
 } from './index';
+import { validateShippingAddressOptions } from './validateShippingAddressOptions';
 
 declare const Kakao: {
   Auth: {
     authorize: Function;
     logout: Function;
     setAccessToken: Function;
+    selectShippingAddress: () => Promise<{ address_id: number }>;
+    getAccessToken: () => string | null;
   };
   API: { request: Function };
 };
@@ -29,19 +30,11 @@ function isoToUnix(value?: string | number) {
 }
 
 const KakaoUser: KakaoUserAPI = {
+  hasToken: () => kRunWebAPI(() => Kakao.Auth.getAccessToken() != null),
   getAccessToken: () =>
     kRunWebAPI(async () => {
-      const { id, expires_in, app_id } = (
-        await kFetch<{
-          id: number;
-          expires_in: number;
-          app_id: number;
-        }>('https://kapi.kakao.com/v1/user/access_token_info', {
-          headers: {
-            ...kGlobalStorage.headers,
-          },
-        })
-      ).body;
+      const { id, expires_in, app_id }: { id: number; expires_in: number; app_id: number } =
+        await Kakao.API.request({ url: '/v1/user/access_token_info' });
 
       return {
         id,
@@ -64,7 +57,7 @@ const KakaoUser: KakaoUserAPI = {
         body: filterNonNullishKeys({
           grant_type: 'authorization_code',
           client_id: kGlobalStorage.restApiKey,
-          redirect_uri: encodeURIComponent(redirectUri),
+          redirect_uri: redirectUri,
           code,
           client_secret: clientSecret,
         }),
@@ -73,12 +66,8 @@ const KakaoUser: KakaoUserAPI = {
       return camelCaseObject(res) as any;
     }),
   setAccessTokenWeb: (token: string) => {
+    Kakao.Auth.setAccessToken(token);
     kGlobalStorage.accessToken = token;
-
-    return new Promise((r) => {
-      Kakao.Auth.setAccessToken(token);
-      r(42);
-    });
   },
   login: (params): Promise<KakaoLoginToken> =>
     kRunWebAPI(() => {
@@ -89,16 +78,28 @@ const KakaoUser: KakaoUserAPI = {
         filterNonNullishKeys({
           loginHint,
           nonce: params?.nonce ?? nonce,
-          prompt: prompt?.join(','),
+          prompt: (
+            prompt ??
+            params?.prompts?.map((value) =>
+              value === 'SelectAccount' ? 'select_account' : value.toLowerCase(),
+            )
+          )?.join(','),
           redirectUri,
-          scope: scope?.join(','),
-          serviceTerms: serviceTerms?.join(','),
+          scope: (scope ?? params?.scopes)?.join(','),
+          serviceTerms: (serviceTerms ?? params?.serviceTerms)?.join(','),
           state,
-          throughTalk,
+          throughTalk: throughTalk ?? (params?.useKakaoAccountLogin ? false : undefined),
         }),
       );
     }),
-  logout: () => kRunWebAPI(() => Kakao.Auth.logout()),
+  logout: () =>
+    kRunWebAPI(async () => {
+      try {
+        await Kakao.Auth.logout();
+      } finally {
+        kGlobalStorage.clearAccessToken();
+      }
+    }),
   isLogined: async (): Promise<boolean> => {
     try {
       const { appId } = await KakaoUser.getAccessToken();
@@ -109,81 +110,186 @@ const KakaoUser: KakaoUserAPI = {
     }
   },
   isKakaoTalkLoginAvailable: async () => false,
-  unlink: () => kRunWebAPI(() => Kakao.API.request({ url: '/v1/user/unlink' })),
+  unlink: () =>
+    kRunWebAPI(async () => {
+      await Kakao.API.request({ url: '/v1/user/unlink' });
+      Kakao.Auth.setAccessToken(null);
+      kGlobalStorage.clearAccessToken();
+    }),
   scopes: (scopes?: string[]) =>
     kRunWebAPI(async () => {
       const response = await Kakao.API.request({
-        url: `/v2/user/scopes${scopes ? '?' + querystring.stringify({ scopes }) : ''}`,
+        url: '/v2/user/scopes',
+        data: scopes?.length ? { scopes } : undefined,
       });
 
       return camelCaseObject(response.scopes) as KakaoScopeInfo[];
     }),
   revokeScopes: (scopes: string[]) =>
-    kRunWebAPI(() =>
-      Kakao.API.request({
+    kRunWebAPI(async () => {
+      await Kakao.API.request({
         url: '/v2/user/revoke/scopes',
         data: {
           scopes,
         },
-      }),
-    ),
-  serviceTerms: () =>
-    kRunWebAPI(
-      async () =>
-        camelCaseObject(
-          (
-            await Kakao.API.request({
-              url: '/v2/user/service_terms',
-            })
-          ).service_terms.map((v) => ({
-            ...v,
-            agreed_at: v.agreed_at ? isoToUnix(v.agreed_at) : null,
-          })),
-        ) as KakaoServiceTerms[],
-    ),
-  shippingAddresses: () =>
-    kRunWebAPI(
-      async () =>
-        camelCaseObject(
-          await Kakao.API.request({
-            url: '/v1/user/shipping_address',
-          }),
-        ) as KakaoShippingAddressResult,
-    ),
+      });
+    }),
+  serviceTerms: ({ result, tags } = {}) =>
+    kRunWebAPI(async () => {
+      const response: {
+        service_terms?:
+          | {
+              tag: string;
+              agreed_at?: string | null;
+              agreed: boolean;
+              required: boolean;
+              revocable: boolean;
+            }[]
+          | null;
+      } = await Kakao.API.request({
+        url: '/v2/user/service_terms',
+        data: filterNonNullishKeys({ result, tags: tags?.join(',') }),
+      });
+
+      return (response.service_terms ?? []).map((term) => ({
+        tag: term.tag,
+        agreedAt: term.agreed_at ? isoToUnix(term.agreed_at) : undefined,
+        agreed: term.agreed,
+        required: term.required,
+        revocable: term.revocable,
+      }));
+    }),
+  revokeServiceTerms: (tags) =>
+    kRunWebAPI(async () => {
+      const response: {
+        revoked_service_terms?: { tag: string; agreed: boolean }[] | null;
+      } = await Kakao.API.request({
+        url: '/v2/user/revoke/service_terms',
+        data: { tags: tags.join(',') },
+      });
+
+      return response.revoked_service_terms ?? [];
+    }),
+  shippingAddresses: ({ addressId, fromUpdatedAt, pageSize } = {}) =>
+    kRunWebAPI(async () => {
+      validateShippingAddressOptions({ addressId, fromUpdatedAt, pageSize });
+
+      const query = new URLSearchParams(
+        Object.entries(
+          filterNonNullishKeys(
+            addressId != null
+              ? { address_id: addressId }
+              : { from_updated_at: fromUpdatedAt, page_size: pageSize },
+          ),
+        ).map(([key, value]) => [key, String(value)]),
+      );
+
+      const { body } = await kFetch<Record<string, unknown>>(
+        `https://kapi.kakao.com/v1/user/shipping_address?${query}`,
+        { headers: { Authorization: `Bearer ${Kakao.Auth.getAccessToken() ?? ''}` } },
+      );
+
+      const response = camelCaseObject(body) as {
+        userId?: number;
+        shippingAddressesNeedsAgreement?: boolean;
+        shippingAddresses?: (Omit<
+          KakaoShippingAddressResult['shippingAddresses'][number],
+          'updatedAt'
+        > & {
+          updatedAt?: string | number;
+        })[];
+      };
+
+      return {
+        userId: response.userId,
+        needsAgreement: response.shippingAddressesNeedsAgreement,
+        shippingAddresses: (response.shippingAddresses ?? []).map((address) => ({
+          ...address,
+          updatedAt: isoToUnix(address.updatedAt),
+        })),
+      };
+    }),
+  selectShippingAddress: () =>
+    kRunWebAPI(async () => {
+      try {
+        const { address_id } = await Kakao.Auth.selectShippingAddress();
+
+        return address_id;
+      } catch (error) {
+        if (error != null && typeof error === 'object' && 'error_code' in error) {
+          throw {
+            code: String(error.error_code),
+            message: 'error_msg' in error ? String(error.error_msg) : undefined,
+          };
+        }
+
+        throw error;
+      }
+    }),
   me: () =>
     kRunWebAPI(async () => {
-      const ret: any = camelCaseObject(await Kakao.API.request({ url: '/v2/user/me' }));
+      const ret = camelCaseObject(await Kakao.API.request({ url: '/v2/user/me' })) as {
+        id: number;
+        connectedAt?: string;
+        synchedAt?: string;
+        kakaoAccount?: Partial<KakaoUserProfile> & {
+          profile?: Partial<
+            Pick<KakaoUserProfile, 'nickname' | 'profileImageUrl' | 'thumbnailImageUrl'>
+          >;
+        };
+        properties?: { nickname?: string; profileImage?: string; thumbnailImage?: string };
+      };
       const kakaoAccount = ret.kakaoAccount ?? {};
       const properties = ret.properties ?? {};
+      const profile = kakaoAccount.profile ?? {};
 
       return {
-        ...ret,
-        ...properties,
-        ...kakaoAccount,
+        id: ret.id,
         email: kakaoAccount.email,
-        name: null,
-        nickname: kakaoAccount.profile.nickname,
-        profileImageUrl: properties.profileImage,
-        thumbnailImageUrl: properties.thumbnailImage,
-        phoneNumber: kakaoAccount.profile.phoneNumber,
-        isEmailValid: ret.isEmailValid,
-        isEmailVerified: ret.isEmailVerified,
+        name: kakaoAccount.name,
+        nickname: profile.nickname ?? properties.nickname,
+        profileImageUrl: profile.profileImageUrl ?? properties.profileImage,
+        thumbnailImageUrl: profile.thumbnailImageUrl ?? properties.thumbnailImage,
+        phoneNumber: kakaoAccount.phoneNumber,
+        isEmailValid: kakaoAccount.isEmailValid,
+        isEmailVerified: kakaoAccount.isEmailVerified,
+        ageRange: kakaoAccount.ageRange,
+        birthday: kakaoAccount.birthday,
+        birthdayType: kakaoAccount.birthdayType,
+        birthyear: kakaoAccount.birthyear,
+        gender: kakaoAccount.gender,
+        isKorean: kakaoAccount.isKorean,
+        ageRangeNeedsAgreement: kakaoAccount.ageRangeNeedsAgreement,
+        birthdayNeedsAgreement: kakaoAccount.birthdayNeedsAgreement,
+        birthyearNeedsAgreement: kakaoAccount.birthyearNeedsAgreement,
+        emailNeedsAgreement: kakaoAccount.emailNeedsAgreement,
+        genderNeedsAgreement: kakaoAccount.genderNeedsAgreement,
+        isKoreanNeedsAgreement: kakaoAccount.isKoreanNeedsAgreement,
+        phoneNumberNeedsAgreement: kakaoAccount.phoneNumberNeedsAgreement,
+        profileNeedsAgreement: kakaoAccount.profileNeedsAgreement,
+        nameNeedsAgreement: kakaoAccount.nameNeedsAgreement,
+        profileImageNeedsAgreement: kakaoAccount.profileImageNeedsAgreement,
+        profileNicknameNeedsAgreement: kakaoAccount.profileNicknameNeedsAgreement,
+        legalBirthDateNeedsAgreement: kakaoAccount.legalBirthDateNeedsAgreement,
         connectedAt: isoToUnix(ret.connectedAt),
         synchedAt: isoToUnix(ret.synchedAt),
-      } as KakaoUser;
+      } as KakaoUserProfile;
     }),
 };
 
 export const {
   isKakaoTalkLoginAvailable,
   isLogined,
+  hasToken,
   login,
   logout,
   me,
   revokeScopes,
   scopes,
   serviceTerms,
+  revokeServiceTerms,
   shippingAddresses,
+  selectShippingAddress,
   unlink,
   setAccessTokenWeb,
   issueAccessTokenWithCodeWeb,

package/src/spec/NativeKakaoUser.ts

@@ -4,6 +4,7 @@ import { TurboModuleRegistry } from 'react-native';
 import type {
   KakaoAccessTokenInfo,
   KakaoLoginToken,
+  KakaoRevokedServiceTerms,
   KakaoScopeInfo,
   KakaoServiceTerms,
   KakaoShippingAddressResult,
@@ -22,10 +23,17 @@ export interface Spec extends TurboModule {
   logout(): Promise<void>;
   unlink(): Promise<void>;
   isLogined(): Promise<boolean>;
+  hasToken(): Promise<boolean>;
   scopes(scopes?: string[]): Promise<KakaoScopeInfo[]>;
   revokeScopes(scopes: string[]): Promise<void>;
-  serviceTerms(): Promise<KakaoServiceTerms[]>;
-  shippingAddresses(): Promise<KakaoShippingAddressResult>;
+  serviceTerms(result?: string, tags?: string[]): Promise<KakaoServiceTerms[]>;
+  revokeServiceTerms(tags: string[]): Promise<KakaoRevokedServiceTerms[]>;
+  shippingAddresses(
+    addressId?: number,
+    fromUpdatedAt?: number,
+    pageSize?: number,
+  ): Promise<KakaoShippingAddressResult>;
+  selectShippingAddress(): Promise<number>;
   me(): Promise<KakaoUser>;
   getAccessToken(): Promise<KakaoAccessTokenInfo>;
 }

package/src/validateShippingAddressOptions.ts

@@ -0,0 +1,30 @@
+import { kAssert } from '@react-native-kakao/core';
+
+export function validateShippingAddressOptions({
+  addressId,
+  fromUpdatedAt,
+  pageSize,
+}: {
+  addressId?: number;
+  fromUpdatedAt?: number;
+  pageSize?: number;
+}) {
+  if (addressId != null) {
+    kAssert(
+      Number.isSafeInteger(addressId),
+      '[shippingAddresses] addressId must be a safe integer',
+    );
+
+    return;
+  }
+
+  kAssert(
+    fromUpdatedAt == null || (Number.isSafeInteger(fromUpdatedAt) && fromUpdatedAt >= 0),
+    '[shippingAddresses] fromUpdatedAt must be a non-negative safe integer in Unix seconds',
+  );
+
+  kAssert(
+    pageSize == null || (Number.isInteger(pageSize) && pageSize >= 2 && pageSize <= 2147483647),
+    '[shippingAddresses] pageSize must be an integer between 2 and 2147483647',
+  );
+}