supabase/web/spec/supabase_js_v2_ref.yml

openref: 0.1

info:
  id: reference/supabase-js
  title: Supabase Client
  description: |

    Supabase JavaScript.

  definition: spec/tsdoc_v1/combined.json
  slugPrefix: '/'
  libraries:
    - name: 'JavaScript'
      id: 'js'
      version: '0.0.1'
  docs:
    path: sdk/
    sidebar:
      - name: 'Auth'
        items:
          - auth.signUp()
          - auth.signIn()
          - auth.signOut()
          - auth.session()
          - auth.user()
          - auth.update()
          - auth.setAuth()
          - auth.onAuthStateChange()
          - auth.api.getUser()
          - auth.api.resetPasswordForEmail()
      - name: 'Auth (Server Only)'
        items:
          - auth.api.listUsers()
          - auth.api.createUser()
          - auth.api.deleteUser()
          - auth.api.generateLink()
          - auth.api.inviteUserByEmail()
          - auth.api.sendMobileOTP()
          - auth.api.updateUserById()
      - name: 'Functions'
        items:
          - invoke()
      - name: 'Database'
        items:
          - select()
          - insert()
          - update()
          - upsert()
          - delete()
          - rpc()
      - name: 'Realtime'
        items:
          - subscribe()
          - removeSubscription()
          - removeAllSubscriptions()
          - getSubscriptions()
      - name: 'Storage'
        items:
          - storage.createBucket()
          - storage.getBucket()
          - storage.listBuckets()
          - storage.updateBucket()
          - storage.deleteBucket()
          - storage.emptyBucket()
          - storage.from.upload()
          - storage.from.download()
          - storage.from.list()
          - storage.from.update()
          - storage.from.move()
          - storage.from.copy()
          - storage.from.remove()
          - storage.from.createSignedUrl()
          - storage.from.createSignedUrls()
          - storage.from.getPublicUrl()
      - name: 'Modifiers'
        items:
          - Using Modifiers
          - limit()
          - order()
          - range()
          - single()
          - maybeSingle()
      - name: 'Filters'
        items:
          - Using Filters
          - .or()
          - .not()
          - .match()
          - .eq()
          - .neq()
          - .gt()
          - .gte()
          - .lt()
          - .lte()
          - .like()
          - .ilike()
          - .is()
          - .in()
          - .contains()
          - .containedBy()
          - .rangeLt()
          - .rangeGt()
          - .rangeGte()
          - .rangeLte()
          - .rangeAdjacent()
          - .overlaps()
          - .textSearch()
          - .filter()

