Local API

The FrogBot Local API gives you the ability to execute the same operations that are available through REST and GraphQL within Node, directly on your server. Here, you don’t need to deal with server latency or network speed whatsoever and can interact directly with your database.

The Local API is incredibly powerful when used in React Server Components and other similar server-side contexts. With FrogBot, you don’t have to leave your server to gather the data you need. It can be incredibly fast and is definitely a game changer.

Here are some common examples of how you can use the Local API:

Fetching FrogBot data within React Server Components
Seeding data via Node seed scripts that you write and maintain
Opening custom Next.js route handlers which feature additional functionality but still rely on FrogBot
Within Access Control and Hooks

Accessing FrogBot

You can gain access to the currently running frogbot object via two ways:

Accessing from args or `req`

In most places within FrogBot itself, you can access frogbot directly from the arguments of Hooks, Access Control, validation functions, and similar. This is the simplest way to access FrogBot in most cases. Most config functions take the req (Request) object, which has FrogBot bound to it (req.frogbot). Example:

const afterChangeHook: CollectionAfterChangeHook = async ({
  req: { frogbot },
}) => {
  const posts = await frogbot.find({
    collection: 'posts',
    overrideAccess: true,
  })
}

Importing it

If you want to import FrogBot in places where you don’t have the option to access it from function arguments or req, you can import it and initialize it.

import { getFrogBot } from 'frogbot'
import config from '@frogbot-config'

const frogbot = await getFrogBot({ config })

getFrogBot accepts:

Option	Type	Default	Description
`config`	`FrogBotSanitizedConfig \| Promise<FrogBotSanitizedConfig>`	Required	The result of `buildConfig`, usually imported from `@frogbot-config`.
`disableDBConnect`	`boolean`	`false`	Starts FrogBot without connecting to the database.
`disableOnInit`	`boolean`	`false`	Skips the config’s `onInit` callbacks, the `onInit` option, trigger reconciliation, autonumber numbering of existing records, and the development-only type and import map generation.
`onInit`	`(frogbot: FrogBot) => void \| Promise<void>`	—	Runs once after startup, before the config’s `onInit` callbacks.
`startChannelGateway`	`boolean`	`true`	Opens gateway connections for channels that need one, such as Discord. Set `false` when `frogbot channels:run` holds the connection in another process.

getFrogBot caches the instance. Later calls with the same config return it and ignore these options. If you’re working in Next.js’ development mode, FrogBot will work with Hot Module Replacement (HMR), and as you make changes to your FrogBot Config, your usage of FrogBot will always be in sync with your changes. In production, getFrogBot simply disables all HMR functionality so you don’t need to write your code any differently. We handle optimization for you in production mode. If you are accessing FrogBot via function arguments or req.frogbot, HMR is automatically supported if you are using it within Next.js. For more information about using FrogBot outside of Next.js, click here.

Local options available

You can specify more options within the Local API vs. REST or GraphQL due to the server-only context that they are executed in.

Local Option	Type	Default	Description
`collection`	`string`	Required	The slug of the collection to operate against.
`context`	`Record<string, unknown>`	—	Context, which will then be passed to `context` and `req.context`, which can be read by hooks. Useful if you want to pass additional information to the hooks which shouldn’t be necessarily part of the document, for example a `triggerBeforeChange` option which can be read by the BeforeChange hook to determine if it should run or not.
`depth`	`number`	`defaultDepth` (`1`)	Control auto-population of nested relationship and upload fields. Capped at `maxDepth`.
`disableErrors`	`boolean`	`false`	When set to `true`, errors will not be thrown. Instead, the `findByID` operation will return `null`, and the `find` operation will return an empty documents array.
`fallbackLocale`	`string`	The locale’s `fallbackLocale`, then `defaultLocale`, when `localization.fallback` is on	Specify a fallback locale to use for any returned documents. Pass `'none'` to turn fallback off.
`locale`	`string`	`defaultLocale`	Specify locale for any returned documents. Pass `'all'` to return every locale.
`overrideAccess`	`boolean`	`false`	Access control runs as `user` or `req.user` unless this is `true`. Pass it on every call: `true` for trusted server work such as scripts, seeds and jobs, `false` with `user` or `req` when acting for a signed-in user.
`populate`	`Record<string, unknown>`	—	Specify populate to control which fields to include to the result from populated documents.
`req`	`FrogBotRequest`	Created for the call	The current request. Pass it to run in the same transaction and give hooks the same `req.user` and `req.context`.
`select`	`SelectType`	—	Specify select to control which fields to include to the result.
`showHiddenFields`	`boolean`	`false`	Opt-in to receiving hidden fields. By default, they are hidden from returned documents in accordance to your config.
`user`	`object`	`req.user`	The user to check access against when `overrideAccess` is `false`.

