telnyx 2.0.0-alpha.0 → 2.0.0-alpha.2

package/CHANGELOG.md

@@ -2,6 +2,15 @@
 
 ## v2
 
+### v2.0.0-alpha.2
+
+- Fix `AI` resource methods and created nested structure
+
+### v2.0.0-alpha.1
+
+- Update actions workflow versions to v4 and `.npmignore` to v2
+- Update examples dependencies
+
 ### v2.0.0-alpha.0
 
 - Add Typescript default config, linter and dependencies

package/README.md

@@ -2,7 +2,6 @@
 
 [![Version](https://img.shields.io/npm/v/telnyx.svg)](https://www.npmjs.org/package/telnyx)
 [![Build Status](https://github.com/team-telnyx/telnyx-node/workflows/CI/badge.svg)](https://github.com/team-telnyx/telnyx-node/actions)
-Coverage Status: Pending
 [![Downloads](https://img.shields.io/npm/dm/telnyx.svg)](https://www.npmjs.com/package/telnyx)
 [![Try on RunKit](https://badge.runkitcdn.com/telnyx.svg)](https://runkit.com/npm/telnyx)
 [![Join Slack](https://img.shields.io/badge/join-slack-infomational)](https://joinslack.telnyx.com/)

package/VERSION

@@ -1 +1 @@
-2.0.0-alpha.0
+2.0.0-alpha.2

package/dist/Error.js

@@ -0,0 +1,156 @@
+export const generate = (rawTelnyxError) => {
+    switch (rawTelnyxError.statusCode) {
+        case 400:
+            return new TelnyxInvalidRequestError(rawTelnyxError);
+        case 401:
+            return new TelnyxAuthenticationError(rawTelnyxError);
+        case 403:
+            return new TelnyxPermissionError(rawTelnyxError);
+        case 404:
+            return new TelnyxResourceNotFoundError(rawTelnyxError);
+        case 405:
+            return new TelnyxMethodNotSupportedError(rawTelnyxError);
+        case 408:
+            return new TelnyxTimeoutError(rawTelnyxError);
+        case 415:
+            return new TelnyxUnsupportedMediaTypeError(rawTelnyxError);
+        case 422:
+            return new TelnyxInvalidParametersError(rawTelnyxError);
+        case 429:
+            return new TelnyxRateLimitError(rawTelnyxError);
+        case 500:
+            return new TelnyxAPIError(rawTelnyxError);
+        case 503:
+            return new TelnyxServiceUnavailableError(rawTelnyxError);
+    }
+    return new TelnyxError({ type: 'Generic', message: 'Unknown Error' });
+};
+/**
+ * TelnyxError is the base error from which all other more specific Telnyx errors derive.
+ * Specifically for errors returned from Telnyx's REST API.
+ */
+export class TelnyxError extends Error {
+    message;
+    type;
+    raw;
+    headers;
+    requestId;
+    detail;
+    code;
+    statusCode;
+    responseBody;
+    constructor(raw = {}, type = null) {
+        super(raw.message);
+        this.type = type || this.constructor.name;
+        this.raw = raw;
+        this.code = raw.code;
+        this.detail = raw.detail;
+        this.headers = raw.headers;
+        this.requestId = raw.requestId;
+        this.statusCode = raw.statusCode;
+        this.responseBody = raw.responseBody;
+        // @ts-expect-error message needs to be required here
+        this.message = raw.message;
+    }
+    /**
+     * Helper factory which takes raw Telnyx errors and outputs wrapping instances
+     */
+    static generate = generate;
+}
+/**
+ * InvalidRequestError is raised when a request is initiated with invalid
+ * parameters.
+ */
+export class TelnyxInvalidRequestError extends TelnyxError {
+    constructor(raw = {}) {
+        super(raw, 'TelnyxInvalidRequestError');
+    }
+}
+/**
+ * APIError is a generic error that may be raised in cases where none of the
+ * other named errors cover the problem. It could also be raised in the case
+ * that a new error has been introduced in the API, but this version of the
+ * Node.JS SDK doesn't know how to handle it.
+ */
+export class TelnyxAPIError extends TelnyxError {
+    constructor(raw = {}) {
+        super(raw, 'TelnyxAPIError');
+    }
+}
+/**
+ * AuthenticationError is raised when invalid credentials are used to connect
+ * to Telnyx's servers.
+ */
+export class TelnyxAuthenticationError extends TelnyxError {
+    constructor(raw = {}) {
+        super(raw, 'TelnyxAuthenticationError');
+    }
+}
+/**
+ * PermissionError is raised in cases where access was attempted on a resource
+ * that wasn't allowed.
+ */
+export class TelnyxPermissionError extends TelnyxError {
+    constructor(raw = {}) {
+        super(raw, 'TelnyxPermissionError');
+    }
+}
+export class TelnyxResourceNotFoundError extends TelnyxError {
+    constructor(raw = {}) {
+        super(raw, 'TelnyxResourceNotFoundError');
+    }
+}
+export class TelnyxMethodNotSupportedError extends TelnyxError {
+    constructor(raw = {}) {
+        super(raw, 'TelnyxMethodNotSupportedError');
+    }
+}
+export class TelnyxTimeoutError extends TelnyxError {
+    constructor(raw = {}) {
+        super(raw, 'TelnyxTimeoutError');
+    }
+}
+export class TelnyxUnsupportedMediaTypeError extends TelnyxError {
+    constructor(raw = {}) {
+        super(raw, 'TelnyxUnsupportedMediaTypeError');
+    }
+}
+export class TelnyxInvalidParametersError extends TelnyxError {
+    constructor(raw = {}) {
+        super(raw, 'TelnyxInvalidParametersError');
+    }
+}
+/**
+ * RateLimitError is raised in cases where an account is putting too much load
+ * on Telnyx's API servers (usually by performing too many requests). Please
+ * back off on request rate.
+ */
+export class TelnyxRateLimitError extends TelnyxError {
+    constructor(raw = {}) {
+        super(raw, 'TelnyxRateLimitError');
+    }
+}
+export class TelnyxServiceUnavailableError extends TelnyxError {
+    constructor(raw = {}) {
+        super(raw, 'TelnyxServiceUnavailableError');
+    }
+}
+/**
+ * TelnyxConnectionError is raised in the event that the SDK can't connect to
+ * Telnyx's servers. That can be for a variety of different reasons from a
+ * downed network to a bad TLS certificate.
+ */
+export class TelnyxConnectionError extends TelnyxError {
+    constructor(raw = {}) {
+        super(raw, 'TelnyxConnectionError');
+    }
+}
+/**
+ * SignatureVerificationError is raised when the signature verification for a
+ * webhook fails
+ */
+export class TelnyxSignatureVerificationError extends TelnyxError {
+    constructor(raw = {}) {
+        super(raw, 'TelnyxSignatureVerificationError');
+    }
+}

package/{src/TelnyxMethod.basic.ts → dist/TelnyxMethod.basic.js}

@@ -1,29 +1,24 @@
 import telnyxMethod from './TelnyxMethod';
-
 export const create = telnyxMethod({
-  method: 'POST',
+    method: 'POST',
 });
-
 export const list = telnyxMethod({
-  method: 'GET',
-  methodType: 'list',
+    method: 'GET',
+    methodType: 'list',
 });
-
 export const retrieve = telnyxMethod({
-  method: 'GET',
-  path: '/{id}',
-  urlParams: ['id'],
+    method: 'GET',
+    path: '/{id}',
+    urlParams: ['id'],
 });
-
 export const update = telnyxMethod({
-  method: 'PATCH',
-  path: '{id}',
-  urlParams: ['id'],
+    method: 'PATCH',
+    path: '{id}',
+    urlParams: ['id'],
 });
-
 // Avoid 'delete' keyword in JS
 export const del = telnyxMethod({
-  method: 'DELETE',
-  path: '{id}',
-  urlParams: ['id'],
+    method: 'DELETE',
+    path: '{id}',
+    urlParams: ['id'],
 });

package/{src/TelnyxMethod.ts → dist/TelnyxMethod.js}

@@ -1,8 +1,6 @@
-import {MethodSpec, TelnyxResourceObject} from './Types';
 import * as utils from './utils';
 import makeRequest from './makeRequest';
-import {makeAutoPaginationMethods} from './autoPagination';
-
+import { makeAutoPaginationMethods } from './autoPagination';
 /**
  * Create an API method from the declared spec.
  *
@@ -22,66 +20,42 @@ import {makeAutoPaginationMethods} from './autoPagination';
  * @param [spec.host] Hostname for the request.
  * @param [spec.transformResponseData]   mutates response data to decorate with any util functions or info.
  */
-function telnyxMethod(
-  spec: MethodSpec,
-): (...args: unknown[]) => Promise<unknown> {
-  return function (
-    this: TelnyxResourceObject,
+function telnyxMethod(spec) {
+    return function (
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    ...args: any[] // needs to be any since callback is extracted from these args and there's no easy way to type all args
-  ): Promise<unknown> {
-    if (spec.paramsValues) {
-      populateUrlParamsWithResource(this, args, spec);
-    }
-
-    const callback = typeof args[args.length - 1] == 'function' && args.pop();
-
-    const requestPromise = utils.callbackifyPromiseWithTimeout(
-      makeRequest(this, args, spec, {}),
-      callback,
-    );
-
-    if (spec.methodType === 'list') {
-      const autoPaginationMethods = makeAutoPaginationMethods(
-        this,
-        args,
-        spec,
-        requestPromise,
-      );
-      Object.assign(requestPromise, autoPaginationMethods);
-    }
-
-    return requestPromise;
-  };
+    ...args // needs to be any since callback is extracted from these args and there's no easy way to type all args
+    ) {
+        if (spec.paramsValues) {
+            populateUrlParamsWithResource(this, args, spec);
+        }
+        const callback = typeof args[args.length - 1] == 'function' && args.pop();
+        const requestPromise = utils.callbackifyPromiseWithTimeout(makeRequest(this, args, spec, {}), callback);
+        if (spec.methodType === 'list') {
+            const autoPaginationMethods = makeAutoPaginationMethods(this, args, spec, requestPromise);
+            Object.assign(requestPromise, autoPaginationMethods);
+        }
+        return requestPromise;
+    };
 }
-
 /**
  * Populate nested method URL params with resource object attributes that match the param name.
  * This allows you to do things like setting the `call_control_id` attribute from an existing call object on a new instance of `telnyx.calls`.
  */
-function populateUrlParamsWithResource(
-  self: TelnyxResourceObject,
-  args: unknown[],
-  spec: MethodSpec,
-) {
-  // if url params is not in resource response data.
-  if (spec.paramsValues && !spec.paramsValues[0]) {
-    const paramsValues = (spec.paramsNames || []).reduce(function (
-      result,
-      name,
-    ) {
-      // @ts-expect-error TODO: cast name to index of self
-      if (self[name]) {
-        // @ts-expect-error TODO: cast name to index of self
-        result.push(self[name]);
-      }
-      return result;
-    }, []);
-
-    args.unshift(paramsValues);
-  } else {
-    args.unshift(spec.paramsValues);
-  }
+function populateUrlParamsWithResource(self, args, spec) {
+    // if url params is not in resource response data.
+    if (spec.paramsValues && !spec.paramsValues[0]) {
+        const paramsValues = (spec.paramsNames || []).reduce(function (result, name) {
+            // @ts-expect-error TODO: cast name to index of self
+            if (self[name]) {
+                // @ts-expect-error TODO: cast name to index of self
+                result.push(self[name]);
+            }
+            return result;
+        }, []);
+        args.unshift(paramsValues);
+    }
+    else {
+        args.unshift(spec.paramsValues);
+    }
 }
-
 export default telnyxMethod;