@unboundcx/sdk 1.0.0

package/services/enroll.js

@@ -0,0 +1,238 @@
+export class EnrollService {
+  constructor(sdk) {
+    this.sdk = sdk;
+  }
+
+  async checkNamespace(namespace) {
+    this.sdk.validateParams(
+      { namespace },
+      {
+        namespace: { type: 'string', required: true },
+      },
+    );
+
+    const params = {
+      query: { namespace },
+    };
+
+    const result = await this.sdk._fetch('/enroll/checkNamespace', 'GET', params);
+    return result;
+  }
+
+  async collectCompanyInfo(companyInfo) {
+    this.sdk.validateParams(
+      { companyInfo },
+      {
+        companyInfo: { type: 'object', required: true },
+      },
+    );
+
+    const params = {
+      body: companyInfo,
+    };
+
+    const result = await this.sdk._fetch('/enroll/companyInfo', 'POST', params);
+    return result;
+  }
+
+  async updateEnrollmentInfo(enrollmentId, updateData) {
+    this.sdk.validateParams(
+      { enrollmentId, updateData },
+      {
+        enrollmentId: { type: 'string', required: true },
+        updateData: { type: 'object', required: true },
+      },
+    );
+
+    const params = {
+      body: updateData,
+    };
+
+    const result = await this.sdk._fetch(`/enroll/enrollment/${enrollmentId}`, 'PUT', params);
+    return result;
+  }
+
+  async validateEnrollment(enrollmentData) {
+    this.sdk.validateParams(
+      { enrollmentData },
+      {
+        enrollmentData: { type: 'object', required: true },
+      },
+    );
+
+    const params = {
+      body: enrollmentData,
+    };
+
+    const result = await this.sdk._fetch('/enroll/validate', 'POST', params);
+    return result;
+  }
+
+  async verifyEmail(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('/enroll/verifyEmail', 'POST', params);
+    return result;
+  }
+
+  async verifySms(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('/enroll/verifySms', 'POST', params);
+    return result;
+  }
+
+  async verifyPayment(paymentData) {
+    this.sdk.validateParams(
+      { paymentData },
+      {
+        paymentData: { type: 'object', required: true },
+      },
+    );
+
+    const params = {
+      body: paymentData,
+    };
+
+    const result = await this.sdk._fetch('/enroll/verifyPayment', 'POST', params);
+    return result;
+  }
+
+  async createStripeVerificationSession(sessionData) {
+    this.sdk.validateParams(
+      { sessionData },
+      {
+        sessionData: { type: 'object', required: true },
+      },
+    );
+
+    const params = {
+      body: sessionData,
+    };
+
+    const result = await this.sdk._fetch('/enroll/stripeVerification', 'POST', params);
+    return result;
+  }
+
+  async getStripeVerificationStatus(sessionId) {
+    this.sdk.validateParams(
+      { sessionId },
+      {
+        sessionId: { type: 'string', required: true },
+      },
+    );
+
+    const params = {
+      query: { sessionId },
+    };
+
+    const result = await this.sdk._fetch('/enroll/stripeVerification/status', 'GET', params);
+    return result;
+  }
+
+  async signAgreement(agreementData) {
+    this.sdk.validateParams(
+      { agreementData },
+      {
+        agreementData: { type: 'object', required: true },
+      },
+    );
+
+    const params = {
+      body: agreementData,
+    };
+
+    const result = await this.sdk._fetch('/enroll/signAgreement', 'POST', params);
+    return result;
+  }
+
+  async getAgreement(agreementType, version) {
+    this.sdk.validateParams(
+      { agreementType },
+      {
+        agreementType: { type: 'string', required: true },
+        version: { type: 'string', required: false },
+      },
+    );
+
+    const params = {
+      query: { type: agreementType, version },
+    };
+
+    const result = await this.sdk._fetch('/enroll/agreement', 'GET', params);
+    return result;
+  }
+
+  async getBrandForEnrollment(enrollmentId) {
+    this.sdk.validateParams(
+      { enrollmentId },
+      {
+        enrollmentId: { type: 'string', required: true },
+      },
+    );
+
+    const result = await this.sdk._fetch(`/enroll/brand/${enrollmentId}`, 'GET');
+    return result;
+  }
+
+  async getBuildStatus(enrollmentId) {
+    this.sdk.validateParams(
+      { enrollmentId },
+      {
+        enrollmentId: { type: 'string', required: true },
+      },
+    );
+
+    const result = await this.sdk._fetch(`/enroll/buildStatus/${enrollmentId}`, 'GET');
+    return result;
+  }
+
+  async completeEnrollment(enrollmentId, completionData) {
+    this.sdk.validateParams(
+      { enrollmentId, completionData },
+      {
+        enrollmentId: { type: 'string', required: true },
+        completionData: { type: 'object', required: true },
+      },
+    );
+
+    const params = {
+      body: completionData,
+    };
+
+    const result = await this.sdk._fetch(`/enroll/complete/${enrollmentId}`, 'POST', params);
+    return result;
+  }
+
+  async createAccountDatabase(enrollmentId) {
+    this.sdk.validateParams(
+      { enrollmentId },
+      {
+        enrollmentId: { type: 'string', required: true },
+      },
+    );
+
+    const result = await this.sdk._fetch(`/enroll/createDatabase/${enrollmentId}`, 'POST');
+    return result;
+  }
+}

