@unboundcx/sdk 1.0.0

package/services/recordTypes.js

@@ -0,0 +1,173 @@
+export class RecordTypesService {
+  constructor(sdk) {
+    this.sdk = sdk;
+    this.user = new UserRecordTypeDefaultsService(sdk);
+  }
+
+  async create({ name, description, create, update, read, delete: deleteUsers }) {
+    this.sdk.validateParams(
+      { name, description },
+      {
+        name: { type: 'string', required: true },
+        description: { type: 'string', required: true },
+        create: { type: 'array', required: false },
+        update: { type: 'array', required: false },
+        read: { type: 'array', required: false },
+        delete: { type: 'array', required: false },
+      },
+    );
+
+    const recordTypeData = { name, description };
+    if (create) recordTypeData.create = create;
+    if (update) recordTypeData.update = update;
+    if (read) recordTypeData.read = read;
+    if (deleteUsers) recordTypeData.delete = deleteUsers;
+
+    const params = {
+      body: recordTypeData,
+    };
+
+    const result = await this.sdk._fetch('/recordTypes/', 'POST', params);
+    return result;
+  }
+
+  async update(id, { name, description, remove, add }) {
+    this.sdk.validateParams(
+      { id },
+      {
+        id: { type: 'string', required: true },
+        name: { type: 'string', required: false },
+        description: { type: 'string', required: false },
+        remove: { type: 'object', required: false },
+        add: { type: 'object', required: false },
+      },
+    );
+
+    const updateData = {};
+    if (name) updateData.name = name;
+    if (description) updateData.description = description;
+    if (remove) updateData.remove = remove;
+    if (add) updateData.add = add;
+
+    const params = {
+      body: updateData,
+    };
+
+    const result = await this.sdk._fetch(`/recordTypes/${id}`, 'PUT', params);
+    return result;
+  }
+
+  async delete(id) {
+    this.sdk.validateParams(
+      { id },
+      {
+        id: { type: 'string', required: true },
+      },
+    );
+
+    const result = await this.sdk._fetch(`/recordTypes/${id}`, 'DELETE');
+    return result;
+  }
+
+  async get(id) {
+    this.sdk.validateParams(
+      { id },
+      {
+        id: { type: 'string', required: true },
+      },
+    );
+
+    const result = await this.sdk._fetch(`/recordTypes/${id}`, 'GET');
+    return result;
+  }
+
+  async list() {
+    const result = await this.sdk._fetch('/recordTypes/', 'GET');
+    return result;
+  }
+}
+
+export class UserRecordTypeDefaultsService {
+  constructor(sdk) {
+    this.sdk = sdk;
+  }
+
+  async create({ recordTypeId, object, userId }) {
+    this.sdk.validateParams(
+      { recordTypeId, object },
+      {
+        recordTypeId: { type: 'string', required: true },
+        object: { type: 'string', required: true },
+        userId: { type: 'string', required: false },
+      },
+    );
+
+    const defaultData = { recordTypeId, object };
+    if (userId) defaultData.userId = userId;
+
+    const params = {
+      body: defaultData,
+    };
+
+    const result = await this.sdk._fetch('/recordTypes/user/', 'POST', params);
+    return result;
+  }
+
+  async update({ recordTypeId, object, userId }) {
+    this.sdk.validateParams(
+      { recordTypeId, object },
+      {
+        recordTypeId: { type: 'string', required: true },
+        object: { type: 'string', required: true },
+        userId: { type: 'string', required: false },
+      },
+    );
+
+    const updateData = { recordTypeId, object };
+    if (userId) updateData.userId = userId;
+
+    const params = {
+      body: updateData,
+    };
+
+    const result = await this.sdk._fetch('/recordTypes/user/', 'PUT', params);
+    return result;
+  }
+
+  async delete({ object, userId }) {
+    this.sdk.validateParams(
+      { object },
+      {
+        object: { type: 'string', required: true },
+        userId: { type: 'string', required: false },
+      },
+    );
+
+    const deleteData = { object };
+    if (userId) deleteData.userId = userId;
+
+    const params = {
+      body: deleteData,
+    };
+
+    const result = await this.sdk._fetch('/recordTypes/user/', 'DELETE', params);
+    return result;
+  }
+
+  async get({ object, userId }) {
+    this.sdk.validateParams(
+      { object },
+      {
+        object: { type: 'string', required: true },
+        userId: { type: 'string', required: false },
+      },
+    );
+
+    const params = {
+      query: { object, userId },
+    };
+
+    const result = await this.sdk._fetch('/recordTypes/user/', 'GET', params);
+    return result;
+  }
+}

