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

package/lib/quick-action.d.ts

@@ -0,0 +1,44 @@
+/**
+ * @file Represents Salesforce QuickAction
+ * @author Shinichi Tomita <shinichi.tomita@gmail.com>
+ */
+import Connection from './connection';
+import { DescribeQuickActionDetailResult, Record, Optional, Schema } from './types';
+/**
+ * type definitions
+ */
+export type QuickActionDefaultValues = {
+    [name: string]: any;
+};
+export type QuickActionResult = {
+    id: string;
+    feedItemIds: Optional<string[]>;
+    success: boolean;
+    created: boolean;
+    contextId: string;
+    errors: Object[];
+};
+/**
+ * A class for quick action
+ */
+export declare class QuickAction<S extends Schema> {
+    _conn: Connection<S>;
+    _path: string;
+    /**
+     *
+     */
+    constructor(conn: Connection<S>, path: string);
+    /**
+     * Describe the action's information (including layout, etc.)
+     */
+    describe(): Promise<DescribeQuickActionDetailResult>;
+    /**
+     * Retrieve default field values in the action (for given record, if specified)
+     */
+    defaultValues(contextId?: string): Promise<QuickActionDefaultValues>;
+    /**
+     * Execute the action for given context Id and record information
+     */
+    execute(contextId: string, record: Record): Promise<QuickActionResult>;
+}
+export default QuickAction;

package/lib/quick-action.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QuickAction = void 0;
+/**
+ * A class for quick action
+ */
+class QuickAction {
+    _conn;
+    _path;
+    /**
+     *
+     */
+    constructor(conn, path) {
+        this._conn = conn;
+        this._path = path;
+    }
+    /**
+     * Describe the action's information (including layout, etc.)
+     */
+    async describe() {
+        const url = `${this._path}/describe`;
+        const body = await this._conn.request(url);
+        return body;
+    }
+    /**
+     * Retrieve default field values in the action (for given record, if specified)
+     */
+    async defaultValues(contextId) {
+        let url = `${this._path}/defaultValues`;
+        if (contextId) {
+            url += `/${contextId}`;
+        }
+        const body = await this._conn.request(url);
+        return body;
+    }
+    /**
+     * Execute the action for given context Id and record information
+     */
+    async execute(contextId, record) {
+        const requestBody = { contextId, record };
+        const resBody = await this._conn.requestPost(this._path, requestBody);
+        return resBody;
+    }
+}
+exports.QuickAction = QuickAction;
+exports.default = QuickAction;

package/lib/record-reference.d.ts

@@ -0,0 +1,46 @@
+/// <reference types="node" />
+/**
+ *
+ */
+import Connection from './connection';
+import { RetrieveOptions, DmlOptions, Schema, SObjectNames, SObjectInputRecord, SObjectUpdateRecord } from './types';
+/**
+ * Remote reference to record information
+ */
+export declare class RecordReference<S extends Schema, N extends SObjectNames<S>, InputRecord extends SObjectInputRecord<S, N> = SObjectInputRecord<S, N>, RetrieveRecord extends SObjectUpdateRecord<S, N> = SObjectUpdateRecord<S, N>> {
+    type: N;
+    id: string;
+    _conn: Connection<S>;
+    /**
+     *
+     */
+    constructor(conn: Connection<S>, type: N, id: string);
+    /**
+     * Retrieve record field information
+     */
+    retrieve(options?: RetrieveOptions): Promise<RetrieveRecord>;
+    /**
+     * Update record field information
+     */
+    update(record: InputRecord, options?: DmlOptions): Promise<import("./types").SaveResult>;
+    /**
+     * Delete record field
+     */
+    destroy(options?: DmlOptions): Promise<import("./types").SaveResult>;
+    /**
+     * Synonym of Record#destroy()
+     */
+    delete: (options?: DmlOptions) => Promise<import("./types").SaveResult>;
+    /**
+     * Synonym of Record#destroy()
+     */
+    del: (options?: DmlOptions) => Promise<import("./types").SaveResult>;
+    /**
+     * Get blob field as stream
+     *
+     * @param {String} fieldName - Blob field name
+     * @returns {stream.Stream}
+     */
+    blob(fieldName: string): import("stream").Duplex;
+}
+export default RecordReference;

