better-auth 1.2.6-beta.7 → 1.2.7-beta.1

package/dist/shared/{better-auth.D4jH-sJA.mjs → better-auth.CWwVo_61.mjs}

@@ -4,7 +4,8 @@ import { createMiddleware, createEndpoint, APIError } from 'better-call';
 import { SocialProviderListEnum, socialProviderList } from '../social-providers/index.mjs';
 import '@better-auth/utils/random';
 import { g as generateState, p as parseState } from './better-auth.BdyOG_p4.mjs';
-import { a as logger } from './better-auth.DH3YjMQH.mjs';
+import { l as logger } from './better-auth.Cqykj82J.mjs';
+import { s as safeJSONParse } from './better-auth.tB5eU6EY.mjs';
 import { g as getDate } from './better-auth.CW6D9eSx.mjs';
 import { g as generateId } from './better-auth.BUPPRXfK.mjs';
 import '@better-auth/utils/hash';
@@ -18,7 +19,7 @@ import '@better-auth/utils';
 import '@better-auth/utils/hex';
 import '@noble/hashes/utils';
 import { g as generateRandomString } from './better-auth.B4Qoxdgc.mjs';
-import { f as parseUserInput } from './better-auth.CepcSj5H.mjs';
+import { f as parseUserInput } from './better-auth.Cc72UxUH.mjs';
 import { b as isDevelopment } from './better-auth.8zoxzg-F.mjs';
 import { createHMAC } from '@better-auth/utils/hmac';
 import '@better-fetch/fetch';
@@ -26,7 +27,6 @@ import 'defu';
 import { s as signJWT } from './better-auth.DDEbWX-S.mjs';
 import { b as getHost, c as getProtocol, g as getOrigin } from './better-auth.VTXNLFMT.mjs';
 import { JWTExpired } from 'jose/errors';
-import { s as safeJSONParse } from './better-auth.tB5eU6EY.mjs';
 import { binary } from '@better-auth/utils/binary';
 
 const optionsMiddleware = createMiddleware(async () => {
@@ -321,14 +321,13 @@ const getSession = () => createAuthEndpoint(
                   type: "object",
                   properties: {
                     session: {
-                      type: "object",
                       $ref: "#/components/schemas/Session"
                     },
                     user: {
-                      type: "object",
                       $ref: "#/components/schemas/User"
                     }
-                  }
+                  },
+                  required: ["session", "user"]
                 }
               }
             }
@@ -404,7 +403,7 @@ const getSession = () => createAuthEndpoint(
       const updateAge = ctx.context.sessionConfig.updateAge;
       const sessionIsDueToBeUpdatedDate = session.session.expiresAt.valueOf() - expiresIn * 1e3 + updateAge * 1e3;
       const shouldBeUpdated = sessionIsDueToBeUpdatedDate <= Date.now();
-      if (shouldBeUpdated) {
+      if (shouldBeUpdated && (!ctx.query?.disableRefresh || !ctx.context.options.session?.disableSessionRefresh)) {
         const updatedSession = await ctx.context.internalAdapter.updateSession(
           session.session.token,
           {
@@ -521,18 +520,7 @@ const listSessions = () => createAuthEndpoint(
                 schema: {
                   type: "array",
                   items: {
-                    type: "object",
-                    properties: {
-                      token: {
-                        type: "string"
-                      },
-                      userId: {
-                        type: "string"
-                      },
-                      expiresAt: {
-                        type: "string"
-                      }
-                    }
+                    $ref: "#/components/schemas/Session"
                   }
                 }
               }
@@ -580,13 +568,33 @@ const revokeSession = createAuthEndpoint(
                 type: "object",
                 properties: {
                   token: {
-                    type: "string"
+                    type: "string",
+                    description: "The token to revoke"
                   }
                 },
                 required: ["token"]
               }
             }
           }
+        },
+        responses: {
+          "200": {
+            description: "Success",
+            content: {
+              "application/json": {
+                schema: {
+                  type: "object",
+                  properties: {
+                    status: {
+                      type: "boolean",
+                      description: "Indicates if the session was revoked successfully"
+                    }
+                  },
+                  required: ["status"]
+                }
+              }
+            }
+          }
         }
       }
     }
