noblox-asset.js 7.4.0

package/lib/datastores/deleteDatastoreEntry.js

@@ -0,0 +1,56 @@
+// Includes
+const http = require('../util/http.js').func
+const RobloxAPIError = require('../util/apiError.js')
+
+// Args
+exports.required = ['universeId', 'datastoreName', 'entryKey']
+exports.optional = ['scope', 'jar']
+
+// Docs
+/**
+ * <p> ☁️ Marks the entry as deleted by creating a tombstone version. Entries are deleted permanently after 30 days. </p>
+ * API Key Permissions:
+ * <ul>
+ *  <li> Delete entry </li>
+ * </ul>
+ * @category Datastores
+ * @param {number} universeId - The ID of the universe
+ * @param {string} datastoreName - Name of the data store
+ * @param {string} entryKey - The key which identifies the entry.
+ * @param {string=} [scope=global] - Defaults to global, similar to Lua API.
+ * @returns {Promise<void>}
+ * @example const noblox = require("noblox.js")
+ * await noblox.deleteDatastoreEntry({ universeId: 127407415, datastoreName: 'LevelStore', entryKey: 'Level_User' })
+**/
+
+// Define
+function deleteDatastoreEntry (universeId, datastoreName, entryKey, scope = 'global', jar) {
+  return new Promise((resolve, reject) => {
+    const httpOpt = {
+      url: `//apis.roblox.com/datastores/v1/universes/${universeId}/standard-datastores/datastore/entries/entry`,
+      options: {
+        resolveWithFullResponse: true,
+        method: 'DELETE',
+        jar,
+        qs: {
+          datastoreName,
+          scope,
+          entryKey
+        }
+      }
+    }
+    return http(httpOpt)
+      .then(function (res) {
+        if (res.statusCode === 204) {
+          resolve()
+        } else {
+          reject(new RobloxAPIError(res))
+        }
+      })
+      .catch(error => reject(error))
+  })
+}
+
+exports.func = function (args) {
+  return deleteDatastoreEntry(args.universeId, args.datastoreName, args.entryKey, args.scope, args.jar)
+}

package/lib/datastores/getDatastoreEntry.js

@@ -0,0 +1,88 @@
+// Includes
+const http = require('../util/http.js').func
+const RobloxAPIError = require('../util/apiError.js')
+
+// Args
+exports.required = ['universeId', 'datastoreName', 'entryKey']
+exports.optional = ['scope', 'versionId', 'jar']
+
+// Docs
+/**
+ * <p> ☁️ Returns the latest value and metadata associated with an entry, or a specific version if versionId is provided. </p>
+ * API Key Permissions:
+ * <ul>
+ *  <li> Read entries </li>
+ *  <li> Read version </li>
+ * </ul>
+ * @category Datastores
+ * @param {number} universeId - The ID of the universe
+ * @param {string} datastoreName - Name of the data store
+ * @param {string} entryKey - The key which identifies the entry.
+ * @param {string=} [scope=global] - Defaults to global, similar to Lua API.
+ * @param {string=} versionId - The version to inspect
+ * @returns {Promise<DatastoreEntry>}
+ * @example const noblox = require("noblox.js")
+ * const entry = await noblox.getDatastoreEntry({ universeId: 127407415, datastoreName: 'LevelStore', entryKey: 'Level_User' })
+**/
+
+// Define
+function getDatastoreEntry (universeId, datastoreName, entryKey, scope = 'global', versionId, jar) {
+  return new Promise((resolve, reject) => {
+    const httpOpt = {
+      url: versionId ? `//apis.roblox.com/datastores/v1/universes/${universeId}/standard-datastores/datastore/entries/entry/versions/version` : `//apis.roblox.com/datastores/v1/universes/${universeId}/standard-datastores/datastore/entries/entry`,
+      options: {
+        resolveWithFullResponse: true,
+        method: 'GET',
+        jar,
+        qs: {
+          datastoreName,
+          scope,
+          entryKey,
+          versionId
+        }
+      }
+    }
+    return http(httpOpt)
+      .then(function (res) {
+        if (res.statusCode === 200) {
+          const response = JSON.parse(res.body)
+          const headers = res.headers
+
+          resolve({
+            data: response,
+            metadata: {
+              robloxEntryCreatedTime: new Date(headers['roblox-entry-created-time']),
+              lastModified: headers['last-modified'] ? new Date(headers['last-modified']) : new Date(headers['roblox-entry-created-time']),
+              robloxEntryVersion: headers['roblox-entry-version'],
+              robloxEntryAttributes: headers['roblox-entry-attributes'],
+              robloxEntryUserIDs: headers['roblox-entry-userids'],
+              contentMD5: headers['content-md5'],
+              contentLength: parseInt(headers['content-length'])
+            }
+          })
+        } else if (res.statusCode === 204) {
+          const headers = res.headers
+
+          resolve({
+            data: null,
+            metadata: {
+              robloxEntryCreatedTime: new Date(headers['roblox-entry-created-time']),
+              lastModified: headers['last-modified'] ? new Date(headers['last-modified']) : new Date(headers['roblox-entry-created-time']),
+              robloxEntryVersion: headers['roblox-entry-version'],
+              robloxEntryAttributes: headers['roblox-entry-attributes'],
+              robloxEntryUserIDs: headers['roblox-entry-userids'],
+              contentMD5: headers['content-md5'],
+              contentLength: headers['content-length']
+            }
+          })
+        } else {
+          reject(new RobloxAPIError(res))
+        }
+      })
+      .catch(error => reject(error))
+  })
+}
+
+exports.func = function (args) {
+  return getDatastoreEntry(args.universeId, args.datastoreName, args.entryKey, args.scope, args.versionId, args.jar)
+}

