@unboundcx/sdk 1.0.0

package/services/notes.js

@@ -0,0 +1,137 @@
+export class NotesService {
+  constructor(sdk) {
+    this.sdk = sdk;
+  }
+
+  async list({
+    relatedId,
+    recordTypeId,
+    limit,
+    orderBy,
+    orderDirection,
+  }) {
+    this.sdk.validateParams(
+      { relatedId, limit, orderBy, orderDirection },
+      {
+        relatedId: { type: 'string', required: true },
+        recordTypeId: { type: 'string', required: false },
+        limit: { type: 'number', required: false },
+        orderBy: { type: 'string', required: false },
+        orderDirection: { type: 'string', required: false },
+      },
+    );
+
+    const params = {
+      query: {
+        relatedId,
+        recordTypeId,
+        limit,
+        orderBy,
+        orderDirection,
+      },
+    };
+
+    const result = await this.sdk._fetch('/notes', 'GET', params);
+    return result;
+  }
+
+  async create({
+    title,
+    relatedId,
+    recordTypeId,
+    content_html,
+    content_binary,
+    content_json,
+    version,
+  }) {
+    this.sdk.validateParams(
+      {
+        title,
+        relatedId,
+        recordTypeId,
+        content_html,
+        content_binary,
+        content_json,
+        version,
+      },
+      {
+        title: { type: 'string', required: false },
+        relatedId: { type: 'string', required: true },
+        recordTypeId: { type: 'string', required: false },
+        content_html: { type: 'string', required: false },
+        content_binary: { type: 'array', required: false },
+        content_json: { type: 'object', required: false },
+        version: { type: 'number', required: false },
+      },
+    );
+
+    const params = {
+      body: {
+        title,
+        relatedId,
+        recordTypeId,
+        content_html,
+        content_binary,
+        content_json,
+        version,
+      },
+    };
+
+    const result = await this.sdk._fetch('/notes', 'POST', params);
+    return result;
+  }
+
+  async update(
+    noteId,
+    { title, content_html, content_binary, content_json, version },
+  ) {
+    this.sdk.validateParams(
+      { noteId, title, content_html, content_binary, content_json, version },
+      {
+        noteId: { type: 'string', required: true },
+        title: { type: 'string', required: false },
+        content_html: { type: 'string', required: false },
+        content_binary: { type: 'array', required: false },
+        content_json: { type: 'object', required: false },
+        version: { type: 'number', required: false },
+      },
+    );
+
+    const params = {
+      body: {
+        title,
+        content_html,
+        content_binary,
+        content_json,
+        version,
+      },
+    };
+
+    const result = await this.sdk._fetch(`/notes/${noteId}`, 'PUT', params);
+    return result;
+  }
+
+  async delete(noteId) {
+    this.sdk.validateParams(
+      { noteId },
+      {
+        noteId: { type: 'string', required: true },
+      },
+    );
+
+    const result = await this.sdk._fetch(`/notes/${noteId}`, 'DELETE');
+    return result;
+  }
+
+  async get(noteId) {
+    this.sdk.validateParams(
+      { noteId },
+      {
+        noteId: { type: 'string', required: true },
+      },
+    );
+
+    const result = await this.sdk._fetch(`/notes/${noteId}`, 'GET');
+    return result;
+  }
+}

package/services/objects.js

