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

package/src/index.web.ts

@@ -1,21 +1,30 @@
 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 {
+  kAssert,
+  kCreateWebError,
+  kFetch,
+  kFetchFormUrlEncoded,
+  kGlobalStorage,
+  kRunWebAPI,
+} from '@react-native-kakao/core';
 
 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: {
+  isInitialized: () => boolean;
   Auth: {
     authorize: Function;
     logout: Function;
     setAccessToken: Function;
+    selectShippingAddress: () => Promise<{ address_id: number }>;
+    getAccessToken: () => string | null;
   };
   API: { request: Function };
 };
@@ -29,19 +38,26 @@ function isoToUnix(value?: string | number) {
 }
 
 const KakaoUser: KakaoUserAPI = {
+  loginWithKakao: () =>
+    kRunWebAPI(() => {
+      throw {
+        code: 'Package-UnsupportedPlatform',
+        message:
+          'loginWithKakao is supported on Android and iOS. Use login with web.redirectUri on web.',
+      };
+    }),
+  refreshToken: () =>
+    kRunWebAPI(() => {
+      throw {
+        code: 'Package-UnsupportedPlatform',
+        message: 'The Kakao JavaScript SDK does not support refreshToken.',
+      };
+    }),
+  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,
@@ -49,7 +65,62 @@ const KakaoUser: KakaoUserAPI = {
         appId: app_id,
       };
     }),