Every operation below accepts these options, except that auth operations and restoreVersion don’t accept select. Each operation below lists the options it adds.

Transactions

When your database uses transactions you need to thread req through to all local operations. Postgres uses transactions and MongoDB uses transactions when you are using replica sets. Passing req without transactions is still recommended.

const post = await frogbot.find({
  collection: 'posts',
  overrideAccess: false,
  req, // passing req is recommended
})

By default, all access control checks are disabled in the Local API, but you can re-enable them if you’d like, as well as pass a specific user to run the operation with.

Collections

The following Collection operations are available through the Local API:

Create#collection-create

// The created Post document is returned
const post = await frogbot.create({
  collection: 'posts', // required
  data: {
    // required
    title: 'sure',
    description: 'maybe',
  },
  locale: 'en',
  fallbackLocale: 'none',
  user: dummyUserDoc,
  overrideAccess: true,
  showHiddenFields: false,

  // If creating verification-enabled auth doc,
  // you can optionally disable the email that is auto-sent
  disableVerificationEmail: true,

  // If your collection supports uploads, you can upload
  // a file directly through the Local API by providing
  // its full, absolute file path.
  filePath: path.resolve(__dirname, './path-to-image.jpg'),

  // Alternatively, you can directly pass a File,
  // if file is provided, filePath will be omitted
  file: uploadedFile,

  // If you want to create a document that is a duplicate of another document
  duplicateFromID: 'document-id-to-duplicate',
})

Accepts the common options plus:

Option	Type	Default	Description
`collection`	`string`	Required	The collection slug.
`data`	`object`	Required	The document data. Typed from your generated types.
`draft`	`boolean`	`false`	Save as a draft. Required fields aren’t validated unless `versions.drafts.validate` is on. Needs drafts.
`disableVerificationEmail`	`boolean`	`false`	Skips the verification email when creating a user in a collection with `auth.verify`.
`file`	`{ data: Buffer; mimetype: string; name: string; size: number; tempFilePath?: string }`	—	Upload collections only. The file to store. Takes precedence over `filePath`.
`filePath`	`string`	—	Upload collections only. Absolute path of a file on disk to store.
`overwriteExistingFiles`	`boolean`	`false`	Upload collections only. When a file with the same name is already stored, replace it instead of saving the upload under a numbered name such as `photo-1.jpg`.
`duplicateFromID`	`string \| number`	—	Copies the data of this document, and its file in an upload collection, into the new document. Fields in `data` override the copied values.
`disableTransaction`	`boolean`	`false`	Set to `true` to skip the database transaction the operation would otherwise open, so its write isn’t rolled back if a later step fails.

Find#collection-find

// Result will be a paginated set of Posts.
// See /queries/pagination for more.
const result = await frogbot.find({
  collection: 'posts', // required
  depth: 2,
  page: 1,
  limit: 10,
  pagination: false, // If you want to disable pagination count, etc.
  where: {}, // pass a `where` query here
  sort: '-title',
  locale: 'en',
  fallbackLocale: 'none',
  user: dummyUser,
  overrideAccess: false,
  showHiddenFields: true,
})

Accepts the common options plus:

Option	Type	Default	Description
`collection`	`string`	Required	The collection slug.
`where`	`Where`	—	A query that limits the documents.
`sort`	`string \| string[]`	Collection `defaultSort`	Sort by one or more fields. Prefix a field with `-` for descending order.
`limit`	`number`	`10`	Documents per page. `0` returns every document. See Pagination.
`page`	`number`	`1`	The page to return.
`pagination`	`boolean`	`true`	Set `false` to return all matching documents and skip counting them.
`draft`	`boolean`	`false`	Return the latest drafts instead of published documents. Needs drafts.
`joins`	`JoinQuery`	—	Pagination, sort, and filters per join field, such as `{ relatedPosts: { limit: 5 } }`. Set a join field to `false` to leave it out, or pass `false` to leave every join field out.

pagination, page, and limit are three related properties documented here.

