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

package/lib/browser/client.d.ts

@@ -0,0 +1,82 @@
+/// <reference types="node" />
+/**
+ * @file Browser client connection management class
+ * @author Shinichi Tomita <shinichi.tomita@gmail.com>
+ */
+import { EventEmitter } from 'events';
+import Connection, { ConnectionConfig } from '../connection';
+import { TokenResponse } from '../oauth2';
+/**
+ *
+ */
+export type LoginOptions = {
+    scope?: string;
+    size?: {
+        width: number;
+        height: number;
+    };
+};
+/**
+ *
+ */
+export declare class BrowserClient extends EventEmitter {
+    _prefix: string;
+    _config: ConnectionConfig | undefined;
+    _connection: Connection | undefined;
+    /**
+     *
+     */
+    constructor(prefix?: string);
+    get connection(): Connection;
+    /**
+     *
+     */
+    init(config: ConnectionConfig): void;
+    /**
+     *
+     */
+    login(options?: LoginOptions): Promise<{
+        status: string;
+    }>;
+    /**
+     *
+     */
+    isLoggedIn(): boolean;
+    /**
+     *
+     */
+    logout(): void;
+    /**
+     * @private
+     */
+    _getTokens(): {
+        accessToken: string | null;
+        instanceUrl: string | null;
+        userInfo: {
+            id: string;
+            organizationId: string;
+            url: string;
+        } | undefined;
+    } | null;
+    /**
+     * @private
+     */
+    _storeTokens(params: TokenResponse): void;
+    /**
+     * @private
+     */
+    _removeTokens(): void;
+    /**
+     * @private
+     */
+    _getError(): any;
+    /**
+     * @private
+     */
+    _storeError(err: any): void;
+}
+/**
+ *
+ */
+declare const client: BrowserClient;
+export default client;

package/lib/browser/client.js

