@jsforce/jsforce-node 3.1.0 → 3.2.1

package/lib/registry/sfdx.js

@@ -120,9 +120,11 @@ class SfdxRegistry {
     async removeConnectionConfig(name) {
         await this._execCommand('force:org:delete', { u: name });
     }
+    // eslint-disable-next-line @typescript-eslint/require-await
     async getClientConfig(_name) {
         return null;
     }
+    // eslint-disable-next-line @typescript-eslint/require-await
     async getClientNames() {
         return [];
     }

package/lib/registry/types.d.ts

@@ -34,7 +34,7 @@ export type RegistryConfig = {
 /**
  *
  */
-export interface Registry {
+export type Registry = {
     getConnectionNames(): Promise<string[]>;
     getConnection<S extends Schema = Schema>(name?: string): Promise<Connection<S> | null>;
     getConnectionConfig(name?: string): Promise<ConnectionConfig | null>;
@@ -44,4 +44,4 @@ export interface Registry {
     getClientConfig(name: string): Promise<ClientConfig | null>;
     getClientNames(): Promise<string[]>;
     registerClientConfig(name: string, clientConfig: ClientConfig): Promise<void>;
-}
+};

package/lib/request.js

@@ -1,11 +1,34 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.setDefaults = void 0;
 const stream_1 = require("stream");
-const node_fetch_1 = __importDefault(require("node-fetch"));
+const node_fetch_1 = __importStar(require("node-fetch"));
 const abort_controller_1 = __importDefault(require("abort-controller"));
 const https_proxy_agent_1 = __importDefault(require("https-proxy-agent"));
 const request_helper_1 = require("./request-helper");
@@ -33,7 +56,10 @@ async function startFetchRequest(request, options, input, output, emitter, count
     const controller = new abort_controller_1.default();
     let retryCount = 0;
     const retryOpts = {
+        statusCodes: options.retry?.statusCodes ?? [429, 500, 502, 503, 504],
         maxRetries: options.retry?.maxRetries ?? 5,
+        minTimeout: options.retry?.minTimeout ?? 500,
+        timeoutFactor: options.retry?.timeoutFactor ?? 2,
         errorCodes: options.retry?.errorCodes ?? [
             'ECONNRESET',
             'ECONNREFUSED',
@@ -53,6 +79,40 @@ async function startFetchRequest(request, options, input, output, emitter, count
             'DELETE',
         ],
     };
+    const shouldRetryRequest = (maxRetry, resOrErr) => {
+        if (!retryOpts.methods.includes(request.method))
+            return false;
+        if (resOrErr instanceof node_fetch_1.Response) {
+            if (retryOpts.statusCodes.includes(resOrErr.status)) {
+                if (maxRetry === retryCount) {
+                    const err = new Error('Request failed');
+                    err.name = 'RequestRetryError';
+                    throw err;
+                }
+                else {
+                    return true;
+                }
+            }
+            return false;
+        }
+        else {
+            if (maxRetry === retryCount)
+                return false;
+            // only retry on operational errors
+            // https://github.com/node-fetch/node-fetch/blob/2.x/ERROR-HANDLING.md#error-handling-with-node-fetch
+            if (resOrErr.name != 'FetchError')
+                return false;
+            if (is_1.default.nodeStream(body) && stream_1.Readable.isDisturbed(body)) {
+                logger.debug('Body of type stream was read, unable to retry request.');
+                return false;
+            }
+            if ('code' in resOrErr &&
+                resOrErr.code &&
+                retryOpts?.errorCodes?.includes(resOrErr.code))
+                return true;
+            return false;
+        }
+    };
     const fetchWithRetries = async (maxRetry = retryOpts?.maxRetries) => {
         const fetchOpts = {
             ...rrequest,
@@ -60,48 +120,55 @@ async function startFetchRequest(request, options, input, output, emitter, count
                 ? { body: input }
                 : {}),
             redirect: 'manual',
+            // @ts-expect-error - differing types of signal? this started abruptly
             signal: controller.signal,
             agent,
         };
         try {
-            return await (0, node_fetch_1.default)(url, fetchOpts);
+            const res = await (0, node_fetch_1.default)(url, fetchOpts);
+            if (shouldRetryRequest(retryOpts.maxRetries, res)) {
+                logger.debug(`retrying for the ${retryCount + 1} time`);
+                logger.debug('reason: statusCode match');
+                await sleep(retryCount === 0
+                    ? retryOpts.minTimeout
+                    : retryOpts.minTimeout * retryOpts.timeoutFactor ** retryCount);
+                // NOTE: this event is only used by tests and will be removed at any time.
+                // jsforce may switch to node's fetch which doesn't emit this event on retries.
+                emitter.emit('retry', retryCount);
+                retryCount++;
+                return await fetchWithRetries(maxRetry);
+            }
+            // should we throw here if the maxRetry already happened and still got the same statusCode?
+            return res;
         }
         catch (err) {
-            logger.debug(`Request failed`);
+            logger.debug('Request failed');
             const error = err;
             // request was canceled by consumer (AbortController), skip retry and rethrow.
             if (error.name === 'AbortError') {
                 throw error;
             }
-            const shouldRetry = () => {
-                // only retry on operational errors
-                if (error.name != 'FetchError')
-                    return false;
-                if (retryCount === maxRetry)
-                    return false;
-                if (!retryOpts?.methods?.includes(request.method))
-                    return false;
-                if (is_1.default.nodeStream(body) && stream_1.Readable.isDisturbed(body)) {
-                    logger.debug('Body of type stream was read, unable to retry request.');
-                    return false;
-                }
-                if ('code' in error &&
-                    error.code &&
-                    retryOpts?.errorCodes?.includes(error.code))
-                    return true;
-                return false;
-            };
-            if (shouldRetry()) {
+            if (shouldRetryRequest(retryOpts.maxRetries, error)) {
                 logger.debug(`retrying for the ${retryCount + 1} time`);
-                logger.debug(`Error: ${error}`);
+                logger.debug(`Error: ${err.message}`);
+                await sleep(retryCount === 0
+                    ? retryOpts.minTimeout
+                    : retryOpts.minTimeout * retryOpts.timeoutFactor ** retryCount);
                 // NOTE: this event is only used by tests and will be removed at any time.
                 // jsforce may switch to node's fetch which doesn't emit this event on retries.
                 emitter.emit('retry', retryCount);
                 retryCount++;
-                return await fetchWithRetries(maxRetry);
+                return fetchWithRetries(maxRetry);
             }
             logger.debug('Skipping retry...');
-            throw err;
+            if (maxRetry === retryCount) {
+                const error = new Error('Request failed', { cause: err });
+                error.name = 'RequestRetryError';
+                throw error;
+            }
+            else {
+                throw err;
+            }
         }
     };
     let res;
@@ -142,3 +209,4 @@ function request(req, options_ = {}) {
     return stream;
 }
 exports.default = request;
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));

package/lib/soap.js

@@ -59,7 +59,7 @@ function castTypeUsingSchema(value, schema, schemaDict = {}) {
             const v = obj[k];
             const nillable = (Array.isArray(s) && s.length === 2 && s[0] === '?') ||
                 ((0, function_1.isMapObject)(s) && '?' in s) ||
-                (typeof s === 'string' && s[0] === '?');
+                (typeof s === 'string' && s.startsWith('?'));
             if (typeof v === 'undefined' && nillable) {
                 return o;
             }
@@ -70,7 +70,7 @@ function castTypeUsingSchema(value, schema, schemaDict = {}) {
         }, obj);
     }
     else {
-        const nillable = typeof schema === 'string' && schema[0] === '?';
+        const nillable = typeof schema === 'string' && schema.startsWith('?');
         const type = typeof schema === 'string'
             ? nillable
                 ? schema.substring(1)
@@ -135,9 +135,9 @@ function toXML(name, value) {
         if ((0, function_1.isMapObject)(value)) {
             for (const k of Object.keys(value)) {
                 const v = value[k];
-                if (k[0] === '@') {
+                if (k.startsWith('@')) {
                     const kk = k.substring(1);
-                    attrs.push(kk + '="' + v + '"');
+                    attrs.push(`${kk}="${v}"`);
                 }
                 else {
                     elems.push(toXML(k, v));

package/lib/soql-builder.js

@@ -75,7 +75,7 @@ function createFieldExpression(field, value) {
     else if (typeof value === 'object' && value !== null) {
         // Otherwise, if an object was passed then process the supplied ops.
         for (const k of Object.keys(value)) {
-            if (k[0] === '$') {
+            if (k.startsWith('$')) {
                 op = k;
                 _value = value[k];
                 break;

package/lib/transport.js

@@ -146,7 +146,7 @@ class XdProxyTransport extends Transport {
     httpRequest(req, _options = {}) {
         const xdProxyUrl = this._xdProxyUrl;
         const { url, body, ...rreq } = req;
-        const canonicalUrl = url.indexOf('/') === 0 ? baseUrl + url : url;
+        const canonicalUrl = url.startsWith('/') ? baseUrl + url : url;
         const xdProxyReq = createXdProxyRequest({ ...rreq, url: canonicalUrl, body }, xdProxyUrl);
         return super.httpRequest(xdProxyReq, {
             followRedirect: (redirectUrl) => createXdProxyRequest({ ...rreq, method: 'GET', url: redirectUrl }, xdProxyUrl),

package/lib/types/common.d.ts

@@ -21,8 +21,11 @@ export type HttpRequest = {
 export type HttpRequestOptions = {
     retry?: {
         maxRetries?: number;
+        minTimeout?: number;
+        timeoutFactor?: number;
         errorCodes?: string[];
         methods?: HttpMethods[];
+        statusCodes?: number[];
     };
     httpProxy?: string;
     timeout?: number;

package/lib/types/projection.d.ts

@@ -3,15 +3,15 @@ import { StringKeys } from './util';
 /**
  *
  */
-type FieldPath_3<SO extends SObjectDefinition> = '*' | StringKeys<SO['Fields']>[];
+type FieldPath_3<SO extends SObjectDefinition> = '*' | Array<StringKeys<SO['Fields']>>;
 type FieldPath_2<SO extends SObjectDefinition, PSOR extends SO['ParentReferences'] = SO['ParentReferences']> = '*' | StringKeys<SO['Fields']> | {
-    [K in StringKeys<PSOR>]?: '*' | FieldPath_3<Extract<PSOR[K], SObjectDefinition>>[];
+    [K in StringKeys<PSOR>]?: '*' | Array<FieldPath_3<Extract<PSOR[K], SObjectDefinition>>>;
 };
 type FieldPath_1<SO extends SObjectDefinition, PSOR extends SO['ParentReferences'] = SO['ParentReferences']> = '*' | StringKeys<SO['Fields']> | {
-    [K in StringKeys<PSOR>]?: '*' | FieldPath_2<Extract<PSOR[K], SObjectDefinition>>[];
+    [K in StringKeys<PSOR>]?: '*' | Array<FieldPath_2<Extract<PSOR[K], SObjectDefinition>>>;
 };
 type FieldPathSpecifier_<S extends Schema, N extends string, SO extends SObjectDefinition = S['SObjects'][N], PSOR extends SO['ParentReferences'] = SO['ParentReferences']> = '*' | StringKeys<SO['Fields']> | {
-    [K in StringKeys<PSOR>]?: '*' | FieldPath_1<Extract<PSOR[K], SObjectDefinition>>[];
+    [K in StringKeys<PSOR>]?: '*' | Array<FieldPath_1<Extract<PSOR[K], SObjectDefinition>>>;
 };
 export type FieldPathSpecifier<S extends Schema, N extends string> = FieldPathSpecifier_<S, N>;
 export type FieldProjectionConfigObject = {

package/lib/types/schema.d.ts

@@ -19,7 +19,7 @@ export type Address = {
     street: string | null;
 };
 export type SObjectFieldType = number | boolean | DateString | BlobString | string | Address;
-export interface SObjectDefinition<N extends string = string> {
+export type SObjectDefinition<N extends string = string> = {
     Name: N;
     Fields: {
         [name: string]: SObjectFieldType | null;
@@ -30,12 +30,12 @@ export interface SObjectDefinition<N extends string = string> {
     ChildRelationships: {
         [name: string]: SObjectDefinition;
     };
-}
-export interface Schema {
+};
+export type Schema = {
     SObjects: {
         [name: string]: SObjectDefinition;
     };
-}
+};
 /**
  *
  */