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

package/lib/sobject.js

@@ -0,0 +1,376 @@
+"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.SObject = void 0;
+/**
+ *
+ */
+const logger_1 = require("./util/logger");
+const record_reference_1 = __importDefault(require("./record-reference"));
+const query_1 = __importStar(require("./query"));
+const quick_action_1 = __importDefault(require("./quick-action"));
+/**
+ * A class for organizing all SObject access
+ */
+class SObject {
+    static _logger = (0, logger_1.getLogger)('sobject');
+    type;
+    _conn;
+    _logger;
+    // layouts: (ln?: string) => Promise<DescribeLayoutResult>;
+    layouts$;
+    layouts$$;
+    // compactLayouts: () => Promise<DescribeCompactLayoutsResult>;
+    compactLayouts$;
+    compactLayouts$$;
+    // approvalLayouts: () => Promise<DescribeApprovalLayoutsResult>;
+    approvalLayouts$;
+    approvalLayouts$$;
+    /**
+     *
+     */
+    constructor(conn, type) {
+        this.type = type;
+        this._conn = conn;
+        this._logger = conn._logLevel
+            ? SObject._logger.createInstance(conn._logLevel)
+            : SObject._logger;
+        const cache = this._conn.cache;
+        const layoutCacheKey = (layoutName) => layoutName
+            ? `layouts.namedLayouts.${layoutName}`
+            : `layouts.${this.type}`;
+        const layouts = SObject.prototype.layouts;
+        this.layouts = cache.createCachedFunction(layouts, this, {
+            key: layoutCacheKey,
+            strategy: 'NOCACHE',
+        });
+        this.layouts$ = cache.createCachedFunction(layouts, this, {
+            key: layoutCacheKey,
+            strategy: 'HIT',
+        });
+        this.layouts$$ = cache.createCachedFunction(layouts, this, {
+            key: layoutCacheKey,
+            strategy: 'IMMEDIATE',
+        });
+        const compactLayoutCacheKey = `compactLayouts.${this.type}`;
+        const compactLayouts = SObject.prototype.compactLayouts;
+        this.compactLayouts = cache.createCachedFunction(compactLayouts, this, {
+            key: compactLayoutCacheKey,
+            strategy: 'NOCACHE',
+        });
+        this.compactLayouts$ = cache.createCachedFunction(compactLayouts, this, {
+            key: compactLayoutCacheKey,
+            strategy: 'HIT',
+        });
+        this.compactLayouts$$ = cache.createCachedFunction(compactLayouts, this, {
+            key: compactLayoutCacheKey,
+            strategy: 'IMMEDIATE',
+        });
+        const approvalLayoutCacheKey = `approvalLayouts.${this.type}`;
+        const approvalLayouts = SObject.prototype.approvalLayouts;
+        this.approvalLayouts = cache.createCachedFunction(approvalLayouts, this, {
+            key: approvalLayoutCacheKey,
+            strategy: 'NOCACHE',
+        });
+        this.approvalLayouts$ = cache.createCachedFunction(approvalLayouts, this, {
+            key: approvalLayoutCacheKey,
+            strategy: 'HIT',
+        });
+        this.approvalLayouts$$ = cache.createCachedFunction(approvalLayouts, this, {
+            key: approvalLayoutCacheKey,
+            strategy: 'IMMEDIATE',
+        });
+    }
+    create(records, options) {
+        return this._conn.create(this.type, records, options);
+    }
+    /**
+     * Synonym of SObject#create()
+     */
+    insert = this.create;
+    retrieve(ids, options) {
+        return this._conn.retrieve(this.type, ids, options);
+    }
+    update(records, options) {
+        return this._conn.update(this.type, records, options);
+    }
+    upsert(records, extIdField, options) {
+        return this._conn.upsert(this.type, records, extIdField, options);
+    }
+    destroy(ids, options) {
+        return this._conn.destroy(this.type, ids, options);
+    }
+    /**
+     * Synonym of SObject#destroy()
+     */
+    delete = this.destroy;
+    /**
+     * Synonym of SObject#destroy()
+     */
+    del = this.destroy;
+    /**
+     * Call Bulk#load() to execute bulkload, returning batch object
+     */
+    bulkload(operation, optionsOrInput, input) {
+        return this._conn.bulk.load(this.type, operation, optionsOrInput, input);
+    }
+    /**
+     * Bulkly insert input data using bulk API
+     */
+    createBulk(input) {
+        return this.bulkload('insert', input);
+    }
+    /**
+     * Synonym of SObject#createBulk()
+     */
+    insertBulk = this.createBulk;
+    /**
+     * Bulkly update records by input data using bulk API
+     */
+    updateBulk(input) {
+        return this.bulkload('update', input);
+    }
+    /**
+     * Bulkly upsert records by input data using bulk API
+     */
+    upsertBulk(input, extIdField) {
+        return this.bulkload('upsert', { extIdField }, input);
+    }
+    /**
+     * Bulkly delete records specified by input data using bulk API
+     */
+    destroyBulk(input) {
+        return this.bulkload('delete', input);
+    }
+    /**
+     * Synonym of SObject#destroyBulk()
+     */
+    deleteBulk = this.destroyBulk;
+    /**
+     * Bulkly hard delete records specified in input data using bulk API
+     */
+    destroyHardBulk(input) {
+        return this.bulkload('hardDelete', input);
+    }
+    /**
+     * Synonym of SObject#destroyHardBulk()
+     */
+    deleteHardBulk = this.destroyHardBulk;
+    /**
+     * Describe SObject metadata
+     */
+    describe() {
+        return this._conn.describe(this.type);
+    }
+    /**
+     *
+     */
+    describe$() {
+        return this._conn.describe$(this.type);
+    }
+    /**
+     *
+     */
+    describe$$() {
+        return this._conn.describe$$(this.type);
+    }
+    /**
+     * Get record representation instance by given id
+     */
+    record(id) {
+        return new record_reference_1.default(this._conn, this.type, id);
+    }
+    /**
+     * Retrieve recently accessed records
+     */
+    recent() {
+        return this._conn.recent(this.type);
+    }
+    /**
+     * Retrieve the updated records
+     */
+    updated(start, end) {
+        return this._conn.updated(this.type, start, end);
+    }
+    /**
+     * Retrieve the deleted records
+     */
+    deleted(start, end) {
+        return this._conn.deleted(this.type, start, end);
+    }
+    /**
+     * Describe layout information for SObject
+     */
+    async layouts(layoutName) {
+        const url = `/sobjects/${this.type}/describe/${layoutName ? `namedLayouts/${layoutName}` : 'layouts'}`;
+        const body = await this._conn.request(url);
+        return body;
+    }
+    /**
+     * @typedef {Object} CompactLayoutInfo
+     * @prop {Array.<Object>} compactLayouts - Array of compact layouts
+     * @prop {String} defaultCompactLayoutId - ID of default compact layout
+     * @prop {Array.<Object>} recordTypeCompactLayoutMappings - Array of record type mappings
+     */
+    /**
+     * Describe compact layout information defined for SObject
+     *
+     * @param {Callback.<CompactLayoutInfo>} [callback] - Callback function
+     * @returns {Promise.<CompactLayoutInfo>}
+     */
+    async compactLayouts() {
+        const url = `/sobjects/${this.type}/describe/compactLayouts`;
+        const body = await this._conn.request(url);
+        return body;
+    }
+    /**
+     * Describe compact layout information defined for SObject
+     *
+     * @param {Callback.<ApprovalLayoutInfo>} [callback] - Callback function
+     * @returns {Promise.<ApprovalLayoutInfo>}
+     */
+    async approvalLayouts() {
+        const url = `/sobjects/${this.type}/describe/approvalLayouts`;
+        const body = await this._conn.request(url);
+        return body;
+    }
+    find(conditions, fields, options = {}) {
+        const { sort, limit, offset, ...qoptions } = options;
+        const config = {
+            fields: fields == null ? undefined : fields,
+            includes: options.includes,
+            table: this.type,
+            conditions: conditions == null ? undefined : conditions,
+            sort,
+            limit,
+            offset,
+        };
+        const query = new query_1.default(this._conn, config, qoptions);
+        return query.setResponseTarget(query_1.ResponseTargets.Records);
+    }
+    findOne(conditions, fields, options = {}) {
+        const query = this.find(conditions, fields, { ...options, limit: 1 });
+        return query.setResponseTarget(query_1.ResponseTargets.SingleRecord);
+    }
+    /**
+     * Find and fetch records only by specifying fields to fetch.
+     */
+    select(fields) {
+        return this.find(null, fields);
+    }
+    /**
+     * Count num of records which matches given conditions
+     */
+    count(conditions) {
+        const query = this.find(conditions, 'count()');
+        return query.setResponseTarget(query_1.ResponseTargets.Count);
+    }
+    /**
+     * Returns the list of list views for the SObject
+     *
+     * @param {Callback.<ListViewsInfo>} [callback] - Callback function
+     * @returns {Promise.<ListViewsInfo>}
+     */
+    listviews() {
+        const url = `${this._conn._baseUrl()}/sobjects/${this.type}/listviews`;
+        return this._conn.request(url);
+    }
+    /**
+     * Returns the list view info in specifed view id
+     *
+     * @param {String} id - List view ID
+     * @returns {ListView}
+     */
+    listview(id) {
+        return new ListView(this._conn, this.type, id); // eslint-disable-line no-use-before-define
+    }
+    /**
+     * Returns all registered quick actions for the SObject
+     *
+     * @param {Callback.<Array.<QuickAction~QuickActionInfo>>} [callback] - Callback function
+     * @returns {Promise.<Array.<QuickAction~QuickActionInfo>>}
+     */
+    quickActions() {
+        return this._conn.request(`/sobjects/${this.type}/quickActions`);
+    }
+    /**
+     * Get reference for specified quick aciton in the SObject
+     *
+     * @param {String} actionName - Name of the quick action
+     * @returns {QuickAction}
+     */
+    quickAction(actionName) {
+        return new quick_action_1.default(this._conn, `/sobjects/${this.type}/quickActions/${actionName}`);
+    }
+}
+exports.SObject = SObject;
+/**
+ * A class for organizing list view information
+ *
+ * @protected
+ * @class ListView
+ * @param {Connection} conn - Connection instance
+ * @param {SObject} type - SObject type
+ * @param {String} id - List view ID
+ */
+class ListView {
+    _conn;
+    type;
+    id;
+    /**
+     *
+     */
+    constructor(conn, type, id) {
+        this._conn = conn;
+        this.type = type;
+        this.id = id;
+    }
+    /**
+     * Executes query for the list view and returns the resulting data and presentation information.
+     */
+    results() {
+        const url = `${this._conn._baseUrl()}/sobjects/${this.type}/listviews/${this.id}/results`;
+        return this._conn.request(url);
+    }
+    /**
+     * Returns detailed information about a list view
+     */
+    describe(options = {}) {
+        const url = `${this._conn._baseUrl()}/sobjects/${this.type}/listviews/${this.id}/describe`;
+        return this._conn.request({ method: 'GET', url, headers: options.headers });
+    }
+    /**
+     * Explain plan for executing list view
+     */
+    explain() {
+        const url = `/query/?explain=${this.id}`;
+        return this._conn.request(url);
+    }
+}
+exports.default = SObject;
+// TODO Bulk

