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

package/lib/registry/file.js

@@ -0,0 +1,51 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FileRegistry = void 0;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const base_1 = require("./base");
+/**
+ *
+ */
+function getDefaultConfigFilePath() {
+    const homeDir = process.env[process.platform === 'win32' ? 'USERPROFILE' : 'HOME'];
+    if (!homeDir) {
+        throw new Error('cannot find user home directory to store configuration files');
+    }
+    return path_1.default.join(homeDir, '.jsforce', 'config.json');
+}
+/**
+ *
+ */
+class FileRegistry extends base_1.BaseRegistry {
+    _configFilePath;
+    constructor({ configFilePath }) {
+        super();
+        this._configFilePath = configFilePath || getDefaultConfigFilePath();
+        try {
+            const data = fs_1.default.readFileSync(this._configFilePath, 'utf-8');
+            this._registryConfig = JSON.parse(data);
+        }
+        catch (e) {
+            //
+        }
+    }
+    _saveConfig() {
+        const data = JSON.stringify(this._registryConfig, null, 4);
+        try {
+            fs_1.default.writeFileSync(this._configFilePath, data);
+            fs_1.default.chmodSync(this._configFilePath, '600');
+        }
+        catch (e) {
+            const configDir = path_1.default.dirname(this._configFilePath);
+            fs_1.default.mkdirSync(configDir);
+            fs_1.default.chmodSync(configDir, '700');
+            fs_1.default.writeFileSync(this._configFilePath, data);
+            fs_1.default.chmodSync(this._configFilePath, '600');
+        }
+    }
+}
+exports.FileRegistry = FileRegistry;

package/lib/registry/index.d.ts

@@ -0,0 +1,8 @@
+import type { Registry } from './types';
+import { FileRegistry } from './file';
+import { SfdxRegistry } from './sfdx';
+import { EmptyRegistry } from './empty';
+declare let registry: Registry;
+export default registry;
+export type { Registry };
+export { FileRegistry, SfdxRegistry, EmptyRegistry };

package/lib/registry/index.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EmptyRegistry = exports.SfdxRegistry = exports.FileRegistry = void 0;
+const file_1 = require("./file");
+Object.defineProperty(exports, "FileRegistry", { enumerable: true, get: function () { return file_1.FileRegistry; } });
+const sfdx_1 = require("./sfdx");
+Object.defineProperty(exports, "SfdxRegistry", { enumerable: true, get: function () { return sfdx_1.SfdxRegistry; } });
+const empty_1 = require("./empty");
+Object.defineProperty(exports, "EmptyRegistry", { enumerable: true, get: function () { return empty_1.EmptyRegistry; } });
+let registry;
+try {
+    registry =
+        process.env.JSFORCE_CONNECTION_REGISTRY === 'sfdx'
+            ? new sfdx_1.SfdxRegistry({})
+            : new file_1.FileRegistry({});
+}
+catch (e) {
+    console.error(e);
+    registry = new empty_1.EmptyRegistry();
+}
+exports.default = registry;

package/lib/registry/sfdx.d.ts

@@ -0,0 +1,56 @@
+import Connection from '../connection';
+import { Registry, ConnectionConfig, ClientConfig } from './types';
+import { Schema } from '../types';
+type SfdxOrgList = {
+    nonScratchOrgs: SfdxOrgInfo[];
+    scratchOrgs: SfdxOrgInfo[];
+};
+type SfdxOrgInfo = {
+    orgId: string;
+    accessToken: string;
+    instanceUrl: string;
+    loginUrl: string;
+    username: string;
+    clientId: string;
+    isDevHub: boolean;
+    connectedStatus: string;
+    lastUsed: string;
+    alias?: string;
+};
+/**
+ *
+ */
+export declare class SfdxRegistry implements Registry {
+    _cliPath: string | undefined;
+    _orgList: Promise<SfdxOrgList> | undefined;
+    _orgInfoMap: {
+        [name: string]: Promise<SfdxOrgInfo>;
+    };
+    _defaultOrgInfo: Promise<SfdxOrgInfo> | undefined;
+    constructor({ cliPath }: {
+        cliPath?: string;
+    });
+    _createCommand(command: string, options?: {
+        [option: string]: any;
+    }, args?: string[]): string;
+    _execCommand<T>(command: string, options?: {
+        [option: string]: any;
+    }, args?: string[]): Promise<T>;
+    _getOrgList(): Promise<SfdxOrgList>;
+    getConnectionNames(): Promise<string[]>;
+    getConnection<S extends Schema = Schema>(name?: string): Promise<Connection<S> | null>;
+    _getOrgInfo(username?: string): Promise<SfdxOrgInfo>;
+    _memoOrgInfo(pOrgInfo: Promise<SfdxOrgInfo>, username?: string): void;
+    getConnectionConfig(name?: string): Promise<{
+        accessToken: string;
+        instanceUrl: string;
+        loginUrl: string;
+    } | null>;
+    saveConnectionConfig(_name: string, _connConfig: ConnectionConfig): Promise<void>;
+    setDefaultConnection(_name: string): Promise<void>;
+    removeConnectionConfig(name: string): Promise<void>;
+    getClientConfig(_name: string): Promise<null>;
+    getClientNames(): Promise<never[]>;
+    registerClientConfig(_name: string, _clientConfig: ClientConfig): Promise<void>;
+}
+export {};

