@react-native-kakao/user 3.1.0 → 3.2.0

package/src/index.web.ts

@@ -1,19 +1,31 @@
 import { camelCaseObject, filterNonNullishKeys, is } from '@mj-studio/js-util';
-import { kFetchFormUrlEncoded, kGlobalStorage, kRunWebAPI } from '@react-native-kakao/core';
+import {
+  kAssert,
+  kCreateWebError,
+  kFetch,
+  kFetchFormUrlEncoded,
+  kGlobalStorage,
+  kRunWebAPI,
+} from '@react-native-kakao/core';
 
 import {
   type KakaoLoginToken,
   type KakaoScopeInfo,
+  type KakaoServiceTerms,
   type KakaoShippingAddressResult,
   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 };
 };
@@ -27,6 +39,22 @@ 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 }: { id: number; expires_in: number; app_id: number } =
@@ -38,7 +66,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;
@@ -55,6 +138,7 @@ const KakaoUser: KakaoUserAPI = {
           client_id: kGlobalStorage.restApiKey,
           redirect_uri: redirectUri,
           code,
+          code_verifier: codeVerifier,
           client_secret: clientSecret,
         }),
       }).then((r) => r.body);
@@ -69,10 +153,12 @@ const KakaoUser: KakaoUserAPI = {
     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 ??
@@ -88,6 +174,13 @@ const KakaoUser: KakaoUserAPI = {
         }),
       );
     }),
+  signup: ({ properties } = {}) =>
+    kRunWebAPI(async () => {
+      await Kakao.API.request({
+        url: '/v1/user/signup',
+        data: filterNonNullishKeys({ properties }),
+      });
+    }),
   logout: () =>
     kRunWebAPI(async () => {
       try {
@@ -119,42 +212,78 @@ const KakaoUser: KakaoUserAPI = {
         data: scopes?.length ? { scopes } : undefined,
       });
 
-      return camelCaseObject(response.scopes) as KakaoScopeInfo[];
+      return camelCaseObject(response.scopes ?? []) as KakaoScopeInfo[];
     }),
-  revokeScopes: (scopes: string[]) =>
+  revokeScopes: async (scopes: string[]) => {
+    await revokeScopesWithResult(scopes);
+  },
+  revokeScopesWithResult,
+  serviceTerms: ({ result, tags } = {}) =>
     kRunWebAPI(async () => {
-      await Kakao.API.request({
-        url: '/v2/user/revoke/scopes',
-        data: {
-          scopes,
-        },
+      const response: {
+        service_terms?:
+          | {
+              tag: string;
+              agreed_at?: string | null;
+              agreed: boolean;
+              required: boolean;
+              revocable: boolean;
+              agreed_by?: string | null;
+            }[]
+          | null;
+      } = await Kakao.API.request({
+        url: '/v2/user/service_terms',
+        data: filterNonNullishKeys({ result, tags: tags?.join(',') }),
       });
+
+      return (response.service_terms ?? []).map(
+        (term): KakaoServiceTerms =>
+          filterNonNullishKeys({
+            tag: term.tag,
+            agreedAt: term.agreed_at ? isoToUnix(term.agreed_at) : undefined,
+            agreed: term.agreed,
+            required: term.required,
+            revocable: term.revocable,
+            agreedBy:
+              term.agreed_by == null
+                ? undefined
+                : term.agreed_by === 'KAUTH' || term.agreed_by === 'KAPI'
+                  ? term.agreed_by
+                  : 'unknown',
+          }),
+      );
     }),
-  serviceTerms: () =>
+  revokeServiceTerms: (tags) =>
     kRunWebAPI(async () => {
       const response: {
-        service_terms?: {
-          tag: string;
-          agreed_at?: string;
-          agreed: boolean;
-          required: boolean;
-          revocable: boolean;
-        }[];
-      } = await Kakao.API.request({ url: '/v2/user/service_terms' });
-
-      return (response.service_terms ?? []).map((term) => ({
-        tag: term.tag,
-        agreedAt: isoToUnix(term.agreed_at),
-        agreed: term.agreed,
-        required: term.required,
-        revocable: term.revocable,
-      }));
-    }),
-  shippingAddresses: () =>
+        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 response = camelCaseObject(
-        await Kakao.API.request({ url: '/v1/user/shipping_address' }),
-      ) as {
+      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<
@@ -172,17 +301,52 @@ const KakaoUser: KakaoUserAPI = {
           ...address,
           updatedAt: isoToUnix(address.updatedAt),
         })),
-      } as KakaoShippingAddressResult;
+      };
     }),
-  me: () =>
+  selectShippingAddress: () =>
     kRunWebAPI(async () => {
-      const ret = camelCaseObject(await Kakao.API.request({ url: '/v2/user/me' })) as {
+      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: ({ propertyKeys, secureResource = true } = {}) =>
+    kRunWebAPI(async () => {
+      const response: { properties?: Record<string, string> } = await Kakao.API.request({
+        url: '/v2/user/me',
+        data: filterNonNullishKeys({
+          property_keys: propertyKeys,
+          secure_resource: secureResource,
+        }),
+      });
+
+      const ret = camelCaseObject(response) 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'>
+            Pick<
+              KakaoUserProfile,
+              'nickname' | 'profileImageUrl' | 'thumbnailImageUrl' | 'isDefaultImage'
+            >
           >;
         };
         properties?: { nickname?: string; profileImage?: string; thumbnailImage?: string };
@@ -190,9 +354,22 @@ const KakaoUser: KakaoUserAPI = {
       const kakaoAccount = ret.kakaoAccount ?? {};
       const properties = ret.properties ?? {};
       const profile = kakaoAccount.profile ?? {};
+      const legalGender = kakaoAccount.legalGender;
 
       return {
         id: ret.id,
+        properties: response.properties ?? {},
+        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: kakaoAccount.name,
         nickname: profile.nickname ?? properties.nickname,
@@ -218,23 +395,41 @@ const KakaoUser: KakaoUserAPI = {
         nameNeedsAgreement: kakaoAccount.nameNeedsAgreement,
         profileImageNeedsAgreement: kakaoAccount.profileImageNeedsAgreement,
         profileNicknameNeedsAgreement: kakaoAccount.profileNicknameNeedsAgreement,
-        legalBirthDateNeedsAgreement: kakaoAccount.legalBirthDateNeedsAgreement,
         connectedAt: isoToUnix(ret.connectedAt),
         synchedAt: isoToUnix(ret.synchedAt),
       } as KakaoUserProfile;
     }),
 };
 
+export function revokeScopesWithResult(scopes: string[]): Promise<KakaoScopeInfo[]> {
+  return kRunWebAPI(async () => {
+    const response = await Kakao.API.request({
+      url: '/v2/user/revoke/scopes',
+      data: { scopes },
+    });
+
+    return camelCaseObject(response.scopes ?? []) as KakaoScopeInfo[];
+  });
+}
+
 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,
@@ -16,17 +18,46 @@ export interface Spec extends TurboModule {
     serviceTerms: string[],
     prompts: string[],
     useKakaoAccountLogin: boolean,
+    iosLaunchMethod: string,
     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>;
+  revokeScopes(scopes: string[]): Promise<KakaoScopeInfo[]>;
+  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(propertyKeys?: string[], 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',
+  );
+}