@jsforce/jsforce-node 0.0.1 → 3.0.0-next.2

package/lib/http-api.js

@@ -0,0 +1,295 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpApi = void 0;
+/**
+ *
+ */
+const events_1 = require("events");
+const xml2js_1 = __importDefault(require("xml2js"));
+const logger_1 = require("./util/logger");
+const promise_1 = require("./util/promise");
+const csv_1 = require("./csv");
+const stream_1 = require("./util/stream");
+const get_body_size_1 = require("./util/get-body-size");
+/** @private */
+function parseJSON(str) {
+    return JSON.parse(str);
+}
+/** @private */
+async function parseXML(str) {
+    return xml2js_1.default.parseStringPromise(str, { explicitArray: false });
+}
+/** @private */
+function parseText(str) {
+    return str;
+}
+/**
+ * HTTP based API class with authorization hook
+ */
+class HttpApi extends events_1.EventEmitter {
+    static _logger = (0, logger_1.getLogger)('http-api');
+    _conn;
+    _logger;
+    _transport;
+    _responseType;
+    _noContentResponse;
+    _options;
+    constructor(conn, options) {
+        super();
+        this._conn = conn;
+        this._logger = conn._logLevel
+            ? HttpApi._logger.createInstance(conn._logLevel)
+            : HttpApi._logger;
+        this._responseType = options.responseType;
+        this._transport = options.transport || conn._transport;
+        this._noContentResponse = options.noContentResponse;
+        this._options = options;
+    }
+    /**
+     * Callout to API endpoint using http
+     */
+    request(request) {
+        return promise_1.StreamPromise.create(() => {
+            const { stream, setStream } = (0, stream_1.createLazyStream)();
+            const promise = (async () => {
+                const refreshDelegate = this.getRefreshDelegate();
+                /* TODO decide remove or not this section */
+                /*
+                // remember previous instance url in case it changes after a refresh
+                const lastInstanceUrl = conn.instanceUrl;
+        
+                // check to see if the token refresh has changed the instance url
+                if(lastInstanceUrl !== conn.instanceUrl){
+                  // if the instance url has changed
+                  // then replace the current request urls instance url fragment
+                  // with the updated instance url
+                  request.url = request.url.replace(lastInstanceUrl,conn.instanceUrl);
+                }
+                */
+                if (refreshDelegate && refreshDelegate.isRefreshing()) {
+                    await refreshDelegate.waitRefresh();
+                    const bodyPromise = this.request(request);
+                    setStream(bodyPromise.stream());
+                    const body = await bodyPromise;
+                    return body;
+                }
+                // hook before sending
+                this.beforeSend(request);
+                this.emit('request', request);
+                this._logger.debug(`<request> method=${request.method}, url=${request.url}`);
+                const requestTime = Date.now();
+                const requestPromise = this._transport.httpRequest(request, this._options);
+                setStream(requestPromise.stream());
+                let response;
+                try {
+                    response = await requestPromise;
+                }
+                catch (err) {
+                    this._logger.error(err);
+                    throw err;
+                }
+                finally {
+                    const responseTime = Date.now();
+                    this._logger.debug(`elapsed time: ${responseTime - requestTime} msec`);
+                }
+                if (!response) {
+                    return;
+                }
+                this._logger.debug(`<response> status=${String(response.statusCode)}, url=${request.url}`);
+                this.emit('response', response);
+                // Refresh token if session has been expired and requires authentication
+                // when session refresh delegate is available
+                if (this.isSessionExpired(response) && refreshDelegate) {
+                    await refreshDelegate.refresh(requestTime);
+                    /* remove the `content-length` header after token refresh
+                     *
+                     * SOAP requests include the access token their the body,
+                     * if the first req had an invalid token and jsforce successfully
+                     * refreshed it we need to remove the `content-length` header
+                     * so that it get's re-calculated again with the new body.
+                     *
+                     * REST request aren't affected by this because the access token
+                     * is sent via HTTP headers
+                     *
+                     * `_message` is only present in SOAP requests
+                     */
+                    if ('_message' in request &&
+                        request.headers &&
+                        'content-length' in request.headers) {
+                        delete request.headers['content-length'];
+                    }
+                    return this.request(request);
+                }
+                if (this.isErrorResponse(response)) {
+                    const err = await this.getError(response);
+                    throw err;
+                }
+                const body = await this.getResponseBody(response);
+                return body;
+            })();
+            return { stream, promise };
+        });
+    }
+    /**
+     * @protected
+     */
+    getRefreshDelegate() {
+        return this._conn._refreshDelegate;
+    }
+    /**
+     * @protected
+     */
+    beforeSend(request) {
+        /* eslint-disable no-param-reassign */
+        const headers = request.headers || {};
+        if (this._conn.accessToken) {
+            headers.Authorization = `Bearer ${this._conn.accessToken}`;
+        }
+        if (this._conn._callOptions) {
+            const callOptions = [];
+            for (const name of Object.keys(this._conn._callOptions)) {
+                callOptions.push(`${name}=${this._conn._callOptions[name]}`);
+            }
+            headers['Sforce-Call-Options'] = callOptions.join(', ');
+        }
+        const bodySize = (0, get_body_size_1.getBodySize)(request.body, headers);
+        const cannotHaveBody = ['GET', 'HEAD', 'OPTIONS'].includes(request.method);
+        if (!cannotHaveBody &&
+            !!request.body &&
+            !('transfer-encoding' in headers) &&
+            !('content-length' in headers) &&
+            !!bodySize) {
+            this._logger.debug(`missing 'content-length' header, setting it to: ${bodySize}`);
+            headers['content-length'] = String(bodySize);
+        }
+        request.headers = headers;
+    }
+    /**
+     * Detect response content mime-type
+     * @protected
+     */
+    getResponseContentType(response) {
+        return (this._responseType ||
+            (response.headers && response.headers['content-type']));
+    }
+    /**
+     * @private
+     */
+    async parseResponseBody(response) {
+        const contentType = this.getResponseContentType(response) || '';
+        const parseBody = /^(text|application)\/xml(;|$)/.test(contentType)
+            ? parseXML
+            : /^application\/json(;|$)/.test(contentType)
+                ? parseJSON
+                : /^text\/csv(;|$)/.test(contentType)
+                    ? csv_1.parseCSV
+                    : parseText;
+        try {
+            return parseBody(response.body);
+        }
+        catch (e) {
+            return response.body;
+        }
+    }
+    /**
+     * Get response body
+     * @protected
+     */
+    async getResponseBody(response) {
+        if (response.statusCode === 204) {
+            // No Content
+            return this._noContentResponse;
+        }
+        const body = await this.parseResponseBody(response);
+        let err;
+        if (this.hasErrorInResponseBody(body)) {
+            err = await this.getError(response, body);
+            throw err;
+        }
+        if (response.statusCode === 300) {
+            // Multiple Choices
+            throw new HttpApiError('Multiple records found', 'MULTIPLE_CHOICES', body);
+        }
+        return body;
+    }
+    /**
+     * Detect session expiry
+     * @protected
+     */
+    isSessionExpired(response) {
+        return response.statusCode === 401;
+    }
+    /**
+     * Detect error response
+     * @protected
+     */
+    isErrorResponse(response) {
+        return response.statusCode >= 400;
+    }
+    /**
+     * Detect error in response body
+     * @protected
+     */
+    hasErrorInResponseBody(_body) {
+        return false;
+    }
+    /**
+     * Parsing error message in response
+     * @protected
+     */
+    parseError(body) {
+        const errors = body;
+        // XML response
+        if (errors.Errors) {
+            return errors.Errors.Error;
+        }
+        return Array.isArray(errors) ? errors[0] : errors;
+    }
+    /**
+     * Get error message in response
+     * @protected
+     */
+    async getError(response, body) {
+        let error;
+        try {
+            error = this.parseError(body || (await this.parseResponseBody(response)));
+        }
+        catch (e) {
+            // eslint-disable no-empty
+        }
+        error =
+            typeof error === 'object' &&
+                error !== null &&
+                typeof error.message === 'string'
+                ? error
+                : {
+                    errorCode: `ERROR_HTTP_${response.statusCode}`,
+                    message: response.body,
+                };
+        if (response.headers['content-type'] === 'text/html') {
+            this._logger.debug(`html response.body: ${response.body}`);
+            return new HttpApiError(`HTTP response contains html content.
+Check that the org exists and can be reached.
+See error.content for the full html response.`, error.errorCode, error.message);
+        }
+        return new HttpApiError(error.message, error.errorCode);
+    }
+}
+exports.HttpApi = HttpApi;
+/**
+ *
+ */
+class HttpApiError extends Error {
+    errorCode;
+    content;
+    constructor(message, errorCode, content) {
+        super(message);
+        this.name = errorCode || this.name;
+        this.errorCode = this.name;
+        this.content = content;
+    }
+}
+exports.default = HttpApi;