package/lib/datastores/getDatastoreEntryVersions.js

@@ -0,0 +1,73 @@
+// Includes
+const http = require('../util/http.js').func
+const RobloxAPIError = require('../util/apiError.js')
+
+// Args
+exports.required = ['universeId', 'datastoreName', 'entryKey']
+exports.optional = ['scope', 'startTime', 'endTime', 'sortOrder', 'limit', 'cursor', 'jar']
+
+// Docs
+/**
+ * <p> ☁️ Returns a list of entry versions of an entry. </p>
+ * API Key Permissions:
+ * <ul>
+ *  <li> List versions </li>
+ * </ul>
+ * @category Datastores
+ * @param {number} universeId - The ID of the universe
+ * @param {string} datastoreName - Name of the data store
+ * @param {string} entryKey - The key which identifies the entry.
+ * @param {(string | boolean)=} [scope=global] - Defaults to global, similar to Lua API.
+ * @param {Date=} startTime - Don't consider versions older than this
+ * @param {Date=} endTime - Don't consider versions younger than this
+ * @param {("Ascending" | "Descending")=} [sortOrder=Ascending] - Older first (Ascending) or younger first (Descending)
+ * @param {number=} limit - Maximum number of items to return
+ * @param {string=} cursor - Provide to request the next set of data
+ * @returns {Promise<EntryVersionsResult>}
+ * @example const noblox = require("noblox.js")
+ * const versions = await noblox.getDatastoreEntryVersions({ universeId: 127407415, datastoreName: 'LevelStore', entryKey: 'Level_User' })
+**/
+
+// Define
+function getDatastoreEntryVersions (universeId, datastoreName, entryKey, scope = 'global', startTime, endTime, sortOrder, limit, cursor, jar) {
+  return new Promise((resolve, reject) => {
+    const httpOpt = {
+      url: `//apis.roblox.com/datastores/v1/universes/${universeId}/standard-datastores/datastore/entries/entry/versions`,
+      options: {
+        resolveWithFullResponse: true,
+        method: 'GET',
+        jar,
+        qs: {
+          datastoreName,
+          scope,
+          entryKey,
+          startTime,
+          endTime,
+          sortOrder,
+          limit,
+          cursor
+        }
+      }
+    }
+    return http(httpOpt)
+      .then(function (res) {
+        if (res.statusCode === 200) {
+          const response = JSON.parse(res.body)
+          response.versions = response.versions.map(version => {
+            version.createdTime = new Date(version.createdTime)
+            version.objectCreatedTime = new Date(version.objectCreatedTime)
+            return version
+          })
+
+          resolve(response)
+        } else {
+          reject(new RobloxAPIError(res))
+        }
+      })
+      .catch(error => reject(error))
+  })
+}
+
+exports.func = function (args) {
+  return getDatastoreEntryVersions(args.universeId, args.datastoreName, args.entryKey, args.scope, args.startTime, args.endTime, args.sortOrder, args.limit, args.cursor, args.jar)
+}

package/lib/datastores/getDatastoreKeys.js