@@ -0,0 +1,244 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BrowserClient = void 0;
+/**
+ * @file Browser client connection management class
+ * @author Shinichi Tomita <shinichi.tomita@gmail.com>
+ */
+const events_1 = require("events");
+const connection_1 = __importDefault(require("../connection"));
+const oauth2_1 = __importDefault(require("../oauth2"));
+/**
+ * @private
+ */
+function popupWin(url, w, h) {
+    const left = screen.width / 2 - w / 2;
+    const top = screen.height / 2 - h / 2;
+    return window.open(url, undefined, `location=yes,toolbar=no,status=no,menubar=no,width=${w},height=${h},top=${top},left=${left}`);
+}
+/**
+ * @private
+ */
+function handleCallbackResponse() {
+    const res = checkCallbackResponse();
+    const state = localStorage.getItem('jsforce_state');
+    if (res && state && res.body.get('state') === state) {
+        localStorage.removeItem('jsforce_state');
+        const [prefix, promptType] = state.split('.');
+        const cli = new BrowserClient(prefix);
+        if (res.success) {
+            cli._storeTokens(Object.fromEntries(res.body));
+            location.hash = '';
+        }
+        else {
+            cli._storeError(res.body);
+        }
+        if (promptType === 'popup') {
+            window.close();
+        }
+        return true;
+    }
+}
+/**
+ * @private
+ */
+function checkCallbackResponse() {
+    let params;
+    if (window.location.hash) {
+        params = new URLSearchParams(window.location.hash.substring(1));
+        if (params.get('access_token')) {
+            return { success: true, body: params };
+        }
+    }
+    else if (window.location.search) {
+        params = new URLSearchParams(window.location.search.substring(1));
+        if (params.get('error')) {
+            return { success: false, body: params };
+        }
+    }
+}
+/**
+ *
+ */
+const DEFAULT_POPUP_WIN_WIDTH = 912;
+const DEFAULT_POPUP_WIN_HEIGHT = 513;
+/** @private **/
+let clientIdx = 0;
+/**
+ *
+ */
+class BrowserClient extends events_1.EventEmitter {
+    _prefix;
+    _config;
+    _connection;
+    /**
+     *
+     */
+    constructor(prefix) {
+        super();
+        this._prefix = prefix || 'jsforce' + clientIdx++;
+    }
+    get connection() {
+        if (!this._connection) {
+            this._connection = new connection_1.default(this._config);
+        }
+        return this._connection;
+    }
+    /**
+     *
+     */
+    init(config) {
+        if (handleCallbackResponse()) {
+            return;
+        }
+        this._config = config;
+        const tokens = this._getTokens();
+        if (tokens) {
+            this.connection._establish(tokens);
+            setTimeout(() => {
+                this.emit('connect', this.connection);
+            }, 10);
+        }
+    }
+    /**
+     *
+     */
+    login(options = {}) {
+        const { scope, size } = options;
+        const oauth2 = new oauth2_1.default(this._config ?? {});
+        const rand = Math.random().toString(36).substring(2);
+        const state = [this._prefix, 'popup', rand].join('.');
+        localStorage.setItem('jsforce_state', state);
+        const authzUrl = oauth2.getAuthorizationUrl({
+            response_type: 'token',
+            state,
+            ...(scope ? { scope } : {}),
+        });
+        const pw = popupWin(authzUrl, size?.width ?? DEFAULT_POPUP_WIN_WIDTH, size?.height ?? DEFAULT_POPUP_WIN_HEIGHT);
+        return new Promise((resolve, reject) => {
+            if (!pw) {
+                const state = [this._prefix, 'redirect', rand].join('.');
+                localStorage.setItem('jsforce_state', state);
+                const authzUrl = oauth2.getAuthorizationUrl({
+                    response_type: 'token',
+                    state,
+                    ...(scope ? { scope } : {}),
+                });
+                location.href = authzUrl;
+                return;
+            }
+            this._removeTokens();
+            const pid = setInterval(() => {
+                try {
+                    if (!pw || pw.closed) {
+                        clearInterval(pid);
+                        const tokens = this._getTokens();
+                        if (tokens) {
+                            this.connection._establish(tokens);
+                            this.emit('connect', this.connection);
+                            resolve({ status: 'connect' });
+                        }
+                        else {
+                            const err = this._getError();
+                            if (err) {
+                                reject(new Error(err.error + ': ' + err.error_description));
+                            }
+                            else {
+                                resolve({ status: 'cancel' });
+                            }
+                        }
+                    }
+                }
+                catch (e) {
+                    //
+                }
+            }, 1000);
+        });
+    }
+    /**
+     *
+     */
+    isLoggedIn() {
+        return !!this.connection.accessToken;
+    }
+    /**
+     *
+     */
+    logout() {
+        this.connection.logout();
+        this._removeTokens();
+        this.emit('disconnect');
+    }
+    /**
+     * @private
+     */
+    _getTokens() {
+        const regexp = new RegExp('(^|;\\s*)' + this._prefix + '_loggedin=true(;|$)');
+        if (document.cookie.match(regexp)) {
+            const issuedAt = Number(localStorage.getItem(this._prefix + '_issued_at'));
+            // 2 hours
+            if (Date.now() < issuedAt + 2 * 60 * 60 * 1000) {
+                let userInfo;
+                const idUrl = localStorage.getItem(this._prefix + '_id');
+                if (idUrl) {
+                    const [id, organizationId] = idUrl.split('/').reverse();
+                    userInfo = { id, organizationId, url: idUrl };
+                }
+                return {
+                    accessToken: localStorage.getItem(this._prefix + '_access_token'),
+                    instanceUrl: localStorage.getItem(this._prefix + '_instance_url'),
+                    userInfo,
+                };
+            }
+        }
+        return null;
+    }
+    /**
+     * @private
+     */
+    _storeTokens(params) {
+        localStorage.setItem(this._prefix + '_access_token', params.access_token);
+        localStorage.setItem(this._prefix + '_instance_url', params.instance_url);
+        localStorage.setItem(this._prefix + '_issued_at', params.issued_at);
+        localStorage.setItem(this._prefix + '_id', params.id);
+        document.cookie = this._prefix + '_loggedin=true;';
+    }
+    /**
+     * @private
+     */
+    _removeTokens() {
+        localStorage.removeItem(this._prefix + '_access_token');
+        localStorage.removeItem(this._prefix + '_instance_url');
+        localStorage.removeItem(this._prefix + '_issued_at');
+        localStorage.removeItem(this._prefix + '_id');
+        document.cookie = this._prefix + '_loggedin=';
+    }
+    /**
+     * @private
+     */
+    _getError() {
+        try {
+            const err = JSON.parse(localStorage.getItem(this._prefix + '_error') ?? '');
+            localStorage.removeItem(this._prefix + '_error');
+            return err;
+        }
+        catch (e) {
+            //
+        }
+    }
+    /**
+     * @private
+     */
+    _storeError(err) {
+        localStorage.setItem(this._prefix + '_error', JSON.stringify(err));
+    }
+}
+exports.BrowserClient = BrowserClient;
+/**
+ *
+ */
+const client = new BrowserClient();
+exports.default = client;