@@ -0,0 +1,163 @@
+export class ObjectsService {
+  constructor(sdk) {
+    this.sdk = sdk;
+  }
+
+  async byId(id, query = {}) {
+    this.sdk.validateParams(
+      { id, query },
+      {
+        id: { type: 'string', required: true },
+        query: { type: 'object', required: false }
+      },
+    );
+
+    const params = {
+      query
+    }
+
+    const result = await this.sdk._fetch(`/object/${id}`, 'GET', params);
+    return result;
+  }
+
+  async query(object, query = {}) {
+    this.sdk.validateParams(
+      { object, query },
+      {
+        object: { type: 'string', required: true },
+        query: { type: 'object', required: false }
+      },
+    );
+
+    const params = {
+      query,
+    }
+
+    const result = await this.sdk._fetch(`/object/query/${object}`, 'GET', params);
+    return result;
+  }
+
+  async updateById(object, id, update) {
+    this.sdk.validateParams(
+      { object, id, update },
+      {
+        object: { type: 'string', required: true },
+        id: { type: 'string', required: true },
+        update: { type: 'object', required: true }
+      },
+    );
+
+    const params = {
+      body: {
+        where: {
+          id,
+        },
+        update,
+      },
+    }
+
+    const result = await this.sdk._fetch(`/object/${object}`, 'PUT', params);
+    return result;
+  }
+
+  async update(object, where, update) {
+    this.sdk.validateParams(
+      { object, where, update },
+      {
+        object: { type: 'string', required: true },
+        where: { type: 'object', required: true },
+        update: { type: 'object', required: true }
+      },
+    );
+
+    const params = {
+      body: {
+        where,
+        update,
+      },
+    }
+
+    const result = await this.sdk._fetch(`/object/${object}`, 'PUT', params);
+    return result;
+  }
+
+  async create(object, body = {}) {
+    this.sdk.validateParams(
+      { object, body },
+      {
+        object: { type: 'string', required: true },
+        body: { type: 'object', required: true }
+      },
+    );
+
+    const params = {
+      body
+    }
+
+    const result = await this.sdk._fetch(`/object/${object}`, 'POST', params);
+    return result;
+  }
+
+  async delete(object, where) {
+    this.sdk.validateParams(
+      { object, where },
+      {
+        object: { type: 'string', required: true },
+        where: { type: 'object', required: true }
+      },
+    );
+
+    const params = {
+      body: {
+        where
+      }
+    }
+
+    const result = await this.sdk._fetch(`/object/${object}`, 'DELETE', params);
+    return result;
+  }
+
+  async deleteById(object, id) {
+    this.sdk.validateParams(
+      { object, id },
+      {
+        object: { type: 'string', required: true },
+        id: { type: 'string', required: true }
+      },
+    );
+
+    const params = {
+      body: {
+        where: {
+          id
+        }
+      }
+    }
+
+    const result = await this.sdk._fetch(`/object/${object}`, 'DELETE', params);
+    return result;
+  }
+
+  async describe(object) {
+    this.sdk.validateParams(
+      { object },
+      {
+        object: { type: 'string', required: true },
+      },
+    );
+
+    const params = {
+    }
+
+    const result = await this.sdk._fetch(`/object/describe/${object}`, 'GET', params);
+    return result;
+  }
+
+  async list() {
+    const params = {
+    }
+
+    const result = await this.sdk._fetch(`/object/`, 'GET', params);
+    return result;
+  }
+}

package/services/phoneNumbers.js