@@ -0,0 +1,63 @@
+// Includes
+const http = require('../util/http.js').func
+const RobloxAPIError = require('../util/apiError.js')
+
+// Args
+exports.required = ['universeId', 'datastoreName']
+exports.optional = ['scope', 'prefix', 'limit', 'cursor', 'jar']
+
+// Docs
+/**
+ * <p> ☁️ Returns a list of entry keys within a data store. </p>
+ * API Key Permissions:
+ * <ul>
+ *  <li> List keys </li>
+ * </ul>
+ * @category Datastores
+ * @param {number} universeId - The ID of the universe
+ * @param {string} datastoreName - Name of the data store
+ * @param {(string | boolean)=} [scope=global] - Defaults to global, similar to Lua API. If set to true, returns keys from all scopes.
+ * @param {string=} prefix - Return only data stores with this prefix
+ * @param {number=} limit - Maximum number of items to return
+ * @param {string=} cursor - Provide to request the next set of data
+ * @returns {Promise<DatastoreKeysResult>}
+ * @example const noblox = require("noblox.js")
+ * const keys = await noblox.getDatastoreKeys({ universeId: 127407415, datastoreName: 'LevelStore' })
+**/
+
+// Define
+function getDatastoreKeys (universeId, datastoreName, scope = 'global', prefix, limit, cursor, jar) {
+  return new Promise((resolve, reject) => {
+    const httpOpt = {
+      url: `//apis.roblox.com/datastores/v1/universes/${universeId}/standard-datastores/datastore/entries`,
+      options: {
+        resolveWithFullResponse: true,
+        method: 'GET',
+        jar,
+        qs: {
+          datastoreName,
+          scope,
+          AllScopes: scope === true,
+          prefix,
+          limit,
+          cursor
+        }
+      }
+    }
+    return http(httpOpt)
+      .then(function (res) {
+        if (res.statusCode === 200) {
+          const response = JSON.parse(res.body)
+
+          resolve(response)
+        } else {
+          reject(new RobloxAPIError(res))
+        }
+      })
+      .catch(error => reject(error))
+  })
+}
+
+exports.func = function (args) {
+  return getDatastoreKeys(args.universeId, args.datastoreName, args.scope, args.prefix, args.limit, args.cursor, args.jar)
+}

package/lib/datastores/getDatastores.js

@@ -0,0 +1,62 @@
+// Includes
+const http = require('../util/http.js').func
+const RobloxAPIError = require('../util/apiError.js')
+
+// Args
+exports.required = ['universeId']
+exports.optional = ['prefix', 'limit', 'cursor', 'jar']
+
+// Docs
+/**
+ * <p> ☁️ Returns a list of data stores belonging to a universe. </p>
+ * API Key Permissions:
+ * <ul>
+ *  <li> List DataStores </li>
+ * </ul>
+ * @category Datastores
+ * @param {number} universeId - The ID of the universe whose data stores are being retrieved.
+ * @param {string=} prefix - Return only data stores with this prefix
+ * @param {number=} limit - Maximum number of items to return
+ * @param {string=} cursor - Provide to request the next set of data
+ * @returns {Promise<DatastoresResult>}
+ * @example const noblox = require("noblox.js")
+ * const datastores = await noblox.getDatastores(1117747196)
+**/
+
+// Define
+function getDatastores (universeId, prefix, limit, cursor, jar) {
+  return new Promise((resolve, reject) => {
+    const httpOpt = {
+      url: `//apis.roblox.com/datastores/v1/universes/${universeId}/standard-datastores`,
+      options: {
+        resolveWithFullResponse: true,
+        method: 'GET',
+        jar,
+        qs: {
+          prefix,
+          limit,
+          cursor
+        }
+      }
+    }
+    return http(httpOpt)
+      .then(function (res) {
+        if (res.statusCode === 200) {
+          const response = JSON.parse(res.body)
+          response.datastores = response.datastores.map(datastore => {
+            datastore.createdTime = new Date(datastore.createdTime)
+            return datastore
+          })
+
+          resolve(response)
+        } else {
+          reject(new RobloxAPIError(res))
+        }
+      })
+      .catch(error => reject(error))
+  })
+}
+
+exports.func = function (args) {
+  return getDatastores(args.universeId, args.prefix, args.limit, args.cursor, args.jar)
+}

package/lib/datastores/incrementDatastoreEntry.js