package/lib/record-reference.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RecordReference = void 0;
+/**
+ * Remote reference to record information
+ */
+class RecordReference {
+    type;
+    id;
+    _conn;
+    /**
+     *
+     */
+    constructor(conn, type, id) {
+        this._conn = conn;
+        this.type = type;
+        this.id = id;
+    }
+    /**
+     * Retrieve record field information
+     */
+    async retrieve(options) {
+        const rec = await this._conn.retrieve(this.type, this.id, options);
+        return rec;
+    }
+    /**
+     * Update record field information
+     */
+    async update(record, options) {
+        const record_ = { ...record, Id: this.id };
+        return this._conn.update(this.type, record_, options);
+    }
+    /**
+     * Delete record field
+     */
+    destroy(options) {
+        return this._conn.destroy(this.type, this.id, options);
+    }
+    /**
+     * Synonym of Record#destroy()
+     */
+    delete = this.destroy;
+    /**
+     * Synonym of Record#destroy()
+     */
+    del = this.destroy;
+    /**
+     * Get blob field as stream
+     *
+     * @param {String} fieldName - Blob field name
+     * @returns {stream.Stream}
+     */
+    blob(fieldName) {
+        const url = [
+            this._conn._baseUrl(),
+            'sobjects',
+            this.type,
+            this.id,
+            fieldName,
+        ].join('/');
+        return this._conn.request(url).stream();
+    }
+}
+exports.RecordReference = RecordReference;
+exports.default = RecordReference;

package/lib/record-stream.d.ts

@@ -0,0 +1,83 @@
+/// <reference types="node" />
+/**
+ * @file Represents stream that handles Salesforce record as stream data
+ * @author Shinichi Tomita <shinichi.tomita@gmail.com>
+ */
+import { Readable, Writable, Duplex, Transform, PassThrough } from 'stream';
+import { Record, Optional } from './types';
+/**
+ * type defs
+ */
+export type RecordStreamSerializeOption = {
+    nullValue?: any;
+};
+export type RecordStreamParseOption = {};
+/**
+ * Class for Record Stream
+ *
+ * @class
+ * @constructor
+ * @extends stream.Transform
+ */
+export declare class RecordStream<R extends Record = Record> extends PassThrough {
+    /**
+     *
+     */
+    constructor();
+    /**
+     * Get record stream of queried records applying the given mapping function
+     */
+    map<RR extends Record>(fn: (rec: R) => Optional<RR>): Transform;
+    /**
+     * Get record stream of queried records, applying the given filter function
+     */
+    filter(fn: (rec: R) => boolean): Duplex;
+    on(ev: string, fn: (...args: any[]) => void): this;
+    addListener: (ev: string, fn: (...args: any[]) => void) => this;
+    /**
+     * Create a record stream which maps records and pass them to downstream
+     */
+    static map<R1 extends Record = Record, R2 extends Record = Record>(fn: (rec: R1) => Optional<R2>): Transform;
+    /**
+     * Create mapping stream using given record template
+     */
+    static recordMapStream<R1 extends Record = Record, R2 extends Record = Record>(record: R2, noeval?: boolean): Transform;
+    /**
+     * Create a record stream which filters records and pass them to downstream
+     *
+     * @param {RecordFilterFunction} fn - Record filtering function
+     * @returns {RecordStream.Serializable}
+     */
+    static filter<R1 extends Record = Record>(fn: (rec: R1) => boolean): Duplex;
+}
+/**
+ * @class RecordStream.Serializable
+ * @extends {RecordStream}
+ */
+export declare class Serializable<R extends Record = Record> extends RecordStream<R> {
+    _dataStreams: {
+        [type: string]: Duplex;
+    };
+    /**
+     * Get readable data stream which emits serialized record data
+     */
+    stream(type?: string, options?: Object): Duplex;
+}
+/**
+ * @class RecordStream.Parsable
+ * @extends {RecordStream}
+ */
+export declare class Parsable<R extends Record = Record> extends RecordStream<R> {
+    _dataStreams: {
+        [type: string]: Duplex;
+    };
+    _execParse: boolean;
+    _incomings: Array<[Readable, Writable]>;
+    /**
+     * Get writable data stream which accepts serialized record data
+     */
+    stream(type?: string, options?: Object): Duplex;
+    on(ev: string, fn: (...args: any[]) => void): this;
+    addListener: (ev: string, fn: (...args: any[]) => void) => this;
+}
+export default RecordStream;