Find by ID#collection-find-by-id

// Result will be a Post document.
const result = await frogbot.findByID({
  collection: 'posts', // required
  id: '507f1f77bcf86cd799439011', // required
  depth: 2,
  locale: 'en',
  fallbackLocale: 'none',
  user: dummyUser,
  overrideAccess: false,
  showHiddenFields: true,
})

Accepts the common options plus:

Option	Type	Default	Description
`collection`	`string`	Required	The collection slug.
`id`	`string \| number`	Required	The document ID.
`draft`	`boolean`	`false`	Return the latest drafts instead of published documents. Needs drafts.
`joins`	`JoinQuery`	—	Pagination, sort, and filters per join field, such as `{ relatedPosts: { limit: 5 } }`. Set a join field to `false` to leave it out, or pass `false` to leave every join field out.

Count#collection-count

// Result will be an object with:
// {
//   totalDocs: 10, // count of the documents satisfies query
// }
const result = await frogbot.count({
  collection: 'posts', // required
  locale: 'en',
  where: {}, // pass a `where` query here
  user: dummyUser,
  overrideAccess: false,
})

Accepts the common options plus:

Option	Type	Default	Description
`collection`	`string`	Required	The collection slug.
`where`	`Where`	—	A query that limits the documents.

FindDistinct#collection-find-distinct

// Result will be an object with:
// {
//   values: [{ title: 'value-1' }, { title: 'value-2' }], // one object per distinct value
//   totalDocs: 10, // count of the distinct values that match the query
//   limit: 10, // values per page
//   page: 1,
//   totalPages: 1,
//   hasNextPage: false,
//   hasPrevPage: false,
//   pagingCounter: 1,
// }
const result = await frogbot.findDistinct({
  collection: 'posts', // required
  locale: 'en',
  where: {}, // pass a `where` query here
  user: dummyUser,
  overrideAccess: false,
  field: 'title',
  sort: 'title',
})

Accepts the common options plus:

Option	Type	Default	Description
`collection`	`string`	Required	The collection slug.
`field`	`string`	Required	The field whose distinct values are returned.
`where`	`Where`	—	A query that limits the documents.
`sort`	`string \| string[]`	—	Sort the values.
`limit`	`number`	—	Values per page.
`page`	`number`	`1`	The page to return.
`pagination`	`boolean`	`true`	Set `false` to return every value.

Update by ID#collection-update-by-id

// Result will be the updated Post document.
const result = await frogbot.update({
  collection: 'posts', // required
  id: '507f1f77bcf86cd799439011', // required
  data: {
    // required
    title: 'sure',
    description: 'maybe',
  },
  depth: 2,
  locale: 'en',
  fallbackLocale: 'none',
  user: dummyUser,
  overrideAccess: false,
  overrideLock: false, // By default, document locks are ignored. Set to false to enforce locks.
  showHiddenFields: true,

  // If your collection supports uploads, you can upload
  // a file directly through the Local API by providing
  // its full, absolute file path.
  filePath: path.resolve(__dirname, './path-to-image.jpg'),

  // If you are uploading a file and would like to replace
  // the existing file instead of generating a new filename,
  // you can set the following property to `true`
  overwriteExistingFiles: true,
})

Accepts the common options plus:

Option	Type	Default	Description
`collection`	`string`	Required	The collection slug.
`id`	`string \| number`	Required	The document ID.
`data`	`object`	Required	The fields to change.
`autosave`	`boolean`	`false`	Saves the update as an autosave draft. Needs `versions.drafts.autosave`.
`draft`	`boolean`	`false`	Save as a draft. Required fields aren’t validated unless `versions.drafts.validate` is on. Needs drafts.
`overrideLock`	`boolean`	`true`	Document locks are ignored by default. Set to `false` to throw while another user holds the lock on the document.
`filePath`	`string`	—	Upload collections only. Absolute path of a new file on disk to store in place of the current one.
`overwriteExistingFiles`	`boolean`	`false`	Upload collections only. When a file with the same name is already stored, replace it instead of saving the upload under a numbered name such as `photo-1.jpg`.
`publishAllLocales`	`boolean`	—	Publishes every locale. Needs status localization.
`unpublishAllLocales`	`boolean`	—	Unpublishes every locale. Needs status localization.
`disableTransaction`	`boolean`	`false`	Set to `true` to skip the database transaction the operation would otherwise open, so its write isn’t rolled back if a later step fails.