@@ -0,0 +1,83 @@
+// Includes
+const http = require('../util/http.js').func
+const crypto = require('crypto')
+const RobloxAPIError = require('../util/apiError.js')
+
+// Args
+exports.required = ['universeId', 'datastoreName', 'entryKey', 'incrementBy']
+exports.optional = ['scope', 'robloxEntryUserIDs', 'robloxEntryAttributes', 'jar']
+
+// Docs
+/**
+ * <p> ☁️ Increments the value for an entry by a given amount, or create a new entry with that amount. </p>
+ * API Key Permissions:
+ * <ul>
+ *  <li> Create entry </li>
+ *  <li> Update entry </li>
+ * </ul>
+ * @category Datastores
+ * @param {number} universeId - The ID of the universe
+ * @param {string} datastoreName - Name of the data store
+ * @param {string} entryKey - The key which identifies the entry.
+ * @param {number} incrementBy - The amount by which the entry should be incremented, or the starting value if it does not exist
+ * @param {string=} [scope=global] - Defaults to global, similar to Lua API.
+ * @param {Array<number>=} robloxEntryUserIDs - Comma-separated list of Roblox user IDs the entry is tagged with. If not provided, existing user IDs are cleared.
+ * @param {object=} robloxEntryAttributes - If not provided, existing attributes are cleared.
+ * @returns {Promise<DatastoreEntry>}
+ * @example const noblox = require("noblox.js")
+ * const entry = await noblox.incrementDatastoreEntry({ universeId: 127407415, datastoreName: 'LevelStore', entryKey: 'Level_User', incrementBy: 2 })
+**/
+
+// Define
+function incrementDatastoreEntry (universeId, datastoreName, entryKey, incrementBy, scope = 'global', robloxEntryUserIDs = [], robloxEntryAttributes, jar) {
+  return new Promise((resolve, reject) => {
+    const httpOpt = {
+      url: `//apis.roblox.com/datastores/v1/universes/${universeId}/standard-datastores/datastore/entries/entry/increment`,
+      options: {
+        resolveWithFullResponse: true,
+        method: 'POST',
+        jar,
+        qs: {
+          datastoreName,
+          scope,
+          entryKey,
+          incrementBy
+        },
+        headers: {
+          'Content-Type': 'application/json',
+          'content-md5': crypto.createHash('md5').update(JSON.stringify(incrementBy)).digest('base64'),
+          'roblox-entry-userids': JSON.stringify(robloxEntryUserIDs),
+          'roblox-entry-attributes': JSON.stringify(robloxEntryAttributes),
+          'content-length': '0'
+        }
+      }
+    }
+    return http(httpOpt)
+      .then(function (res) {
+        if (res.statusCode === 200) {
+          const response = JSON.parse(res.body)
+          const headers = res.headers
+
+          resolve({
+            data: response,
+            metadata: {
+              robloxEntryCreatedTime: new Date(headers['roblox-entry-created-time']),
+              lastModified: headers['last-modified'] ? new Date(headers['last-modified']) : new Date(headers['roblox-entry-created-time']),
+              robloxEntryVersion: headers['roblox-entry-version'],
+              robloxEntryAttributes: headers['roblox-entry-attributes'],
+              robloxEntryUserIDs: headers['roblox-entry-userids'],
+              contentMD5: headers['content-md5'],
+              contentLength: parseInt(headers['content-length'])
+            }
+          })
+        } else {
+          reject(new RobloxAPIError(res))
+        }
+      })
+      .catch(error => reject(error))
+  })
+}
+
+exports.func = function (args) {
+  return incrementDatastoreEntry(args.universeId, args.datastoreName, args.entryKey, args.incrementBy, args.scope, args.robloxEntryUserIDs, args.robloxEntryAttributes, args.jar)
+}

package/lib/datastores/setDatastoreEntry.js