package/lib/browser/jsonp.d.ts

@@ -0,0 +1,12 @@
+/// <reference types="node" />
+/**
+ *
+ */
+import { Transform } from 'stream';
+import { HttpRequest } from '../types';
+declare function createRequest(jsonpParam?: string, timeout?: number): (params: HttpRequest) => Transform;
+declare const _default: {
+    supported: boolean;
+    createRequest: typeof createRequest;
+};
+export default _default;

package/lib/browser/jsonp.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ *
+ */
+const stream_1 = require("stream");
+let _index = 0;
+async function processJsonpRequest(params, jsonpParam, timeout) {
+    if (params.method.toUpperCase() !== 'GET') {
+        throw new Error('JSONP only supports GET request.');
+    }
+    _index += 1;
+    const cbFuncName = `_jsforce_jsonpCallback_${_index}`;
+    const callbacks = window;
+    let url = params.url;
+    url += url.indexOf('?') > 0 ? '&' : '?';
+    url += `${jsonpParam}=${cbFuncName}`;
+    const script = document.createElement('script');
+    script.type = 'text/javascript';
+    script.src = url;
+    if (document.documentElement) {
+        document.documentElement.appendChild(script);
+    }
+    let pid;
+    try {
+        const res = await new Promise((resolve, reject) => {
+            pid = setTimeout(() => {
+                reject(new Error('JSONP call time out.'));
+            }, timeout);
+            callbacks[cbFuncName] = resolve;
+        });
+        return {
+            statusCode: 200,
+            headers: { 'content-type': 'application/json' },
+            body: JSON.stringify(res),
+        };
+    }
+    finally {
+        clearTimeout(pid);
+        if (document.documentElement) {
+            document.documentElement.removeChild(script);
+        }
+        delete callbacks[cbFuncName];
+    }
+}
+function createRequest(jsonpParam = 'callback', timeout = 10000) {
+    return (params) => {
+        const stream = new stream_1.Transform({
+            transform(chunk, encoding, callback) {
+                callback();
+            },
+            flush() {
+                (async () => {
+                    const response = await processJsonpRequest(params, jsonpParam, timeout);
+                    stream.emit('response', response);
+                    stream.emit('complete', response);
+                    stream.push(response.body);
+                    stream.push(null);
+                })();
+            },
+        });
+        stream.end();
+        return stream;
+    };
+}
+exports.default = {
+    supported: typeof window !== 'undefined' && typeof document !== 'undefined',
+    createRequest,
+};

package/lib/browser/registry.d.ts

@@ -0,0 +1,3 @@
+import { EmptyRegistry } from '../registry/empty';
+declare const registry: EmptyRegistry;
+export default registry;

package/lib/browser/registry.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const empty_1 = require("../registry/empty");
+const registry = new empty_1.EmptyRegistry();
+exports.default = registry;

package/lib/browser/request.d.ts

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

package/lib/browser/request.js