package/lib/index.d.ts

@@ -0,0 +1,13 @@
+import jsforce from './jsforce';
+import './api/analytics';
+import './api/apex';
+import './api/bulk';
+import './api/bulk2';
+import './api/chatter';
+import './api/metadata';
+import './api/soap';
+import './api/streaming';
+import './api/tooling';
+export * from './types';
+export * from './core';
+export default jsforce;

package/lib/index.js

@@ -0,0 +1,32 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const jsforce_1 = __importDefault(require("./jsforce"));
+require("./api/analytics");
+require("./api/apex");
+require("./api/bulk");
+require("./api/bulk2");
+require("./api/chatter");
+require("./api/metadata");
+require("./api/soap");
+require("./api/streaming");
+require("./api/tooling");
+__exportStar(require("./types"), exports);
+__exportStar(require("./core"), exports);
+exports.default = jsforce_1.default;

package/lib/jsforce.d.ts

@@ -0,0 +1,26 @@
+/// <reference types="node" />
+import { EventEmitter } from 'events';
+import VERSION from './VERSION';
+import Connection from './connection';
+import OAuth2 from './oauth2';
+import SfDate from './date';
+import { Registry } from './registry';
+import { BrowserClient } from './browser/client';
+import { JwtOAuth2 } from './jwtOAuth2';
+/**
+ *
+ */
+declare class JSforce extends EventEmitter {
+    VERSION: typeof VERSION;
+    Connection: typeof Connection;
+    OAuth2: typeof OAuth2;
+    JwtOAuth2: typeof JwtOAuth2;
+    SfDate: typeof SfDate;
+    Date: typeof SfDate;
+    BrowserClient: typeof BrowserClient;
+    registry: Registry;
+    browser: BrowserClient;
+}
+export declare function registerModule(name: string, factory: (conn: Connection) => any): void;
+declare const jsforce: JSforce;
+export default jsforce;