package/services/externalOAuth.js

@@ -0,0 +1,117 @@
+export class ExternalOAuthService {
+  constructor(sdk) {
+    this.sdk = sdk;
+  }
+
+  async create({ name, provider, scopes, credentials, configuration }) {
+    this.sdk.validateParams(
+      { name, provider, scopes },
+      {
+        name: { type: 'string', required: true },
+        provider: { type: 'string', required: true },
+        scopes: { type: 'array', required: true },
+        credentials: { type: 'object', required: false },
+        configuration: { type: 'object', required: false },
+      },
+    );
+
+    const oauthData = { name, provider, scopes };
+    if (credentials) oauthData.credentials = credentials;
+    if (configuration) oauthData.configuration = configuration;
+
+    const params = {
+      body: oauthData,
+    };
+
+    const result = await this.sdk._fetch('/externalOAuth', 'POST', params);
+    return result;
+  }
+
+  async update(id, { name, scopes, credentials, configuration }) {
+    this.sdk.validateParams(
+      { id },
+      {
+        id: { type: 'string', required: true },
+        name: { type: 'string', required: false },
+        scopes: { type: 'array', required: false },
+        credentials: { type: 'object', required: false },
+        configuration: { type: 'object', required: false },
+      },
+    );
+
+    const updateData = {};
+    if (name) updateData.name = name;
+    if (scopes) updateData.scopes = scopes;
+    if (credentials) updateData.credentials = credentials;
+    if (configuration) updateData.configuration = configuration;
+
+    const params = {
+      body: updateData,
+    };
+
+    const result = await this.sdk._fetch(`/externalOAuth/${id}`, 'PUT', params);
+    return result;
+  }
+
+  async delete(id) {
+    this.sdk.validateParams(
+      { id },
+      {
+        id: { type: 'string', required: true },
+      },
+    );
+
+    const result = await this.sdk._fetch(`/externalOAuth/${id}`, 'DELETE');
+    return result;
+  }
+
+  async get(id) {
+    this.sdk.validateParams(
+      { id },
+      {
+        id: { type: 'string', required: true },
+      },
+    );
+
+    const result = await this.sdk._fetch(`/externalOAuth/${id}`, 'GET');
+    return result;
+  }
+
+  async getByName(name) {
+    this.sdk.validateParams(
+      { name },
+      {
+        name: { type: 'string', required: true },
+      },
+    );
+
+    const params = {
+      query: { name },
+    };
+
+    const result = await this.sdk._fetch('/externalOAuth/byName', 'GET', params);
+    return result;
+  }
+
+  async getByScopeAndProvider(scope, provider) {
+    this.sdk.validateParams(
+      { scope, provider },
+      {
+        scope: { type: 'string', required: true },
+        provider: { type: 'string', required: true },
+      },
+    );
+
+    const params = {
+      query: { scope, provider },
+    };
+
+    const result = await this.sdk._fetch('/externalOAuth/byScopeAndProvider', 'GET', params);
+    return result;
+  }
+
+  async list() {
+    const result = await this.sdk._fetch('/externalOAuth', 'GET');
+    return result;
+  }
+}

package/services/generateId.js