package/services/sipEndpoints.js

@@ -0,0 +1,93 @@
+export class SipEndpointsService {
+  constructor(sdk) {
+    this.sdk = sdk;
+  }
+
+  async create({ username, password, domain, displayName, description }) {
+    this.sdk.validateParams(
+      { username, password, domain },
+      {
+        username: { type: 'string', required: true },
+        password: { type: 'string', required: true },
+        domain: { type: 'string', required: true },
+        displayName: { type: 'string', required: false },
+        description: { type: 'string', required: false },
+      },
+    );
+
+    const endpointData = { username, password, domain };
+    if (displayName) endpointData.displayName = displayName;
+    if (description) endpointData.description = description;
+
+    const params = {
+      body: endpointData,
+    };
+
+    const result = await this.sdk._fetch('/sipEndpoints', 'POST', params);
+    return result;
+  }
+
+  async getWebRtcDetails() {
+    const params = {};
+    const result = await this.sdk._fetch('/sipEndpoints', 'GET', params, true);
+    return result;
+  }
+
+  async getUsersWebRtc() {
+    const result = await this.sdk._fetch('/sipEndpoints/users/webrtc', 'GET');
+    return result;
+  }
+
+  async list() {
+    const result = await this.sdk._fetch('/sipEndpoints/list', 'GET');
+    return result;
+  }
+
+  async get(endpointId) {
+    this.sdk.validateParams(
+      { endpointId },
+      {
+        endpointId: { type: 'string', required: true },
+      },
+    );
+
+    const result = await this.sdk._fetch(`/sipEndpoints/${endpointId}`, 'GET');
+    return result;
+  }
+
+  async update(endpointId, { displayName, description, enabled }) {
+    this.sdk.validateParams(
+      { endpointId },
+      {
+        endpointId: { type: 'string', required: true },
+        displayName: { type: 'string', required: false },
+        description: { type: 'string', required: false },
+        enabled: { type: 'boolean', required: false },
+      },
+    );
+
+    const updateData = {};
+    if (displayName) updateData.displayName = displayName;
+    if (description) updateData.description = description;
+    if (enabled !== undefined) updateData.enabled = enabled;
+
+    const params = {
+      body: updateData,
+    };
+
+    const result = await this.sdk._fetch(`/sipEndpoints/${endpointId}`, 'PUT', params);
+    return result;
+  }
+
+  async delete(endpointId) {
+    this.sdk.validateParams(
+      { endpointId },
+      {
+        endpointId: { type: 'string', required: true },
+      },
+    );
+
+    const result = await this.sdk._fetch(`/sipEndpoints/${endpointId}`, 'DELETE');
+    return result;
+  }
+}

package/services/storage.js