@@ -634,7 +642,8 @@ const revokeSessions = createAuthEndpoint(
                   type: "object",
                   properties: {
                     status: {
-                      type: "boolean"
+                      type: "boolean",
+                      description: "Indicates if all sessions were revoked successfully"
                     }
                   },
                   required: ["status"]
@@ -681,9 +690,11 @@ const revokeOtherSessions = createAuthEndpoint(
                   type: "object",
                   properties: {
                     status: {
-                      type: "boolean"
+                      type: "boolean",
+                      description: "Indicates if all other sessions were revoked successfully"
                     }
-                  }
+                  },
+                  required: ["status"]
                 }
               }
             }
@@ -774,11 +785,14 @@ const sendVerificationEmail = createAuthEndpoint(
                 properties: {
                   email: {
                     type: "string",
-                    description: "The email to send the verification email to"
+                    description: "The email to send the verification email to",
+                    example: "user@example.com"
                   },
                   callbackURL: {
                     type: "string",
-                    description: "The URL to use for email verification callback"
+                    description: "The URL to use for email verification callback",
+                    example: "https://example.com/callback",
+                    nullable: true
                   }
                 },
                 required: ["email"]
@@ -795,7 +809,26 @@ const sendVerificationEmail = createAuthEndpoint(
                   type: "object",
                   properties: {
                     status: {
-                      type: "boolean"
+                      type: "boolean",
+                      description: "Indicates if the email was sent successfully",
+                      example: true
+                    }
+                  }
+                }
+              }
+            }
+          },
+          "400": {
+            description: "Bad Request",
+            content: {
+              "application/json": {
+                schema: {
+                  type: "object",
+                  properties: {
+                    message: {
+                      type: "string",
+                      description: "Error message",
+                      example: "Verification email isn't enabled"
                     }
                   }
                 }
@@ -842,6 +875,26 @@ const verifyEmail = createAuthEndpoint(
     metadata: {
       openapi: {
         description: "Verify the email of the user",
+        parameters: [
+          {
+            name: "token",
+            in: "query",
+            description: "The token to verify the email",
+            required: true,
+            schema: {
+              type: "string"
+            }
+          },
+          {
+            name: "callbackURL",
+            in: "query",
+            description: "The URL to redirect to after email verification",
+            required: false,
+            schema: {
+              type: "string"
+            }
+          }
+        ],
         responses: {
           "200": {
             description: "Success",
@@ -852,13 +905,52 @@ const verifyEmail = createAuthEndpoint(
                   properties: {
                     user: {
                       type: "object",
-                      ref: "#/components/schemas/User"
+                      properties: {
+                        id: {
+                          type: "string",
+                          description: "User ID"
+                        },
+                        email: {
+                          type: "string",
+                          description: "User email"
+                        },
+                        name: {
+                          type: "string",
+                          description: "User name"
+                        },
+                        image: {
+                          type: "string",
+                          description: "User image URL"
+                        },
+                        emailVerified: {
+                          type: "boolean",
+                          description: "Indicates if the user email is verified"
+                        },
+                        createdAt: {
+                          type: "string",
+                          description: "User creation date"
+                        },
+                        updatedAt: {
+                          type: "string",
+                          description: "User update date"
+                        }
+                      },
+                      required: [
+                        "id",
+                        "email",
+                        "name",
+                        "image",
+                        "emailVerified",
+                        "createdAt",
+                        "updatedAt"
+                      ]
                     },
                     status: {
-                      type: "boolean"
-                    }
-                  },
-                  required: ["user", "status"]
+                      type: "boolean",
+                      description: "Indicates if the email was verified successfully"
+                    },
+                    required: ["user", "status"]
+                  }
                 }
               }
             }
@@ -980,7 +1072,7 @@ const verifyEmail = createAuthEndpoint(
       if (!currentSession || currentSession.user.email !== parsed.email) {
         const session = await ctx.context.internalAdapter.createSession(
           user.user.id,
-          ctx.request
+          ctx.headers
         );
         if (!session) {
           throw new APIError("INTERNAL_SERVER_ERROR", {
@@ -1018,7 +1110,8 @@ async function handleOAuthUserInfo(c, {
   userInfo,
   account,
   callbackURL,
-  disableSignUp
+  disableSignUp,
+  overrideUserInfo
 }) {
   const dbUser = await c.context.internalAdapter.findOAuthUser(
     userInfo.email.toLowerCase(),
@@ -1096,6 +1189,13 @@ async function handleOAuthUserInfo(c, {
         );
       }
     }
+    if (overrideUserInfo) {
+      await c.context.internalAdapter.updateUser(dbUser.user.id, {
+        ...userInfo,
+        email: userInfo.email.toLowerCase(),
+        emailVerified: userInfo.email.toLocaleLowerCase() === dbUser.user.email ? dbUser.user.emailVerified || userInfo.emailVerified : userInfo.emailVerified
+      });
+    }
   } else {
     if (disableSignUp) {
       return {
@@ -1105,11 +1205,11 @@ async function handleOAuthUserInfo(c, {
       };
     }
     try {
+      const { id: _, ...restUserInfo } = userInfo;
       user = await c.context.internalAdapter.createOAuthUser(
         {
-          ...userInfo,
-          email: userInfo.email.toLowerCase(),
-          id: void 0
+          ...restUserInfo,
+          email: userInfo.email.toLowerCase()
         },
         {
           accessToken: account.accessToken,
@@ -1165,7 +1265,7 @@ async function handleOAuthUserInfo(c, {
   }
   const session = await c.context.internalAdapter.createSession(
     user.id,
-    c.request
+    c.headers
   );
   if (!session) {
     return {
@@ -1295,29 +1395,64 @@ const signInSocial = createAuthEndpoint(
     metadata: {
       openapi: {
         description: "Sign in with a social provider",
+        operationId: "socialSignIn",
         responses: {
           "200": {
-            description: "Success",
+            description: "Success - Returns either session details or redirect URL",
             content: {
               "application/json": {
                 schema: {
+                  // todo: we need support for multiple schema
                   type: "object",
+                  description: "Session response when idToken is provided",
                   properties: {
-                    token: {
-                      type: "string"
-                    },
-                    user: {
-                      type: "object",
-                      ref: "#/components/schemas/User"
+                    redirect: {
+                      type: "boolean",
+                      enum: [false]
                     },
-                    url: {
-                      type: "string"
+                    token: {
+                      type: "string",
+                      description: "Session token",
+                      url: {
+                        type: "null",
+                        nullable: true
+                      },
+                      user: {
+                        type: "object",
+                        properties: {
+                          id: { type: "string" },
+                          email: { type: "string" },
+                          name: {
+                            type: "string",
+                            nullable: true
+                          },
+                          image: {
+                            type: "string",
+                            nullable: true
+                          },
+                          emailVerified: {
+                            type: "boolean"
+                          },
+                          createdAt: {
+                            type: "string",
+                            format: "date-time"
+                          },
+                          updatedAt: {
+                            type: "string",
+                            format: "date-time"
+                          }
+                        },
+                        required: [
+                          "id",
+                          "email",
+                          "emailVerified",
+                          "createdAt",
+                          "updatedAt"
+                        ]
+                      }
                     },
-                    redirect: {
-                      type: "boolean"
-                    }
-                  },
-                  required: ["redirect"]
+                    required: ["redirect", "token", "user"]
+                  }
                 }
               }
             }
@@ -1376,7 +1511,14 @@ const signInSocial = createAuthEndpoint(
           message: BASE_ERROR_CODES.FAILED_TO_GET_USER_INFO
         });
       }
-      if (!userInfo.user.email) {
+      const mapProfileToUser = await provider.options?.mapProfileToUser?.(
+        userInfo.user
+      );
+      const userData = {
+        ...userInfo.user,
+        ...mapProfileToUser
+      };
+      if (!userData.email) {
         c.context.logger.error("User email not found", {
           provider: c.body.provider
         });
@@ -1386,11 +1528,12 @@ const signInSocial = createAuthEndpoint(
       }
       const data = await handleOAuthUserInfo(c, {
         userInfo: {
-          email: userInfo.user.email,
-          id: userInfo.user.id,
-          name: userInfo.user.name || "",
-          image: userInfo.user.image,
-          emailVerified: userInfo.user.emailVerified || false
+          ...userData,
+          email: userData.email,
+          id: userData.id,
+          name: userData.name || "",
+          image: userData.image,
+          emailVerified: userData.emailVerified || false
         },
         account: {
           providerId: provider.id,
@@ -1471,27 +1614,61 @@ const signInEmail = createAuthEndpoint(
         description: "Sign in with email and password",
         responses: {
           "200": {
-            description: "Success",
+            description: "Success - Returns either session details or redirect URL",
             content: {
               "application/json": {
                 schema: {
+                  // todo: we need support for multiple schema
                   type: "object",
+                  description: "Session response when idToken is provided",
                   properties: {
-                    token: {
-                      type: "string"
+                    redirect: {
+                      type: "boolean",
+                      enum: [false]
                     },
-                    user: {
-                      type: "object",
-                      ref: "#/components/schemas/User"
+                    token: {
+                      type: "string",
+                      description: "Session token"
                     },
                     url: {
-                      type: "string"
+                      type: "null",
+                      nullable: true
                     },
-                    redirect: {
-                      type: "boolean"
+                    user: {
+                      type: "object",
+                      properties: {
+                        id: { type: "string" },
+                        email: { type: "string" },
+                        name: {
+                          type: "string",
+                          nullable: true
+                        },
+                        image: {
+                          type: "string",
+                          nullable: true
+                        },
+                        emailVerified: {
+                          type: "boolean"
+                        },
+                        createdAt: {
+                          type: "string",
+                          format: "date-time"
+                        },
+                        updatedAt: {
+                          type: "string",
+                          format: "date-time"
+                        }
+                      },
+                      required: [
+                        "id",
+                        "email",
+                        "emailVerified",
+                        "createdAt",
+                        "updatedAt"
+                      ]
                     }
                   },
-                  required: ["token", "user", "redirect"]
+                  required: ["redirect", "token", "user"]
                 }
               }
             }
@@ -1618,7 +1795,8 @@ const schema = z.object({
   error: z.string().optional(),
   device_id: z.string().optional(),
   error_description: z.string().optional(),
-  state: z.string().optional()
+  state: z.string().optional(),
+  user: z.string().optional()
 });
 const callbackOAuth = createAuthEndpoint(
   "/callback/:id",
@@ -1697,7 +1875,10 @@ const callbackOAuth = createAuthEndpoint(
       c.context.logger.error("", e);
       throw redirectOnError("invalid_code");
     }
-    const userInfo = await provider.getUserInfo(tokens).then((res) => res?.user);
+    const userInfo = await provider.getUserInfo({
+      ...tokens,
+      user: c.body?.user ? safeJSONParse(c.body.user) : void 0
+    }).then((res) => res?.user);
     if (!userInfo) {
       c.context.logger.error("Unable to get user info");
       return redirectOnError("unable_to_get_user_info");
@@ -1720,19 +1901,34 @@ const callbackOAuth = createAuthEndpoint(
         if (existingAccount.userId.toString() !== link.userId.toString()) {
           return redirectOnError("account_already_linked_to_different_user");
         }
-      }
-      const newAccount = await c.context.internalAdapter.createAccount(
-        {
-          userId: link.userId,
-          providerId: provider.id,
-          accountId: userInfo.id,
-          ...tokens,
-          scope: tokens.scopes?.join(",")
-        },
-        c
-      );
-      if (!newAccount) {
-        return redirectOnError("unable_to_link_account");
+        const updateData = Object.fromEntries(
+          Object.entries({
+            accessToken: tokens.accessToken,
+            idToken: tokens.idToken,
+            refreshToken: tokens.refreshToken,
+            accessTokenExpiresAt: tokens.accessTokenExpiresAt,
+            refreshTokenExpiresAt: tokens.refreshTokenExpiresAt,
+            scope: tokens.scopes?.join(",")
+          }).filter(([_, value]) => value !== void 0)
+        );
+        await c.context.internalAdapter.updateAccount(
+          existingAccount.id,
+          updateData
+        );
+      } else {
+        const newAccount = await c.context.internalAdapter.createAccount(
+          {
+            userId: link.userId,
+            providerId: provider.id,
+            accountId: userInfo.id,
+            ...tokens,
+            scope: tokens.scopes?.join(",")
+          },
+          c
+        );
+        if (!newAccount) {
+          return redirectOnError("unable_to_link_account");
+        }
       }
       let toRedirectTo2;
       try {
@@ -2114,9 +2310,9 @@ const updateUser = () => createAuthEndpoint(
                 schema: {
                   type: "object",
                   properties: {
-                    user: {
-                      type: "object",
-                      ref: "#/components/schemas/User"
+                    status: {
+                      type: "boolean",
+                      description: "Indicates if the update was successful"
                     }
                   }
                 }
@@ -2195,17 +2391,66 @@ const changePassword = createAuthEndpoint(
         description: "Change the password of the user",
         responses: {
           "200": {
-            description: "Success",
+            description: "Password successfully changed",
             content: {
               "application/json": {
                 schema: {
                   type: "object",
                   properties: {
+                    token: {
+                      type: "string",
+                      nullable: true,
+                      // Only present if revokeOtherSessions is true
+                      description: "New session token if other sessions were revoked"
+                    },
                     user: {
-                      description: "The user object",
-                      $ref: "#/components/schemas/User"
+                      type: "object",
+                      properties: {
+                        id: {
+                          type: "string",
+                          description: "The unique identifier of the user"
+                        },
+                        email: {
+                          type: "string",
+                          format: "email",
+                          description: "The email address of the user"
+                        },
+                        name: {
+                          type: "string",
+                          description: "The name of the user"
+                        },
+                        image: {
+                          type: "string",
+                          format: "uri",
+                          nullable: true,
+                          description: "The profile image URL of the user"
+                        },
+                        emailVerified: {
+                          type: "boolean",
+                          description: "Whether the email has been verified"
+                        },
+                        createdAt: {
+                          type: "string",
+                          format: "date-time",
+                          description: "When the user was created"
+                        },
+                        updatedAt: {
+                          type: "string",
+                          format: "date-time",
+                          description: "When the user was last updated"
+                        }
+                      },
+                      required: [
+                        "id",
+                        "email",
+                        "name",
+                        "emailVerified",
+                        "createdAt",
+                        "updatedAt"
+                      ]
                     }
-                  }
+                  },
+                  required: ["user"]
                 }
               }
             }
@@ -2371,11 +2616,23 @@ const deleteUser = createAuthEndpoint(
         description: "Delete the user",
         responses: {
           "200": {
-            description: "Success",
+            description: "User deletion processed successfully",
             content: {
               "application/json": {
                 schema: {
-                  type: "object"
+                  type: "object",
+                  properties: {
+                    success: {
+                      type: "boolean",
+                      description: "Indicates if the operation was successful"
+                    },
+                    message: {
+                      type: "string",
+                      enum: ["User deleted", "Verification email sent"],
+                      description: "Status message of the deletion process"
+                    }
+                  },
+                  required: ["success", "message"]
                 }
               }
             }
@@ -2445,7 +2702,9 @@ const deleteUser = createAuthEndpoint(
       await ctx.context.internalAdapter.createVerificationValue({
         value: session.user.id,
         identifier: `delete-account-${token}`,
-        expiresAt: new Date(Date.now() + 1e3 * 60 * 60 * 24)
+        expiresAt: new Date(
+          Date.now() + (ctx.context.options.user.deleteUser?.deleteTokenExpiresIn || 60 * 60 * 24) * 1e3
+        )
       });
       const url = `${ctx.context.baseURL}/delete-user/callback?token=${token}&callbackURL=${ctx.body.callbackURL || "/"}`;
       await ctx.context.options.user.deleteUser.sendDeleteAccountVerification(
@@ -2487,7 +2746,36 @@ const deleteUserCallback = createAuthEndpoint(
       token: z.string(),
       callbackURL: z.string().optional()
     }),
-    use: [originCheck((ctx) => ctx.query.callbackURL)]
+    use: [originCheck((ctx) => ctx.query.callbackURL)],
+    metadata: {
+      openapi: {
+        description: "Callback to complete user deletion with verification token",
+        responses: {
+          "200": {
+            description: "User successfully deleted",
+            content: {
+              "application/json": {
+                schema: {
+                  type: "object",
+                  properties: {
+                    success: {
+                      type: "boolean",
+                      description: "Indicates if the deletion was successful"
+                    },
+                    message: {
+                      type: "string",
+                      enum: ["User deleted"],
+                      description: "Confirmation message"
+                    }
+                  },
+                  required: ["success", "message"]
+                }
+              }
+            }
+          }
+        }
+      }
+    }
   },
   async (ctx) => {
     if (!ctx.context.options.user?.deleteUser?.enabled) {
@@ -2554,20 +2842,24 @@ const changeEmail = createAuthEndpoint(
       openapi: {
         responses: {
           "200": {
-            description: "Success",
+            description: "Email change request processed successfully",
             content: {
               "application/json": {
                 schema: {
                   type: "object",
                   properties: {
-                    user: {
-                      type: "object",
-                      ref: "#/components/schemas/User"
-                    },
                     status: {
-                      type: "boolean"
+                      type: "boolean",
+                      description: "Indicates if the request was successful"
+                    },
+                    message: {
+                      type: "string",
+                      enum: ["Email updated", "Verification email sent"],
+                      description: "Status message of the email change process",
+                      nullable: true
                     }
-                  }
+                  },
+                  required: ["status"]
                 }
               }
             }
@@ -2770,7 +3062,8 @@ const error = createAuthEndpoint(
             content: {
               "text/html": {
                 schema: {
-                  type: "string"
+                  type: "string",
+                  description: "The HTML content of the error page"
                 }
               }
             }
@@ -2799,16 +3092,18 @@ const ok = createAuthEndpoint(
         description: "Check if the API is working",
         responses: {
           "200": {
-            description: "Success",
+            description: "API is working",
             content: {
               "application/json": {
                 schema: {
                   type: "object",
                   properties: {
                     ok: {
-                      type: "boolean"
+                      type: "boolean",
+                      description: "Indicates if the API is working"
                     }
-                  }
+                  },
+                  required: ["ok"]
                 }
               }
             }
@@ -2849,20 +3144,32 @@ const listUserAccounts = createAuthEndpoint(
                         type: "string"
                       },
                       createdAt: {
-                        type: "string"
+                        type: "string",
+                        format: "date-time"
                       },
                       updatedAt: {
+                        type: "string",
+                        format: "date-time"
+                      }
+                    },
+                    accountId: {
+                      type: "string"
+                    },
+                    scopes: {
+                      type: "array",
+                      items: {
                         type: "string"
-                      },
-                      accountId: {
-                        type: "string"
-                      },
-                      scopes: {
-                        type: "array",
-                        items: { type: "string" }
                       }
                     }
-                  }
+                  },
+                  required: [
+                    "id",
+                    "provider",
+                    "createdAt",
+                    "updatedAt",
+                    "accountId",
+                    "scopes"
+                  ]
                 }
               }
             }
@@ -2905,7 +3212,15 @@ const linkSocialAccount = createAuthEndpoint(
        */
       provider: z.enum(socialProviderList, {
         description: "The OAuth2 provider to use"
-      })
+      }),
+      /**
+       * Additional scopes to request when linking the account.
+       * This is useful for requesting additional permissions when
+       * linking a social account compared to the initial authentication.
+       */
+      scopes: z.array(z.string(), {
+        description: "Additional scopes to request from the provider"
+      }).optional()
     }),
     use: [sessionMiddleware],
     metadata: {
@@ -2920,10 +3235,12 @@ const linkSocialAccount = createAuthEndpoint(
                   type: "object",
                   properties: {
                     url: {
-                      type: "string"
+                      type: "string",
+                      description: "The authorization URL to redirect the user to"
                     },
                     redirect: {
-                      type: "boolean"
+                      type: "boolean",
+                      description: "Indicates if the user should be redirected to the authorization URL"
                     }
                   },
                   required: ["url", "redirect"]
@@ -2958,7 +3275,8 @@ const linkSocialAccount = createAuthEndpoint(
     const url = await provider.createAuthorizationURL({
       state: state.state,
       codeVerifier: state.codeVerifier,
-      redirectURI: `${c.context.baseURL}/callback/${provider.id}`
+      redirectURI: `${c.context.baseURL}/callback/${provider.id}`,
+      scopes: c.body.scopes
     });
     return c.json({
       url: url.toString(),
@@ -2974,7 +3292,29 @@ const unlinkAccount = createAuthEndpoint(
       providerId: z.string(),
       accountId: z.string().optional()
     }),
-    use: [freshSessionMiddleware]
+    use: [freshSessionMiddleware],
+    metadata: {
+      openapi: {
+        description: "Unlink an account",
+        responses: {
+          "200": {
+            description: "Success",
+            content: {
+              "application/json": {
+                schema: {
+                  type: "object",
+                  properties: {
+                    status: {
+                      type: "boolean"
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    }
   },
   async (ctx) => {
     const { providerId, accountId } = ctx.body;