Update Many#collection-update-many

// Result will be an object with:
// {
//   docs: [], // each document that was updated
//   errors: [], // each error also includes the id of the document
// }
const result = await frogbot.update({
  collection: 'posts', // required
  where: {
    // required
    fieldName: { equals: 'value' },
  },
  data: {
    // required
    title: 'sure',
    description: 'maybe',
  },
  depth: 0,
  locale: 'en',
  fallbackLocale: 'none',
  user: dummyUser,
  overrideAccess: false,
  overrideLock: false, // By default, document locks are ignored. Set to false to enforce locks.
  showHiddenFields: true,

  // If your collection supports uploads, you can upload
  // a file directly through the Local API by providing
  // its full, absolute file path.
  filePath: path.resolve(__dirname, './path-to-image.jpg'),

  // If you are uploading a file and would like to replace
  // the existing file instead of generating a new filename,
  // you can set the following property to `true`
  overwriteExistingFiles: true,
})

Accepts the common options plus:

Option	Type	Default	Description
`collection`	`string`	Required	The collection slug.
`where`	`Where`	Required	A query selecting the documents.
`data`	`object`	Required	The fields to change on every matching document.
`draft`	`boolean`	`false`	Save as a draft. Required fields aren’t validated unless `versions.drafts.validate` is on. Needs drafts.
`overrideLock`	`boolean`	`true`	Document locks are ignored by default. Set to `false` to skip documents another user holds the lock on; each is reported in `errors`.
`filePath`	`string`	—	Upload collections only. Absolute path of a new file on disk to store in place of the current one.
`overwriteExistingFiles`	`boolean`	`false`	Upload collections only. When a file with the same name is already stored, replace it instead of saving the upload under a numbered name such as `photo-1.jpg`.
`publishAllLocales`	`boolean`	—	Publishes every locale. Needs status localization.
`unpublishAllLocales`	`boolean`	—	Unpublishes every locale. Needs status localization.
`disableTransaction`	`boolean`	`false`	Set to `true` to skip the database transaction the operation would otherwise open, so its write isn’t rolled back if a later step fails.

Delete#collection-delete

// Result will be the now-deleted Post document.
const result = await frogbot.delete({
  collection: 'posts', // required
  id: '507f1f77bcf86cd799439011', // required
  depth: 2,
  locale: 'en',
  fallbackLocale: 'none',
  user: dummyUser,
  overrideAccess: false,
  overrideLock: false, // By default, document locks are ignored. Set to false to enforce locks.
  showHiddenFields: true,
})

Accepts the common options plus:

Option	Type	Default	Description
`collection`	`string`	Required	The collection slug.
`id`	`string \| number`	Required	The document ID.
`overrideLock`	`boolean`	`true`	Document locks are ignored by default. Set to `false` to throw while another user holds the lock on the document.
`disableTransaction`	`boolean`	`false`	Set to `true` to skip the database transaction the operation would otherwise open, so its write isn’t rolled back if a later step fails.

Delete Many#collection-delete-many

// Result will be an object with:
// {
//   docs: [], // each document that is now deleted
//   errors: [], // any errors that occurred, including the id of the errored on document
// }
const result = await frogbot.delete({
  collection: 'posts', // required
  where: {
    // required
    fieldName: { equals: 'value' },
  },
  depth: 0,
  locale: 'en',
  fallbackLocale: 'none',
  user: dummyUser,
  overrideAccess: false,
  overrideLock: false, // By default, document locks are ignored. Set to false to enforce locks.
  showHiddenFields: true,
})

Accepts the common options plus:

Option	Type	Default	Description
`collection`	`string`	Required	The collection slug.
`where`	`Where`	Required	A query selecting the documents.
`overrideLock`	`boolean`	`true`	Document locks are ignored by default. Set to `false` to skip documents another user holds the lock on; each is reported in `errors`.
`disableTransaction`	`boolean`	`false`	Set to `true` to skip the database transaction the operation would otherwise open, so its write isn’t rolled back if a later step fails.

Duplicate#collection-duplicate

// Result will be the new copy of the Post document.
const result = await frogbot.duplicate({
  collection: 'posts', // required
  overrideAccess: true,
  id: '507f1f77bcf86cd799439011', // required
})

Accepts the common options plus:

Option	Type	Default	Description
`collection`	`string`	Required	The collection slug.
`id`	`string \| number`	Required	The ID of the document to copy.
`disableTransaction`	`boolean`	`false`	Set to `true` to skip the database transaction the operation would otherwise open, so its write isn’t rolled back if a later step fails.

Fails when the collection sets disableDuplicate. Field beforeDuplicate hooks run on the copied data.

Versions

If a collection has Versions enabled, these operations are available:

Find Versions#collection-find-versions

// Result will be a paginated set of versions.
const result = await frogbot.findVersions({
  collection: 'posts', // required
  overrideAccess: true,
  where: { parent: { equals: '507f1f77bcf86cd799439011' } },
  sort: '-updatedAt',
  limit: 10,
})

Accepts the common options plus:

Option	Type	Default	Description
`collection`	`string`	Required	The collection slug.
`where`	`Where`	—	A query on version documents, such as `{ parent: { equals: id } }`.
`sort`	`string \| string[]`	—	Sort by one or more version fields, such as `'-updatedAt'`.
`limit`	`number`	`10`	Versions per page.
`page`	`number`	`1`	The page to return.
`pagination`	`boolean`	`true`	Set `false` to return all matching versions.

Find Version by ID#collection-find-version-by-id

const version = await frogbot.findVersionByID({
  collection: 'posts', // required
  overrideAccess: true,
  id: '61cf752c19cdf1b1af7b61f1', // required
})

Accepts the common options plus:

Option	Type	Default	Description
`collection`	`string`	Required	The collection slug.
`id`	`string \| number`	Required	The version ID.

Count Versions#collection-count-versions

const { totalDocs } = await frogbot.countVersions({
  collection: 'posts', // required
  overrideAccess: true,
  where: { parent: { equals: '507f1f77bcf86cd799439011' } },
})

Accepts the common options plus:

Option	Type	Default	Description
`collection`	`string`	Required	The collection slug.
`where`	`Where`	—	A query on version documents.

Restore Version#collection-restore-version

// Result will be the document with the version's data.
const post = await frogbot.restoreVersion({
  collection: 'posts', // required
  overrideAccess: true,
  id: '61cf752c19cdf1b1af7b61f1', // required
})

Accepts the common options, except select, plus:

Option	Type	Default	Description
`collection`	`string`	Required	The collection slug.
`id`	`string \| number`	Required	The ID of the version to restore.

Auth Operations

If a collection has Authentication enabled, additional Local API operations will be available:

Auth

// If you're using Next.js, you'll have to import headers from next/headers, like so:
// import { headers as nextHeaders } from 'next/headers'

// you'll also have to await headers inside your function, or component, like so:
// const headers = await nextHeaders()

// If you're using FrogBot outside of Next.js, you'll have to provide headers accordingly.

// result will be formatted as follows:
// {
//    permissions: { ... }, // object containing current user's permissions
//    user: { ... }, // currently logged in user's document
//    responseHeaders: { ... } // returned headers from the response
// }

const result = await frogbot.auth({ headers, canSetHeaders: false })

Option	Type	Default	Description
`headers`	`Headers`	Required	The incoming request headers, read for the auth cookie, `Authorization` header, or API key.
`canSetHeaders`	`boolean`	`false`	Lets auth strategies return `responseHeaders`, such as a refreshed cookie. They come back as `result.responseHeaders`.
`req`	`FrogBotRequest`	—	The current request, passed to custom strategies.

auth doesn’t accept the common options.

// result will be formatted as follows:
// {
//   token: 'o38jf0q34jfij43f3f...', // JWT used for auth
//   user: { ... } // the user document that just logged in
//   exp: 1609619861 // the UNIX timestamp when the JWT will expire
// }

const result = await frogbot.login({
  collection: 'users', // required
  data: {
    // required
    email: 'dev@frogbot.com',
    password: 'rip',
  },
  req: req, // optional, pass a Request object to be provided to all hooks
  depth: 2,
  locale: 'en',
  fallbackLocale: 'none',
  overrideAccess: false,
  showHiddenFields: true,
})

Accepts the common options, except select, plus:

Option	Type	Default	Description
`collection`	`string`	Required	The collection slug.
`data`	`{ email: string; password: string }`	Required	The user’s credentials.

Forgot Password

// Returned token will allow for a password reset
const token = await frogbot.forgotPassword({
  collection: 'users', // required
  data: {
    // required
    email: 'dev@frogbot.com',
  },
  req: req, // pass a Request object to be provided to all hooks
})