@@ -0,0 +1,39 @@
+export class GenerateIdService {
+  constructor(sdk) {
+    this.sdk = sdk;
+  }
+
+  async createId({ service, serviceCode }) {
+    // Either service or serviceCode is required
+    if (!service && !serviceCode) {
+      throw new Error('Either service or serviceCode parameter is required');
+    }
+
+    this.sdk.validateParams(
+      { service, serviceCode },
+      {
+        service: { type: 'string', required: false },
+        serviceCode: { type: 'string', required: false },
+      },
+    );
+
+    const params = {
+      query: { service, serviceCode },
+    };
+
+    const result = await this.sdk._fetch('/generateId/', 'POST', params);
+    return result;
+  }
+
+  async validateId(input) {
+    this.sdk.validateParams(
+      { input },
+      {
+        input: { type: 'string', required: true },
+      },
+    );
+
+    const result = await this.sdk._fetch(`/generateId/${input}`, 'GET');
+    return result;
+  }
+}

package/services/googleCalendar.js

@@ -0,0 +1,92 @@
+export class GoogleCalendarService {
+  constructor(sdk) {
+    this.sdk = sdk;
+  }
+
+  async setupWebhook({ calendarId, eventTypes, webhookUrl, expirationTime }) {
+    this.sdk.validateParams(
+      { calendarId, eventTypes, webhookUrl },
+      {
+        calendarId: { type: 'string', required: true },
+        eventTypes: { type: 'array', required: true },
+        webhookUrl: { type: 'string', required: true },
+        expirationTime: { type: 'number', required: false },
+      },
+    );
+
+    const webhookData = { calendarId, eventTypes, webhookUrl };
+    if (expirationTime) webhookData.expirationTime = expirationTime;
+
+    const params = {
+      body: webhookData,
+    };
+
+    const result = await this.sdk._fetch('/googleCalendar/webhook', 'POST', params);
+    return result;
+  }
+
+  async removeWebhook(webhookId) {
+    this.sdk.validateParams(
+      { webhookId },
+      {
+        webhookId: { type: 'string', required: true },
+      },
+    );
+
+    const result = await this.sdk._fetch(`/googleCalendar/webhook/${webhookId}`, 'DELETE');
+    return result;
+  }
+
+  async listWebhooks() {
+    const result = await this.sdk._fetch('/googleCalendar/webhooks', 'GET');
+    return result;
+  }
+
+  async getCalendarList() {
+    const result = await this.sdk._fetch('/googleCalendar/calendars', 'GET');
+    return result;
+  }
+
+  async getCalendarEvents(calendarId, options = {}) {
+    this.sdk.validateParams(
+      { calendarId },
+      {
+        calendarId: { type: 'string', required: true },
+      },
+    );
+
+    // Validate optional parameters
+    const validationSchema = {};
+    if ('timeMin' in options) validationSchema.timeMin = { type: 'string' };
+    if ('timeMax' in options) validationSchema.timeMax = { type: 'string' };
+    if ('maxResults' in options) validationSchema.maxResults = { type: 'number' };
+    if ('orderBy' in options) validationSchema.orderBy = { type: 'string' };
+
+    if (Object.keys(validationSchema).length > 0) {
+      this.sdk.validateParams(options, validationSchema);
+    }
+
+    const params = {
+      query: { calendarId, ...options },
+    };
+
+    const result = await this.sdk._fetch('/googleCalendar/events', 'GET', params);
+    return result;
+  }
+
+  async processCalendarChange(changeData) {
+    this.sdk.validateParams(
+      { changeData },
+      {
+        changeData: { type: 'object', required: true },
+      },
+    );
+
+    const params = {
+      body: changeData,
+    };
+
+    const result = await this.sdk._fetch('/googleCalendar/processChange', 'POST', params);
+    return result;
+  }
+}

package/services/layouts.js

@@ -0,0 +1,91 @@
+export class LayoutsService {
+  constructor(sdk) {
+    this.sdk = sdk;
+  }
+
+  async get(objectName, id, query = {}) {
+    this.sdk.validateParams(
+      { objectName, id, query },
+      {
+        objectName: { type: 'string', required: false },
+        id: { type: 'string', required: false },
+        query: { type: 'object', required: false },
+      },
+    );
+
+    const params = {
+      query,
+    }
+
+    let uri = `/layouts/${objectName}`;
+    if (id) {
+      uri = `${uri}/${id}`
+    }
+
+    const result = await this.sdk._fetch(uri, 'GET', params);
+    return result;
+  }
+
+  async create(layout) {
+    this.sdk.validateParams(
+      { layout },
+      {
+        layout: { type: 'object', required: true },
+      },
+    );
+
+    const params = {
+      body: layout,
+    }
+
+    const result = await this.sdk._fetch('/layouts/', 'POST', params);
+    return result;
+  }
+
+  async update(id, layout) {
+    this.sdk.validateParams(
+      { id, layout },
+      {
+        id: { type: 'string', required: true },
+        layout: { type: 'object', required: true },
+      },
+    );
+
+    const params = {
+      body: layout,
+    }
+
+    const result = await this.sdk._fetch(`/layouts/${id}`, 'PUT', params);
+    return result;
+  }
+
+  async delete(id) {
+    this.sdk.validateParams(
+      { id },
+      {
+        id: { type: 'string', required: true },
+      },
+    );
+
+    const params = {}
+
+    const result = await this.sdk._fetch(`/layouts/${id}`, 'DELETE', params);
+    return result;
+  }
+
+  async dynamicSelectSearch(query) {
+    this.sdk.validateParams(
+      { query },
+      {
+        query: { type: 'object', required: true },
+      },
+    );
+
+    const params = {
+      query,
+    }
+
+    const result = await this.sdk._fetch('/layouts/dynamic-select-search', 'GET', params);
+    return result;
+  }
+}