@@ -0,0 +1,215 @@
+export class PhoneNumbersService {
+  constructor(sdk) {
+    this.sdk = sdk;
+    this.carrier = new PhoneNumberCarrierService(sdk);
+  }
+
+  async search({ 
+    type, 
+    country, 
+    state, 
+    city, 
+    startsWith, 
+    endsWith, 
+    contains, 
+    limit, 
+    minimumBlockSize, 
+    sms, 
+    mms, 
+    voice 
+  }) {
+    // Validate optional parameters
+    const validationSchema = {};
+    if ('type' in arguments[0]) validationSchema.type = { type: 'string' };
+    if ('country' in arguments[0]) validationSchema.country = { type: 'string' };
+    if ('state' in arguments[0]) validationSchema.state = { type: 'string' };
+    if ('city' in arguments[0]) validationSchema.city = { type: 'string' };
+    if ('startsWith' in arguments[0]) validationSchema.startsWith = { type: 'string' };
+    if ('endsWith' in arguments[0]) validationSchema.endsWith = { type: 'string' };
+    if ('contains' in arguments[0]) validationSchema.contains = { type: 'string' };
+    if ('limit' in arguments[0]) validationSchema.limit = { type: 'number' };
+    if ('minimumBlockSize' in arguments[0]) validationSchema.minimumBlockSize = { type: 'number' };
+    if ('sms' in arguments[0]) validationSchema.sms = { type: 'boolean' };
+    if ('mms' in arguments[0]) validationSchema.mms = { type: 'boolean' };
+    if ('voice' in arguments[0]) validationSchema.voice = { type: 'boolean' };
+
+    if (Object.keys(validationSchema).length > 0) {
+      this.sdk.validateParams(arguments[0], validationSchema);
+    }
+
+    const params = {
+      query: { 
+        type, 
+        country, 
+        state, 
+        city, 
+        startsWith, 
+        endsWith, 
+        contains, 
+        limit, 
+        minimumBlockSize, 
+        sms, 
+        mms, 
+        voice 
+      },
+    };
+
+    const result = await this.sdk._fetch('/phoneNumbers/search', 'GET', params);
+    return result;
+  }
+
+  async order({ phoneNumbers, name }) {
+    this.sdk.validateParams(
+      { phoneNumbers },
+      {
+        phoneNumbers: { type: 'array', required: true },
+        name: { type: 'string', required: false },
+      },
+    );
+
+    const orderData = { phoneNumbers };
+    if (name) orderData.name = name;
+
+    const params = {
+      body: orderData,
+    };
+
+    const result = await this.sdk._fetch('/phoneNumbers/order', 'POST', params);
+    return result;
+  }
+
+  async remove(phoneNumber) {
+    this.sdk.validateParams(
+      { phoneNumber },
+      {
+        phoneNumber: { type: 'string', required: true },
+      },
+    );
+
+    const result = await this.sdk._fetch(`/phoneNumbers/${phoneNumber}`, 'DELETE');
+    return result;
+  }
+
+  async update(id, { 
+    name, 
+    messagingWebHookUrl, 
+    voiceWebHookUrl, 
+    voiceAppExternalUrl, 
+    voiceAppExternalMethod, 
+    voiceApp, 
+    voiceAppMetaData, 
+    voiceRecordTypeId, 
+    messagingRecordTypeId 
+  }) {
+    this.sdk.validateParams(
+      { id },
+      {
+        id: { type: 'string', required: true },
+        name: { type: 'string', required: false },
+        messagingWebHookUrl: { type: 'string', required: false },
+        voiceWebHookUrl: { type: 'string', required: false },
+        voiceAppExternalUrl: { type: 'string', required: false },
+        voiceAppExternalMethod: { type: 'string', required: false },
+        voiceApp: { type: 'string', required: false },
+        voiceAppMetaData: { type: 'object', required: false },
+        voiceRecordTypeId: { type: 'string', required: false },
+        messagingRecordTypeId: { type: 'string', required: false },
+      },
+    );
+
+    const updateData = {};
+    if (name) updateData.name = name;
+    if (messagingWebHookUrl) updateData.messagingWebHookUrl = messagingWebHookUrl;
+    if (voiceWebHookUrl) updateData.voiceWebHookUrl = voiceWebHookUrl;
+    if (voiceAppExternalUrl) updateData.voiceAppExternalUrl = voiceAppExternalUrl;
+    if (voiceAppExternalMethod) updateData.voiceAppExternalMethod = voiceAppExternalMethod;
+    if (voiceApp) updateData.voiceApp = voiceApp;
+    if (voiceAppMetaData) updateData.voiceAppMetaData = voiceAppMetaData;
+    if (voiceRecordTypeId) updateData.voiceRecordTypeId = voiceRecordTypeId;
+    if (messagingRecordTypeId) updateData.messagingRecordTypeId = messagingRecordTypeId;
+
+    const params = {
+      body: updateData,
+    };
+
+    const result = await this.sdk._fetch(`/phoneNumbers/${id}`, 'PUT', params);
+    return result;
+  }
+
+  async updateCnam(phoneNumber, { cnam }) {
+    this.sdk.validateParams(
+      { phoneNumber, cnam },
+      {
+        phoneNumber: { type: 'string', required: true },
+        cnam: { type: 'string', required: true },
+      },
+    );
+
+    const params = {
+      body: { cnam },
+    };
+
+    const result = await this.sdk._fetch(`/phoneNumbers/cnam/${phoneNumber}`, 'PUT', params);
+    return result;
+  }
+
+  async format(number) {
+    this.sdk.validateParams(
+      { number },
+      {
+        number: { type: 'string', required: true },
+      },
+    );
+
+    const result = await this.sdk._fetch(`/phoneNumbers/format/${number}`, 'GET');
+    return result;
+  }
+}
+
+export class PhoneNumberCarrierService {
+  constructor(sdk) {
+    this.sdk = sdk;
+  }
+
+  async sync(carrier, { updateVoiceConnection, updateMessagingConnection }) {
+    this.sdk.validateParams(
+      { carrier },
+      {
+        carrier: { type: 'string', required: true },
+        updateVoiceConnection: { type: 'boolean', required: false },
+        updateMessagingConnection: { type: 'boolean', required: false },
+      },
+    );
+
+    const params = {
+      query: { updateVoiceConnection, updateMessagingConnection },
+    };
+
+    const result = await this.sdk._fetch(`/phoneNumbers/carrier/syncPhoneNumbers/${carrier}`, 'POST', params);
+    return result;
+  }
+
+  async getDetails(phoneNumber) {
+    this.sdk.validateParams(
+      { phoneNumber },
+      {
+        phoneNumber: { type: 'string', required: true },
+      },
+    );
+
+    const result = await this.sdk._fetch(`/phoneNumbers/carrier/${phoneNumber}`, 'GET');
+    return result;
+  }
+
+  async delete(phoneNumber) {
+    this.sdk.validateParams(
+      { phoneNumber },
+      {
+        phoneNumber: { type: 'string', required: true },
+      },
+    );
+
+    const result = await this.sdk._fetch(`/phoneNumbers/carrier/${phoneNumber}`, 'DELETE');
+    return result;
+  }
+}