@@ -0,0 +1,168 @@
+export class StorageService {
+  constructor(sdk) {
+    this.sdk = sdk;
+  }
+
+  async uploadFiles(files, options = {}) {
+    const { classification, expireAfter, isPublic, metadata } = options;
+
+    // Validate files parameter
+    if (!files) {
+      throw new Error('Files parameter is required');
+    }
+
+    // Handle different file input formats
+    let formData;
+    if (typeof window !== 'undefined' && files instanceof FormData) {
+      // Browser FormData
+      formData = files;
+    } else if (typeof window !== 'undefined' && files instanceof FileList) {
+      // Browser FileList
+      formData = new FormData();
+      for (let i = 0; i < files.length; i++) {
+        formData.append('files', files[i]);
+      }
+    } else if (Array.isArray(files)) {
+      // File array (Node.js or Browser)
+      formData = new FormData();
+      files.forEach((file, index) => {
+        formData.append('files', file);
+      });
+    } else if (typeof files === 'object' && files.path) {
+      // Single file object (Node.js)
+      formData = new FormData();
+      formData.append('files', files);
+    } else {
+      throw new Error('Invalid files format. Expected FormData, FileList, File array, or File object');
+    }
+
+    // Add optional parameters to FormData
+    if (classification) formData.append('classification', classification);
+    if (expireAfter) formData.append('expireAfter', expireAfter);
+    if (isPublic !== undefined) formData.append('isPublic', isPublic.toString());
+    if (metadata) formData.append('metadata', JSON.stringify(metadata));
+
+    const params = {
+      body: formData,
+      headers: {
+        // Let browser/Node.js set Content-Type with boundary for multipart/form-data
+      }
+    };
+
+    // Remove Content-Type to let FormData set it properly
+    delete params.headers['Content-Type'];
+
+    const result = await this.sdk._fetch('/storage/upload', 'POST', params);
+    return result;
+  }
+
+  async getFile(storageId, download = false) {
+    this.sdk.validateParams(
+      { storageId },
+      {
+        storageId: { type: 'string', required: true },
+        download: { type: 'boolean', required: false },
+      },
+    );
+
+    const params = {};
+    if (download) {
+      params.query = { download: 'true' };
+    }
+
+    const result = await this.sdk._fetch(`/storage/file/${storageId}`, 'GET', params);
+    return result;
+  }
+
+  async getFileUrl(storageId, download = false) {
+    this.sdk.validateParams(
+      { storageId },
+      {
+        storageId: { type: 'string', required: true },
+        download: { type: 'boolean', required: false },
+      },
+    );
+
+    let url;
+    if (this.sdk.environment === 'node') {
+      url = `${this.sdk.baseURL}/storage/file/${storageId}`;
+    } else {
+      url = `${this.sdk.fullUrl}/storage/file/${storageId}`;
+    }
+
+    if (download) {
+      url += '?download=true';
+    }
+
+    return url;
+  }
+
+  async deleteFile(storageId) {
+    this.sdk.validateParams(
+      { storageId },
+      {
+        storageId: { type: 'string', required: true },
+      },
+    );
+
+    const result = await this.sdk._fetch(`/storage/file/${storageId}`, 'DELETE');
+    return result;
+  }
+
+  async getStorageClassifications() {
+    const result = await this.sdk._fetch('/storage/classifications', 'GET');
+    return result;
+  }
+
+  async getFileInfo(storageId) {
+    this.sdk.validateParams(
+      { storageId },
+      {
+        storageId: { type: 'string', required: true },
+      },
+    );
+
+    const result = await this.sdk._fetch(`/storage/file/${storageId}/info`, 'GET');
+    return result;
+  }
+
+  async updateFileMetadata(storageId, metadata) {
+    this.sdk.validateParams(
+      { storageId, metadata },
+      {
+        storageId: { type: 'string', required: true },
+        metadata: { type: 'object', required: true },
+      },
+    );
+
+    const params = {
+      body: { metadata },
+    };
+
+    const result = await this.sdk._fetch(`/storage/file/${storageId}/metadata`, 'PUT', params);
+    return result;
+  }
+
+  async listFiles(options = {}) {
+    const { classification, limit, offset, orderBy, orderDirection } = options;
+
+    // Validate optional parameters
+    const validationSchema = {};
+    if ('classification' in options) validationSchema.classification = { type: 'string' };
+    if ('limit' in options) validationSchema.limit = { type: 'number' };
+    if ('offset' in options) validationSchema.offset = { type: 'number' };
+    if ('orderBy' in options) validationSchema.orderBy = { type: 'string' };
+    if ('orderDirection' in options) validationSchema.orderDirection = { type: 'string' };
+
+    if (Object.keys(validationSchema).length > 0) {
+      this.sdk.validateParams(options, validationSchema);
+    }
+
+    const params = {
+      query: options,
+    };
+
+    const result = await this.sdk._fetch('/storage/files', 'GET', params);
+    return result;
+  }
+}

package/services/subscriptions.js