@@ -0,0 +1,202 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setDefaults = void 0;
+const request_helper_1 = require("../request-helper");
+const stream_1 = require("../util/stream");
+/**
+ * As the request streming is not yet supported on major browsers,
+ * it is set to false for now.
+ */
+const supportsReadableStream = false;
+/*
+(async () => {
+  try {
+    if (
+      typeof fetch === 'function' &&
+      typeof Request === 'function' &&
+      typeof ReadableStream === 'function'
+    ) {
+      // this feature detection requires dummy POST request
+      const req = new Request('data:text/plain,', {
+        method: 'POST',
+        body: new ReadableStream(),
+      });
+      // if it has content-type header it doesn't regard body as stream
+      if (req.headers.has('Content-Type')) {
+        return false;
+      }
+      await (await fetch(req)).text();
+      return true;
+    }
+  } catch (e) {
+    // error might occur in env with CSP without connect-src data:
+    return false;
+  }
+  return false;
+})();
+*/
+/**
+ *
+ */
+function toWhatwgReadableStream(ins) {
+    return new ReadableStream({
+        start(controller) {
+            ins.on('data', (chunk) => controller.enqueue(chunk));
+            ins.on('end', () => controller.close());
+        },
+    });
+}
+/**
+ *
+ */
+async function readWhatwgReadableStream(rs, outs) {
+    const reader = rs.getReader();
+    async function readAndWrite() {
+        const { done, value } = await reader.read();
+        if (done) {
+            outs.end();
+            return false;
+        }
+        outs.write(value);
+        return true;
+    }
+    while (await readAndWrite())
+        ;
+}
+/**
+ *
+ */
+async function startFetchRequest(request, options, input, output, emitter, counter = 0) {
+    const { followRedirect } = options;
+    const { url, body: reqBody, ...rreq } = request;
+    const body = input && /^(post|put|patch)$/i.test(request.method)
+        ? supportsReadableStream
+            ? toWhatwgReadableStream(input)
+            : await (0, stream_1.readAll)(input)
+        : undefined;
+    const controller = typeof AbortController !== 'undefined' ? new AbortController() : undefined;
+    const res = await (0, request_helper_1.executeWithTimeout)(() => fetch(url, {
+        ...rreq,
+        ...(body ? { body } : {}),
+        redirect: 'manual',
+        ...(controller ? { signal: controller.signal } : {}),
+        ...{ allowHTTP1ForStreamingUpload: true }, // Chrome allows request stream only in HTTP2/QUIC unless this opt-in flag
+    }), options.timeout, () => controller?.abort());
+    const headers = {};
+    // @ts-expect-error
+    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);
+    if (res.body) {
+        readWhatwgReadableStream(res.body, output);
+    }
+    else {
+        output.end();
+    }
+}
+/**
+ *
+ */
+function getResponseHeaderNames(xhr) {
+    const headerLines = (xhr.getAllResponseHeaders() || '')
+        .split(/[\r\n]+/)
+        .filter((l) => l.trim() !== '');
+    return headerLines.map((headerLine) => headerLine.split(/\s*:/)[0].toLowerCase());
+}
+/**
+ *
+ */
+async function startXmlHttpRequest(request, options, input, output, emitter, counter = 0) {
+    const { method, url, headers: reqHeaders } = request;
+    const { followRedirect } = options;
+    const reqBody = input && /^(post|put|patch)$/i.test(method) ? await (0, stream_1.readAll)(input) : null;
+    const xhr = new XMLHttpRequest();
+    await (0, request_helper_1.executeWithTimeout)(() => {
+        xhr.open(method, url);
+        if (reqHeaders) {
+            for (const header in reqHeaders) {
+                xhr.setRequestHeader(header, reqHeaders[header]);
+            }
+        }
+        if (options.timeout) {
+            xhr.timeout = options.timeout;
+        }
+        xhr.responseType = 'arraybuffer';
+        xhr.send(reqBody);
+        return new Promise((resolve, reject) => {
+            xhr.onload = () => resolve();
+            xhr.onerror = reject;
+            xhr.ontimeout = reject;
+            xhr.onabort = reject;
+        });
+    }, options.timeout, () => xhr.abort());
+    const headerNames = getResponseHeaderNames(xhr);
+    const headers = headerNames.reduce((headers, headerName) => ({
+        ...headers,
+        [headerName]: xhr.getResponseHeader(headerName) || '',
+    }), {});
+    const response = {
+        statusCode: xhr.status,
+        headers: headers,
+    };
+    if (followRedirect && (0, request_helper_1.isRedirect)(response.statusCode)) {
+        try {
+            (0, request_helper_1.performRedirectRequest)(request, response, followRedirect, counter, (req) => startXmlHttpRequest(req, options, undefined, output, emitter, counter + 1));
+        }
+        catch (err) {
+            emitter.emit('error', err);
+        }
+        return;
+    }
+    let body;
+    if (!response.statusCode) {
+        response.statusCode = 400;
+        body = Buffer.from('Access Declined');
+    }
+    else {
+        body = Buffer.from(xhr.response);
+    }
+    emitter.emit('response', response);
+    output.write(body);
+    output.end();
+}
+/**
+ *
+ */
+let defaults = {};
+/**
+ *
+ */
+function setDefaults(defaults_) {
+    defaults = defaults_;
+}
+exports.setDefaults = setDefaults;
+/**
+ *
+ */
+function request(req, options_ = {}) {
+    const options = { ...defaults, ...options_ };
+    const { input, output, stream } = (0, request_helper_1.createHttpRequestHandlerStreams)(req, options);
+    if (typeof window !== 'undefined' && typeof window.fetch === 'function') {
+        startFetchRequest(req, options, input, output, stream);
+    }
+    else {
+        startXmlHttpRequest(req, options, input, output, stream);
+    }
+    return stream;
+}
+exports.default = request;