package/lib/jsforce.js

@@ -0,0 +1,67 @@
+"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.registerModule = void 0;
+const events_1 = require("events");
+const VERSION_1 = __importDefault(require("./VERSION"));
+const connection_1 = __importDefault(require("./connection"));
+const oauth2_1 = __importDefault(require("./oauth2"));
+const date_1 = __importDefault(require("./date"));
+const registry_1 = __importDefault(require("./registry"));
+const client_1 = __importStar(require("./browser/client"));
+const jwtOAuth2_1 = require("./jwtOAuth2");
+/**
+ *
+ */
+class JSforce extends events_1.EventEmitter {
+    VERSION = VERSION_1.default;
+    Connection = connection_1.default;
+    OAuth2 = oauth2_1.default;
+    JwtOAuth2 = jwtOAuth2_1.JwtOAuth2;
+    SfDate = date_1.default;
+    Date = date_1.default;
+    BrowserClient = client_1.BrowserClient;
+    registry = registry_1.default;
+    browser = client_1.default;
+}
+function registerModule(name, factory) {
+    jsforce.on('connection:new', (conn) => {
+        let obj = undefined;
+        Object.defineProperty(conn, name, {
+            get() {
+                obj = obj ?? factory(conn);
+                return obj;
+            },
+            enumerable: true,
+            configurable: true,
+        });
+    });
+}
+exports.registerModule = registerModule;
+const jsforce = new JSforce();
+exports.default = jsforce;