package/services/portals.js

@@ -0,0 +1,127 @@
+export class PortalsService {
+  constructor(sdk) {
+    this.sdk = sdk;
+  }
+
+  async create({ name, domain, settings, isPublic, customCss, customJs, favicon, logo }) {
+    this.sdk.validateParams(
+      { name, domain },
+      {
+        name: { type: 'string', required: true },
+        domain: { type: 'string', required: true },
+        settings: { type: 'object', required: false },
+        isPublic: { type: 'boolean', required: false },
+        customCss: { type: 'string', required: false },
+        customJs: { type: 'string', required: false },
+        favicon: { type: 'string', required: false },
+        logo: { type: 'string', required: false },
+      },
+    );
+
+    const portalData = { name, domain };
+    if (settings) portalData.settings = settings;
+    if (isPublic !== undefined) portalData.isPublic = isPublic;
+    if (customCss) portalData.customCss = customCss;
+    if (customJs) portalData.customJs = customJs;
+    if (favicon) portalData.favicon = favicon;
+    if (logo) portalData.logo = logo;
+
+    const params = {
+      body: portalData,
+    };
+
+    const result = await this.sdk._fetch('/portals', 'POST', params);
+    return result;
+  }
+
+  async update(portalId, { name, domain, settings, isPublic, customCss, customJs, favicon, logo }) {
+    this.sdk.validateParams(
+      { portalId },
+      {
+        portalId: { type: 'string', required: true },
+        name: { type: 'string', required: false },
+        domain: { type: 'string', required: false },
+        settings: { type: 'object', required: false },
+        isPublic: { type: 'boolean', required: false },
+        customCss: { type: 'string', required: false },
+        customJs: { type: 'string', required: false },
+        favicon: { type: 'string', required: false },
+        logo: { type: 'string', required: false },
+      },
+    );
+
+    const updateData = {};
+    if (name) updateData.name = name;
+    if (domain) updateData.domain = domain;
+    if (settings) updateData.settings = settings;
+    if (isPublic !== undefined) updateData.isPublic = isPublic;
+    if (customCss) updateData.customCss = customCss;
+    if (customJs) updateData.customJs = customJs;
+    if (favicon) updateData.favicon = favicon;
+    if (logo) updateData.logo = logo;
+
+    const params = {
+      body: updateData,
+    };
+
+    const result = await this.sdk._fetch(`/portals/${portalId}`, 'PUT', params);
+    return result;
+  }
+
+  async delete(portalId) {
+    this.sdk.validateParams(
+      { portalId },
+      {
+        portalId: { type: 'string', required: true },
+      },
+    );
+
+    const result = await this.sdk._fetch(`/portals/${portalId}`, 'DELETE');
+    return result;
+  }
+
+  async get(portalId) {
+    this.sdk.validateParams(
+      { portalId },
+      {
+        portalId: { type: 'string', required: true },
+      },
+    );
+
+    const result = await this.sdk._fetch(`/portals/${portalId}`, 'GET');
+    return result;
+  }
+
+  async getPublic(domain) {
+    this.sdk.validateParams(
+      { domain },
+      {
+        domain: { type: 'string', required: true },
+      },
+    );
+
+    const params = {
+      query: { domain },
+    };
+
+    const result = await this.sdk._fetch('/portals/public', 'GET', params);
+    return result;
+  }
+
+  async list() {
+    const result = await this.sdk._fetch('/portals', 'GET');
+    return result;
+  }
+
+  async verifyDns(portalId) {
+    this.sdk.validateParams(
+      { portalId },
+      {
+        portalId: { type: 'string', required: true },
+      },
+    );
+
+    const result = await this.sdk._fetch(`/portals/${portalId}/verify-dns`, 'POST');
+    return result;
+  }
+}