package/lib/cache.d.ts

@@ -0,0 +1,74 @@
+/// <reference types="node" />
+/**
+ * @file Manages asynchronous method response cache
+ * @author Shinichi Tomita <shinichi.tomita@gmail.com>
+ */
+import { EventEmitter } from 'events';
+/**
+ * type def
+ */
+export type CachingOptions = {
+    key?: string | ((...args: any[]) => string);
+    namespace?: string;
+    strategy: 'NOCACHE' | 'HIT' | 'IMMEDIATE';
+};
+type CacheValue<T> = {
+    error?: Error;
+    result: T;
+};
+export type CachedFunction<Fn> = Fn & {
+    clear: (...args: any[]) => void;
+};
+/**
+ * Class for managing cache entry
+ *
+ * @private
+ * @class
+ * @constructor
+ * @template T
+ */
+declare class CacheEntry<T> extends EventEmitter {
+    _fetching: boolean;
+    _value: CacheValue<T> | void;
+    /**
+     * Get value in the cache entry
+     *
+     * @param {() => Promise<T>} [callback] - Callback function callbacked the cache entry updated
+     * @returns {T|undefined}
+     */
+    get(callback?: (v: T) => any): CacheValue<T> | void;
+    /**
+     * Set value in the cache entry
+     */
+    set(value: CacheValue<T>): void;
+    /**
+     * Clear cached value
+     */
+    clear(): void;
+}
+/**
+ * Caching manager for async methods
+ *
+ * @class
+ * @constructor
+ */
+export declare class Cache {
+    private _entries;
+    /**
+     * retrive cache entry, or create if not exists.
+     *
+     * @param {String} [key] - Key of cache entry
+     * @returns {CacheEntry}
+     */
+    get(key: string): CacheEntry<any>;
+    /**
+     * clear cache entries prefix matching given key
+     */
+    clear(key?: string): void;
+    /**
+     * Enable caching for async call fn to lookup the response cache first,
+     * then invoke original if no cached value.
+     */
+    createCachedFunction<Fn extends Function>(fn: Fn, scope: any, options?: CachingOptions): CachedFunction<Fn>;
+}
+export default Cache;