package/lib/registry/sfdx.js

@@ -0,0 +1,133 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SfdxRegistry = void 0;
+const child_process_1 = require("child_process");
+const strip_ansi_1 = __importDefault(require("strip-ansi"));
+const connection_1 = __importDefault(require("../connection"));
+function isNotNullOrUndefined(v) {
+    return v != null;
+}
+/**
+ *
+ */
+class SfdxRegistry {
+    _cliPath;
+    _orgList;
+    _orgInfoMap = {};
+    _defaultOrgInfo;
+    constructor({ cliPath }) {
+        this._cliPath = cliPath;
+    }
+    _createCommand(command, options = {}, args = []) {
+        return `${this._cliPath ? this._cliPath + '/' : ''}sfdx ${command} ${Object.keys(options)
+            .map((option) => `${option.length > 1 ? '--' : '-'}${option}${options[option] != null ? ' ' + options[option] : ''}`)
+            .join(' ')} --json ${args.join(' ')}`;
+    }
+    async _execCommand(command, options = {}, args = []) {
+        const cmd = this._createCommand(command, options, args);
+        const buf = await new Promise((resolve, reject) => {
+            (0, child_process_1.exec)(cmd, (err, ret) => {
+                if (err && !ret) {
+                    reject(err);
+                }
+                else {
+                    resolve(ret);
+                }
+            });
+        });
+        const body = (0, strip_ansi_1.default)(buf.toString());
+        let ret;
+        try {
+            ret = JSON.parse(body);
+        }
+        catch (e) {
+            throw new Error(`Unexpectedd output from Sfdx cli: ${body}`);
+        }
+        if (ret.status === 0 && ret.result) {
+            return ret.result;
+        }
+        else {
+            const err = new Error(ret.message);
+            err.name = ret.name;
+            throw err;
+        }
+    }
+    async _getOrgList() {
+        if (!this._orgList) {
+            this._orgList = this._execCommand('force:org:list');
+        }
+        return this._orgList;
+    }
+    async getConnectionNames() {
+        const { nonScratchOrgs, scratchOrgs } = await this._getOrgList();
+        return [
+            ...nonScratchOrgs.map((o) => o.alias).filter(isNotNullOrUndefined),
+            ...scratchOrgs.map((o) => o.alias).filter(isNotNullOrUndefined),
+            ...nonScratchOrgs.map((o) => o.username),
+            ...scratchOrgs.map((o) => o.username),
+        ];
+    }
+    async getConnection(name) {
+        const config = await this.getConnectionConfig(name);
+        return config ? new connection_1.default(config) : null;
+    }
+    async _getOrgInfo(username) {
+        const options = username ? { u: username } : {};
+        if (!username || !this._orgInfoMap[username]) {
+            const pOrgInfo = this._execCommand('force:org:display', options);
+            this._memoOrgInfo(pOrgInfo, username);
+        }
+        const orgInfo = username
+            ? this._orgInfoMap[username]
+            : this._defaultOrgInfo;
+        if (!orgInfo) {
+            throw new Error('no orginfo found');
+        }
+        return orgInfo;
+    }
+    _memoOrgInfo(pOrgInfo, username) {
+        const pOrgInfo_ = pOrgInfo.then((orgInfo) => {
+            this._orgInfoMap[orgInfo.username] = pOrgInfo_;
+            if (orgInfo.alias) {
+                this._orgInfoMap[orgInfo.alias] = pOrgInfo_;
+            }
+            return orgInfo;
+        });
+        if (username) {
+            this._orgInfoMap[username] = pOrgInfo_;
+        }
+        else {
+            this._defaultOrgInfo = pOrgInfo_;
+        }
+    }
+    async getConnectionConfig(name) {
+        const orgInfo = await this._getOrgInfo(name);
+        if (!orgInfo) {
+            return null;
+        }
+        const { accessToken, instanceUrl, loginUrl } = orgInfo;
+        return { accessToken, instanceUrl, loginUrl };
+    }
+    async saveConnectionConfig(_name, _connConfig) {
+        // nothing to do
+    }
+    async setDefaultConnection(_name) {
+        // nothing to do
+    }
+    async removeConnectionConfig(name) {
+        await this._execCommand('force:org:delete', { u: name });
+    }
+    async getClientConfig(_name) {
+        return null;
+    }
+    async getClientNames() {
+        return [];
+    }
+    async registerClientConfig(_name, _clientConfig) {
+        // nothing to do
+    }
+}
+exports.SfdxRegistry = SfdxRegistry;