pages:
  auth.signUp():
    title: 'signUp()'
    $ref: '@supabase/gotrue-js.GoTrueClient.signUp'
    notes: |
      - By default, the user will need to verify their email address before logging in. If you would like to change this, you can disable "Email Confirmations" by going to Authentication -> Settings on [app.supabase.com](https://app.supabase.com)
      - If "Email Confirmations" is turned on, a `user` is returned but `session` will be null
      - If "Email Confirmations" is turned off, both a `user` and a `session` will be returned
      - When the user confirms their email address, they will be redirected to localhost:3000 by default. To change this, you can go to Authentication -> Settings on [app.supabase.com](https://app.supabase.com)
      - If signUp() is called for an existing confirmed user:
          - If "Enable email confirmations" is enabled on the "Authentication" -> "Settings" page, an obfuscated / fake user object will be returned.
          - If "Enable email confirmations" is disabled, an error with a message "User already registered" will be returned.
      - To check if a user already exists, refer to getUser().
    examples:
      - name: Sign up.
        isSpotlight: true
        js: |
          ```js
          const { user, session, error } = await supabase.auth.signUp({
            email: 'example@email.com',
            password: 'example-password',
          })
          ```
      - name: Sign up with additional user meta data.
        isSpotlight: true
        js: |
          ```js
          const { user, session, error } = await supabase.auth.signUp(
            {
              email: 'example@email.com',
              password: 'example-password',
            },
            {
              data: { 
                first_name: 'John', 
                age: 27,
              }
            }
          )
          ```
      - name: Sign up with third-party providers.
        hideCodeBlock: true
        description: |
          You can sign up with OAuth providers using the [`signIn()`](/docs/reference/javascript/auth-signin#sign-in-using-third-party-providers) method.
      - name: Sign up with Phone.
        description: |
          Supabase supports Phone Auth. After a user has verified their number, they can use the [`signIn()`](/docs/reference/javascript/auth-signin#sign-in-using-phone) method.
        js: |
          ```js
          const { user, session, error } = await supabase.auth.signUp({
            phone: '+13334445555',
            password: 'some-password',
          })

          // After receiving an SMS with One Time Password.
          let { session, error } = await supabase.auth.verifyOTP({
            phone: '+13334445555',
            token: '123456',
          })
          ```

  auth.signIn():
    title: 'signIn()'
    $ref: '@supabase/gotrue-js.GoTrueClient.signIn'
    notes: |
      - A user can sign up either via email or OAuth.
      - If you provide `email` without a `password`, the user will be sent a magic link.
      - The magic link's destination URL is determined by the SITE_URL config variable. To change this, you can go to Authentication -> Settings on [app.supabase.com](https://app.supabase.com)
      - Specifying a `provider` will open the browser to the relevant login page.
    examples:
      - name: Sign in with email.
        isSpotlight: true
        js: |
          ```js
          const { user, session, error } = await supabase.auth.signIn({
            email: 'example@email.com',
            password: 'example-password',
          })
          ```
      - name: Sign in with magic link.
        description: If no password is provided, the user will be sent a "magic link" to their email address, which they can click to open your application with a valid session. By default, a given user can only request a Magic Link once every 60 seconds.
        js: |
          ```js
          const { user, session, error } = await supabase.auth.signIn({
            email: 'example@email.com'
          })
          ```
      - name: Sign in using third-party providers.
        description: Supabase supports many different [third-party providers](https://supabase.com/docs/guides/auth#providers).
        js: |
          ```js
          const { user, session, error } = await supabase.auth.signIn({
            // provider can be 'github', 'google', 'gitlab', and more
            provider: 'github'
          })
          ```
      - name: Sign in with Phone.
        description: Supabase supports Phone Auth.
        js: |
          ```js
          const { user, session, error } = await supabase.auth.signIn({
            phone: '+13334445555',
            password: 'some-password',
          })
          ```
      - name: Sign in with redirect.
        description: |
          Note that the `redirectTo` param is only relevant for OAuth logins, where the login flow is managed by 
          the Auth server. If you are using email/phone logins you should set up your own redirects (within the email/sms template).
           
          Sometimes you want to control where the user is redirected to after they are logged in. Supabase supports this for 
          any URL path on your website (the URL must either be on the same domain as your Site URL [see Auth>Settings in dashboard], or must match one of the Additional Redirect URLs [also in Auth>Settings]).
        js: |
          ```js
          const { user, session, error } = await supabase.auth.signIn({
            provider: 'github'
          }, {
            redirectTo: 'https://example.com/welcome'
          })
          ```
      - name: Sign in with scopes.
        description: |
          If you need additional data from an OAuth provider, you can include a space-separated list of scopes in your request to get back an OAuth provider token.
          You may also need to specify the scopes in the provider's OAuth app settings, depending on the provider.
        js: |
          ```js
          const { user, session, error } = await supabase.auth.signIn({
            provider: 'github'
          }, {
            scopes: 'repo gist notifications'
          })
          const oAuthToken = session.provider_token // use to access provider API
          ```
      - name: Sign in using a refresh token (e.g. in React Native).
        description: |
          If you are completing a sign up or login in a React Native app you can pass the refresh token obtained from the provider to obtain a session.
        js: |
          ```js
          // An example using Expo's `AuthSession`
          const redirectUri = AuthSession.makeRedirectUri({ useProxy: false });
          const provider = 'google';

          AuthSession.startAsync({
            authUrl: `https://MYSUPABASEAPP.supabase.co/auth/v1/authorize?provider=${provider}&redirect_to=${redirectUri}`,
            returnUrl: redirectUri,
          }).then(async (response: any) => {
            if (!response) return;
            const { user, session, error } = await supabase.auth.signIn({
              refreshToken: response.params?.refresh_token,
            });
          });
          ```

  auth.signOut():
    title: 'signOut()'
    $ref: '@supabase/gotrue-js.GoTrueClient.signOut'
    examples:
      - name: Sign out
        isSpotlight: true
        js: |
          ```js
          const { error } = await supabase.auth.signOut()
          ```

  auth.session():
    title: 'session()'
    $ref: '@supabase/gotrue-js.GoTrueClient.session'
    examples:
      - name: Get the session data
        isSpotlight: true
        js: |
          ```js
          const session = supabase.auth.session()
          ```

  auth.user():
    title: 'user()'
    $ref: '@supabase/gotrue-js.GoTrueClient.user'
    notes: |
      This method gets the user object from memory.
    examples:
      - name: Get the logged in user
        isSpotlight: true
        js: |
          ```js
          const user = supabase.auth.user()
          ```

  auth.update():
    title: 'update()'
    $ref: '@supabase/gotrue-js.GoTrueClient.update'
    notes: |
      User email: Email updates will send an email to both the user's current and new email with a confirmation link by default.
      To toggle this behavior off and only send a single confirmation link to the new email, toggle "Double confirm email changes" under "Authentication" -> "Settings" off.


      User metadata: It's generally better to store user data in a table inside your public schema (i.e. `public.users`). 
      Use the `update()` method if you have data which rarely changes or is specific only to the logged in user.
    examples:
      - name: Update email for authenticated user.
        description: Sends a "Confirm Email Change" email to the new email address.
        isSpotlight: true
        js: |
          ```js
          const { user, error } = await supabase.auth.update({email: 'new@email.com'})
          ```
      - name: Update password for authenticated user.
        isSpotlight: true
        js: |
          ```js
          const { user, error } = await supabase.auth.update({password: 'new password'})
          ```
      - name: Update a user's metadata.
        isSpotlight: true
        js: |
          ```js
          const { user, error } = await supabase.auth.update({ 
            data: { hello: 'world' } 
          })
          ```

  auth.setAuth():
    title: 'setAuth()'
    $ref: '@supabase/gotrue-js.GoTrueClient.setAuth'
    examples:
      - name: Basic example.
        description: This is most useful on server-side functions where you cannot log the user in, but have access to the user's access token.
        isSpotlight: true
        js: |
          ```js
          function apiFunction(req, res) {
            // Assuming the access token was sent as a header "X-Supabase-Auth"
            const { access_token } = req.get('X-Supabase-Auth') 

            // You can now use it within a Supabase Client 
            const supabase = createClient("https://xyzcompany.supabase.co", "public-anon-key")
            const { user, error } = supabase.auth.setAuth(access_token)

            // This client will now send requests as this user
            const { data } = await supabase.from('your_table').select()
          }
          ```
      - name: With Express.
        isSpotlight: true
        js: |
          ```js

          /**
          * Make a request from the client to your server function
          */
          async function makeApiRequest() {
            const token = newClient.session()?.access_token

            await fetch('https://example.com/withAuth', {
               method: 'GET',
               withCredentials: true,
               credentials: 'include',
               headers: {
                'Content-Type': 'application/json',
                'Authorization': bearer, // Your own auth
                'X-Supabase-Auth': token, // Set the Supabase user
               }
            })
          }

          /**
          * Use the Auth token in your server-side function.
          */
          async function apiFunction(req, res) {
            const { access_token } = req.get('X-Supabase-Auth') 

            // You can now use it within a Supabase Client 
            const supabase = createClient("https://xyzcompany.supabase.co", "public-anon-key")
            const { user, error } = supabase.auth.setAuth(access_token)

            // This client will now send requests as this user
            const { data } = await supabase.from('your_table').select()
          }
          ```

  auth.onAuthStateChange():
    title: 'onAuthStateChange()'
    $ref: '@supabase/gotrue-js.GoTrueClient.onAuthStateChange'
    examples:
      - name: Listen to auth changes
        isSpotlight: true
        js: |
          ```js
          supabase.auth.onAuthStateChange((event, session) => {
            console.log(event, session)
          })
          ```
      - name: Listen to sign in
        js: |
          ```js
          supabase.auth.onAuthStateChange((event, session) => {
            if (event == 'SIGNED_IN') console.log('SIGNED_IN', session)
          })
          ```
      - name: Listen to sign out
        js: |
          ```js
          supabase.auth.onAuthStateChange((event, session) => {
            if (event == 'SIGNED_OUT') console.log('SIGNED_OUT', session)
          })
          ```
      - name: Listen to token refresh
        js: |
          ```js
          supabase.auth.onAuthStateChange((event, session) => {
            if (event == 'TOKEN_REFRESHED') console.log('TOKEN_REFRESHED', session)
          })
          ```
      - name: Listen to user updates
        js: |
          ```js
          supabase.auth.onAuthStateChange((event, session) => {
            if (event == 'USER_UPDATED') console.log('USER_UPDATED', session)
          })
          ```
      - name: Listen to user deleted
        js: |
          ```js
          supabase.auth.onAuthStateChange((event, session) => {
            if (event == 'USER_DELETED') console.log('USER_DELETED', session)
          })
          ```
      - name: Listen to password recovery events
        js: |
          ```js
          supabase.auth.onAuthStateChange((event, session) => {
            if (event == 'PASSWORD_RECOVERY') console.log('PASSWORD_RECOVERY', session)
          })
          ```
  auth.api.getUser():
    title: 'getUser()'
    $ref: '@supabase/gotrue-js.GoTrueApi.getUser'
    notes: |
      - Fetches the user object from the database instead of local storage.
      - Note that user() fetches the user object from local storage which might not be the most updated.
      - Requires the user's access_token.
    examples:
      - name: Fetch the user object using the access_token jwt.
        isSpotlight: true
        js: |
          ```js
          const { user, error } = await supabase.auth.api.getUser(
            'ACCESS_TOKEN_JWT',
          )
          ```

  auth.api.listUsers():
    title: 'listUsers()'
    $ref: '@supabase/gotrue-js.GoTrueApi.listUsers'
    notes: |
      - Requires a `service_role` key.
      - This function should be called on a server. Never expose your `service_role` key in the browser.
    examples:
      - name: Get a full list of users.
        isSpotlight: true
        js: |
          ```js
          const { data: user, error } = await supabase.auth.api.listUsers()
          ```

  auth.api.createUser():
    title: 'createUser()'
    $ref: '@supabase/gotrue-js.GoTrueApi.createUser'
    notes: |
      - Requires a `service_role` key.
      - This function should be called on a server. Never expose your `service_role` key in the browser.
      - If you do not provide the `email_confirm` and `phone_confirm` options to this function, both will default to false.
    examples:
      - name: Create a new user.
        isSpotlight: true
        js: |
          ```js
          const { data: user, error } = await supabase.auth.api.createUser({
            email: 'user@email.com',
            password: 'password',
            user_metadata: { name: 'Yoda' }
          })
          ```
      - name: Auto-confirm email.
        isSpotlight: true
        js: |
          ```js
          const { data: user, error } = await supabase.auth.api.createUser({
            email: 'user@email.com',
            email_confirm: true
          })
          ```
      - name: Auto-confirm phone.
        isSpotlight: true
        js: |
          ```js
          const { data: user, error } = await supabase.auth.api.createUser({
            phone: '1234567890',
            phone_confirm: true
          })
          ```

  auth.api.deleteUser():
    title: 'deleteUser()'
    $ref: '@supabase/gotrue-js.GoTrueApi.deleteUser'
    notes: |
      - Requires a `service_role` key.
      - This function should be called on a server. Never expose your `service_role` key in the browser.
    examples:
      - name: Remove a user completely.
        isSpotlight: true
        js: |
          ```js
          const { data: user, error } = await supabase.auth.api.deleteUser(
            '715ed5db-f090-4b8c-a067-640ecee36aa0'
          )
          ```

  auth.api.inviteUserByEmail():
    title: 'inviteUserByEmail()'
    $ref: '@supabase/gotrue-js.GoTrueApi.inviteUserByEmail'
    notes: |
      - Requires a `service_role` key.
      - This function should only be called on a server. Never expose your `service_role` key in the browser.
    examples:
      - name: Basic example.
        isSpotlight: false
        js: |
          ```js
          const { data: user, error } = await supabase.auth
            .api
            .inviteUserByEmail('email@example.com')
          ```

  auth.api.sendMobileOTP():
    title: 'sendMobileOTP()'
    $ref: '@supabase/gotrue-js.GoTrueApi.sendMobileOTP'
    notes: |
      - Requires a `service_role` key.
      - This function should only be called on a server. Never expose your `service_role` key in the browser.
    examples:
      - name: Basic example.
        isSpotlight: false
        js: |
          ```js
          const { data: user, error } = await supabase.auth
            .api
            .sendMobileOTP('12345879')
          ```

  auth.api.resetPasswordForEmail():
    title: 'resetPasswordForEmail()'
    $ref: '@supabase/gotrue-js.GoTrueApi.resetPasswordForEmail'
    notes: |
      Sends a reset request to an email address.

      When the user clicks the reset link in the email they will be forwarded to:

      `<SITE_URL>#access_token=x&refresh_token=y&expires_in=z&token_type=bearer&type=recovery`

      Your app must detect `type=recovery` in the fragment and display a password reset form to the user.

      You should then use the access_token in the url and new password to update the user as follows:

      ```js
      const { error, data } = await supabase.auth.api
            .updateUser(access_token, { password : new_password })
      ```
    examples:
      - name: Reset password
        isSpotlight: true
        js: |
          ```js
          const { data, error } = await supabase.auth.api
            .resetPasswordForEmail('user@email.com')
          ```

  auth.api.generateLink():
    title: 'generateLink()'
    $ref: '@supabase/gotrue-js.GoTrueApi.generateLink'
    notes: |
      - Requires a `service_role` key.
      - This function should only be called on a server. Never expose your `service_role` key in the browser.
    examples:
      - name: Generate invite link.
        isSpotlight: false
        js: |
          ```js
          const { data: user, error } = await supabase.auth.api.generateLink(
            'invite',
            'email@example.com'
          )
          ```

  auth.api.updateUserById():
    title: 'updateUserById()'
    $ref: '@supabase/gotrue-js.GoTrueApi.updateUserById'
    notes: |
      - Requires a `service_role` key.
      - This function should only be called on a server. Never expose your `service_role` key in the browser.
    examples:
      - name: Updates a user's email.
        isSpotlight: true
        js: |
          ```js
          const { data: user, error } = await supabase.auth.api.updateUserById(
            '6aa5d0d4-2a9f-4483-b6c8-0cf4c6c98ac4',
            { email: 'new@email.com' }
          )
          ```
      - name: Updates a user's password.
        isSpotlight: true
        js: |
          ```js
          const { data: user, error } = await supabase.auth.api.updateUserById(
            '6aa5d0d4-2a9f-4483-b6c8-0cf4c6c98ac4',
            { password: 'new_password' }
          )
          ```
      - name: Updates a user's metadata.
        isSpotlight: true
        js: |
          ```js
          const { data: user, error } = await supabase.auth.api.updateUserById(
            '6aa5d0d4-2a9f-4483-b6c8-0cf4c6c98ac4',
            { user_metadata: { hello: 'world' } }
          )
          ```
      - name: Updates a user's app_metadata.
        isSpotlight: true
        js: |
          ```js
          const { data: user, error } = await supabase.auth.api.updateUserById(
            '6aa5d0d4-2a9f-4483-b6c8-0cf4c6c98ac4',
            { app_metadata: { plan: 'trial' } }
          )
          ```
      - name: Confirms a user's email address.
        isSpotlight: true
        js: |
          ```js
          const { data: user, error } = await supabase.auth.api.updateUserById(
            '6aa5d0d4-2a9f-4483-b6c8-0cf4c6c98ac4',
            { email_confirm: true }
          )
          ```
      - name: Confirms a user's phone number.
        isSpotlight: true
        js: |
          ```js
          const { data: user, error } = await supabase.auth.api.updateUserById(
            '6aa5d0d4-2a9f-4483-b6c8-0cf4c6c98ac4',
            { phone_confirm: true }
          )
          ```
  invoke():
    title: 'invoke()'
    description: |
      Invokes a Supabase Function.
    $ref: '@supabase/functions-js.FunctionsClient.invoke'
    notes: |
      - Requires an Authorization header.
      - Invoke params generally match the [Fetch API](https://developer.mozilla.org/en-US/docs/Web/API/Fetch_API) spec.
    examples:
      - name: Basic invocation.
        isSpotlight: true
        js: |
          ```js
          const { data: user, error } = await supabase.functions.invoke('hello', {
            body: JSON.stringify({ foo: 'bar' })
          })
          ```
      - name: Specifying response type.
        description: |
          By default, `invoke()` will parse the response as JSON. You can parse the response in the following formats: `json`, `blob`, `text`, and `arrayBuffer`.
        isSpotlight: true
        js: |
          ```js
          const { data: user, error } = await supabase.functions.invoke('hello', {
            responseType: 'text',
            body: JSON.stringify({ foo: 'bar' })
          })
          ```
      - name: Parsing custom headers.
        description: |
          You can pass custom headers to your function. Note: supabase-js automatically passes the `Authorization` header with the signed in user's JWT.
        isSpotlight: true
        js: |
          ```js
          const { data: user, error } = await supabase.functions.invoke('hello', {
            headers: { 
              "my-custom-header": 'my-custom-header-value' 
            },
            body: JSON.stringify({ foo: 'bar' })
          })
          ```

  select():
    title: 'Fetch data: select()'
    $ref: '@supabase/postgrest-js."lib/PostgrestQueryBuilder".PostgrestQueryBuilder.select'
    notes: |
      - By default, Supabase projects will return a maximum of 1,000 rows. This setting can be changed in Project API Settings. It's recommended that you keep it low to limit the payload size of accidental or malicious requests. You can use `range()` queries to paginate through your data.
      - `select()` can be combined with [Modifiers](/docs/reference/javascript/using-modifiers)
      - `select()` can be combined with [Filters](/docs/reference/javascript/using-filters)
      - If using the Supabase hosted platform `apikey` is technically a reserved keyword, since the API gateway will pluck it out for authentication. [It should be avoided as a column name](https://github.com/supabase/supabase/issues/5465).
    examples:
      - name: Getting your data
        isSpotlight: true
        js: |
          ```js
          const { data, error } = await supabase
            .from('cities')
            .select()
          ```
      - name: Selecting specific columns
        description: You can select specific fields from your tables.
        js: |
          ```js
          const { data, error } = await supabase
            .from('cities')
            .select('name')
          ```
      - name: Query foreign tables
        description: If your database has foreign key relationships, you can query related tables too.
        js: |
          ```js
          const { data, error } = await supabase
            .from('countries')
            .select(`
              name,
              cities (
                name
              )
            `)
          ```
        note: |
          What about join tables
          If you're in a situation where your tables are **NOT** directly related, but instead are joined by a _join table_,
          you can still use the `select()` method to query the related data. The PostgREST engine detects the relationship automatically.
          For more details, [follow the link](https://postgrest.org/en/latest/api.html#embedding-through-join-tables).
      - name: Query the same foreign table multiple times
        description: |
          Sometimes you will need to query the same foreign table twice. 
          In this case, you can use the name of the joined column to identify 
          which join you intend to use. For convenience, you can also give an 
          alias for each column. For example, if we had a shop of products, 
          and we wanted to get the supplier and the purchaser at the same time 
          (both in the users) table:
        js: |
          ```js
          const { data, error } = await supabase
            .from('products')
            .select(`
              id,
              supplier:supplier_id ( name ),
              purchaser:purchaser_id ( name )
            `)
          ```
      - name: Filtering with inner joins
        description: |
          If you want to filter a table based on a child table's values you can use the `!inner()` function. For example, if you wanted 
          to select all rows in a `message` table which belong to a user with the `username` "Jane":
        js: |
          ```js
          const { data, error } = await supabase
            .from('messages')
            .select('*, users!inner(*)')
            .eq('users.username', 'Jane')
          ```
      - name: Querying with count option
        description: |
          You can get the number of rows by using the count option.
          Allowed values for count option are `null`, [exact](https://postgrest.org/en/stable/api.html#exact-count), [planned](https://postgrest.org/en/stable/api.html#planned-count) and [estimated](https://postgrest.org/en/stable/api.html#estimated-count).
        js: |
          ```js
          const { data, error, count } = await supabase
            .from('cities')
            .select('name', { count: 'exact' }) // if you don't want to return any rows, you can use { count: 'exact', head: true }
          ```
      - name: Querying JSON data
        description: |
          If you have data inside of a JSONB column, you can apply select 
          and query filters to the data values. Postgres offers a 
          [number of operators](https://www.postgresql.org/docs/current/functions-json.html) 
          for querying JSON data. Also see 
          [PostgREST docs](http://postgrest.org/en/v7.0.0/api.html#json-columns) for more details.
        js: |
          ```js
          const { data, error } = await supabase
            .from('users')
            .select(`
              id, name,
              address->street
            `)
            .eq('address->postcode', 90210)
          ```
      - name: Return data as CSV
        description: |
          By default the data is returned in JSON format, however you can also request for it to be returned as Comma Separated Values.
        js: |
          ```js
          const { data, error } = await supabase
            .from('users')
            .select()
            .csv()
          ```
      - name: Aborting requests in-flight
        description: |
          You can use an [`AbortController`](https://developer.mozilla.org/en-US/docs/Web/API/AbortController) to abort requests. Note that `status` and `statusText` doesn't mean anything for aborted requests, since the request wasn't actually fulfilled.
        js: |
          ```js
          const ac = new AbortController()
          supabase
            .from('very_big_table')
            .select()
            .abortSignal(ac.signal)
            .then(console.log)
          ac.abort()
          // {
          //   error: {
          //     message: 'FetchError: The user aborted a request.',
          //     details: '',
          //     hint: '',
          //     code: ''
          //   },
          //   data: null,
          //   body: null,
          //   count: null,
          //   status: 400,
          //   statusText: 'Bad Request'
          // }
          ```

  insert():
    title: 'Create data: insert()'
    $ref: '@supabase/postgrest-js."lib/PostgrestQueryBuilder".PostgrestQueryBuilder.insert'
    notes: |
      - By default, every time you run `insert()`, the client library will make a `select` to return the full record.
      This is convenient, but it can also cause problems if your Policies are not configured to allow the `select` operation. 
      If you are using Row Level Security and you are encountering problems, try setting the `returning` param to `minimal`.
    examples:
      - name: Create a record
        isSpotlight: true
        js: |
          ```js
          const { data, error } = await supabase
            .from('cities')
            .insert([
              { name: 'The Shire', country_id: 554 }
            ])
          ```
      - name: Bulk create
        description: |
          When running a bulk create, the operation is handled in a single transaction. If any of the inserts fail, all other operations are 
          rolled back.
        js: |
          ```js
          const { data, error } = await supabase
            .from('cities')
            .insert([
              { name: 'The Shire', country_id: 554 },
              { name: 'Rohan', country_id: 555 },
            ])
          ```
      - name: Upsert
        description: |
          For upsert, if set to true, primary key columns would need to be included 
          in the data parameter in order for an update to properly happen. Also, primary keys 
          used must be natural, not surrogate. There are however, 
          [workarounds](https://github.com/PostgREST/postgrest/issues/1118) 
          for surrogate primary keys.
        js: |
          ```js
          const { data, error } = await supabase
            .from('cities')
            .insert(
              [
                { name: 'The Shire', country_id: 554 },
                { name: 'Rohan', country_id: 555 },
                { name: 'City by the Bay', country_id:840}
              ],
              { upsert: true })
          ```

  update():
    title: 'Modify data: update()'
    $ref: '@supabase/postgrest-js."lib/PostgrestQueryBuilder".PostgrestQueryBuilder.update'
    notes: |
      - `update()` should always be combined with [Filters](/docs/reference/javascript/using-filters) to target the item(s) you wish to update.
    examples:
      - name: Updating your data
        isSpotlight: true
        js: |
          ```js
          const { data, error } = await supabase
            .from('cities')
            .update({ name: 'Middle Earth' })
            .match({ name: 'Auckland' })
          ```
      - name: Updating JSON data
        description: |
          Postgres offers a 
          [number of operators](https://www.postgresql.org/docs/current/functions-json.html) 
          for working with JSON data. Right now it is only possible to update an entire JSON document, 
          but we are [working on ideas](https://github.com/PostgREST/postgrest/issues/465) for updating individual keys.
        js: |
          ```js
          const { data, error } = await supabase
            .from('users')
            .update(`
              address: { 
                street: 'Melrose Place',
                postcode: 90210
              }
            `)
            .eq('address->postcode', 90210)
          ```

  upsert():
    title: 'Upsert data: upsert()'
    $ref: '@supabase/postgrest-js."lib/PostgrestQueryBuilder".PostgrestQueryBuilder.upsert'
    notes: |
      - Primary keys should be included in the data payload in order for an update to work correctly. 
      - Primary keys  must be natural, not surrogate. There are however, [workarounds](https://github.com/PostgREST/postgrest/issues/1118) for surrogate primary keys.
    examples:
      - name: Upsert your data
        isSpotlight: true
        js: |
          ```js
          const { data, error } = await supabase
            .from('messages')
            .upsert({ id: 3, message: 'foo', username: 'supabot' })
          ```
      - name: Bulk Upsert your data
        isSpotlight: false
        js: |
          ```js
          const { data, error } = await supabase
            .from('messages')
            .upsert([
            { id: 3, message: 'foo', username: 'supabot' },
            { id: 4, message: 'bar', username: 'supabot' }
            ])
          ```
      - name: Upserting into tables with constraints
        description: |
          Running the following will cause supabase to upsert data into the `users` table. 
          If the username 'supabot' already exists, the `onConflict` argument tells supabase to overwrite that row 
          based on the column passed into `onConflict`.
        isSpotlight: true
        js: |
          ```js
          const { data, error } = await supabase
            .from('users')
            .upsert({ username: 'supabot' }, { onConflict: 'username' })
          ```
      - name: Return the exact number of rows
        isSpotlight: true
        js: |
          ```js
          const { data, error, count } = await supabase
            .from('users')
            .upsert({ 
                id: 3, message: 'foo', 
                username: 'supabot' 
            }, { 
              count: 'exact' 
            })
          ```

  delete():
    title: 'Delete data: delete()'
    $ref: '@supabase/postgrest-js."lib/PostgrestQueryBuilder".PostgrestQueryBuilder.delete'
    notes: |
      - `delete()` should always be combined with [filters](/docs/reference/javascript/using-filters) to target the item(s) you wish to delete.
      - If you use `delete()` with filters and you have
        [RLS](/docs/learn/auth-deep-dive/auth-row-level-security) enabled, only
        rows visible through `SELECT` policies are deleted. Note that by default
        no rows are visible, so you need at least one `SELECT`/`ALL` policy that
        makes the rows visible.
    examples:
      - name: Delete records
        isSpotlight: true
        js: |
          ```js
          const { data, error } = await supabase
            .from('cities')
            .delete()
            .match({ id: 666 })
          ```

  rpc():
    title: 'Postgres functions: rpc()'
    description: |
      You can call Postgres functions as a "Remote Procedure Call".

      That's a fancy way of saying that you can put some logic into your database then call it from anywhere.
      It's especially useful when the logic rarely changes - like password resets and updates.

      ```sql
      create or replace function hello_world() returns text as $$
        select 'Hello world';
      $$ language sql;
      ```
    $ref: '@supabase/postgrest-js."PostgrestClient".PostgrestClient.rpc'
    examples:
      - name: Call a Postgres function
        isSpotlight: true
        description: This is an example of invoking a Postgres function with no parameters.
        js: |
          ```js
          const { data, error } = await supabase
            .rpc('hello_world')
          ```
      - name: With Parameters
        js: |
          ```js
          const { data, error } = await supabase
            .rpc('echo_city', { name: 'The Shire' })
          ```
      - name: Bulk processing
        description: You can process large payloads at once using [array parameters](https://postgrest.org/en/stable/api.html#calling-functions-with-array-parameters).
        js: |
          ```js
          const { data, error } = await postgrest
            .rpc('echo_cities', { names: ['The Shire', 'Mordor'] })
          ```
      - name: With filters
        description: |
          Postgres functions that return tables can also be combined with
          [Modifiers](/docs/reference/javascript/using-modifiers) and 
          [Filters](/docs/reference/javascript/using-filters).
        js: |
          ```js
          const { data, error } = await supabase
            .rpc('echo_all_cities')
            .select('name, population')
            .eq('name', 'The Shire')
          ```
      - name: With count option
        description: |
          You can specify a count option to get the row count along with your data.
          Allowed values for count option are `null`, `exact`, `planned` and `estimated`.
        js: |
          ```js
          const { data, error, count } = await supabase
            .rpc('hello_world', {}, { count: 'exact' })
          ```

  subscribe():
    title: 'on().subscribe()'
    $ref: '@supabase/supabase-js.lib/SupabaseQueryBuilder.SupabaseQueryBuilder.on'
    notes: |
      - Realtime is disabled by default for new Projects for better database performance and security. You can turn it on by [managing replication](/docs/guides/api#managing-realtime).
      - If you want to receive the "previous" data for updates and deletes, you will need to set `REPLICA IDENTITY` to `FULL`, like this: `ALTER TABLE your_table REPLICA IDENTITY FULL;`
    examples:
      - name: Listen to all database changes
        isSpotlight: true
        js: |
          ```js
          const mySubscription = supabase
            .from('*')
            .on('*', payload => {
              console.log('Change received!', payload)
            })
            .subscribe()
          ```
      - name: Listening to a specific table
        js: |
          ```js
          const mySubscription = supabase
            .from('countries')
            .on('*', payload => {
              console.log('Change received!', payload)
            })
            .subscribe()
          ```
      - name: Listening to inserts
        js: |
          ```js
          const mySubscription = supabase
            .from('countries')
            .on('INSERT', payload => {
              console.log('Change received!', payload)
            })
            .subscribe()
          ```
      - name: Listening to updates
        description: |
          By default, Supabase will send only the updated record. If you want to receive the previous values as well you can 
          enable full replication for the table you are listening too: 

          ```sql
          alter table "your_table" replica identity full;
          ```
        js: |
          ```js
          const mySubscription = supabase
            .from('countries')
            .on('UPDATE', payload => {
              console.log('Change received!', payload)
            })
            .subscribe()
          ```
      - name: Listening to deletes
        description: |
          By default, Supabase does not send deleted records. If you want to receive the deleted record you can 
          enable full replication for the table you are listening too: 

          ```sql
          alter table "your_table" replica identity full;
          ```
        js: |
          ```js
          const mySubscription = supabase
            .from('countries')
            .on('DELETE', payload => {
              console.log('Change received!', payload)
            })
            .subscribe()
          ```
      - name: Listening to multiple events
        description: You can chain listeners if you want to listen to multiple events for each table.
        js: |
          ```js
          const mySubscription = supabase
            .from('countries')
            .on('INSERT', handleRecordInserted)
            .on('DELETE', handleRecordDeleted)
            .subscribe()
          ```
      - name: Listening to row level changes
        description: You can listen to individual rows using the format `{table}:{col}=eq.{val}` - where `{col}` is the column name, and `{val}` is the value which you want to match.
        notes: |
          - ``eq`` filter works with all database types as under the hood, it's casting both the filter value and the database value to the correct type and then comparing them.
        js: |
          ```js
          const mySubscription = supabase
            .from('countries:id=eq.200')
            .on('UPDATE', handleRecordUpdated)
            .subscribe()
          ```

  removeSubscription():
    title: 'removeSubscription()'
    $ref: '@supabase/supabase-js.index.SupabaseClient.removeSubscription'
    notes: |
      - Removing subscriptions is a great way to maintain the performance of your project's database. Supabase will automatically handle cleanup 30 seconds after a user is disconnected, but unused subscriptions may cause degradation as more users are simultaneously subscribed.
    examples:
      - name: Remove a subscription
        isSpotlight: true
        js: |
          ```js
          supabase.removeSubscription(mySubscription)
          ```

  removeAllSubscriptions():
    title: 'removeAllSubscriptions()'
    $ref: '@supabase/supabase-js.index.SupabaseClient.removeAllSubscriptions'
    notes: |
      - Removing subscriptions is a great way to maintain the performance of your project's database. Supabase will automatically handle cleanup 30 seconds after a user is disconnected, but unused subscriptions may cause degradation as more users are simultaneously subscribed.
    examples:
      - name: Removes all subscriptions
        isSpotlight: true
        js: |
          ```js
          supabase.removeAllSubscriptions()
          ```

  getSubscriptions():
    title: 'getSubscriptions()'
    $ref: '@supabase/supabase-js.index.SupabaseClient.getSubscriptions'
    examples:
      - name: Get all subscriptions
        isSpotlight: true
        js: |
          ```js
          const subscriptions = supabase.getSubscriptions()
          ```

  storage.listBuckets():
    title: 'listBuckets()'
    $ref: '@supabase/storage-js."lib/StorageBucketApi".StorageBucketApi.listBuckets'
    notes: |
      - Policy permissions required:
        - `buckets` permissions: `select` 
        - `objects` permissions: none
    examples:
      - name: List buckets
        isSpotlight: true
        js: |
          ```js
          const { data, error } = await supabase
            .storage
            .listBuckets()
          ```

  storage.getBucket():
    title: 'getBucket()'
    $ref: '@supabase/storage-js."lib/StorageBucketApi".StorageBucketApi.getBucket'
    notes: |
      - Policy permissions required:
        - `buckets` permissions: `select` 
        - `objects` permissions: none
    examples:
      - name: Get bucket
        isSpotlight: true
        js: |
          ```js
          const { data, error } = await supabase
            .storage
            .getBucket('avatars')
          ```

  storage.createBucket():
    title: 'createBucket()'
    $ref: '@supabase/storage-js."lib/StorageBucketApi".StorageBucketApi.createBucket'
    notes: |
      - Policy permissions required:
        - `buckets` permissions: `insert` 
        - `objects` permissions: none
    examples:
      - name: Create bucket
        isSpotlight: true
        js: |
          ```js
          const { data, error } = await supabase
            .storage
            .createBucket('avatars', { public: false })
          ```

  storage.emptyBucket():
    title: 'emptyBucket()'
    $ref: '@supabase/storage-js."lib/StorageBucketApi".StorageBucketApi.emptyBucket'
    notes: |
      - Policy permissions required:
        - `buckets` permissions: `select` 
        - `objects` permissions: `select` and `delete`
    examples:
      - name: Empty bucket
        isSpotlight: true
        js: |
          ```js
          const { data, error } = await supabase
            .storage
            .emptyBucket('avatars')
          ```
  storage.updateBucket():
    title: 'updateBucket()'
    $ref: '@supabase/storage-js."lib/StorageBucketApi".StorageBucketApi.updateBucket'
    notes: |
      - Policy permissions required:
        - `buckets` permissions: `update`
        - `objects` permissions: none
    examples:
      - name: Update bucket
        isSpotlight: true
        js: |
          ```js
          const { data, error } = await supabase
            .storage
            .updateBucket('avatars', { public: false })
          ```

  storage.deleteBucket():
    title: 'deleteBucket()'
    $ref: '@supabase/storage-js."lib/StorageBucketApi".StorageBucketApi.deleteBucket'
    notes: |
      - Policy permissions required:
        - `buckets` permissions: `select` and `delete`
        - `objects` permissions: none
    examples:
      - name: Delete bucket
        isSpotlight: true
        js: |
          ```js
          const { data, error } = await supabase
            .storage
            .deleteBucket('avatars')
          ```

  storage.from.upload():
    title: 'from.upload()'
    $ref: '@supabase/storage-js."lib/StorageFileApi".StorageFileApi.upload'
    notes: |
      - Policy permissions required:
        - `buckets` permissions: none 
        - `objects` permissions: `insert`
      - For React Native, using either `Blob`, `File` or `FormData` does not work as intended. Upload file using `ArrayBuffer` from base64 file data instead, see example below.
    examples:
      - name: Upload file
        isSpotlight: true
        js: |
          ```js
          const avatarFile = event.target.files[0]
          const { data, error } = await supabase
            .storage
            .from('avatars')
            .upload('public/avatar1.png', avatarFile, {
              cacheControl: '3600',
              upsert: false
            })
          ```
      - name: Upload file using `ArrayBuffer` from base64 file data
        js: |
          ```js
          import { decode } from 'base64-arraybuffer'

          const { data, error } = await supabase
            .storage
            .from('avatars')
            .upload('public/avatar1.png', decode('base64FileData'), {
              contentType: 'image/png'
            })
          ```

  storage.from.update():
    title: 'from.update()'
    $ref: '@supabase/storage-js."lib/StorageFileApi".StorageFileApi.update'
    notes: |
      - Policy permissions required:
        - `buckets` permissions: none 
        - `objects` permissions: `update` and `select`
      - For React Native, using either `Blob`, `File` or `FormData` does not work as intended. Update file using `ArrayBuffer` from base64 file data instead, see example below.
    examples:
      - name: Update file
        isSpotlight: true
        js: |
          ```js
          const avatarFile = event.target.files[0]
          const { data, error } = await supabase
            .storage
            .from('avatars')
            .update('public/avatar1.png', avatarFile, {
              cacheControl: '3600',
              upsert: false
            })
          ```
      - name: Update file using `ArrayBuffer` from base64 file data
        js: |
          ```js
          import {decode} from 'base64-arraybuffer'

          const { data, error } = await supabase
            .storage
            .from('avatars')
            .update('public/avatar1.png', decode('base64FileData'), {
              contentType: 'image/png'
            })
          ```

  storage.from.move():
    title: 'from.move()'
    $ref: '@supabase/storage-js."lib/StorageFileApi".StorageFileApi.move'
    notes: |
      - Policy permissions required:
        - `buckets` permissions: none 
        - `objects` permissions: `update` and `select`
    examples:
      - name: Move file
        isSpotlight: true
        js: |
          ```js
          const { data, error } = await supabase
            .storage
            .from('avatars')
            .move('public/avatar1.png', 'private/avatar2.png')
          ```

  storage.from.copy():
    title: 'from.copy()'
    $ref: '@supabase/storage-js."lib/StorageFileApi".StorageFileApi.copy'
    notes: |
      - Policy permissions required:
        - `buckets` permissions: none 
        - `objects` permissions: `update` and `select`
    examples:
      - name: Copy file
        isSpotlight: true
        js: |
          ```js
          const { data, error } = await supabase
            .storage
            .from('avatars')
            .copy('public/avatar1.png', 'private/avatar2.png')
          ```

  storage.from.createSignedUrl():
    title: 'from.createSignedUrl()'
    $ref: '@supabase/storage-js."lib/StorageFileApi".StorageFileApi.createSignedUrl'
    notes: |
      - Policy permissions required:
        - `buckets` permissions: none 
        - `objects` permissions: `select`
    examples:
      - name: Create Signed URL
        isSpotlight: true
        js: |
          ```js
          const { signedURL, error } = await supabase
            .storage
            .from('avatars')
            .createSignedUrl('folder/avatar1.png', 60)
          ```

  storage.from.createSignedUrls():
    title: 'from.createSignedUrls()'
    $ref: '@supabase/storage-js."lib/StorageFileApi".StorageFileApi.createSignedUrls'
    notes: |
      - Policy permissions required:
        - `buckets` permissions: none 
        - `objects` permissions: `select`
    examples:
      - name: Create Signed URLs
        isSpotlight: true
        js: |
          ```js
          const { data, error } = await supabase
            .storage
            .from('avatars')
            .createSignedUrls(['folder/avatar1.png', 'folder/avatar2.png'], 60)
          ```

  storage.from.getPublicUrl():
    title: 'from.getPublicUrl()'
    $ref: '@supabase/storage-js."lib/StorageFileApi".StorageFileApi.getPublicUrl'
    notes: |
      - The bucket needs to be set to public, either via [updateBucket()](/docs/reference/javascript/storage-updatebucket) or by going to Storage on [app.supabase.com](https://app.supabase.com), clicking the overflow menu on a bucket and choosing "Make public"
      - Policy permissions required:
        - `buckets` permissions: none 
        - `objects` permissions: none
    examples:
      - name: Returns the URL for an asset in a public bucket
        isSpotlight: true
        js: |
          ```js
          const { publicURL, error } = supabase
            .storage
            .from('public-bucket')
            .getPublicUrl('folder/avatar1.png')
          ```

  storage.from.download():
    title: 'from.download()'
    $ref: '@supabase/storage-js."lib/StorageFileApi".StorageFileApi.download'
    notes: |
      - Policy permissions required:
        - `buckets` permissions: none 
        - `objects` permissions: `select`
    examples:
      - name: Download file
        isSpotlight: true
        js: |
          ```js
          const { data, error } = await supabase
            .storage
            .from('avatars')
            .download('folder/avatar1.png')
          ```

  storage.from.remove():
    title: 'from.remove()'
    $ref: '@supabase/storage-js."lib/StorageFileApi".StorageFileApi.remove'
    notes: |
      - Policy permissions required:
        - `buckets` permissions: none 
        - `objects` permissions: `delete` and `select`
    examples:
      - name: Delete file
        isSpotlight: true
        js: |
          ```js
          const { data, error } = await supabase
            .storage
            .from('avatars')
            .remove(['folder/avatar1.png'])
          ```

  storage.from.list():
    title: 'from.list()'
    $ref: '@supabase/storage-js."lib/StorageFileApi".StorageFileApi.list'
    notes: |
      - Policy permissions required:
        - `buckets` permissions: none 
        - `objects` permissions: `select`
    examples:
      - name: List files in a bucket
        isSpotlight: true
        js: |
          ```js
          const { data, error } = await supabase
            .storage
            .from('avatars')
            .list('folder', {
              limit: 100,
              offset: 0,
              sortBy: { column: 'name', order: 'asc' },
            })
          ```
      - name: Search files in a bucket
        js: |
          ```js
          const { data, error } = await supabase
            .storage
            .from('avatars')
            .list('folder', {
              limit: 100,
              offset: 0,
              sortBy: { column: 'name', order: 'asc' },
              search: 'jon'
            })
          ```

  Using Modifiers:
    description: |
      Modifiers can be used on `select()` queries. 

      If a Postgres function returns a table response, you can also apply modifiers to the `rpc()` function.

  limit():
    $ref: '@supabase/postgrest-js."lib/PostgrestFilterBuilder".PostgrestFilterBuilder.limit'
    examples:
      - name: With `select()`
        isSpotlight: true
        js: |
          ```js
          const { data, error } = await supabase
            .from('cities')
            .select('name, country_id')
            .limit(1)
          ```
      - name: With embedded resources
        js: |
          ```js
          const { data, error } = await supabase
            .from('countries')
            .select('name, cities(name)')
            .eq('name', 'United States')
            .limit(1, { foreignTable: 'cities' })
          ```

  order():
    $ref: '@supabase/postgrest-js."lib/PostgrestFilterBuilder".PostgrestFilterBuilder.order'
    examples:
      - name: With `select()`
        isSpotlight: true
        js: |
          ```js
          const { data, error } = await supabase
            .from('cities')
            .select('name', 'country_id')
            .order('id', { ascending: false })
          ```
      - name: With embedded resources
        js: |
          ```js
          const { data, error } = await supabase
            .from('countries')
            .select('name, cities(name)')
            .eq('name', 'United States')
            .order('name', {foreignTable: 'cities'})
          ```

  range():
    $ref: '@supabase/postgrest-js."lib/PostgrestFilterBuilder".PostgrestFilterBuilder.range'
    examples:
      - name: With `select()`
        isSpotlight: true
        js: |
          ```js
          const { data, error } = await supabase
            .from('cities')
            .select('name, country_id')
            .range(0,3)
          ```

  single():
    $ref: '@supabase/postgrest-js."lib/PostgrestFilterBuilder".PostgrestFilterBuilder.single'
    examples:
      - name: With `select()`
        isSpotlight: true
        js: |
          ```js
          const { data, error } = await supabase
            .from('cities')
            .select('name, country_id')
            .limit(1)
            .single()
          ```

  maybeSingle():
    $ref: '@supabase/postgrest-js."lib/PostgrestFilterBuilder".PostgrestFilterBuilder.maybeSingle'
    examples:
      - name: With `select()`
        isSpotlight: true
        js: |
          ```js
          const { data, error } = await supabase
            .from('cities')
            .select('name, country_id')
            .eq('name', 'Singapore')
            .maybeSingle()
          ```

  Using Filters:
    description: |
      Filters can be used on `select()`, `update()`, and `delete()` queries. 

      If a Postgres function returns a table response, you can also apply filters.

      ### Applying Filters

      You must apply your filters to the end of your query. For example:

      ```js
      const { data, error } = await supabase
        .from('cities')
        .select('name, country_id')
        .eq('name', 'The Shire')    // Correct

      const { data, error } = await supabase
        .from('cities')
        .eq('name', 'The Shire')    // Incorrect
        .select('name, country_id')
      ```

      ### Chaining

      Filters can be chained together to produce advanced queries. For example:

      ```js
      const { data, error } = await supabase
        .from('cities')
        .select('name, country_id')
        .gte('population', 1000)
        .lt('population', 10000)
      ```

      ### Conditional Chaining

      Filters can be built up one step at a time and then executed. For example:

      ```js
      const filterByName = null
      const filterPopLow = 1000
      const filterPopHigh = 10000

      let query = supabase
        .from('cities')
        .select('name, country_id')
        
      if (filterByName)  { query = query.eq('name', filterByName) }
      if (filterPopLow)  { query = query.gte('population', filterPopLow) }
      if (filterPopHigh) { query = query.lt('population', filterPopHigh) }

      const { data, error } = await query
      ```

  .or():
    $ref: '@supabase/postgrest-js."lib/PostgrestFilterBuilder".PostgrestFilterBuilder.or'
    notes: |
      - `.or()` expects you to use the raw [PostgREST syntax](https://postgrest.org/en/stable/api.html#horizontal-filtering-rows) for the filter names and values.

        ```js
        .or('id.in.(6,7), arraycol.cs.{"a","b"}')  // Use Postgres list () for in filter. Array {} for array column and 'cs' for contains.
        .or(`id.in.(${arrList}),arraycol.cs.{${arr}}`)	// You can insert a javascipt array for list or array on array column.
        .or(`id.in.(${arrList}),rangecol.cs.[${arrRange})`)	// You can insert a javascipt array for list or range on a range column.
        ```
    examples:
      - name: With `select()`
        isSpotlight: true
        js: |
          ```js
          const { data, error } = await supabase
            .from('cities')
            .select('name, country_id')
            .or('id.eq.20,id.eq.30')
          ```
      - name: Use `or` with `and`
        isSpotlight: true
        js: |
          ```js
          const { data, error } = await supabase
            .from('cities')
            .select('name, country_id')
            .or('id.gt.20,and(name.eq.New Zealand,name.eq.France)')
          ```
      - name: Use `or` on foreign tables
        isSpotlight: true
        js: |
          ```js
          const { data, error } = await supabase
            .from('countries')
            .select('id, cities(*)')
            .or('name.eq.Wellington,name.eq.Paris', { foreignTable: "cities" })
          ```

  .not():
    $ref: '@supabase/postgrest-js."lib/PostgrestFilterBuilder".PostgrestFilterBuilder.not'
    notes: |
      - `.not()` expects you to use the raw [PostgREST syntax](https://postgrest.org/en/stable/api.html#horizontal-filtering-rows) for the filter names and values.

        ```js
          .not('name','eq','Paris')
          .not('arraycol','cs','{"a","b"}') // Use Postgres array {} for array column and 'cs' for contains.
          .not('rangecol','cs','(1,2]') // Use Postgres range syntax for range column.
          .not('id','in','(6,7)')  // Use Postgres list () for in filter.
          .not('id','in',`(${arr})`)  // You can insert a javascript array.
        ```
    examples:
      - name: With `select()`
        isSpotlight: true
        js: |
          ```js
          const { data, error } = await supabase
            .from('cities')
            .select('name, country_id')
            .not('name', 'eq', 'Paris')
          ```
      - name: With `update()`
        js: |
          ```js
          const { data, error } = await supabase
            .from('cities')
            .update({ name: 'Mordor' })
            .not('name', 'eq', 'Paris')
          ```
      - name: With `delete()`
        js: |
          ```js
          const { data, error } = await supabase
            .from('cities')
            .delete()
            .not('name', 'eq', 'Paris')
          ```
      - name: With `rpc()`
        js: |
          ```js
          // Only valid if the Postgres function returns a table type.
          const { data, error } = await supabase
            .rpc('echo_all_cities')
            .not('name', 'eq', 'Paris')
          ```

  .match():
    $ref: '@supabase/postgrest-js."lib/PostgrestFilterBuilder".PostgrestFilterBuilder.match'
    examples:
      - name: With `select()`
        isSpotlight: true
        js: |
          ```js
          const { data, error } = await supabase
            .from('cities')
            .select('name, country_id')
            .match({name: 'Beijing', country_id: 156})
          ```
      - name: With `update()`
        js: |
          ```js
          const { data, error } = await supabase
            .from('cities')
            .update({ name: 'Mordor' })
            .match({name: 'Beijing', country_id: 156})
          ```
      - name: With `delete()`
        js: |
          ```js
          const { data, error } = await supabase
            .from('cities')
            .delete()
            .match({name: 'Beijing', country_id: 156})
          ```
      - name: With `rpc()`
        js: |
          ```js
          // Only valid if the Postgres function returns a table type.
          const { data, error } = await supabase
            .rpc('echo_all_cities')
            .match({name: 'Beijing', country_id: 156})
          ```

  .eq():
    $ref: '@supabase/postgrest-js."lib/PostgrestFilterBuilder".PostgrestFilterBuilder.eq'
    examples:
      - name: With `select()`
        isSpotlight: true
        js: |
          ```js
          const { data, error } = await supabase
            .from('cities')
            .select('name, country_id')
            .eq('name', 'The shire')
          ```
      - name: With `update()`
        js: |
          ```js
          const { data, error } = await supabase
            .from('cities')
            .update({ name: 'Mordor' })
            .eq('name', 'San Francisco')
          ```
      - name: With `delete()`
        js: |
          ```js
          const { data, error } = await supabase
            .from('cities')
            .delete()
            .eq('name', 'Mordor')
          ```
      - name: With `rpc()`
        js: |
          ```js
          // Only valid if the Postgres function returns a table type.
          const { data, error } = await supabase
            .rpc('echo_all_cities')
            .eq('name', 'San Francisco')
          ```

  .neq():
    $ref: '@supabase/postgrest-js."lib/PostgrestFilterBuilder".PostgrestFilterBuilder.neq'
    examples:
      - name: With `select()`
        isSpotlight: true
        js: |
          ```js
          const { data, error } = await supabase
            .from('cities')
            .select('name, country_id')
            .neq('name', 'The shire')
          ```
      - name: With `update()`
        js: |
          ```js
          const { data, error } = await supabase
            .from('cities')
            .update({ name: 'Mordor' })
            .neq('name', 'San Francisco')
          ```
      - name: With `delete()`
        js: |
          ```js
          const { data, error } = await supabase
            .from('cities')
            .delete()
            .neq('name', 'Mordor')
          ```
      - name: With `rpc()`
        js: |
          ```js
          // Only valid if the Postgres function returns a table type.
          const { data, error } = await supabase
            .rpc('echo_all_cities')
            .neq('name', 'Lagos')
          ```

  .gt():
    $ref: '@supabase/postgrest-js."lib/PostgrestFilterBuilder".PostgrestFilterBuilder.gt'
    examples:
      - name: With `select()`
        isSpotlight: true
        js: |
          ```js
          const { data, error } = await supabase
            .from('cities')
            .select('name, country_id')
            .gt('country_id', 250)
          ```
      - name: With `update()`
        js: |
          ```js
          const { data, error } = await supabase
            .from('cities')
            .update({ name: 'Mordor' })
            .gt('country_id', 250)
          ```
      - name: With `delete()`
        js: |
          ```js
          const { data, error } = await supabase
            .from('cities')
            .delete()
            .gt('country_id', 250)
          ```
      - name: With `rpc()`
        js: |
          ```js
          // Only valid if the Postgres function returns a table type.
          const { data, error } = await supabase
            .rpc('echo_all_cities')
            .gt('country_id', 250)
          ```

  .gte():
    $ref: '@supabase/postgrest-js."lib/PostgrestFilterBuilder".PostgrestFilterBuilder.gte'
    examples:
      - name: With `select()`
        isSpotlight: true
        js: |
          ```js
          const { data, error } = await supabase
            .from('cities')
            .select('name, country_id')
            .gte('country_id', 250)
          ```
      - name: With `update()`
        js: |
          ```js
          const { data, error } = await supabase
            .from('cities')
            .update({ name: 'Mordor' })
            .gte('country_id', 250)
          ```
      - name: With `delete()`
        js: |
          ```js
          const { data, error } = await supabase
            .from('cities')
            .delete()
            .gte('country_id', 250)
          ```
      - name: With `rpc()`
        js: |
          ```js
          // Only valid if the Postgres function returns a table type.
          const { data, error } = await supabase
            .rpc('echo_all_cities')
            .gte('country_id', 250)
          ```

  .lt():
    $ref: '@supabase/postgrest-js."lib/PostgrestFilterBuilder".PostgrestFilterBuilder.lt'
    examples:
      - name: With `select()`
        isSpotlight: true
        js: |
          ```js
          const { data, error } = await supabase
            .from('cities')
            .select('name, country_id')
            .lt('country_id', 250)
          ```
      - name: With `update()`
        js: |
          ```js
          const { data, error } = await supabase
            .from('cities')
            .update({ name: 'Mordor' })
            .lt('country_id', 250)
          ```
      - name: With `delete()`
        js: |
          ```js
          const { data, error } = await supabase
            .from('cities')
            .delete()
            .lt('country_id', 250)
          ```
      - name: With `rpc()`
        js: |
          ```js
          // Only valid if the Postgres function returns a table type.
          const { data, error } = await supabase
            .rpc('echo_all_cities')
            .lt('country_id', 250)
          ```

  .lte():
    $ref: '@supabase/postgrest-js."lib/PostgrestFilterBuilder".PostgrestFilterBuilder.lte'
    examples:
      - name: With `select()`
        isSpotlight: true
        js: |
          ```js
          const { data, error } = await supabase
            .from('cities')
            .select('name, country_id')
            .lte('country_id', 250)
          ```
      - name: With `update()`
        js: |
          ```js
          const { data, error } = await supabase
            .from('cities')
            .update({ name: 'Mordor' })
            .lte('country_id', 250)
          ```
      - name: With `delete()`
        js: |
          ```js
          const { data, error } = await supabase
            .from('cities')
            .delete()
            .lte('country_id', 250)
          ```
      - name: With `rpc()`
        js: |
          ```js
          // Only valid if the Postgres function returns a table type.
          const { data, error } = await supabase
            .rpc('echo_all_cities')
            .lte('country_id', 250)
          ```

  .like():
    $ref: '@supabase/postgrest-js."lib/PostgrestFilterBuilder".PostgrestFilterBuilder.like'
    examples:
      - name: With `select()`
        isSpotlight: true
        js: |
          ```js
          const { data, error } = await supabase
            .from('cities')
            .select('name, country_id')
            .like('name', '%la%')
          ```
      - name: With `update()`
        js: |
          ```js
          const { data, error } = await supabase
            .from('cities')
            .update({ name: 'Mordor' })
            .like('name', '%la%')
          ```
      - name: With `delete()`
        js: |
          ```js
          const { data, error } = await supabase
            .from('cities')
            .delete()
            .like('name', '%la%')
          ```
      - name: With `rpc()`
        js: |
          ```js
          // Only valid if the Postgres function returns a table type.
          const { data, error } = await supabase
            .rpc('echo_all_cities')
            .like('name', '%la%')
          ```

  .ilike():
    $ref: '@supabase/postgrest-js."lib/PostgrestFilterBuilder".PostgrestFilterBuilder.ilike'
    examples:
      - name: With `select()`
        isSpotlight: true
        js: |
          ```js
          const { data, error } = await supabase
            .from('cities')
            .select('name, country_id')
            .ilike('name', '%la%')
          ```
      - name: With `update()`
        js: |
          ```js
          const { data, error } = await supabase
            .from('cities')
            .update({ name: 'Mordor' })
            .ilike('name', '%la%')
          ```
      - name: With `delete()`
        js: |
          ```js
          const { data, error } = await supabase
            .from('cities')
            .delete()
            .ilike('name', '%la%')
          ```
      - name: With `rpc()`
        js: |
          ```js
          // Only valid if the Postgres function returns a table type.
          const { data, error } = await supabase
            .rpc('echo_all_cities')
            .ilike('name', '%la%')
          ```

  .is():
    $ref: '@supabase/postgrest-js."lib/PostgrestFilterBuilder".PostgrestFilterBuilder.is'
    examples:
      - name: With `select()`
        isSpotlight: true
        js: |
          ```js
          const { data, error } = await supabase
            .from('cities')
            .select('name, country_id')
            .is('name', null)
          ```
      - name: With `update()`
        js: |
          ```js
          const { data, error } = await supabase
            .from('cities')
            .update({ name: 'Mordor' })
            .is('name', null)
          ```
      - name: With `delete()`
        js: |
          ```js
          const { data, error } = await supabase
            .from('cities')
            .delete()
            .is('name', null)
          ```
      - name: With `rpc()`
        js: |
          ```js
          // Only valid if the Postgres function returns a table type.
          const { data, error } = await supabase
            .rpc('echo_all_cities')
            .is('name', null)
          ```

  .in():
    $ref: '@supabase/postgrest-js."lib/PostgrestFilterBuilder".PostgrestFilterBuilder.in'
    examples:
      - name: With `select()`
        isSpotlight: true
        js: |
          ```js
          const { data, error } = await supabase
            .from('cities')
            .select('name, country_id')
            .in('name', ['Rio de Janeiro', 'San Francisco'])
          ```
      - name: With `update()`
        js: |
          ```js
          const { data, error } = await supabase
            .from('cities')
            .update({ name: 'Mordor' })
            .in('name', ['Rio de Janeiro', 'San Francisco'])
          ```
      - name: With `delete()`
        js: |
          ```js
          const { data, error } = await supabase
            .from('cities')
            .delete()
            .in('name', ['Rio de Janeiro', 'San Francisco'])
          ```
      - name: With `rpc()`
        js: |
          ```js
          // Only valid if the Postgres function returns a table type.
          const { data, error } = await supabase
            .rpc('echo_all_cities')
            .in('name', ['Rio de Janeiro', 'San Francisco'])
          ```

  .contains():
    $ref: '@supabase/postgrest-js."lib/PostgrestFilterBuilder".PostgrestFilterBuilder.cs'
    notes: |
      - `.contains()` can work on array columns or range columns.
        It is very useful for finding rows where a tag array contains all the values in the filter array.

        ```js
        .contains('arraycol',["a","b"]) // You can use a javascript array for an array column
        .contains('arraycol','{"a","b"}') // You can use a string with Postgres array {} for array column.
        .contains('rangecol','(1,2]') // Use Postgres range syntax for range column.
        .contains('rangecol',`(${arr}]`) // You can insert an array into a string.
        ```
    examples:
      - name: With `select()`
        isSpotlight: true
        js: |
          ```js
          const { data, error } = await supabase
            .from('countries')
            .select('name, id, main_exports')
            .contains('main_exports', ['oil'])
          ```
      - name: With `update()`
        js: |
          ```js
          const { data, error } = await supabase
            .from('countries')
            .update({ name: 'Mordor' })
            .contains('main_exports', ['oil'])
          ```
      - name: With `delete()`
        js: |
          ```js
          const { data, error } = await supabase
            .from('countries')
            .delete()
            .contains('main_exports', ['oil'])
          ```
      - name: With `rpc()`
        js: |
          ```js
          // Only valid if the Postgres function returns a table type.
          const { data, error } = await supabase
            .rpc('echo_all_countries')
            .contains('main_exports', ['oil'])
          ```

  .containedBy():
    $ref: '@supabase/postgrest-js."lib/PostgrestFilterBuilder".PostgrestFilterBuilder.cd'
    notes: |
      - `.containedBy()` can work on array columns or range columns.

        ```js
        .containedBy('arraycol',["a","b"]) // You can use a javascript array for an array column
        .containedBy('arraycol','{"a","b"}') // You can use a string with Postgres array {} for array column.
        .containedBy('rangecol','(1,2]') // Use Postgres range syntax for range column.
        .containedBy('rangecol',`(${arr}]`) // You can insert an array into a string.
        ```
    examples:
      - name: With `select()`
        isSpotlight: true
        js: |
          ```js
          const { data, error } = await supabase
            .from('countries')
            .select('name, id, main_exports')
            .containedBy('main_exports', ['cars', 'food', 'machine'])
          ```
      - name: With `update()`
        js: |
          ```js
          const { data, error } = await supabase
            .from('countries')
            .update({ name: 'Mordor' })
            .containedBy('main_exports', ['orks', 'surveillance', 'evil'])
          ```
      - name: With `delete()`
        js: |
          ```js
          const { data, error } = await supabase
            .from('countries')
            .delete()
            .containedBy('main_exports', ['cars', 'food', 'machine'])
          ```
      - name: With `rpc()`
        js: |
          ```js
          // Only valid if the Postgres function returns a table type.
          const { data, error } = await supabase
            .rpc('echo_all_countries')
            .containedBy('main_exports', ['cars', 'food', 'machine'])
          ```

  .rangeLt():
    $ref: '@supabase/postgrest-js."lib/PostgrestFilterBuilder".PostgrestFilterBuilder.sl'
    examples:
      - name: With `select()`
        isSpotlight: true
        js: |
          ```js
          const { data, error } = await supabase
            .from('countries')
            .select('name, id, population_range_millions')
            .rangeLt('population_range_millions', '[150, 250]')
          ```
      - name: With `update()`
        js: |
          ```js
          const { data, error } = await supabase
            .from('countries')
            .update({ name: 'Mordor' })
            .rangeLt('population_range_millions', '[150, 250]')
          ```
      - name: With `delete()`
        js: |
          ```js
          const { data, error } = await supabase
            .from('countries')
            .delete()
            .rangeLt('population_range_millions', '[150, 250]')
          ```
      - name: With `rpc()`
        js: |
          ```js
          // Only valid if the Postgres function returns a table type.
          const { data, error } = await supabase
            .rpc('echo_all_countries')
            .rangeLt('population_range_millions', '[150, 250]')
          ```

  .rangeGt():
    $ref: '@supabase/postgrest-js."lib/PostgrestFilterBuilder".PostgrestFilterBuilder.sr'
    examples:
      - name: With `select()`
        isSpotlight: true
        js: |
          ```js
          const { data, error } = await supabase
            .from('countries')
            .select('name, id, population_range_millions')
            .rangeGt('population_range_millions', '[150, 250]')
          ```
      - name: With `update()`
        js: |
          ```js
          const { data, error } = await supabase
            .from('countries')
            .update({ name: 'Mordor' })
            .rangeGt('population_range_millions', '[150, 250]')
          ```
      - name: With `delete()`
        js: |
          ```js
          const { data, error } = await supabase
            .from('countries')
            .delete()
            .rangeGt('population_range_millions', '[150, 250]')
          ```
      - name: With `rpc()`
        js: |
          ```js
          // Only valid if the Postgres function returns a table type.
          const { data, error } = await supabase
            .rpc('echo_all_countries')
            .rangeGt('population_range_millions', '[150, 250]')
          ```

  .rangeGte():
    $ref: '@supabase/postgrest-js."lib/PostgrestFilterBuilder".PostgrestFilterBuilder.nxl'
    examples:
      - name: With `select()`
        isSpotlight: true
        js: |
          ```js
          const { data, error } = await supabase
            .from('countries')
            .select('name, id, population_range_millions')
            .rangeGte('population_range_millions', '[150, 250]')
          ```
      - name: With `update()`
        js: |
          ```js
          const { data, error } = await supabase
            .from('countries')
            .update({ name: 'Mordor' })
            .rangeGte('population_range_millions', '[150, 250]')
          ```
      - name: With `delete()`
        js: |
          ```js
          const { data, error } = await supabase
            .from('countries')
            .delete()
            .rangeGte('population_range_millions', '[150, 250]')
          ```
      - name: With `rpc()`
        js: |
          ```js
          // Only valid if the Postgres function returns a table type.
          const { data, error } = await supabase
            .rpc('echo_all_countries')
            .rangeGte('population_range_millions', '[150, 250]')
          ```

  .rangeLte():
    $ref: '@supabase/postgrest-js."lib/PostgrestFilterBuilder".PostgrestFilterBuilder.nxr'
    examples:
      - name: With `select()`
        isSpotlight: true
        js: |
          ```js
          const { data, error } = await supabase
            .from('countries')
            .select('name, id, population_range_millions')
            .rangeLte('population_range_millions', '[150, 250]')
          ```
      - name: With `update()`
        js: |
          ```js
          const { data, error } = await supabase
            .from('countries')
            .update({ name: 'Mordor' })
            .rangeLte('population_range_millions', '[150, 250]')
          ```
      - name: With `delete()`
        js: |
          ```js
          const { data, error } = await supabase
            .from('countries')
            .delete()
            .rangeLte('population_range_millions', '[150, 250]')
          ```
      - name: With `rpc()`
        js: |
          ```js
          // Only valid if the Postgres function returns a table type.
          const { data, error } = await supabase
            .rpc('echo_all_countries')
            .rangeLte('population_range_millions', '[150, 250]')
          ```

  .rangeAdjacent():
    $ref: '@supabase/postgrest-js."lib/PostgrestFilterBuilder".PostgrestFilterBuilder.adj'
    examples:
      - name: With `select()`
        isSpotlight: true
        js: |
          ```js
          const { data, error } = await supabase
            .from('countries')
            .select('name, id, population_range_millions')
            .rangeAdjacent('population_range_millions', '[70, 185]')
          ```
      - name: With `update()`
        js: |
          ```js
          const { data, error } = await supabase
            .from('countries')
            .update({ name: 'Mordor' })
            .rangeAdjacent('population_range_millions', '[70, 185]')
          ```
      - name: With `delete()`
        js: |
          ```js
          const { data, error } = await supabase
            .from('countries')
            .delete()
            .rangeAdjacent('population_range_millions', '[70, 185]')
          ```
      - name: With `rpc()`
        js: |
          ```js
          // Only valid if the Postgres function returns a table type.
          const { data, error } = await supabase
            .rpc('echo_all_countries')
            .rangeAdjacent('population_range_millions', '[70, 185]')
          ```

  .overlaps():
    $ref: '@supabase/postgrest-js."lib/PostgrestFilterBuilder".PostgrestFilterBuilder.ov'
    notes: |
      - `.overlaps()` can work on array columns or range columns.

        ```js
        .overlaps('arraycol',["a","b"]) // You can use a javascript array for an array column
        .overlaps('arraycol','{"a","b"}') // You can use a string with Postgres array {} for array column.
        .overlaps('rangecol','(1,2]') // Use Postgres range syntax for range column.
        .overlaps('rangecol',`(${arr}]`)  // You can insert an array into a string.
        ```
    examples:
      - name: With `select()`
        isSpotlight: true
        js: |
          ```js
          const { data, error } = await supabase
            .from('countries')
            .select('name, id, main_exports')
            .overlaps('main_exports', ['computers', 'minerals'])
          ```
      - name: With `update()`
        js: |
          ```js
          let countries = await supabase
            .from('countries')
            .update({ name: 'Mordor' })
            .overlaps('main_exports', ['computers', 'minerals'])
          ```
      - name: With `delete()`
        js: |
          ```js
          const { data, error } = await supabase
            .from('countries')
            .delete()
            .overlaps('main_exports', ['computers', 'minerals'])
          ```
      - name: With `rpc()`
        js: |
          ```js
          // Only valid if the Postgres function returns a table type.
          const { data, error } = await supabase
            .rpc('echo_all_countries')
            .overlaps('main_exports', ['computers', 'minerals'])
          ```

  .textSearch():
    $ref: '@supabase/postgrest-js."lib/PostgrestFilterBuilder".PostgrestFilterBuilder.fts'
    examples:
      - name: Text search
        js: |
          ```js
          const { data, error } = await supabase
            .from('quotes')
            .select('catchphrase')
            .textSearch('catchphrase', `'fat' & 'cat'`, { 
              config: 'english' 
            })
          ```
      - name: Basic normalization
        description: Uses PostgreSQL's `plainto_tsquery` function.
        js: |
          ```js
          const { data, error } = await supabase
            .from('quotes')
            .select('catchphrase')
            .textSearch('catchphrase', `'fat' & 'cat'`, { 
              type: 'plain',
              config: 'english' 
            })
          ```
      - name: Full normalization
        description: Uses PostgreSQL's `phraseto_tsquery` function.
        js: |
          ```js
          const { data, error } = await supabase
            .from('quotes')
            .select('catchphrase')
            .textSearch('catchphrase', `'fat' & 'cat'`, { 
              type: 'phrase',
              config: 'english' 
            })
          ```
      - name: Websearch
        description: |
          Uses PostgreSQL's `websearch_to_tsquery` function. 
          This function will never raise syntax errors, which makes it possible to use raw user-supplied input for search, and can be used 
          with advanced operators.

          - `unquoted text`: text not inside quote marks will be converted to terms separated by & operators, as if processed by plainto_tsquery.
          - `"quoted text"`: text inside quote marks will be converted to terms separated by <-> operators, as if processed by phraseto_tsquery.
          - `OR`: the word “or” will be converted to the | operator.
          - `-`: a dash will be converted to the ! operator.

        js: |
          ```js
          const { data, error } = await supabase
            .from('quotes')
            .select('catchphrase')
            .textSearch('catchphrase', `'fat or cat'`, { 
              type: 'websearch',
              config: 'english'
            })
          ```

  .filter():
    $ref: '@supabase/postgrest-js."lib/PostgrestFilterBuilder".PostgrestFilterBuilder.filter'
    notes: |
      - `.filter()` expects you to use the raw [PostgREST syntax](https://postgrest.org/en/stable/api.html#horizontal-filtering-rows) for the filter names and values, so it should only be used as an escape hatch in case other filters don't work.
        ```js
          .filter('arraycol','cs','{"a","b"}') // Use Postgres array {} for array column and 'cs' for contains.
          .filter('rangecol','cs','(1,2]') // Use Postgres range syntax for range column.
          .filter('id','in','(6,7)')  // Use Postgres list () for in filter.
          .filter('id','in',`(${arr})`)  // You can insert a javascript array.
        ```
    examples:
      - name: With `select()`
        isSpotlight: true
        js: |
          ```js
          const { data, error } = await supabase
            .from('cities')
            .select('name, country_id')
            .filter('name', 'in', '("Paris","Tokyo")')
          ```
      - name: With `update()`
        js: |
          ```js
          const { data, error } = await supabase
            .from('cities')
            .update({ name: 'Mordor' })
            .filter('name', 'in', '("Paris","Tokyo")')
          ```
      - name: With `delete()`
        js: |
          ```js
          const { data, error } = await supabase
            .from('cities')
            .delete()
            .filter('name', 'in', '("Paris","Tokyo")')
          ```
      - name: With `rpc()`
        js: |
          ```js
          // Only valid if the Postgres function returns a table type.
          const { data, error } = await supabase
            .rpc('echo_all_cities')
            .filter('name', 'in', '("Paris","Tokyo")')
          ```
      - name: Filter embedded resources
        js: |
          ```js
          const { data, error } = await supabase
            .from('cities')
            .select('name, countries ( name )')
            .filter('countries.name', 'in', '("France","Japan")')
          ```