@@ -0,0 +1,80 @@
+// Includes
+const http = require('../util/http.js').func
+const crypto = require('crypto')
+const RobloxAPIError = require('../util/apiError.js')
+
+// Args
+exports.required = ['universeId', 'datastoreName', 'entryKey', 'body']
+exports.optional = ['scope', 'matchVersion', 'exclusiveCreate', 'robloxEntryUserIDs', 'robloxEntryAttributes', 'jar']
+
+// Docs
+/**
+ * <p> ☁️ Sets the value, metadata and user IDs associated with an entry. </p>
+ * <p>
+ * Note: You cannot use both matchVersion and exclusiveCreate. MD5 checksum is automatically generated.
+ * </p>
+ * API Key Permissions:
+ * <ul>
+ *  <li> Create entry </li>
+ *  <li> Update entry </li>
+ * </ul>
+ * @category Datastores
+ * @param {number} universeId - The ID of the universe
+ * @param {string} datastoreName - Name of the data store
+ * @param {string} entryKey - The key which identifies the entry.
+ * @param {any} body - The value the key should be set to.
+ * @param {string=} [scope=global] - Defaults to global, similar to Lua API.
+ * @param {string=} matchVersion - Only update if current version matches this.
+ * @param {boolean} [exclusiveCreate=false] - Only create the entry if it does not exist.
+ * @param {Array<number>=} robloxEntryUserIDs - Comma-separated list of Roblox user IDs the entry is tagged with. If not provided, existing user IDs are cleared.
+ * @param {object=} robloxEntryAttributes - If not provided, existing attributes are cleared.
+ * @returns {Promise<EntryVersion>}
+ * @example const noblox = require("noblox.js")
+ * const response = await noblox.setDatastoreEntry({ universeId: 127407415, datastoreName: 'LevelStore', entryKey: 'Level_Random', body: 230, robloxEntryUserIDs: [55549140], robloxEntryAttributes: { node: true } }))
+**/
+
+// Define
+function setDatastoreEntry (universeId, datastoreName, entryKey, body, scope = 'global', matchVersion, exclusiveCreate = false, robloxEntryUserIDs = [], robloxEntryAttributes, jar) {
+  return new Promise((resolve, reject) => {
+    const httpOpt = {
+      url: `//apis.roblox.com/datastores/v1/universes/${universeId}/standard-datastores/datastore/entries/entry`,
+      options: {
+        resolveWithFullResponse: true,
+        method: 'POST',
+        jar,
+        qs: {
+          datastoreName,
+          scope,
+          entryKey,
+          matchVersion,
+          exclusiveCreate
+        },
+        headers: {
+          'Content-Type': 'application/json',
+          'content-md5': crypto.createHash('md5').update(JSON.stringify(body)).digest('base64'),
+          'roblox-entry-userids': JSON.stringify(robloxEntryUserIDs),
+          'roblox-entry-attributes': JSON.stringify(robloxEntryAttributes)
+        },
+        body: JSON.stringify(body)
+      }
+    }
+    return http(httpOpt)
+      .then(function (res) {
+        if (res.statusCode === 200) {
+          const response = JSON.parse(res.body)
+
+          response.createdTime = new Date(response.createdTime)
+          response.objectCreatedTime = new Date(response.objectCreatedTime)
+
+          resolve(response)
+        } else {
+          reject(new RobloxAPIError(res))
+        }
+      })
+      .catch(error => reject(error))
+  })
+}
+
+exports.func = function (args) {
+  return setDatastoreEntry(args.universeId, args.datastoreName, args.entryKey, args.body, args.scope, args.matchVersion, args.exclusiveCreate, args.robloxEntryUserIDs, args.robloxEntryAttributes, args.jar)
+}

package/lib/develop/canManage.js

@@ -0,0 +1,42 @@
+// Includes
+const http = require('../util/http.js').func
+const RobloxAPIError = require('../util/apiError.js')
+
+// Args
+exports.required = ['userId', 'assetId']
+
+// Docs
+/**
+ * ✅ Returns whether the user can manage a given asset.
+ * @category Develop
+ * @alias canManage
+ * @param {number} userId - The id of the user.
+ * @param {number} assetId - The id of the asset.
+ * @returns {Promise<boolean>}
+ * @example const noblox = require("noblox.js")
+ * let canManage = await noblox.canManage(123456, 234567)
+**/
+
+// Define
+function canManage (userId, assetId) {
+  return http({
+    url: `//develop.roblox.com/v1/user/${userId}/canmanage/${assetId}`,
+    options: {
+      method: 'GET',
+      resolveWithFullResponse: true
+    }
+  })
+    .then(function (res) {
+      const { body } = res
+      const { Success: success, CanManage: canManage } = JSON.parse(body)
+      if (success) {
+        return canManage
+      } else {
+        throw new RobloxAPIError(res)
+      }
+    })
+}
+
+exports.func = function ({ userId, assetId }) {
+  return canManage(userId, assetId)
+}