@unboundcx/sdk-internal 2.0.2 → 2.2.0

package/index.js

@@ -8,6 +8,8 @@ import { InternalServersService } from './services/servers.js';
 import { InternalSocketService } from './services/socket.js';
 import { InternalMasterAuthService } from './services/masterAuth.js';
 import { InternalBrandingService } from './services/branding.js';
+import { InternalPhoneNumbersService } from './services/phoneNumbers.js';
+import { buildObjectEventV2 } from './utils/buildObjectEventV2.js';
 
 export class InternalSDK {
   constructor(sdk, buildMasterApiAuthFn) {
@@ -22,6 +24,7 @@ export class InternalSDK {
     this.socket = new InternalSocketService(sdk);
     this.masterAuth = new InternalMasterAuthService(sdk);
     this.branding = new InternalBrandingService(sdk);
+    this.phoneNumbers = new InternalPhoneNumbersService(sdk);
 
     // Proxy all base SDK properties and methods
     this._proxyBaseSDK();
@@ -123,3 +126,5 @@ export {
 export { InternalSocketService } from './services/socket.js';
 export { InternalMasterAuthService } from './services/masterAuth.js';
 export { InternalBrandingService } from './services/branding.js';
+export { InternalPhoneNumbersService } from './services/phoneNumbers.js';
+export { buildObjectEventV2 } from './utils/buildObjectEventV2.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@unboundcx/sdk-internal",
-  "version": "2.0.2",
+  "version": "2.2.0",
   "description": "Internal SDK extension for Unbound - Provides access to internal APIs and administrative functions",
   "main": "index.js",
   "type": "module",
@@ -32,6 +32,7 @@
   "files": [
     "*.js",
     "services/**/*.js",
+    "utils/**/*.js",
     "types/**/*.d.ts",
     "README.md",
     "LICENSE"
@@ -43,6 +44,9 @@
     },
     "./services/*": {
       "import": "./services/*.js"
+    },
+    "./utils/*": {
+      "import": "./utils/*.js"
     }
   },
   "scripts": {

package/services/masterAuth.js

@@ -32,4 +32,37 @@ export class InternalMasterAuthService {
     );
     return result;
   }
+
+  /**
+   * Mint an internal service token — the kind baked into pods as BOOT_TOKEN.
+   *
+   * Requires internal auth (the caller must already hold a valid internal
+   * token). Intended for manual/operational use: the returned token is stored
+   * in Zeus connection storage and injected into the services that need it.
+   *
+   * @param {object}  [opts]
+   * @param {string}  [opts.service='internal'] - value for the `service` claim
+   * @param {number}  [opts.expiresIn]          - lifetime in seconds; omit for a
+   *                                              non-expiring token (matches the
+   *                                              legacy BOOT_TOKEN)
+   */
+  async createInternalToken({ service = 'internal', expiresIn } = {}) {
+    this.sdk.validateParams(
+      { service, expiresIn },
+      {
+        service: { type: 'string', required: false },
+        expiresIn: { type: 'number', required: false },
+      },
+    );
+
+    const body = { service };
+    if (expiresIn !== undefined) body.expiresIn = expiresIn;
+
+    const result = await this.sdk._fetch(
+      '/internal/masterAuth/internal-token',
+      'POST',
+      { body },
+    );
+    return result;
+  }
 }

package/services/phoneNumbers.js

@@ -0,0 +1,31 @@
+export class InternalPhoneNumbersService {
+  constructor(sdk) {
+    this.sdk = sdk;
+  }
+
+  /**
+   * Claim a number from Telnyx into the global phoneNumbers inventory as an
+   * unassigned row. Requires an internal auth token — this bypasses normal
+   * ordering/billing and is not part of the public SDK.
+   *
+   * @param {Object} params
+   * @param {string} params.phoneNumber - +E.164 number that already exists on the Telnyx account
+   */
+  async createInventory({ phoneNumber }) {
+    this.sdk.validateParams(
+      { phoneNumber },
+      {
+        phoneNumber: { type: 'string', required: true },
+      },
+    );
+
+    const result = await this.sdk._fetch(
+      '/internal/phoneNumbers/inventory',
+      'POST',
+      {
+        body: { phoneNumber },
+      },
+    );
+    return result;
+  }
+}

package/utils/buildObjectEventV2.js

@@ -0,0 +1,74 @@
+/**
+ * Build a spec-valid `objects.event.v2` envelope for non-api writers
+ * (task-router, cdr-user-status, ...) that mutate object-backed tables with
+ * raw SQL and need to emit live-update events without an HTTP round-trip
+ * through app1-api.
+ *
+ * Pure helper — no NATS/publish side effects. Callers publish the returned
+ * `{ subject, payload }` themselves via their own service's NATS client and
+ * subject-prefix handling.
+ *
+ * @param {Object} params
+ * @param {'create'|'update'|'delete'} params.action
+ * @param {string} params.objectName - plural object/table name, e.g. 'tasks'
+ * @param {string} params.accountId
+ * @param {string|number} params.recordTypeId
+ * @param {Object|null} [params.oldRow] - full pre-mutation row image; null for 'create'
+ * @param {Object|null} [params.newRow] - full post-mutation row image; null for 'delete'
+ * @param {number} [params.now] - ms timestamp used for rowVersion/ts; defaults to Date.now()
+ * @returns {{ subject: string, payload: Object }}
+ */
+export function buildObjectEventV2({
+  action,
+  objectName,
+  accountId,
+  recordTypeId,
+  oldRow = null,
+  newRow = null,
+  now,
+}) {
+  const changedFields =
+    oldRow && newRow ? diffChangedFields(oldRow, newRow) : [];
+
+  const ts = now ?? Date.now();
+
+  return {
+    subject: 'objects.event.v2',
+    payload: {
+      action,
+      objectName,
+      accountId,
+      recordTypeId,
+      oldRow,
+      newRow,
+      changedFields,
+      rowVersion: ts,
+      ts,
+      sourceCluster: process.env.CLUSTER_NAME || 'unknown',
+    },
+  };
+}
+
+function diffChangedFields(oldRow, newRow) {
+  const fields = new Set([...Object.keys(oldRow), ...Object.keys(newRow)]);
+  const changed = [];
+  for (const field of fields) {
+    if (!isEqualValue(oldRow[field], newRow[field])) {
+      changed.push(field);
+    }
+  }
+  return changed;
+}
+
+function isEqualValue(a, b) {
+  if (a === b) return true;
+  if (a == null || b == null) return a === b;
+  if (typeof a === 'object' && typeof b === 'object') {
+    try {
+      return JSON.stringify(a) === JSON.stringify(b);
+    } catch {
+      return false;
+    }
+  }
+  return false;
+}