package/services/login.js

@@ -0,0 +1,76 @@
+export class LoginService {
+  constructor(sdk) {
+    this.sdk = sdk;
+  }
+
+  async login(username, password, namespace) {
+    this.sdk.validateParams(
+      { username, password },
+      {
+        username: { type: 'string', required: true },
+        password: { type: 'string', required: true },
+        namespace: { type: 'string', required: false },
+      },
+    );
+
+    const options = {
+      body: { username, password, tokenType: 'cookie', namespace },
+    };
+
+    const login = await this.sdk._fetch('/login', 'POST', options, true);
+
+    if (typeof window !== 'undefined') {
+      const canUseLocalStorage = typeof localStorage !== 'undefined';
+      if (login?.namespace && canUseLocalStorage) {
+        localStorage.setItem('unbound_url', login.url);
+        localStorage.setItem('unbound_userId', login.userId);
+        localStorage.setItem('unbound_namespace', login.namespace);
+      }
+    }
+
+    return {
+      valid: true,
+      userId: login.userId,
+      namespace: login.namespace,
+      url: login.url,
+    };
+  }
+
+  async logout() {
+    const logout = await this.sdk._fetch('/login', 'DELETE', {}, true);
+
+    if (typeof window !== 'undefined') {
+      const canUseLocalStorage = typeof localStorage !== 'undefined';
+      if (canUseLocalStorage) {
+        localStorage.removeItem('unbound_url');
+        localStorage.removeItem('unbound_userId');
+        localStorage.removeItem('unbound_namespace');
+      }
+    }
+
+    return true;
+  }
+
+  async validate() {
+    const options = {};
+    const validation = await this.sdk._fetch('/login/validate', 'POST', options, true);
+    return validation;
+  }
+
+  async changePassword(currentPassword, newPassword) {
+    this.sdk.validateParams(
+      { currentPassword, newPassword },
+      {
+        currentPassword: { type: 'string', required: true },
+        newPassword: { type: 'string', required: true },
+      },
+    );
+
+    const options = {
+      body: { currentPassword, newPassword },
+    };
+
+    const result = await this.sdk._fetch('/login/changePassword', 'POST', options);
+    return result;
+  }
+}

package/services/lookup.js

@@ -0,0 +1,53 @@
+export class LookupService {
+  constructor(sdk) {
+    this.sdk = sdk;
+  }
+
+  async cnam(phoneNumber) {
+    this.sdk.validateParams(
+      { phoneNumber },
+      {
+        phoneNumber: { type: 'string', required: true },
+      },
+    );
+
+    const params = {
+      query: { phoneNumber },
+    };
+
+    const result = await this.sdk._fetch('/lookup/cnam', 'GET', params);
+    return result;
+  }
+
+  async lrn(phoneNumber) {
+    this.sdk.validateParams(
+      { phoneNumber },
+      {
+        phoneNumber: { type: 'string', required: true },
+      },
+    );
+
+    const params = {
+      query: { phoneNumber },
+    };
+
+    const result = await this.sdk._fetch('/lookup/lrn', 'GET', params);
+    return result;
+  }
+
+  async number(phoneNumber) {
+    this.sdk.validateParams(
+      { phoneNumber },
+      {
+        phoneNumber: { type: 'string', required: true },
+      },
+    );
+
+    const params = {
+      query: { phoneNumber },
+    };
+
+    const result = await this.sdk._fetch('/lookup/number', 'GET', params);
+    return result;
+  }
+}