@@ -0,0 +1,73 @@
+export class SubscriptionsService {
+  constructor(sdk) {
+    this.sdk = sdk;
+    this.socket = new SocketSubscriptionsService(sdk);
+  }
+}
+
+export class SocketSubscriptionsService {
+  constructor(sdk) {
+    this.sdk = sdk;
+  }
+
+  async getConnection(sessionId) {
+    this.sdk.validateParams(
+      { sessionId },
+      {
+        sessionId: { type: 'string', required: false },
+      },
+    );
+
+    const params = {
+      query: {
+        sessionId
+      }
+    }
+
+    const result = await this.sdk._fetch('/subscriptions/socket/connection', 'GET', params);
+    return result;
+  }
+
+  async create(sessionId, subscriptionParams) {
+    this.sdk.validateParams(
+      { sessionId, subscriptionParams },
+      {
+        sessionId: { type: 'string', required: true },
+        subscriptionParams: { type: 'object', required: true },
+      },
+    );
+
+    const params = {
+      body: {
+        sessionId,
+        ...subscriptionParams,
+      }
+    }
+
+    let uri = `/subscriptions/socket/`;
+    if (subscriptionParams?.id) {
+      uri = `/subscriptions/socket/${subscriptionParams.id}`;
+    }
+    const result = await this.sdk._fetch(uri, 'POST', params);
+    return result;
+  }
+
+  async delete(id, sessionId) {
+    this.sdk.validateParams(
+      { id, sessionId },
+      {
+        id: { type: 'string', required: false },
+        sessionId: { type: 'string', required: true },
+      },
+    );
+
+    const params = {
+      body: {
+        sessionId
+      }
+    }
+
+    const result = await this.sdk._fetch(`/subscriptions/socket/${id}`, 'DELETE', params);
+    return result;
+  }
+}

package/services/verification.js

@@ -0,0 +1,87 @@
+export class VerificationService {
+  constructor(sdk) {
+    this.sdk = sdk;
+  }
+
+  async createSmsVerification({ phoneNumber, code, expiresIn, metadata }) {
+    this.sdk.validateParams(
+      { phoneNumber },
+      {
+        phoneNumber: { type: 'string', required: true },
+        code: { type: 'string', required: false },
+        expiresIn: { type: 'number', required: false },
+        metadata: { type: 'object', required: false },
+      },
+    );
+
+    const verificationData = { phoneNumber };
+    if (code) verificationData.code = code;
+    if (expiresIn) verificationData.expiresIn = expiresIn;
+    if (metadata) verificationData.metadata = metadata;
+
+    const params = {
+      body: verificationData,
+    };
+
+    const result = await this.sdk._fetch('/verification/sms', 'POST', params);
+    return result;
+  }
+
+  async validateSmsVerification(phoneNumber, code) {
+    this.sdk.validateParams(
+      { phoneNumber, code },
+      {
+        phoneNumber: { type: 'string', required: true },
+        code: { type: 'string', required: true },
+      },
+    );
+
+    const params = {
+      body: { phoneNumber, code },
+    };
+
+    const result = await this.sdk._fetch('/verification/sms/validate', 'POST', params);
+    return result;
+  }
+
+  async createEmailVerification({ email, code, expiresIn, metadata }) {
+    this.sdk.validateParams(
+      { email },
+      {
+        email: { type: 'string', required: true },
+        code: { type: 'string', required: false },
+        expiresIn: { type: 'number', required: false },
+        metadata: { type: 'object', required: false },
+      },
+    );
+
+    const verificationData = { email };
+    if (code) verificationData.code = code;
+    if (expiresIn) verificationData.expiresIn = expiresIn;
+    if (metadata) verificationData.metadata = metadata;
+
+    const params = {
+      body: verificationData,
+    };
+
+    const result = await this.sdk._fetch('/verification/email', 'POST', params);
+    return result;
+  }
+
+  async validateEmailVerification(email, code) {
+    this.sdk.validateParams(
+      { email, code },
+      {
+        email: { type: 'string', required: true },
+        code: { type: 'string', required: true },
+      },
+    );
+
+    const params = {
+      body: { email, code },
+    };
+
+    const result = await this.sdk._fetch('/verification/email/validate', 'POST', params);
+    return result;
+  }
+}