-  issueAccessTokenWithCodeWeb: ({ clientSecret, code, redirectUri }) =>
+  issueAccessTokenWithCode: ({ code, codeVerifier, redirectUri, web }) =>
+    kRunWebAPI(async () => {
+      kAssert(
+        is.string(code) && code.length > 0 && is.string(redirectUri) && redirectUri.length > 0,
+        '[issueAccessTokenWithCode] code and redirectUri are required on web',
+      );
+
+      if (typeof Kakao === 'undefined' || !Kakao.isInitialized()) {
+        kCreateWebError({
+          code: 'Package-SDKNotInitialized',
+          message: 'Initialize the Kakao SDK before exchanging an authorization code.',
+        });
+      }
+
+      const token = await KakaoUser.issueAccessTokenWithCodeWeb({
+        code,
+        codeVerifier,
+        redirectUri: redirectUri!,
+        clientSecret: web?.clientSecret,
+      });
+
+      if (
+        !is.string(token.accessToken) ||
+        !token.accessToken ||
+        !is.string(token.refreshToken) ||
+        !token.refreshToken ||
+        !is.string(token.tokenType) ||
+        (token.idToken != null && !is.string(token.idToken)) ||
+        !Number.isFinite(token.expiresIn) ||
+        token.expiresIn < 0 ||
+        !Number.isFinite(token.refreshTokenExpiresIn) ||
+        token.refreshTokenExpiresIn < 0 ||
+        (token.scope != null && !is.string(token.scope))
+      ) {
+        kCreateWebError({
+          code: 'Package-APIResponseNotFound',
+          message: 'issueAccessTokenWithCode returned invalid token data.',
+        });
+      }
+
+      const issuedAt = Math.floor(Date.now() / 1000);
+      KakaoUser.setAccessTokenWeb(token.accessToken);
+
+      return {
+        accessToken: token.accessToken,
+        refreshToken: token.refreshToken,
+        tokenType: token.tokenType,
+        idToken: token.idToken,
+        accessTokenExpiresIn: token.expiresIn,
+        refreshTokenExpiresIn: token.refreshTokenExpiresIn,
+        accessTokenExpiresAt: issuedAt + token.expiresIn,
+        refreshTokenExpiresAt: issuedAt + token.refreshTokenExpiresIn,
+        scopes: token.scope?.split(' ').filter(Boolean) ?? [],
+      };
+    }),
+  issueAccessTokenWithCodeWeb: ({ clientSecret, code, codeVerifier, redirectUri }) =>
     kRunWebAPI(async () => {
       const res = await kFetchFormUrlEncoded<{
         token_type: string;
@@ -64,8 +135,9 @@ const KakaoUser: KakaoUserAPI = {
         body: filterNonNullishKeys({
           grant_type: 'authorization_code',
           client_id: kGlobalStorage.restApiKey,
-          redirect_uri: encodeURIComponent(redirectUri),
+          redirect_uri: redirectUri,
           code,
+          code_verifier: codeVerifier,
           client_secret: clientSecret,
         }),
       }).then((r) => r.body);
@@ -73,32 +145,49 @@ 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(() => {
       const { loginHint, nonce, prompt, redirectUri, scope, state, throughTalk, serviceTerms } =
         params?.web ?? {};
+      const channelPublicIds = params?.channelPublicIds;
 
       return Kakao.Auth.authorize(
         filterNonNullishKeys({
-          loginHint,
+          loginHint: params?.loginHint ?? loginHint,
+          channelPublicId: channelPublicIds?.length ? channelPublicIds.join(',') : undefined,
           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()),
+  signup: ({ properties } = {}) =>
+    kRunWebAPI(async () => {
+      await Kakao.API.request({
+        url: '/v1/user/signup',
+        data: filterNonNullishKeys({ properties }),
+      });
+    }),
+  logout: () =>
+    kRunWebAPI(async () => {
+      try {
+        await Kakao.Auth.logout();
+      } finally {
+        kGlobalStorage.clearAccessToken();
+      }
+    }),
   isLogined: async (): Promise<boolean> => {
     try {
       const { appId } = await KakaoUser.getAccessToken();
@@ -109,81 +198,214 @@ 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,
-    ),
-  me: () =>
+      });
+    }),
+  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 () => {
-      const ret: any = camelCaseObject(await Kakao.API.request({ url: '/v2/user/me' }));
+      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;
+      }
+    }),
+  updateProfile: ({ properties }) =>
+    kRunWebAPI(async () => {
+      await Kakao.API.request({ url: '/v1/user/update_profile', data: { properties } });
+    }),
+  me: ({ secureResource = true } = {}) =>
+    kRunWebAPI(async () => {
+      const ret = camelCaseObject(
+        await Kakao.API.request({ url: '/v2/user/me', data: { secure_resource: secureResource } }),
+      ) as {
+        id: number;
+        hasSignedUp?: boolean | null;
+        forPartner?: { uuid?: string };
+        groupUserToken?: string;
+        connectedAt?: string;
+        synchedAt?: string;
+        kakaoAccount?: Partial<KakaoUserProfile> & {
+          profile?: Partial<
+            Pick<
+              KakaoUserProfile,
+              'nickname' | 'profileImageUrl' | 'thumbnailImageUrl' | 'isDefaultImage'
+            >
+          >;
+        };
+        properties?: { nickname?: string; profileImage?: string; thumbnailImage?: string };
+      };
       const kakaoAccount = ret.kakaoAccount ?? {};
       const properties = ret.properties ?? {};
+      const profile = kakaoAccount.profile ?? {};
+      const legalGender = kakaoAccount.legalGender;
 
       return {
-        ...ret,
-        ...properties,
-        ...kakaoAccount,
+        id: ret.id,
+        hasSignedUp: ret.hasSignedUp ?? null,
+        uuid: ret.forPartner?.uuid ?? null,
+        groupUserToken: ret.groupUserToken ?? null,
+        isDefaultImage: profile.isDefaultImage ?? null,
+        isLeapMonth: kakaoAccount.isLeapMonth ?? null,
+        legalName: kakaoAccount.legalName ?? null,
+        legalNameNeedsAgreement: kakaoAccount.legalNameNeedsAgreement ?? null,
+        legalBirthDate: kakaoAccount.legalBirthDate ?? null,
+        legalBirthDateNeedsAgreement: kakaoAccount.legalBirthDateNeedsAgreement,
+        legalGender: legalGender === 'female' || legalGender === 'male' ? legalGender : null,
+        legalGenderNeedsAgreement: kakaoAccount.legalGenderNeedsAgreement ?? null,
         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,
         connectedAt: isoToUnix(ret.connectedAt),
         synchedAt: isoToUnix(ret.synchedAt),
-      } as KakaoUser;
+      } as KakaoUserProfile;
     }),
 };
 
 export const {
+  loginWithKakao,
+  refreshToken,
+  issueAccessTokenWithCode,
   isKakaoTalkLoginAvailable,
   isLogined,
+  hasToken,
   login,
+  signup,
   logout,
   me,
+  updateProfile,
   revokeScopes,
   scopes,
   serviceTerms,
+  revokeServiceTerms,
   shippingAddresses,
+  selectShippingAddress,
   unlink,
   setAccessTokenWeb,
   issueAccessTokenWithCodeWeb,

package/src/spec/NativeKakaoUser.ts

@@ -1,9 +1,11 @@
 import type { TurboModule } from 'react-native';
 import { TurboModuleRegistry } from 'react-native';
+import type { UnsafeObject } from 'react-native/Libraries/Types/CodegenTypes';
 
 import type {
   KakaoAccessTokenInfo,
   KakaoLoginToken,
+  KakaoRevokedServiceTerms,
   KakaoScopeInfo,
   KakaoServiceTerms,
   KakaoShippingAddressResult,
@@ -18,15 +20,43 @@ export interface Spec extends TurboModule {
     useKakaoAccountLogin: boolean,
     scopes?: string[],
     nonce?: string,
+    loginHint?: string,
+    channelPublicIds?: string[],
+    androidRequestCode?: number,
   ): Promise<KakaoLoginToken>;
+  loginWithKakao(
+    uiMode: string,
+    orientation: string,
+    launchMethod: string,
+    prompts: string[],
+    loginHint?: string,
+    nonce?: string,
+    channelPublicIds?: string[],
+    serviceTerms?: string[],
+  ): Promise<KakaoLoginToken>;
+  issueAccessTokenWithCode(
+    code: string,
+    codeVerifier?: string,
+    redirectUri?: string,
+  ): Promise<KakaoLoginToken>;
+  refreshToken(token?: UnsafeObject, iosLoggingEnabled?: boolean): Promise<KakaoLoginToken>;
+  signup(properties?: UnsafeObject): Promise<void>;
   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>;
-  me(): Promise<KakaoUser>;
+  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(secureResource?: boolean): Promise<KakaoUser>;
+  updateProfile(properties: UnsafeObject): Promise<void>;
   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',
+  );
+}