package/lib/registry/types.d.ts

@@ -0,0 +1,47 @@
+/**
+ * @file Registry for connection information, cached in local file system
+ * @author Shinichi Tomita <shinichi.tomita@gmail.com>
+ */
+import { Connection } from '..';
+import { Schema } from '../types';
+export type ConnectionConfig = {
+    instanceUrl?: string;
+    accessToken?: string;
+    refreshToken?: string;
+    loginUrl?: string;
+    oauth2?: ClientConfig;
+};
+export type PersistConnectionConfig = {
+    client?: string;
+    instanceUrl?: string;
+    accessToken?: string;
+};
+export type ClientConfig = {
+    clientId?: string;
+    clientSecret?: string;
+    redirectUri?: string;
+    loginUrl?: string;
+};
+export type RegistryConfig = {
+    default?: string;
+    clients?: {
+        [name: string]: ClientConfig;
+    };
+    connections?: {
+        [name: string]: PersistConnectionConfig;
+    };
+};
+/**
+ *
+ */
+export interface Registry {
+    getConnectionNames(): Promise<string[]>;
+    getConnection<S extends Schema = Schema>(name?: string): Promise<Connection<S> | null>;
+    getConnectionConfig(name?: string): Promise<ConnectionConfig | null>;
+    saveConnectionConfig(name: string, connConfig: ConnectionConfig): Promise<void>;
+    setDefaultConnection(name: string): Promise<void>;
+    removeConnectionConfig(name: string): Promise<void>;
+    getClientConfig(name: string): Promise<ClientConfig | null>;
+    getClientNames(): Promise<string[]>;
+    registerClientConfig(name: string, clientConfig: ClientConfig): Promise<void>;
+}

package/lib/registry/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/request-helper.d.ts

@@ -0,0 +1,23 @@
+/// <reference types="node" />
+import { PassThrough } from 'stream';
+import { HttpRequest, HttpRequestOptions, HttpResponse } from './types';
+/**
+ *
+ */
+export declare function createHttpRequestHandlerStreams(req: HttpRequest, options?: HttpRequestOptions): {
+    input: PassThrough;
+    output: PassThrough;
+    stream: import("stream").Duplex;
+};
+/**
+ *
+ */
+export declare function isRedirect(status: number): boolean;
+/**
+ *
+ */
+export declare function performRedirectRequest(req: HttpRequest, res: Omit<HttpResponse, 'body'>, followRedirect: NonNullable<HttpRequestOptions['followRedirect']>, counter: number, redirectCallback: (req: HttpRequest) => void): void;
+/**
+ *
+ */
+export declare function executeWithTimeout<T>(execFn: () => Promise<T>, msec: number | undefined, cancelCallback?: () => void): Promise<T>;

package/lib/request-helper.js