package/lib/soql-builder.d.ts

@@ -0,0 +1,25 @@
+export type Condition = string | {
+    [field: string]: any;
+} | Array<{
+    [field: string]: any;
+}>;
+export type SortDir = 'ASC' | 'DESC' | 'asc' | 'desc' | 1 | -1;
+export type Sort = string | Array<[string, SortDir]> | {
+    [field: string]: SortDir;
+};
+export type QueryConfig = {
+    fields?: string[];
+    includes?: {
+        [field: string]: QueryConfig;
+    };
+    table?: string;
+    conditions?: Condition;
+    sort?: Sort;
+    limit?: number;
+    offset?: number;
+};
+/**
+ * Create SOQL
+ * @private
+ */
+export declare function createSOQL(query: QueryConfig): string;

package/lib/soql-builder.js

@@ -0,0 +1,226 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createSOQL = void 0;
+/**
+ * @file Create and build SOQL string from configuration
+ * @author Shinichi Tomita <shinichi.tomita@gmail.com>
+ */
+const date_1 = __importDefault(require("./date"));
+/** @private **/
+function escapeSOQLString(str) {
+    return String(str || '').replace(/'/g, "\\'");
+}
+/** @private **/
+function createFieldsClause(fields, childQueries = {}) {
+    const cqueries = Object.values(childQueries);
+    // eslint-disable-next-line no-use-before-define
+    return [
+        ...(fields || ['Id']),
+        ...cqueries.map((cquery) => `(${createSOQL(cquery)})`),
+    ].join(', ');
+}
+/** @private **/
+function createValueExpression(value) {
+    if (Array.isArray(value)) {
+        return value.length > 0
+            ? `(${value.map(createValueExpression).join(', ')})`
+            : undefined;
+    }
+    if (value instanceof date_1.default) {
+        return value.toString();
+    }
+    if (typeof value === 'string') {
+        return `'${escapeSOQLString(value)}'`;
+    }
+    if (typeof value === 'number') {
+        return value.toString();
+    }
+    if (value === null) {
+        return 'null';
+    }
+    return value;
+}
+const opMap = {
+    '=': '=',
+    $eq: '=',
+    '!=': '!=',
+    $ne: '!=',
+    '>': '>',
+    $gt: '>',
+    '<': '<',
+    $lt: '<',
+    '>=': '>=',
+    $gte: '>=',
+    '<=': '<=',
+    $lte: '<=',
+    $like: 'LIKE',
+    $nlike: 'NOT LIKE',
+    $in: 'IN',
+    $nin: 'NOT IN',
+    $includes: 'INCLUDES',
+    $excludes: 'EXCLUDES',
+    $exists: 'EXISTS',
+};
+/** @private **/
+function createFieldExpression(field, value) {
+    let op = '$eq';
+    let _value = value;
+    // Assume the `$in` operator if value is an array and none was supplied.
+    if (Array.isArray(value)) {
+        op = '$in';
+    }
+    else if (typeof value === 'object' && value !== null) {
+        // Otherwise, if an object was passed then process the supplied ops.
+        for (const k of Object.keys(value)) {
+            if (k[0] === '$') {
+                op = k;
+                _value = value[k];
+                break;
+            }
+        }
+    }
+    const sfop = opMap[op];
+    if (!sfop || typeof _value === 'undefined') {
+        return null;
+    }
+    const valueExpr = createValueExpression(_value);
+    if (typeof valueExpr === 'undefined') {
+        return null;
+    }
+    switch (sfop) {
+        case 'NOT LIKE':
+            return `(${['NOT', field, 'LIKE', valueExpr].join(' ')})`;
+        case 'EXISTS':
+            return [field, _value ? '!=' : '=', 'null'].join(' ');
+        default:
+            return [field, sfop, valueExpr].join(' ');
+    }
+}
+/** @private **/
+function createOrderByClause(sort = []) {
+    let _sort = [];
+    if (typeof sort === 'string') {
+        if (/,|\s+(asc|desc)\s*$/.test(sort)) {
+            // must be specified in pure "order by" clause. Return raw config.
+            return sort;
+        }
+        // sort order in mongoose-style expression.
+        // e.g. "FieldA -FieldB" => "ORDER BY FieldA ASC, FieldB DESC"
+        _sort = sort.split(/\s+/).map((field) => {
+            let dir = 'ASC'; // ascending
+            const flag = field[0];
+            if (flag === '-') {
+                dir = 'DESC';
+                field = field.substring(1); // eslint-disable-line no-param-reassign
+            }
+            else if (flag === '+') {
+                field = field.substring(1); // eslint-disable-line no-param-reassign
+            }
+            return [field, dir];
+        });
+    }
+    else if (Array.isArray(sort)) {
+        _sort = sort;
+    }
+    else {
+        _sort = Object.entries(sort).map(([field, dir]) => [field, dir]);
+    }
+    return _sort
+        .map(([field, dir]) => {
+        /* eslint-disable no-param-reassign */
+        switch (String(dir)) {
+            case 'DESC':
+            case 'desc':
+            case 'descending':
+            case '-':
+            case '-1':
+                dir = 'DESC';
+                break;
+            default:
+                dir = 'ASC';
+        }
+        return `${field} ${dir}`;
+    })
+        .join(', ');
+}
+/** @private **/
+function createConditionClause(conditions = {}, operator = 'AND', depth = 0) {
+    if (typeof conditions === 'string') {
+        return conditions;
+    }
+    let conditionList = [];
+    if (!Array.isArray(conditions)) {
+        // if passed in hash object
+        const conditionsMap = conditions;
+        conditionList = Object.keys(conditionsMap).map((key) => ({
+            key,
+            value: conditionsMap[key],
+        }));
+    }
+    else {
+        conditionList = conditions.map((cond) => {
+            const conds = Object.keys(cond).map((key) => ({ key, value: cond[key] }));
+            return conds.length > 1
+                ? { key: '$and', value: conds.map((c) => ({ [c.key]: c.value })) }
+                : conds[0];
+        });
+    }
+    const conditionClauses = conditionList
+        .map((cond) => {
+        let d = depth + 1;
+        let op;
+        switch (cond.key) {
+            case '$or':
+            case '$and':
+            case '$not':
+                if (operator !== 'NOT' && conditionList.length === 1) {
+                    d = depth; // not change tree depth
+                }
+                op = cond.key === '$or' ? 'OR' : cond.key === '$and' ? 'AND' : 'NOT';
+                return createConditionClause(cond.value, op, d);
+            default:
+                return createFieldExpression(cond.key, cond.value);
+        }
+    })
+        .filter((expr) => expr);
+    let hasParen;
+    if (operator === 'NOT') {
+        hasParen = depth > 0;
+        return `${hasParen ? '(' : ''}NOT ${conditionClauses[0]}${hasParen ? ')' : ''}`;
+    }
+    hasParen = depth > 0 && conditionClauses.length > 1;
+    return ((hasParen ? '(' : '') +
+        conditionClauses.join(` ${operator} `) +
+        (hasParen ? ')' : ''));
+}
+/**
+ * Create SOQL
+ * @private
+ */
+function createSOQL(query) {
+    let soql = [
+        'SELECT ',
+        createFieldsClause(query.fields, query.includes),
+        ' FROM ',
+        query.table,
+    ].join('');
+    const cond = createConditionClause(query.conditions);
+    if (cond) {
+        soql += ` WHERE ${cond}`;
+    }
+    const orderby = createOrderByClause(query.sort);
+    if (orderby) {
+        soql += ` ORDER BY ${orderby}`;
+    }
+    if (query.limit) {
+        soql += ` LIMIT ${query.limit}`;
+    }
+    if (query.offset) {
+        soql += ` OFFSET ${query.offset}`;
+    }
+    return soql;
+}
+exports.createSOQL = createSOQL;

package/lib/transport.d.ts

@@ -0,0 +1,63 @@
+/// <reference types="node" />
+/**
+ *
+ */
+import { Duplex } from 'stream';
+import { HttpRequest, HttpRequestOptions, HttpResponse } from './types';
+import { StreamPromise } from './util/promise';
+/**
+ * Class for HTTP request transport
+ *
+ * @class
+ * @protected
+ */
+export declare class Transport {
+    /**
+     */
+    httpRequest(req: HttpRequest, options?: HttpRequestOptions): StreamPromise<HttpResponse>;
+    /**
+     * @protected
+     */
+    getRequestStreamCreator(): (req: HttpRequest, options: HttpRequestOptions) => Duplex;
+}
+/**
+ * Class for JSONP request transport
+ */
+export declare class JsonpTransport extends Transport {
+    static supprted: boolean;
+    _jsonpParam: string;
+    constructor(jsonpParam: string);
+    getRequestStreamCreator(): (req: HttpRequest, options: HttpRequestOptions) => Duplex;
+}
+/**
+ * Class for Sfdc Canvas request transport
+ */
+export declare class CanvasTransport extends Transport {
+    static supported: boolean;
+    _signedRequest: any;
+    constructor(signedRequest: any);
+    getRequestStreamCreator(): (req: HttpRequest, options: HttpRequestOptions) => Duplex;
+}
+/**
+ * Class for HTTP request transport using cross-domain AJAX proxy service
+ */
+export declare class XdProxyTransport extends Transport {
+    _xdProxyUrl: string;
+    constructor(xdProxyUrl: string);
+    /**
+     * Make HTTP request via AJAX proxy
+     */
+    httpRequest(req: HttpRequest, _options?: HttpRequestOptions): StreamPromise<HttpResponse>;
+}
+/**
+ * Class for HTTP request transport using a proxy server
+ */
+export declare class HttpProxyTransport extends Transport {
+    _httpProxy: string;
+    constructor(httpProxy: string);
+    /**
+     * Make HTTP request via proxy server
+     */
+    httpRequest(req: HttpRequest, options_?: HttpRequestOptions): StreamPromise<HttpResponse>;
+}
+export default Transport;