Accepts the common options, except select, plus:

Option	Type	Default	Description
`collection`	`string`	Required	The collection slug.
`data`	`{ email: string }`	Required	The email address of the user.
`disableEmail`	`boolean`	`false`	Generates the token without sending the reset email.
`expiration`	`number`	`3600000`	How long the token stays valid, in milliseconds.

Reset Password

// Result will be formatted as follows:
// {
//   token: 'o38jf0q34jfij43f3f...', // JWT used for auth
//   user: { ... } // the user document that just logged in
// }
const result = await frogbot.resetPassword({
  collection: 'users', // required
  data: {
    // required
    password: req.body.password, // the new password to set
    token: 'afh3o2jf2p3f...', // the token generated from the forgotPassword operation
  },
  req: req, // optional, pass a Request object to be provided to all hooks
})

Accepts the common options, except select, plus:

Option	Type	Default	Description
`collection`	`string`	Required	The collection slug.
`data`	`{ password: string; token: string }`	Required	The new password and the token from `forgotPassword`.

Unlock

// Returned result will be a boolean representing success or failure
const result = await frogbot.unlock({
  collection: 'users', // required
  data: {
    // required
    email: 'dev@frogbot.com',
  },
  req: req, // optional, pass a Request object to be provided to all hooks
  overrideAccess: true,
})

Accepts the common options, except select, plus:

Option	Type	Default	Description
`collection`	`string`	Required	The collection slug.
`data`	`{ email: string }`	Required	The email address of the user to unlock.

Verify

// Returned result will be a boolean representing success or failure
const result = await frogbot.verifyEmail({
  collection: 'users', // required
  token: 'afh3o2jf2p3f...', // the token saved on the user as `_verificationToken`
})

Accepts the common options, except select, plus:

Option	Type	Default	Description
`collection`	`string`	Required	The collection slug.
`token`	`string`	Required	The user’s verification token.

TypeScript

Local API calls will automatically infer your generated types. Here is an example of usage:

// Properly inferred as `Post` type
const post = await frogbot.create({
  collection: 'posts',
  overrideAccess: true,

  // Data will now be typed as Post and give you type hints
  data: {
    title: 'my title',
    description: 'my description',
  },
})

Start here

Basics

Managing Data

Features

Ecosystem

Deployment

Accessing FrogBot

Accessing from args or `req`

Importing it

Local options available

Transactions

Collections

Create#collection-create

Find#collection-find

Find by ID#collection-find-by-id

Count#collection-count

FindDistinct#collection-find-distinct

Update by ID#collection-update-by-id

Update Many#collection-update-many

Delete#collection-delete

Delete Many#collection-delete-many

Duplicate#collection-duplicate

Versions

Find Versions#collection-find-versions

Find Version by ID#collection-find-version-by-id

Count Versions#collection-count-versions

Restore Version#collection-restore-version

Auth Operations

Auth

Forgot Password

Reset Password

Unlock

Verify

TypeScript

​Accessing FrogBot

​Accessing from args or req

​Importing it

​Local options available

​Transactions

​Collections

​Create#collection-create

​Find#collection-find

​Find by ID#collection-find-by-id

​Count#collection-count

​FindDistinct#collection-find-distinct

​Update by ID#collection-update-by-id

​Update Many#collection-update-many

​Delete#collection-delete

​Delete Many#collection-delete-many

​Duplicate#collection-duplicate

​Versions

​Find Versions#collection-find-versions

​Find Version by ID#collection-find-version-by-id

​Count Versions#collection-count-versions

​Restore Version#collection-restore-version

​Auth Operations

​Auth

​Login

​Forgot Password

​Reset Password

​Unlock

​Verify

​TypeScript

Accessing FrogBot

Accessing from args or `req`

Importing it

Local options available

Transactions

Collections

Create#collection-create

Find#collection-find

Find by ID#collection-find-by-id

Count#collection-count

FindDistinct#collection-find-distinct

Update by ID#collection-update-by-id

Update Many#collection-update-many

Delete#collection-delete

Delete Many#collection-delete-many

Duplicate#collection-duplicate

Versions

Find Versions#collection-find-versions

Find Version by ID#collection-find-version-by-id

Count Versions#collection-count-versions

Restore Version#collection-restore-version

Auth Operations

Auth

Login

Forgot Password

Reset Password

Unlock

Verify

TypeScript