@caruuto/caruuto-js 0.1.0

package/.editorconfig

@@ -0,0 +1,9 @@
+root = true
+
+[*]
+charset = utf-8
+end_of_line = lf
+indent_size = 2
+indent_style = space
+insert_final_newline = true
+trim_trailing_whitespace = true

package/.eslintignore

@@ -0,0 +1 @@
+node_modules

package/.eslintrc.js

@@ -0,0 +1,19 @@
+module.exports = {
+  env: {
+    es2021: true,
+    mocha: true,
+    node: true
+  },
+  extends: ['eslint:recommended', 'plugin:prettier/recommended'],
+  overrides: [],
+  parserOptions: {
+    ecmaVersion: 12,
+    sourceType: 'module'
+  },
+  plugins: [],
+  rules: {
+    'no-redeclare': 0,
+    'prettier/prettier': 0,
+    quotes: ['error', 'single']
+  }
+}

package/.prettierignore

@@ -0,0 +1 @@
+node_modules

package/CHANGELOG.md

@@ -0,0 +1,6 @@
+# Change Log
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](http://keepachangelog.com/)
+and this project adheres to [Semantic Versioning](http://semver.org/).

package/README.md

@@ -0,0 +1,3 @@
+# Caruuto JS
+
+> A high-level library for interacting with Caruuto

package/index.js

@@ -0,0 +1,41 @@
+const CaruutoClient = function (caruutoUrl, caruutoApiKey) {
+  this.options = {}
+  this.options.caruutoUrl = caruutoUrl
+  this.options.caruutoApiKey = caruutoApiKey
+
+  this.options.version = '1'
+  this.options.callback = this._processRequest.bind(this)
+}
+
+// -----------------------------------------
+// Attach fetcher
+// -----------------------------------------
+
+require('./lib/performFetch')(CaruutoClient)
+
+// -----------------------------------------
+// Attach helpers
+// -----------------------------------------
+
+require('./lib/helpers')(CaruutoClient)
+
+// -----------------------------------------
+// Attach filters
+// -----------------------------------------
+
+require('./lib/filters')(CaruutoClient)
+
+// -----------------------------------------
+// Attach terminators
+// -----------------------------------------
+
+require('./lib/terminators')(CaruutoClient)
+
+module.exports = CaruutoClient
+
+/**
+ * Creates a new Caruuto Client.
+ */
+module.exports.createClient = (caruutoUrl, caruutoApiKey) => {
+  return new CaruutoClient(caruutoUrl, caruutoApiKey)
+}

package/lib/filters.js

@@ -0,0 +1,321 @@
+module.exports = function (CaruutoClient) {
+  /**
+   * Select a page
+   *
+   * @param {Number} page
+   * @return API
+   * @api public
+   */
+  CaruutoClient.prototype.goToPage = function (page) {
+    this.page = page
+
+    return this
+  }
+
+  /**
+   * Select a collection
+   *
+   * @param {String} collection
+   * @return API
+   * @api public
+   */
+  CaruutoClient.prototype.in = function (collection) {
+    this.collection = collection
+
+    return this
+  }
+
+  /**
+   * Select a bucket
+   *
+   * @param {String} bucket
+   * @return API
+   * @api public
+   */
+  CaruutoClient.prototype.inMedia = function (bucket) {
+    bucket = bucket || true
+
+    this.mediaBucket = bucket
+
+    return this
+  }
+
+  /**
+   * Select a document limit
+   *
+   * @param {Number} limit
+   * @return API
+   * @api public
+   */
+  CaruutoClient.prototype.limitTo = function (limit) {
+    this.limit = limit
+
+    return this
+  }
+
+  /**
+   * Select a field to sort on and the sort direction
+   *
+   * @param {String} sortField
+   * @param {String} sortOrder
+   * @return API
+   * @api public
+   */
+  CaruutoClient.prototype.sortBy = function (sortField, sortOrder) {
+    this.sort = this.sort || {}
+    this.sort[sortField] = sortOrder === 'desc' ? -1 : 1
+
+    return this
+  }
+
+  /**
+   * Select the fields to retrieve
+   *
+   * @param {Array} fields
+   * @return API
+   * @api public
+   */
+  CaruutoClient.prototype.useFields = function (fields) {
+    if (fields !== undefined) {
+      const fieldsObj = {}
+
+      fields.forEach(function (field) {
+        fieldsObj[field] = 1
+      })
+
+      this.fields = JSON.stringify(fieldsObj)
+    }
+
+    return this
+  }
+
+  /**
+   * Select the version to be used
+   *
+   * @param {String} version
+   * @return API
+   * @api public
+   */
+  CaruutoClient.prototype.useVersion = function (version) {
+    this.customVersion = version
+
+    return this
+  }
+
+  /**
+   * Set the saved query to a Mongo query expression
+   *
+   * @param {Object} query
+   * @return API
+   * @api public
+   */
+  CaruutoClient.prototype.where = function (query) {
+    this.query = query
+
+    return this
+  }
+
+  /**
+   * Add a /^value/i regex expression to the saved query
+   *
+   * @param {String} field
+   * @param {String} value
+   * @return API
+   * @api public
+   */
+  CaruutoClient.prototype.whereFieldBeginsWith = function (field, value) {
+    this._addToQuery(field, '$regex', '^' + value)
+
+    return this
+  }
+
+  /**
+   * Add a /value/i regex expression to the saved query
+   *
+   * @param {String} field
+   * @param {String} value
+   * @return API
+   * @api public
+   */
+  CaruutoClient.prototype.whereFieldContains = function (field, value) {
+    this._addToQuery(field, '$regex', value)
+
+    return this
+  }
+
+  /**
+   * Add a negated /value/i regex expression to the saved query
+   *
+   * @param {String} field
+   * @param {String} value
+   * @return API
+   * @api public
+   */
+  CaruutoClient.prototype.whereFieldDoesNotContain = function (field, value) {
+    this._addToQuery(field, '$not', '/' + value + '/i')
+
+    return this
+  }
+
+  /**
+   * Add a {$exists: false} expression to the saved query
+   *
+   * @param {String} field
+   * @return API
+   * @api public
+   */
+  CaruutoClient.prototype.whereFieldDoesNotExist = function (field) {
+    this._addToQuery(field, '$eq', null)
+
+    return this
+  }
+
+  /**
+   * Add a /value$/i regex expression to the saved query
+   *
+   * @param {String} field
+   * @param {String} value
+   * @return API
+   * @api public
+   */
+  CaruutoClient.prototype.whereFieldEndsWith = function (field, value) {
+    this._addToQuery(field, '$regex', value + '$')
+
+    return this
+  }
+
+  /**
+   * Add a {$exists: true} expression to the saved query
+   *
+   * @param {String} field
+   * @return API
+   * @api public
+   */
+  CaruutoClient.prototype.whereFieldExists = function (field) {
+    this._addToQuery(field, '$ne', null)
+
+    return this
+  }
+
+  /**
+   * Add an exact match expression to the saved query
+   *
+   * @param {String} field
+   * @param {String} value
+   * @return API
+   * @api public
+   */
+  CaruutoClient.prototype.whereFieldIsEqualTo = function (field, value) {
+    this._addToQuery(field, value)
+
+    return this
+  }
+
+  /**
+   * Add a $gt expression to the saved query
+   *
+   * @param {String} field
+   * @param {Number} value
+   * @return API
+   * @api public
+   */
+  CaruutoClient.prototype.whereFieldIsGreaterThan = function (field, value) {
+    this._addToQuery(field, '$gt', value)
+
+    return this
+  }
+
+  /**
+   * Add a $gte expression to the saved query
+   *
+   * @param {String} field
+   * @param {Number} value
+   * @return API
+   * @api public
+   */
+  CaruutoClient.prototype.whereFieldIsGreaterThanOrEqualTo = function (
+    field,
+    value
+  ) {
+    this._addToQuery(field, '$gte', value)
+
+    return this
+  }
+
+  /**
+   * Add a $lt expression to the saved query
+   *
+   * @param {String} field
+   * @param {Number} value
+   * @return API
+   * @api public
+   */
+  CaruutoClient.prototype.whereFieldIsLessThan = function (field, value) {
+    this._addToQuery(field, '$lt', value)
+
+    return this
+  }
+
+  /**
+   * Add a $lte expression to the saved query
+   *
+   * @param {String} field
+   * @param {Number} value
+   * @return API
+   * @api public
+   */
+  CaruutoClient.prototype.whereFieldIsLessThanOrEqualTo = function (
+    field,
+    value
+  ) {
+    this._addToQuery(field, '$lte', value)
+
+    return this
+  }
+
+  /**
+   * Add a negated exact match expression to the saved query
+   *
+   * @param {String} field
+   * @param {String} value
+   * @return API
+   * @api public
+   */
+  CaruutoClient.prototype.whereFieldIsNotEqualTo = function (field, value) {
+    if (isNaN(value)) {
+      this._addToQuery(field, '$not', '/^' + value + '$/i')
+    } else {
+      this._addToQuery(field, '$ne', value)
+    }
+
+    return this
+  }
+
+  /**
+   * Add a $nin expression to the saved query
+   *
+   * @param {String} field
+   * @param {Array} matches
+   * @return API
+   * @api public
+   */
+  CaruutoClient.prototype.whereFieldIsNotOneOf = function (field, matches) {
+    this._addToQuery(field, '$nin', matches)
+
+    return this
+  }
+
+  /**
+   * Add a $in expression to the saved query
+   *
+   * @param {String} field
+   * @param {Array} matches
+   * @return API
+   * @api public
+   */
+  CaruutoClient.prototype.whereFieldIsOneOf = function (field, matches) {
+    this._addToQuery(field, '$in', matches)
+
+    return this
+  }
+}

package/lib/helpers.js

@@ -0,0 +1,246 @@
+const querystring = require('query-string')
+const parseUrl = require('url-parse')
+
+module.exports = function (CaruutoClient) {
+  /**
+   * Add a Mongo query expression to the save query
+   *
+   * @param {String} field
+   * @param {String} operator
+   * @param {String} value
+   * @return undefined
+   * @api private
+   */
+  CaruutoClient.prototype._addToQuery = function (field, operator, value) {
+    if (this.query === undefined) {
+      this.query = {}
+    }
+
+    if (this.query[field] === undefined) {
+      this.query[field] = {}
+    }
+
+    if (value === undefined) {
+      this.query[field] = operator
+    } else {
+      this.query[field][operator] = value
+    }
+  }
+
+  /**
+   * Build an API URL
+   *
+   * @param {Object} options
+   * @return String
+   * @api private
+   */
+  CaruutoClient.prototype._buildURL = function (options) {
+    // console.log('options :>> ', options)
+    options = options || {}
+
+    options.version = `v${this.options.version || 0}`
+
+    let url = ''
+
+    url += this.options.caruutoUrl
+    // url += ':' + this.options.port
+
+    if (this.mediaBucket) {
+      url +=
+        '/media' +
+        (typeof this.mediaBucket === 'string' ? '/' + this.mediaBucket : '')
+    } else if (this.collection) {
+      url += '/' + options.version + '/' + this.collection
+    } else {
+      url +=
+        '/' +
+        (this.customVersion !== undefined
+          ? this.customVersion
+          : options.version) +
+        '/' +
+        this.endpoint
+    }
+
+    if (options.signUrl) {
+      url += '/sign'
+    }
+
+    // if (options.config) {
+    //   url += '/config'
+    // }
+
+    if (options.status) {
+      url += '/status'
+    }
+
+    if (options.collections) {
+      url += '/api/contentTypes'
+    }
+
+    // if (options.stats) {
+    //   url += '/stats'
+    // }
+
+    if (this.count) {
+      url += '/count'
+    }
+
+    if (options.id) {
+      url += '/' + options.id
+    }
+
+    if (options.useParams) {
+      const params = {}
+
+      if (this.query) {
+        params.filter = JSON.stringify(this._encodeObjectKeys(this.query))
+      }
+
+      if (this.fields) {
+        params.fields = this.fields
+      }
+
+      if (!isNaN(parseInt(this.limit))) {
+        params.count = this.limit
+      }
+
+      if (this.page) {
+        params.page = this.page
+      }
+
+      if (this.compose !== undefined) {
+        params.compose = this.compose
+      }
+
+      if (typeof this.history !== 'undefined') {
+        params.includeHistory = this.history
+      }
+
+      if (this.sort) {
+        params.sort = JSON.stringify(this.sort)
+      }
+
+      const paramsStr = querystring.stringify(params, {
+        encode: false
+      })
+
+      if (paramsStr.length > 0) {
+        url += '?' + paramsStr
+      }
+    }
+
+    return url
+  }
+
+  /**
+   * Formats a request as an object
+   *
+   * @param {Object} options - request options
+   * @return Object
+   * @api private
+   */
+  CaruutoClient.prototype._createRequestObject = function (options) {
+    const parsedUri = parseUrl(options.uri)
+    const requestObject = Object.assign({}, options, {
+      uri: {
+        href: parsedUri.href,
+        hostname: parsedUri.hostname,
+        path: parsedUri.path,
+        port: parsedUri.port,
+        protocol: parsedUri.protocol
+      }
+    })
+
+    if (this.headers) {
+      requestObject.headers = this.headers
+    }
+
+    if (typeof this.options.callback === 'function') {
+      return this.options.callback(requestObject, this)
+    }
+
+    return requestObject
+  }
+
+  /**
+   * Recursively URI encodes all properties of an object
+   * @param  {Object} object The object to encode
+   * @return {Object}        The encoded object
+   */
+  CaruutoClient.prototype._encodeObjectKeys = function (object) {
+    return Object.keys(object).reduce((result, key) => {
+      if (
+        object[key] &&
+        typeof object[key] === 'object' &&
+        !Array.isArray(object[key])
+      ) {
+        result[key] = this._encodeObjectKeys(object[key])
+      } else {
+        result[key] =
+          typeof object[key] === 'string'
+            ? encodeURIComponent(object[key])
+            : object[key]
+      }
+
+      return result
+    }, {})
+  }
+
+  /**
+   * Logs a message
+   *
+   * @param {String} message
+   * @return undefined
+   * @api private
+   */
+  CaruutoClient.prototype._log = function (message) {
+    if (console && console.log) {
+      console.log(`[Caruuto JS] ${message}`)
+    }
+  }
+
+  /**
+   * Clear any saved options and parameters
+   *
+   * @return undefined
+   * @api private
+   */
+  CaruutoClient.prototype._reset = function () {
+    this.params = {}
+    this.customVersion = undefined
+    this.property = undefined
+  }
+
+  /**
+   * Set a header on the response object
+   *
+   * @param {String} name
+   * @param {String} value
+   * @return undefined
+   * @api private
+   */
+  CaruutoClient.prototype._setHeader = function (name, value) {
+    this.headers = this.headers || {}
+
+    this.headers[name] = value
+  }
+
+  /**
+   * Strip reserved properties from document object
+   *
+   * @param {Object} document
+   * @return Object
+   * @api private
+   */
+  CaruutoClient.prototype._stripReservedProperties = function (document) {
+    const sanitisedDocument = {}
+
+    Object.keys(document).forEach(property => {
+      if (this.reservedProperties.indexOf(property) === -1) {
+        sanitisedDocument[property] = document[property]
+      }
+    })
+
+    return sanitisedDocument
+  }
+}

package/lib/performFetch.js

@@ -0,0 +1,72 @@
+const crossFetch = require('cross-fetch')
+const debug = require('debug')('caruuto-js')
+
+const resolveFetch = customFetch => {
+  let _fetch
+
+  if (customFetch) {
+    _fetch = customFetch
+  } else if (typeof fetch === 'undefined') {
+    _fetch = crossFetch
+  } else {
+    _fetch = fetch
+  }
+
+  return (...args) => _fetch(...args)
+}
+
+module.exports = function (CaruutoClient) {
+  /**
+   * Makes a request to API and handles possible failures
+   *
+   * @param {Object} options - request options
+   * @return Results
+   * @api private
+   */
+  CaruutoClient.prototype._processRequest = async function (requestObject) {
+    const fetch = resolveFetch(this.options.fetch)
+    const options = {
+      headers: Object.assign({}, requestObject.headers),
+      method: requestObject.method,
+      uri: requestObject.uri.href
+    }
+
+    if (requestObject.body) {
+      options.body = requestObject.body
+    }
+
+    if (
+      requestObject.headers &&
+      requestObject.headers['content-type'] &&
+      requestObject.headers['content-type'] !== 'application/json'
+    ) {
+      options.json = false
+    }
+
+    debug(`Querying URI: ${decodeURIComponent(options.uri)}`)
+
+    // console.log('options :>> ', options)
+
+    const response = await fetch(options.uri, options).catch(err => {
+      console.log('err :>> ', err)
+      return Promise.reject(err)
+    })
+
+    if (response.status >= 400) {
+      const err = new Error()
+      err.status = response.status
+      err.uri = options.uri
+
+      try {
+        const responseData = await response.json()
+
+        if (responseData.message) {
+          err.message = responseData.message
+        }
+      } catch (error) {}
+      return Promise.reject(err)
+    }
+
+    return await response.json()
+  }
+}

package/lib/terminators.js

@@ -0,0 +1,210 @@
+module.exports = function (CaruutoClient) {
+  /**
+   * Create one/multiple documents or hooks
+   *
+   * @param {Object} data
+   * @return Promise
+   * @api public
+   */
+  CaruutoClient.prototype.create = function (data) {
+    this.terminator = 'create'
+
+    const requestPayload = {
+      method: 'POST',
+      uri: this._buildURL()
+    }
+
+    // if (this._isValidHook()) {
+    //   requestPayload.body = data
+
+    //   this._setHeader('content-type', 'text/plain')
+    // } else {
+    requestPayload.body =
+      data instanceof Array
+        ? data.map(this._stripReservedProperties.bind(this))
+        : this._stripReservedProperties(data)
+    // }
+
+    return this._createRequestObject(requestPayload)
+  }
+
+  /**
+   * Delete the documents affected by the saved query
+   *
+   * @return Promise
+   * @api public
+   */
+  CaruutoClient.prototype.delete = function () {
+    this.terminator = 'delete'
+
+    const requestPayload = {
+      method: 'DELETE',
+      uri: this._buildURL()
+    }
+
+    // if (!this._isValidHook()) {
+    //   if (this.isClient) {
+    //     if (!this.isClient.id && !this.isClient.self) {
+    //       throw new Error(
+    //         'Unable run delete on all clients. Please use the whereClientIs() filter.'
+    //       )
+    //     }
+    //   } else {
+    if (this.query === undefined) {
+      throw new Error('Unable to find query for delete')
+    }
+
+    requestPayload.body = {
+      query: this.query
+    }
+    //   }
+    // }
+
+    return this._createRequestObject(requestPayload)
+  }
+
+  /**
+   * Get the documents affected by the saved query
+   *
+   * @return Promise
+   * @api public
+   */
+  CaruutoClient.prototype.find = function (options) {
+    this.terminator = 'find'
+
+    if (options && options.extractMetadata) {
+      this.count = true
+    }
+
+    return this._createRequestObject({
+      method: 'GET',
+      uri: this._buildURL({
+        useParams: true
+      })
+    })
+  }
+
+  /**
+   * Get a list of all collections
+   *
+   * @return Promise
+   * @api public
+   */
+  CaruutoClient.prototype.getCollections = function () {
+    this.terminator = 'getCollections'
+
+    return this._createRequestObject({
+      method: 'GET',
+      uri: this._buildURL({ collections: true })
+    })
+  }
+
+  /**
+   * Get the config for a collection if one is specified, or for main API if not
+   *
+   * @return Promise
+   * @api public
+   */
+  CaruutoClient.prototype.getConfig = function () {
+    this.terminator = 'getConfig'
+
+    return this._createRequestObject({
+      method: 'GET',
+      uri: this._buildURL({ config: true })
+    })
+  }
+
+  /**
+   * Get the languages supported by the API
+   *
+   * @return Promise
+   * @api public
+   */
+  // CaruutoClient.prototype.getLanguages = function () {
+  //   this.terminator = 'getLanguages'
+
+  //   return this._createRequestObject({
+  //     method: 'GET',
+  //     uri: this._buildURL({ languages: true })
+  //   })
+  // }
+
+  /**
+   * Get a signed URL for media upload
+   *
+   * @return Promise
+   * @api public
+   */
+  CaruutoClient.prototype.getSignedUrl = function (parameters) {
+    this.terminator = 'getSignedUrl'
+
+    return this._createRequestObject({
+      body: parameters,
+      method: 'POST',
+      uri: this._buildURL({ signUrl: true })
+    })
+  }
+
+  /**
+   * Get the status of the API
+   *
+   * @return Promise
+   * @api public
+   */
+  CaruutoClient.prototype.getStatus = function () {
+    this.terminator = 'getStatus'
+
+    return this._createRequestObject({
+      method: 'POST',
+      uri: this._buildURL({ status: true })
+    })
+  }
+
+  /**
+   * Update the documents affect by the saved query
+   *
+   * @param {Object} update
+   * @return Promise
+   * @api public
+   */
+  CaruutoClient.prototype.update = function (update) {
+    this.terminator = 'update'
+
+    const requestPayload = {
+      method: 'PUT',
+      uri: this._buildURL()
+    }
+
+    // if (this._isValidHook()) {
+    //   requestPayload.body = update
+
+    //   this._setHeader('content-type', 'text/plain')
+    // } else {
+    //   if (this.isClient) {
+    //     if (!this.isClient.id && !this.isClient.self) {
+    //       throw new Error(
+    //         'Unable to run update on all clients. Please use whereClientIs() or whereClientIsSelf() filters.'
+    //       )
+    //     }
+
+    //     // Remove `clientId` from the payload.
+    //     if (update.clientId) {
+    //       delete update.clientId
+    //     }
+
+    //     requestPayload.body = update
+    //   } else {
+    if (this.query === undefined) {
+      throw new Error('Unable to find query for update')
+    }
+
+    requestPayload.body = {
+      query: this.query,
+      update: this._stripReservedProperties(update)
+    }
+    // }
+    // }
+
+    return this._createRequestObject(requestPayload)
+  }
+}

package/package.json

@@ -0,0 +1,68 @@
+{
+  "name": "@caruuto/caruuto-js",
+  "version": "0.1.0",
+  "description": "A high-level library for interacting with Caruuto",
+  "exports": "./index.js",
+  "scripts": {
+    "test": "eslint --ext js,jsx . && prettier --write '**/*.{js,jsx,md,html,css}' && NODE_ENV=test mocha {test,core/test}/**/*.js",
+    "posttest": "./scripts/coverage.js"
+  },
+  "author": "Jim Lambie <jim@27.works>",
+  "license": "GPL",
+  "dependencies": {
+    "cross-fetch": "^3.1.6",
+    "debug": "^2.6.1",
+    "got": "^11.0.0",
+    "mocha": "^10.2.0",
+    "query-string": "5.0.1",
+    "url-parse": "1.4.3"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Caruuto/caruuto-js.git"
+  },
+  "bugs": {
+    "url": "https://github.com/Caruuto/caruuto-js/issues"
+  },
+  "engines": {
+    "node": ">=16"
+  },
+  "husky": {
+    "hooks": {
+      "pre-commit": "lint-staged"
+    }
+  },
+  "lint-staged": {
+    "*.{js,jsx,md,html,css}": [
+      "prettier --write",
+      "git add"
+    ]
+  },
+  "homepage": "https://github.com/Caruuto/caruuto-js",
+  "devDependencies": {
+    "coveralls": "^3.0.2",
+    "eslint": "8.5.0",
+    "eslint-config-next": "13.0.5",
+    "eslint-config-prettier": "^8.6.0",
+    "eslint-plugin-prettier": "^4.2.1",
+    "eslint-plugin-react": "^7.32.2",
+    "form-data": "^4.0.0",
+    "husky": "^8.0.0",
+    "lint-staged": "^13.2.1",
+    "mockery": "^1.7.0",
+    "nock": "^12.0.0",
+    "nyc": "^15.0.1",
+    "prettier": "2.8.4",
+    "prettier-standard": "^15.0.1",
+    "should": "^9.0.2",
+    "sinon": "^4.5.0",
+    "standard": "^16.0.3",
+    "supertest": "^4.0.0",
+    "underscore": "^1.8.3"
+  },
+  "standard.options": {
+    "ignore": [],
+    "plugins": [],
+    "envs": []
+  }
+}

package/scripts/coverage.js

@@ -0,0 +1,12 @@
+#! /usr/bin/env node
+
+const exec = require('child_process').exec
+
+if (process.env['CI']) {
+  exec(
+    'cat ./coverage/lcov.info | ./node_modules/coveralls/bin/coveralls.js',
+    (err, out) => {
+      if (err) console.log(err)
+    }
+  )
+}

package/x.js

@@ -0,0 +1,13 @@
+const { createClient } = require('./index')
+
+;(async () => {
+  const x = createClient('https://caruuto-next.27.works/api', 'apiKey2')
+
+  x.in('surveys')
+  // x.whereFieldContains('title', 'John')
+  x.goToPage(1)
+
+  const y = await x.find().catch(console.log)
+
+  console.log(y)
+})()