package/lib/jwtOAuth2.d.ts

@@ -0,0 +1,8 @@
+import OAuth2, { OAuth2Config } from './oauth2';
+/**
+ * @deprecated
+ */
+export declare class JwtOAuth2 extends OAuth2 {
+    constructor(config: OAuth2Config);
+    jwtAuthorize(innerToken: string): Promise<any>;
+}

package/lib/jwtOAuth2.js

@@ -0,0 +1,23 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JwtOAuth2 = void 0;
+const oauth2_1 = __importDefault(require("./oauth2"));
+/**
+ * @deprecated
+ */
+class JwtOAuth2 extends oauth2_1.default {
+    constructor(config) {
+        console.warn('JwtOAuth2 is deprecated and will be removed in next stable release, please use OAuth2 instead.');
+        super(config);
+    }
+    jwtAuthorize(innerToken) {
+        return super._postParams({
+            grant_type: 'urn:ietf:params:oauth:grant-type:jwt-bearer',
+            assertion: innerToken,
+        });
+    }
+}
+exports.JwtOAuth2 = JwtOAuth2;

package/lib/oauth2.d.ts

@@ -0,0 +1,92 @@
+import Transport from './transport';
+import { Optional } from './types';
+/**
+ * type defs
+ */
+export type OAuth2Config = {
+    clientId?: string;
+    clientSecret?: string;
+    redirectUri?: string;
+    loginUrl?: string;
+    authzServiceUrl?: string;
+    tokenServiceUrl?: string;
+    revokeServiceUrl?: string;
+    proxyUrl?: string;
+    httpProxy?: string;
+    useVerifier?: boolean;
+};
+export type AuthzRequestParams = {
+    scope?: string;
+    state?: string;
+    code_challenge?: string;
+} & {
+    [attr: string]: string;
+};
+export type TokenResponse = {
+    token_type: 'Bearer';
+    /**
+     * Identity URL
+     *
+     * The format of the URL is https://login.salesforce.com/id/orgID/userID.
+     */
+    id: string;
+    access_token: string;
+    refresh_token?: string;
+    signature: string;
+    issued_at: string;
+    instance_url: string;
+    sfdc_community_url?: string;
+    sfdc_community_id?: string;
+};
+/**
+ * OAuth2 class
+ */
+export declare class OAuth2 {
+    loginUrl: string;
+    authzServiceUrl: string;
+    tokenServiceUrl: string;
+    revokeServiceUrl: string;
+    clientId: Optional<string>;
+    clientSecret: Optional<string>;
+    redirectUri: Optional<string>;
+    codeVerifier: Optional<string>;
+    _transport: Transport;
+    /**
+     *
+     */
+    constructor(config: OAuth2Config);
+    /**
+     * Get Salesforce OAuth2 authorization page URL to redirect user agent.
+     */
+    getAuthorizationUrl(params?: AuthzRequestParams): string;
+    /**
+     * OAuth2 Refresh Token Flow
+     */
+    refreshToken(refreshToken: string): Promise<TokenResponse>;
+    /**
+     * Send access token request to the token endpoint.
+     * When a code (string) is passed in first argument, it will use Web Server Authentication Flow (Authorization Code Grant).
+     * Otherwise, it will use the specified `grant_type` and pass parameters to the endpoint.
+     */
+    requestToken(codeOrParams: string | {
+        grant_type: string;
+        [name: string]: string;
+    }, params?: {
+        [prop: string]: string;
+    }): Promise<TokenResponse>;
+    /**
+     * OAuth2 Username-Password Flow (Resource Owner Password Credentials)
+     */
+    authenticate(username: string, password: string): Promise<TokenResponse>;
+    /**
+     * OAuth2 Revoke Session Token
+     */
+    revokeToken(token: string): Promise<void>;
+    /**
+     * @private
+     */
+    _postParams(params: {
+        [name: string]: string;
+    }): Promise<any>;
+}
+export default OAuth2;