@@ -0,0 +1,102 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.executeWithTimeout = exports.performRedirectRequest = exports.isRedirect = exports.createHttpRequestHandlerStreams = void 0;
+const stream_1 = require("stream");
+const stream_2 = require("./util/stream");
+const form_data_1 = __importDefault(require("form-data"));
+/**
+ *
+ */
+function createHttpRequestHandlerStreams(req, options = {}) {
+    const { body: reqBody } = req;
+    const input = new stream_1.PassThrough();
+    const output = new stream_1.PassThrough();
+    const duplex = (0, stream_2.concatStreamsAsDuplex)(input, output);
+    if (typeof reqBody !== 'undefined') {
+        setTimeout(() => {
+            if (reqBody instanceof form_data_1.default) {
+                duplex.end(reqBody.getBuffer());
+            }
+            else {
+                duplex.end(reqBody, 'utf8');
+            }
+        }, 0);
+    }
+    duplex.on('response', async (res) => {
+        if (duplex.listenerCount('complete') > 0) {
+            const resBody = await (0, stream_2.readAll)(duplex, options.encoding);
+            duplex.emit('complete', {
+                ...res,
+                body: resBody,
+            });
+        }
+    });
+    return { input, output, stream: duplex };
+}
+exports.createHttpRequestHandlerStreams = createHttpRequestHandlerStreams;
+const redirectStatuses = new Set([301, 302, 303, 307, 308]);
+/**
+ *
+ */
+function isRedirect(status) {
+    return redirectStatuses.has(status);
+}
+exports.isRedirect = isRedirect;
+/**
+ *
+ */
+const MAX_REDIRECT_COUNT = 10;
+/**
+ *
+ */
+function performRedirectRequest(req, res, followRedirect, counter, redirectCallback) {
+    if (counter >= MAX_REDIRECT_COUNT) {
+        throw new Error('Reached to maximum redirect count');
+    }
+    const redirectUrl = res.headers['location'];
+    if (!redirectUrl) {
+        throw new Error('No redirect URI found');
+    }
+    const getRedirectRequest = typeof followRedirect === 'function'
+        ? followRedirect
+        : () => ({
+            method: 'GET',
+            url: redirectUrl,
+            headers: req.headers,
+        });
+    const nextReqParams = getRedirectRequest(redirectUrl);
+    if (!nextReqParams) {
+        throw new Error('Cannot handle redirect for ' + redirectUrl);
+    }
+    redirectCallback(nextReqParams);
+}
+exports.performRedirectRequest = performRedirectRequest;
+/**
+ *
+ */
+async function executeWithTimeout(execFn, msec, cancelCallback) {
+    let timeout = false;
+    const pid = msec != null
+        ? setTimeout(() => {
+            timeout = true;
+            cancelCallback?.();
+        }, msec)
+        : undefined;
+    let res;
+    try {
+        res = await execFn();
+    }
+    finally {
+        if (pid) {
+            clearTimeout(pid);
+        }
+    }
+    if (timeout) {
+        throw new Error('Request Timeout');
+    }
+    return res;
+}
+exports.executeWithTimeout = executeWithTimeout;

package/lib/request.d.ts

@@ -0,0 +1,11 @@
+/// <reference types="node" />
+import { Duplex } from 'stream';
+import { HttpRequest, HttpRequestOptions } from './types';
+/**
+ *
+ */
+export declare function setDefaults(defaults_: HttpRequestOptions): void;
+/**
+ *
+ */
+export default function request(req: HttpRequest, options_?: HttpRequestOptions): Duplex;

package/lib/request.js

