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

package/lib/oauth2.js

@@ -0,0 +1,245 @@
+"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.OAuth2 = void 0;
+/**
+ *
+ */
+const crypto_1 = require("crypto");
+const querystring_1 = __importDefault(require("querystring"));
+const transport_1 = __importStar(require("./transport"));
+const defaultOAuth2Config = {
+    loginUrl: 'https://login.salesforce.com',
+};
+// Makes a nodejs base64 encoded string compatible with rfc4648 alternative encoding for urls.
+// @param base64Encoded a nodejs base64 encoded string
+function base64UrlEscape(base64Encoded) {
+    // builtin node js base 64 encoding is not 64 url compatible.
+    // See https://toolsn.ietf.org/html/rfc4648#section-5
+    return base64Encoded
+        .replace(/\+/g, '-')
+        .replace(/\//g, '_')
+        .replace(/=/g, '');
+}
+/**
+ * OAuth2 class
+ */
+class OAuth2 {
+    loginUrl;
+    authzServiceUrl;
+    tokenServiceUrl;
+    revokeServiceUrl;
+    clientId;
+    clientSecret;
+    redirectUri;
+    codeVerifier;
+    _transport;
+    /**
+     *
+     */
+    constructor(config) {
+        const { loginUrl, authzServiceUrl, tokenServiceUrl, revokeServiceUrl, clientId, clientSecret, redirectUri, proxyUrl, httpProxy, useVerifier, } = config;
+        if (authzServiceUrl && tokenServiceUrl) {
+            this.loginUrl = authzServiceUrl.split('/').slice(0, 3).join('/');
+            this.authzServiceUrl = authzServiceUrl;
+            this.tokenServiceUrl = tokenServiceUrl;
+            this.revokeServiceUrl =
+                revokeServiceUrl || `${this.loginUrl}/services/oauth2/revoke`;
+        }
+        else {
+            this.loginUrl = loginUrl || defaultOAuth2Config.loginUrl;
+            this.authzServiceUrl = `${this.loginUrl}/services/oauth2/authorize`;
+            this.tokenServiceUrl = `${this.loginUrl}/services/oauth2/token`;
+            this.revokeServiceUrl = `${this.loginUrl}/services/oauth2/revoke`;
+        }
+        this.clientId = clientId;
+        this.clientSecret = clientSecret;
+        this.redirectUri = redirectUri;
+        if (proxyUrl) {
+            this._transport = new transport_1.XdProxyTransport(proxyUrl);
+        }
+        else if (httpProxy) {
+            this._transport = new transport_1.HttpProxyTransport(httpProxy);
+        }
+        else {
+            this._transport = new transport_1.default();
+        }
+        if (useVerifier) {
+            // Set a code verifier string for OAuth authorization
+            this.codeVerifier = base64UrlEscape((0, crypto_1.randomBytes)(Math.ceil(128)).toString('base64'));
+        }
+    }
+    /**
+     * Get Salesforce OAuth2 authorization page URL to redirect user agent.
+     */
+    getAuthorizationUrl(params = {}) {
+        if (this.codeVerifier) {
+            // code verifier must be a base 64 url encoded hash of 128 bytes of random data. Our random data is also
+            // base 64 url encoded. See Connection.create();
+            const codeChallenge = base64UrlEscape((0, crypto_1.createHash)('sha256').update(this.codeVerifier).digest('base64'));
+            params.code_challenge = codeChallenge;
+        }
+        const _params = {
+            ...params,
+            response_type: 'code',
+            client_id: this.clientId,
+            redirect_uri: this.redirectUri,
+        };
+        return (this.authzServiceUrl +
+            (this.authzServiceUrl.indexOf('?') >= 0 ? '&' : '?') +
+            querystring_1.default.stringify(_params));
+    }
+    /**
+     * OAuth2 Refresh Token Flow
+     */
+    async refreshToken(refreshToken) {
+        if (!this.clientId) {
+            throw new Error('No OAuth2 client id information is specified');
+        }
+        const params = {
+            grant_type: 'refresh_token',
+            refresh_token: refreshToken,
+            client_id: this.clientId,
+        };
+        if (this.clientSecret) {
+            params.client_secret = this.clientSecret;
+        }
+        const ret = await this._postParams(params);
+        return ret;
+    }
+    /**
+     * 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.
+     */
+    async requestToken(codeOrParams, params = {}) {
+        if (typeof codeOrParams === 'string' &&
+            (!this.clientId || !this.redirectUri)) {
+            throw new Error('No OAuth2 client id or redirect uri configuration is specified');
+        }
+        const _params = {
+            ...params,
+            ...(typeof codeOrParams === 'string'
+                ? { grant_type: 'authorization_code', code: codeOrParams }
+                : codeOrParams),
+        };
+        if (this.clientId) {
+            _params.client_id = this.clientId;
+        }
+        if (this.clientSecret) {
+            _params.client_secret = this.clientSecret;
+        }
+        if (this.redirectUri) {
+            _params.redirect_uri = this.redirectUri;
+        }
+        const ret = await this._postParams(_params);
+        return ret;
+    }
+    /**
+     * OAuth2 Username-Password Flow (Resource Owner Password Credentials)
+     */
+    async authenticate(username, password) {
+        if (!this.clientId || !this.clientSecret || !this.redirectUri) {
+            throw new Error('No valid OAuth2 client configuration set');
+        }
+        const ret = await this._postParams({
+            grant_type: 'password',
+            username,
+            password,
+            client_id: this.clientId,
+            client_secret: this.clientSecret,
+            redirect_uri: this.redirectUri,
+        });
+        return ret;
+    }
+    /**
+     * OAuth2 Revoke Session Token
+     */
+    async revokeToken(token) {
+        const response = await this._transport.httpRequest({
+            method: 'POST',
+            url: this.revokeServiceUrl,
+            body: querystring_1.default.stringify({ token }),
+            headers: {
+                'content-type': 'application/x-www-form-urlencoded',
+            },
+        });
+        if (response.statusCode >= 400) {
+            let res = querystring_1.default.parse(response.body);
+            if (!res || !res.error) {
+                res = {
+                    error: `ERROR_HTTP_${response.statusCode}`,
+                    error_description: response.body,
+                };
+            }
+            throw new (class extends Error {
+                constructor({ error, error_description, }) {
+                    super(error_description);
+                    this.name = error;
+                }
+            })(res);
+        }
+    }
+    /**
+     * @private
+     */
+    async _postParams(params) {
+        if (this.codeVerifier)
+            params.code_verifier = this.codeVerifier;
+        const response = await this._transport.httpRequest({
+            method: 'POST',
+            url: this.tokenServiceUrl,
+            body: querystring_1.default.stringify(params),
+            headers: {
+                'content-type': 'application/x-www-form-urlencoded',
+            },
+        });
+        let res;
+        try {
+            res = JSON.parse(response.body);
+        }
+        catch (e) {
+            /* eslint-disable no-empty */
+        }
+        if (response.statusCode >= 400) {
+            res = res || {
+                error: `ERROR_HTTP_${response.statusCode}`,
+                error_description: response.body,
+            };
+            throw new (class extends Error {
+                constructor({ error, error_description, }) {
+                    super(error_description);
+                    this.name = error;
+                }
+            })(res);
+        }
+        return res;
+    }
+}
+exports.OAuth2 = OAuth2;
+exports.default = OAuth2;

package/lib/process.d.ts

@@ -0,0 +1,157 @@
+/**
+ * @file Process class to manage/run workflow rule and approval process
+ * @author Shinichi Tomita <shinichi.tomita@gmail.com>
+ */
+import Connection from './connection';
+import { ProcessRules, Schema } from './types';
+/**
+ *
+ */
+export type ProcessRuleDefinition = {
+    id: string;
+    name: string;
+    object: string;
+};
+/**
+ *
+ */
+export type ProcessRuleTriggerResult = {
+    success: true;
+} | {
+    success: false;
+    errors: Array<{
+        message: string;
+    }>;
+};
+/**
+ * A class which manages process (workflow) rules
+ */
+export declare class ProcessRule<S extends Schema> {
+    _conn: Connection<S>;
+    /**
+     *
+     */
+    constructor(conn: Connection<S>);
+    /**
+     * Get all process rule definitions registered to sobjects
+     */
+    list(): Promise<ProcessRules>;
+    /**
+     * Trigger process rule for given entities
+     */
+    trigger(contextIds: string | string[]): import("./util/promise").StreamPromise<{
+        errors: null;
+        success: true;
+    } | {
+        errors: any[];
+        success: false;
+    }>;
+}
+/**
+ *
+ */
+export type ApprovalProcessDefinition = {
+    id: string;
+    name: string;
+    object: string;
+    sortOrder: number;
+    description: string | null;
+};
+/**
+ *
+ */
+export type ApprovalProcessRequestResult = {
+    success: true;
+    actorIds: string[];
+    entityId: string;
+    instanceId: string;
+    instanceStatus: string;
+    newWorkItemIds: string[];
+} | {
+    success: false;
+    errors: Array<{
+        message: string;
+    }>;
+};
+/**
+ *
+ */
+export type ApprovalProcessActionOptions = {
+    processDefinitionNameOrId?: string;
+    skipEntryCriteria?: boolean;
+};
+/**
+ * A class which manages approval processes
+ */
+export declare class ApprovalProcess<S extends Schema> {
+    _conn: Connection<S>;
+    /**
+     *
+     */
+    constructor(conn: Connection<S>);
+    /**
+     * Get all approval process definitions registered to sobjects
+     */
+    list(): Promise<{
+        [index: string]: ApprovalProcessDefinition;
+    }>;
+    /**
+     * Send bulk requests for approval process
+     */
+    request(requests: Array<ApprovalProcessRequestConfig | ApprovalProcessRequest<S>>): import("./util/promise").StreamPromise<ApprovalProcessRequestResult[]>;
+    /**
+     * Create approval process request
+     *
+     * @private
+     */
+    _createRequest(actionType: 'Submit' | 'Approve' | 'Reject', contextId: string, comments?: string, options?: ApprovalProcessActionOptions): ApprovalProcessRequest<S>;
+    /**
+     * Submit approval request for an item
+     */
+    submit(contextId: string, comments?: string, options?: ApprovalProcessActionOptions): ApprovalProcessRequest<S>;
+    /**
+     * Approve approval request for an item
+     */
+    approve(workitemId: string, comments?: string, options?: ApprovalProcessActionOptions): ApprovalProcessRequest<S>;
+    /**
+     * Reject approval request for an item
+     */
+    reject(workitemId: string, comments?: string, options?: ApprovalProcessActionOptions): ApprovalProcessRequest<S>;
+}
+/**
+ *
+ */
+export type ApprovalProcessRequestConfig = {
+    actionType: 'Submit' | 'Approve' | 'Reject';
+    contextId: string;
+    comments?: string;
+    nextApproverIds?: string[];
+    processDefinitionNameOrId?: string;
+    skipEntryCriteria?: boolean;
+};
+/**
+ * A class representing approval process request
+ */
+declare class ApprovalProcessRequest<S extends Schema> {
+    _process: ApprovalProcess<S>;
+    _request: ApprovalProcessRequestConfig;
+    _promise: Promise<ApprovalProcessRequestResult> | undefined;
+    constructor(process: ApprovalProcess<S>, request: ApprovalProcessRequestConfig);
+    /**
+     * Promise/A+ interface
+     * http://promises-aplus.github.io/promises-spec/
+     */
+    then<U>(onResolve?: (res: ApprovalProcessRequestResult) => U | PromiseLike<U> | null, onReject?: (err: any) => U | PromiseLike<U> | null): void;
+}
+/**
+ * A class which manages process rules and approval processes
+ */
+export declare class Process<S extends Schema> {
+    rule: ProcessRule<S>;
+    approval: ApprovalProcess<S>;
+    /**
+     *
+     */
+    constructor(conn: Connection<S>);
+}
+export default Process;

package/lib/process.js

@@ -0,0 +1,143 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Process = exports.ApprovalProcess = exports.ProcessRule = void 0;
+/**
+ * A class which manages process (workflow) rules
+ */
+class ProcessRule {
+    _conn;
+    /**
+     *
+     */
+    constructor(conn) {
+        this._conn = conn;
+    }
+    /**
+     * Get all process rule definitions registered to sobjects
+     */
+    async list() {
+        const res = await this._conn.request('/process/rules');
+        return res.rules;
+    }
+    /**
+     * Trigger process rule for given entities
+     */
+    trigger(contextIds) {
+        const contextIds_ = Array.isArray(contextIds) ? contextIds : [contextIds];
+        // https://developer.salesforce.com/docs/atlas.en-us.api_rest.meta/api_rest/dome_process_rules_trigger.htm
+        return this._conn.request({
+            method: 'POST',
+            url: '/process/rules/',
+            body: JSON.stringify({
+                contextIds: contextIds_,
+            }),
+            headers: {
+                'content-type': 'application/json',
+            },
+        });
+    }
+}
+exports.ProcessRule = ProcessRule;
+/**
+ * A class which manages approval processes
+ */
+class ApprovalProcess {
+    _conn;
+    /**
+     *
+     */
+    constructor(conn) {
+        this._conn = conn;
+    }
+    /**
+     * Get all approval process definitions registered to sobjects
+     */
+    async list() {
+        const res = await this._conn.request('/process/approvals');
+        return res.approvals;
+    }
+    /**
+     * Send bulk requests for approval process
+     */
+    request(requests) {
+        const requests_ = requests.map((req) => '_request' in req ? req._request : req);
+        return this._conn.request({
+            method: 'POST',
+            url: '/process/approvals',
+            headers: { 'content-type': 'application/json' },
+            body: JSON.stringify({ requests: requests_ }),
+        });
+    }
+    /**
+     * Create approval process request
+     *
+     * @private
+     */
+    _createRequest(actionType, contextId, comments, options = {}) {
+        return new ApprovalProcessRequest(this, {
+            actionType,
+            contextId,
+            comments,
+            ...options,
+        });
+    }
+    /**
+     * Submit approval request for an item
+     */
+    submit(contextId, comments, options) {
+        return this._createRequest('Submit', contextId, comments, options);
+    }
+    /**
+     * Approve approval request for an item
+     */
+    approve(workitemId, comments, options = {}) {
+        return this._createRequest('Approve', workitemId, comments, options);
+    }
+    /**
+     * Reject approval request for an item
+     */
+    reject(workitemId, comments, options = {}) {
+        return this._createRequest('Reject', workitemId, comments, options);
+    }
+}
+exports.ApprovalProcess = ApprovalProcess;
+/**
+ * A class representing approval process request
+ */
+class ApprovalProcessRequest {
+    _process;
+    _request;
+    _promise;
+    constructor(process, request) {
+        this._process = process;
+        this._request = request;
+    }
+    /**
+     * Promise/A+ interface
+     * http://promises-aplus.github.io/promises-spec/
+     */
+    then(onResolve, onReject) {
+        if (!this._promise) {
+            this._promise = this._process
+                .request([this])
+                .then((rets) => rets[0]);
+        }
+        this._promise.then(onResolve, onReject);
+    }
+}
+/**
+ * A class which manages process rules and approval processes
+ */
+class Process {
+    rule;
+    approval;
+    /**
+     *
+     */
+    constructor(conn) {
+        this.rule = new ProcessRule(conn);
+        this.approval = new ApprovalProcess(conn);
+    }
+}
+exports.Process = Process;
+exports.default = Process;