package/lib/record-stream.js

@@ -0,0 +1,233 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Parsable = exports.Serializable = exports.RecordStream = void 0;
+/**
+ * @file Represents stream that handles Salesforce record as stream data
+ * @author Shinichi Tomita <shinichi.tomita@gmail.com>
+ */
+const stream_1 = require("stream");
+const csv_1 = require("./csv");
+const stream_2 = require("./util/stream");
+/**
+ * @private
+ */
+function evalMapping(value, mapping) {
+    if (typeof value === 'string') {
+        const m = /^\$\{(\w+)\}$/.exec(value);
+        if (m) {
+            return mapping[m[1]];
+        }
+        return value.replace(/\$\{(\w+)\}/g, ($0, prop) => {
+            const v = mapping[prop];
+            return typeof v === 'undefined' || v === null ? '' : String(v);
+        });
+    }
+    return value;
+}
+/**
+ * @private
+ */
+function convertRecordForSerialization(record, options = {}) {
+    return Object.keys(record).reduce((rec, key) => {
+        const value = rec[key];
+        let urec;
+        if (key === 'attributes') {
+            // 'attributes' prop will be ignored
+            urec = { ...rec };
+            delete urec[key];
+            return urec;
+        }
+        else if (options.nullValue && value === null) {
+            return { ...rec, [key]: options.nullValue };
+        }
+        else if (value !== null && typeof value === 'object') {
+            const precord = convertRecordForSerialization(value, options);
+            return Object.keys(precord).reduce((prec, pkey) => {
+                prec[`${key}.${pkey}`] = precord[pkey]; // eslint-disable-line no-param-reassign
+                return prec;
+            }, { ...rec });
+        }
+        return rec;
+    }, record);
+}
+/**
+ * @private
+ */
+function createPipelineStream(s1, s2) {
+    s1.pipe(s2);
+    return (0, stream_2.concatStreamsAsDuplex)(s1, s2, { writableObjectMode: true });
+}
+/**
+ * @private
+ */
+const CSVStreamConverter = {
+    serialize(options = {}) {
+        const { nullValue, ...csvOpts } = options;
+        return createPipelineStream(
+        // eslint-disable-next-line no-use-before-define
+        RecordStream.map((record) => convertRecordForSerialization(record, options)), (0, csv_1.serializeCSVStream)(csvOpts));
+    },
+    parse(options = {}) {
+        return (0, csv_1.parseCSVStream)(options);
+    },
+};
+/**
+ * @private
+ */
+const DataStreamConverters = {
+    csv: CSVStreamConverter,
+};
+/**
+ * Class for Record Stream
+ *
+ * @class
+ * @constructor
+ * @extends stream.Transform
+ */
+class RecordStream extends stream_1.PassThrough {
+    /**
+     *
+     */
+    constructor() {
+        super({ objectMode: true });
+    }
+    /**
+     * Get record stream of queried records applying the given mapping function
+     */
+    map(fn) {
+        return this.pipe(RecordStream.map(fn));
+    }
+    /**
+     * Get record stream of queried records, applying the given filter function
+     */
+    filter(fn) {
+        return this.pipe(RecordStream.filter(fn));
+    }
+    /* @override */
+    on(ev, fn) {
+        return super.on(ev === 'record' ? 'data' : ev, fn);
+    }
+    /* @override */
+    addListener = this.on;
+    /* --------------------------------------------------- */
+    /**
+     * Create a record stream which maps records and pass them to downstream
+     */
+    static map(fn) {
+        const mapStream = new stream_1.Transform({
+            objectMode: true,
+            transform(record, enc, callback) {
+                const rec = fn(record) || record; // if not returned record, use same record
+                mapStream.push(rec);
+                callback();
+            },
+        });
+        return mapStream;
+    }
+    /**
+     * Create mapping stream using given record template
+     */
+    static recordMapStream(record, noeval) {
+        return RecordStream.map((rec) => {
+            const mapped = { Id: rec.Id };
+            for (const prop of Object.keys(record)) {
+                mapped[prop] = noeval ? record[prop] : evalMapping(record[prop], rec);
+            }
+            return mapped;
+        });
+    }
+    /**
+     * Create a record stream which filters records and pass them to downstream
+     *
+     * @param {RecordFilterFunction} fn - Record filtering function
+     * @returns {RecordStream.Serializable}
+     */
+    static filter(fn) {
+        const filterStream = new stream_1.Transform({
+            objectMode: true,
+            transform(record, enc, callback) {
+                if (fn(record)) {
+                    filterStream.push(record);
+                }
+                callback();
+            },
+        });
+        return filterStream;
+    }
+}
+exports.RecordStream = RecordStream;
+/**
+ * @class RecordStream.Serializable
+ * @extends {RecordStream}
+ */
+class Serializable extends RecordStream {
+    _dataStreams = {};
+    /**
+     * Get readable data stream which emits serialized record data
+     */
+    stream(type = 'csv', options = {}) {
+        if (this._dataStreams[type]) {
+            return this._dataStreams[type];
+        }
+        const converter = DataStreamConverters[type];
+        if (!converter) {
+            throw new Error(`Converting [${type}] data stream is not supported.`);
+        }
+        const dataStream = new stream_1.PassThrough();
+        this.pipe(converter.serialize(options)).pipe(dataStream);
+        this._dataStreams[type] = dataStream;
+        return dataStream;
+    }
+}
+exports.Serializable = Serializable;
+/**
+ * @class RecordStream.Parsable
+ * @extends {RecordStream}
+ */
+class Parsable extends RecordStream {
+    _dataStreams = {};
+    _execParse = false;
+    _incomings = [];
+    /**
+     * Get writable data stream which accepts serialized record data
+     */
+    stream(type = 'csv', options = {}) {
+        if (this._dataStreams[type]) {
+            return this._dataStreams[type];
+        }
+        const converter = DataStreamConverters[type];
+        if (!converter) {
+            throw new Error(`Converting [${type}] data stream is not supported.`);
+        }
+        const dataStream = new stream_1.PassThrough();
+        const parserStream = converter.parse(options);
+        parserStream.on('error', (err) => this.emit('error', err));
+        parserStream
+            .pipe(this)
+            .pipe(new stream_1.PassThrough({ objectMode: true, highWaterMark: 500 * 1000 }));
+        if (this._execParse) {
+            dataStream.pipe(parserStream);
+        }
+        else {
+            this._incomings.push([dataStream, parserStream]);
+        }
+        this._dataStreams[type] = dataStream;
+        return dataStream;
+    }
+    /* @override */
+    on(ev, fn) {
+        if (ev === 'readable' || ev === 'record') {
+            if (!this._execParse) {
+                this._execParse = true;
+                for (const [dataStream, parserStream] of this._incomings) {
+                    dataStream.pipe(parserStream);
+                }
+            }
+        }
+        return super.on(ev, fn);
+    }
+    /* @override */
+    addListener = this.on;
+}
+exports.Parsable = Parsable;
+exports.default = RecordStream;