@@ -0,0 +1,75 @@
+"use strict";
+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 node_fetch_1 = __importDefault(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");
+/**
+ *
+ */
+let defaults = {};
+/**
+ *
+ */
+function setDefaults(defaults_) {
+    defaults = defaults_;
+}
+exports.setDefaults = setDefaults;
+/**
+ *
+ */
+async function startFetchRequest(request, options, input, output, emitter, counter = 0) {
+    const { httpProxy, followRedirect } = options;
+    const agent = httpProxy ? (0, https_proxy_agent_1.default)(httpProxy) : undefined;
+    const { url, body, ...rrequest } = request;
+    const controller = new abort_controller_1.default();
+    let res;
+    try {
+        res = await (0, request_helper_1.executeWithTimeout)(() => (0, node_fetch_1.default)(url, {
+            ...rrequest,
+            ...(input && /^(post|put|patch)$/i.test(request.method)
+                ? { body: input }
+                : {}),
+            redirect: 'manual',
+            signal: controller.signal,
+            agent,
+        }), options.timeout, () => controller.abort());
+    }
+    catch (err) {
+        emitter.emit('error', err);
+        return;
+    }
+    const headers = {};
+    for (const headerName of res.headers.keys()) {
+        headers[headerName.toLowerCase()] = res.headers.get(headerName);
+    }
+    const response = {
+        statusCode: res.status,
+        headers,
+    };
+    if (followRedirect && (0, request_helper_1.isRedirect)(response.statusCode)) {
+        try {
+            (0, request_helper_1.performRedirectRequest)(request, response, followRedirect, counter, (req) => startFetchRequest(req, options, undefined, output, emitter, counter + 1));
+        }
+        catch (err) {
+            emitter.emit('error', err);
+        }
+        return;
+    }
+    emitter.emit('response', response);
+    res.body.pipe(output);
+}
+/**
+ *
+ */
+function request(req, options_ = {}) {
+    const options = { ...defaults, ...options_ };
+    const { input, output, stream } = (0, request_helper_1.createHttpRequestHandlerStreams)(req, options);
+    startFetchRequest(req, options, input, output, stream);
+    return stream;
+}
+exports.default = request;

package/lib/session-refresh-delegate.d.ts

@@ -0,0 +1,31 @@
+/**
+ *
+ */
+import { Logger } from './util/logger';
+import { Callback, Schema } from './types';
+import Connection from './connection';
+import { TokenResponse } from './oauth2';
+/**
+ *
+ */
+export type SessionRefreshFunc<S extends Schema> = (conn: Connection<S>, callback: Callback<string, TokenResponse>) => void;
+/**
+ *
+ */
+export declare class SessionRefreshDelegate<S extends Schema> {
+    static _logger: Logger;
+    private _refreshFn;
+    private _conn;
+    private _logger;
+    private _lastRefreshedAt;
+    private _refreshPromise;
+    constructor(conn: Connection<S>, refreshFn: SessionRefreshFunc<S>);
+    /**
+     * Refresh access token
+     * @private
+     */
+    refresh(since: number): Promise<void>;
+    isRefreshing(): boolean;
+    waitRefresh(): Promise<void>;
+}
+export default SessionRefreshDelegate;

package/lib/session-refresh-delegate.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SessionRefreshDelegate = void 0;
+/**
+ *
+ */
+const logger_1 = require("./util/logger");
+/**
+ *
+ */
+class SessionRefreshDelegate {
+    static _logger = (0, logger_1.getLogger)('session-refresh-delegate');
+    _refreshFn;
+    _conn;
+    _logger;
+    _lastRefreshedAt = undefined;
+    _refreshPromise = undefined;
+    constructor(conn, refreshFn) {
+        this._conn = conn;
+        this._logger = conn._logLevel
+            ? SessionRefreshDelegate._logger.createInstance(conn._logLevel)
+            : SessionRefreshDelegate._logger;
+        this._refreshFn = refreshFn;
+    }
+    /**
+     * Refresh access token
+     * @private
+     */
+    async refresh(since) {
+        // Callback immediately When refreshed after designated time
+        if (this._lastRefreshedAt && this._lastRefreshedAt > since) {
+            return;
+        }
+        if (this._refreshPromise) {
+            await this._refreshPromise;
+            return;
+        }
+        try {
+            this._logger.info('<refresh token>');
+            this._refreshPromise = new Promise((resolve, reject) => {
+                this._refreshFn(this._conn, (err, accessToken, res) => {
+                    if (!err) {
+                        this._logger.debug('Connection refresh completed.');
+                        this._conn.accessToken = accessToken;
+                        this._conn.emit('refresh', accessToken, res);
+                        resolve();
+                    }
+                    else {
+                        reject(err);
+                    }
+                });
+            });
+            await this._refreshPromise;
+            this._logger.info('<refresh complete>');
+        }
+        finally {
+            this._refreshPromise = undefined;
+            this._lastRefreshedAt = Date.now();
+        }
+    }
+    isRefreshing() {
+        return !!this._refreshPromise;
+    }
+    async waitRefresh() {
+        return this._refreshPromise;
+    }
+}
+exports.SessionRefreshDelegate = SessionRefreshDelegate;
+exports.default = SessionRefreshDelegate;