package/lib/registry/base.d.ts

@@ -0,0 +1,43 @@
+import Connection from '../connection';
+import { RegistryConfig, Registry, ConnectionConfig, PersistConnectionConfig, ClientConfig } from './types';
+import { Schema } from '../types';
+/**
+ *
+ */
+export declare class BaseRegistry implements Registry {
+    _registryConfig: RegistryConfig;
+    _saveConfig(): void;
+    _getClients(): {
+        [name: string]: ClientConfig;
+    };
+    _getConnections(): {
+        [name: string]: PersistConnectionConfig;
+    };
+    getConnectionNames(): Promise<string[]>;
+    getConnection<S extends Schema = Schema>(name: string): Promise<Connection<S> | null>;
+    getConnectionConfig(name?: string): Promise<{
+        instanceUrl?: string | undefined;
+        accessToken?: string | undefined;
+    } | {
+        oauth2: {
+            clientId?: string | undefined;
+            clientSecret?: string | undefined;
+            redirectUri?: string | undefined;
+            loginUrl?: string | undefined;
+        };
+        instanceUrl?: string | undefined;
+        accessToken?: string | undefined;
+    } | null>;
+    saveConnectionConfig(name: string, connConfig: ConnectionConfig): Promise<void>;
+    _findClientName({ clientId, loginUrl }: ClientConfig): string | null;
+    setDefaultConnection(name: string): Promise<void>;
+    removeConnectionConfig(name: string): Promise<void>;
+    getClientConfig(name: string): Promise<{
+        clientId?: string | undefined;
+        clientSecret?: string | undefined;
+        redirectUri?: string | undefined;
+        loginUrl?: string | undefined;
+    }>;
+    getClientNames(): Promise<string[]>;
+    registerClientConfig(name: string, clientConfig: ClientConfig): Promise<void>;
+}

package/lib/registry/base.js

@@ -0,0 +1,96 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseRegistry = void 0;
+const connection_1 = __importDefault(require("../connection"));
+/**
+ *
+ */
+class BaseRegistry {
+    _registryConfig = {};
+    _saveConfig() {
+        throw new Error('_saveConfig must be implemented in subclass');
+    }
+    _getClients() {
+        return this._registryConfig.clients || (this._registryConfig.clients = {});
+    }
+    _getConnections() {
+        return (this._registryConfig.connections ||
+            (this._registryConfig.connections = {}));
+    }
+    async getConnectionNames() {
+        return Object.keys(this._getConnections());
+    }
+    async getConnection(name) {
+        const config = await this.getConnectionConfig(name);
+        return config ? new connection_1.default(config) : null;
+    }
+    async getConnectionConfig(name) {
+        if (!name) {
+            name = this._registryConfig['default'];
+        }
+        const connections = this._getConnections();
+        const connConfig = name ? connections[name] : undefined;
+        if (!connConfig) {
+            return null;
+        }
+        const { client, ...connConfig_ } = connConfig;
+        if (client) {
+            return {
+                ...connConfig_,
+                oauth2: { ...(await this.getClientConfig(client)) },
+            };
+        }
+        return connConfig_;
+    }
+    async saveConnectionConfig(name, connConfig) {
+        const connections = this._getConnections();
+        const { oauth2, ...connConfig_ } = connConfig;
+        let persistConnConfig = connConfig_;
+        if (oauth2) {
+            const clientName = this._findClientName(oauth2);
+            if (clientName) {
+                persistConnConfig = { ...persistConnConfig, client: clientName };
+            }
+            delete connConfig.oauth2;
+        }
+        connections[name] = persistConnConfig;
+        this._saveConfig();
+    }
+    _findClientName({ clientId, loginUrl }) {
+        const clients = this._getClients();
+        for (const name of Object.keys(clients)) {
+            const client = clients[name];
+            if (client.clientId === clientId &&
+                (client.loginUrl || 'https://login.salesforce.com') === loginUrl) {
+                return name;
+            }
+        }
+        return null;
+    }
+    async setDefaultConnection(name) {
+        this._registryConfig['default'] = name;
+        this._saveConfig();
+    }
+    async removeConnectionConfig(name) {
+        const connections = this._getConnections();
+        delete connections[name];
+        this._saveConfig();
+    }
+    async getClientConfig(name) {
+        const clients = this._getClients();
+        const clientConfig = clients[name];
+        return clientConfig && { ...clientConfig };
+    }
+    async getClientNames() {
+        return Object.keys(this._getClients());
+    }
+    async registerClientConfig(name, clientConfig) {
+        const clients = this._getClients();
+        clients[name] = clientConfig;
+        this._saveConfig();
+    }
+}
+exports.BaseRegistry = BaseRegistry;

package/lib/registry/empty.d.ts

@@ -0,0 +1,7 @@
+import { BaseRegistry } from './base';
+/**
+ *
+ */
+export declare class EmptyRegistry extends BaseRegistry {
+    _saveConfig(): void;
+}

package/lib/registry/empty.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EmptyRegistry = void 0;
+const base_1 = require("./base");
+/**
+ *
+ */
+class EmptyRegistry extends base_1.BaseRegistry {
+    _saveConfig() {
+        // ignore all call requests
+    }
+}
+exports.EmptyRegistry = EmptyRegistry;

package/lib/registry/file.d.ts

@@ -0,0 +1,11 @@
+import { BaseRegistry } from './base';
+/**
+ *
+ */
+export declare class FileRegistry extends BaseRegistry {
+    _configFilePath: string;
+    constructor({ configFilePath }: {
+        configFilePath?: string;
+    });
+    _saveConfig(): void;
+}