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

package/lib/api/streaming.js

@@ -0,0 +1,252 @@
+"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;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StreamingExtension = exports.Streaming = exports.Subscription = exports.Client = void 0;
+/**
+ * @file Manages Streaming APIs
+ * @author Shinichi Tomita <shinichi.tomita@gmail.com>
+ */
+const events_1 = require("events");
+const faye_1 = require("faye");
+Object.defineProperty(exports, "Client", { enumerable: true, get: function () { return faye_1.Client; } });
+Object.defineProperty(exports, "Subscription", { enumerable: true, get: function () { return faye_1.Subscription; } });
+const jsforce_1 = require("../jsforce");
+const StreamingExtension = __importStar(require("./streaming/extension"));
+exports.StreamingExtension = StreamingExtension;
+/*--------------------------------------------*/
+/**
+ * Streaming API topic class
+ */
+class Topic {
+    _streaming;
+    name;
+    constructor(streaming, name) {
+        this._streaming = streaming;
+        this.name = name;
+    }
+    /**
+     * Subscribe listener to topic
+     */
+    subscribe(listener) {
+        return this._streaming.subscribe(this.name, listener);
+    }
+    /**
+     * Unsubscribe listener from topic
+     */
+    unsubscribe(subscr) {
+        this._streaming.unsubscribe(this.name, subscr);
+        return this;
+    }
+}
+/*--------------------------------------------*/
+/**
+ * Streaming API Generic Streaming Channel
+ */
+class Channel {
+    _streaming;
+    _id;
+    name;
+    constructor(streaming, name) {
+        this._streaming = streaming;
+        this.name = name;
+    }
+    /**
+     * Subscribe to channel
+     */
+    subscribe(listener) {
+        return this._streaming.subscribe(this.name, listener);
+    }
+    unsubscribe(subscr) {
+        this._streaming.unsubscribe(this.name, subscr);
+        return this;
+    }
+    async push(events) {
+        const isArray = Array.isArray(events);
+        const pushEvents = Array.isArray(events) ? events : [events];
+        const conn = this._streaming._conn;
+        if (!this._id) {
+            this._id = conn
+                .sobject('StreamingChannel')
+                .findOne({ Name: this.name }, ['Id'])
+                .then((rec) => rec?.Id);
+        }
+        const id = await this._id;
+        if (!id) {
+            throw new Error(`No streaming channel available for name: ${this.name}`);
+        }
+        const channelUrl = `/sobjects/StreamingChannel/${id}/push`;
+        const rets = await conn.requestPost(channelUrl, {
+            pushEvents,
+        });
+        return isArray ? rets : rets[0];
+    }
+}
+/*--------------------------------------------*/
+/**
+ * Streaming API class
+ */
+class Streaming extends events_1.EventEmitter {
+    _conn;
+    _topics = {};
+    _fayeClients = {};
+    /**
+     *
+     */
+    constructor(conn) {
+        super();
+        this._conn = conn;
+    }
+    /* @private */
+    _createClient(forChannelName, extensions) {
+        // forChannelName is advisory, for an API workaround. It does not restrict or select the channel.
+        const needsReplayFix = typeof forChannelName === 'string' && forChannelName.indexOf('/u/') === 0;
+        const endpointUrl = [
+            this._conn.instanceUrl,
+            // special endpoint "/cometd/replay/xx.x" is only available in 36.0.
+            // See https://releasenotes.docs.salesforce.com/en-us/summer16/release-notes/rn_api_streaming_classic_replay.htm
+            'cometd' +
+                (needsReplayFix === true && this._conn.version === '36.0'
+                    ? '/replay'
+                    : ''),
+            this._conn.version,
+        ].join('/');
+        const fayeClient = new faye_1.Client(endpointUrl, {});
+        fayeClient.setHeader('Authorization', 'OAuth ' + this._conn.accessToken);
+        if (Array.isArray(extensions)) {
+            for (const extension of extensions) {
+                fayeClient.addExtension(extension);
+            }
+        }
+        // prevent streaming API server error
+        const dispatcher = fayeClient._dispatcher;
+        if (dispatcher.getConnectionTypes().indexOf('callback-polling') === -1) {
+            dispatcher.selectTransport('long-polling');
+            dispatcher._transport.batching = false;
+        }
+        return fayeClient;
+    }
+    /** @private **/
+    _getFayeClient(channelName) {
+        const isGeneric = channelName.indexOf('/u/') === 0;
+        const clientType = isGeneric ? 'generic' : 'pushTopic';
+        if (!this._fayeClients[clientType]) {
+            this._fayeClients[clientType] = this._createClient(channelName);
+        }
+        return this._fayeClients[clientType];
+    }
+    /**
+     * Get named topic
+     */
+    topic(name) {
+        this._topics = this._topics || {};
+        const topic = (this._topics[name] =
+            this._topics[name] || new Topic(this, name));
+        return topic;
+    }
+    /**
+     * Get channel for channel name
+     */
+    channel(name) {
+        return new Channel(this, name);
+    }
+    /**
+     * Subscribe topic/channel
+     */
+    subscribe(name, listener) {
+        const channelName = name.indexOf('/') === 0 ? name : '/topic/' + name;
+        const fayeClient = this._getFayeClient(channelName);
+        return fayeClient.subscribe(channelName, listener);
+    }
+    /**
+     * Unsubscribe topic
+     */
+    unsubscribe(name, subscription) {
+        const channelName = name.indexOf('/') === 0 ? name : '/topic/' + name;
+        const fayeClient = this._getFayeClient(channelName);
+        fayeClient.unsubscribe(channelName, subscription);
+        return this;
+    }
+    /**
+     * Create a Streaming client, optionally with extensions
+     *
+     * See Faye docs for implementation details: https://faye.jcoglan.com/browser/extensions.html
+     *
+     * Example usage:
+     *
+     * ```javascript
+     * const jsforce = require('jsforce');
+     *
+     * // Establish a Salesforce connection. (Details elided)
+     * const conn = new jsforce.Connection({ … });
+     *
+     * const fayeClient = conn.streaming.createClient();
+     *
+     * const subscription = fayeClient.subscribe(channel, data => {
+     *   console.log('topic received data', data);
+     * });
+     *
+     * subscription.cancel();
+     * ```
+     *
+     * Example with extensions, using Replay & Auth Failure extensions in a server-side Node.js app:
+     *
+     * ```javascript
+     * const jsforce = require('jsforce');
+     * const { StreamingExtension } = require('jsforce/api/streaming');
+     *
+     * // Establish a Salesforce connection. (Details elided)
+     * const conn = new jsforce.Connection({ … });
+     *
+     * const channel = "/event/My_Event__e";
+     * const replayId = -2; // -2 is all retained events
+     *
+     * const exitCallback = () => process.exit(1);
+     * const authFailureExt = new StreamingExtension.AuthFailure(exitCallback);
+     *
+     * const replayExt = new StreamingExtension.Replay(channel, replayId);
+     *
+     * const fayeClient = conn.streaming.createClient([
+     *   authFailureExt,
+     *   replayExt
+     * ]);
+     *
+     * const subscription = fayeClient.subscribe(channel, data => {
+     *   console.log('topic received data', data);
+     * });
+     *
+     * subscription.cancel();
+     * ```
+     */
+    createClient(extensions) {
+        return this._createClient(null, extensions);
+    }
+}
+exports.Streaming = Streaming;
+/*--------------------------------------------*/
+/*
+ * Register hook in connection instantiation for dynamically adding this API module features
+ */
+(0, jsforce_1.registerModule)('streaming', (conn) => new Streaming(conn));
+exports.default = Streaming;

package/lib/api/tooling.d.ts

@@ -0,0 +1,284 @@
+import Connection from '../connection';
+import Cache, { CachedFunction } from '../cache';
+import SObject from '../sobject';
+import { DescribeGlobalResult, DescribeSObjectResult, HttpRequest, Schema, SObjectNames } from '../types';
+/**
+ *
+ */
+export type ExecuteAnonymousResult = {
+    compiled: boolean;
+    compileProblem: string | null;
+    success: boolean;
+    line: number;
+    column: number;
+    exceptionMessage: string | null;
+    exceptionStackTrace: string | null;
+};
+export type RunTestLevel = 'RunSpecifiedTests' | 'RunLocalTests' | 'RunAllTestsInOrg';
+type TestsNode = {
+    classId: string;
+    testMethods?: string[];
+} | {
+    className: string;
+    testMethods?: string[];
+};
+export type RunTestsRequest = {
+    tests: TestsNode[];
+    maxFailedTests?: number;
+    testLevel?: RunTestLevel;
+    skipCodeCoverage?: boolean;
+};
+export type RunTestsAsyncRequest = {
+    classids?: string;
+    classNames?: string;
+    suiteids?: string;
+    suiteNames?: string;
+    maxFailedTests?: number;
+    testLevel?: RunTestLevel;
+    skipCodeCoverage?: boolean;
+} | {
+    tests: TestsNode[];
+    maxFailedTests?: number;
+    testLevel?: RunTestLevel;
+    skipCodeCoverage?: boolean;
+};
+type CodeCoverageResult = {
+    id: string;
+    locationsNotCovered: any[];
+    name: string;
+    namespace: string | null;
+    numLocations: number;
+    numLocationsNotCovered: number;
+    type: string;
+};
+type CodeCoverageWarning = {
+    id: string;
+    message: string;
+    name: string | null;
+    namespace: string | null;
+};
+type FlowCoverageResult = {
+    elementsNotCovered: string[];
+    flowId: string;
+    flowName: string;
+    flowNamespace: string | null;
+    numElements: number;
+    numElementsNotCovered: number;
+    processType: string;
+};
+type FlowCoverageWarning = {
+    flowId: string;
+    flowName: string;
+    flowNamespace: string | null;
+    message: string;
+};
+type RunTestSuccess = {
+    id: string;
+    methodName: string;
+    name: string;
+    namespace: string | null;
+    seeAllData: boolean;
+    time: number;
+};
+type RunTestFailure = {
+    id: string;
+    message: string;
+    methodName: string;
+    name: string;
+    namespace: string | null;
+    seeAllData: boolean;
+    stackTrace: string;
+    time: number;
+    type: string;
+};
+export type RunTestsResult = {
+    apexLogId: string;
+    codeCoverage: CodeCoverageResult[];
+    codeCoverageWarnings: CodeCoverageWarning[];
+    flowCoverage: FlowCoverageResult[];
+    flowCoverageWarnings: FlowCoverageWarning[];
+    numFailures: number;
+    numTestsRun: number;
+    successes: RunTestSuccess[];
+    failures: RunTestFailure[];
+    totalTime: number;
+};
+type ConstructorDeclaration = {
+    methodDoc: string | null;
+    name: string;
+    parameters: Array<{
+        name: string;
+        type: string;
+    }>;
+    references: any[];
+};
+type MethodDeclaration = {
+    argTypes: string[];
+    isStatic: boolean;
+    methodDoc: string | null;
+    name: string;
+    parameters: Array<{
+        name: string;
+        type: string;
+    }>;
+    references: any[];
+};
+type PropertyDeclaration = {
+    name: string;
+    references: any[];
+};
+type ClassDeclaration = {
+    constructors: ConstructorDeclaration[];
+    methods: MethodDeclaration[];
+    properties: PropertyDeclaration[];
+};
+export type CompletionsResult = {
+    publicDeclarations?: {
+        [namespace: string]: {
+            [name: string]: ClassDeclaration;
+        };
+    };
+    completions?: {
+        [component: string]: {
+            simple: boolean;
+            attribs: {
+                [attr: string]: {};
+            };
+        };
+    };
+};
+/**
+ * API class for Tooling API call
+ */
+export declare class Tooling<S extends Schema> {
+    _conn: Connection<S>;
+    get version(): string;
+    /**
+     * Execute query by using SOQL
+     */
+    query: Connection<S>['query'];
+    /**
+     * Query next record set by using query locator
+     */
+    queryMore: Connection<S>['queryMore'];
+    _ensureVersion: Connection<S>['_ensureVersion'];
+    /**
+     * Create records
+     */
+    create: Connection<S>['create'];
+    _createSingle: (type: string, record: import("../types").Record, options: import("../types").DmlOptions) => Promise<unknown>;
+    _createParallel: (type: string, records: import("../types").Record[], options: import("../types").DmlOptions) => Promise<unknown[]>;
+    _createMany: (type: string, records: import("../types").Record[], options: import("../types").DmlOptions) => Promise<import("../types").SaveResult[]>;
+    /**
+     * Synonym of Tooling#create()
+     */
+    insert: {
+        <N extends string, InputRecord extends Partial<import("../types").SObjectRecord<any, N, "*", import("../types").Record, {}>> = Partial<import("../types").SObjectRecord<any, N, "*", import("../types").Record, {}>>>(type: N, records: InputRecord[], options?: import("../types").DmlOptions | undefined): Promise<import("../types").SaveResult[]>;
+        <N_1 extends string, InputRecord_1 extends Partial<import("../types").SObjectRecord<any, N_1, "*", import("../types").Record, {}>> = Partial<import("../types").SObjectRecord<any, N_1, "*", import("../types").Record, {}>>>(type: N_1, record: InputRecord_1, options?: import("../types").DmlOptions | undefined): Promise<import("../types").SaveResult>;
+        <N_2 extends string, InputRecord_2 extends Partial<import("../types").SObjectRecord<any, N_2, "*", import("../types").Record, {}>> = Partial<import("../types").SObjectRecord<any, N_2, "*", import("../types").Record, {}>>>(type: N_2, records: InputRecord_2 | InputRecord_2[], options?: import("../types").DmlOptions | undefined): Promise<import("../types").SaveResult | import("../types").SaveResult[]>;
+    };
+    /**
+     * Retrieve specified records
+     */
+    retrieve: Connection<S>['retrieve'];
+    _retrieveSingle: (type: string, id: string, options: import("../types").RetrieveOptions) => Promise<unknown>;
+    _retrieveParallel: (type: string, ids: string[], options: import("../types").RetrieveOptions) => Promise<unknown[]>;
+    _retrieveMany: (type: string, ids: string[], options: import("../types").RetrieveOptions) => Promise<unknown>;
+    /**
+     * Update records
+     */
+    update: Connection<S>['update'];
+    _updateSingle: (type: string, record: import("../types").Record, options: import("../types").DmlOptions) => Promise<import("../types").SaveResult>;
+    _updateParallel: (type: string, records: import("../types").Record[], options: import("../types").DmlOptions) => Promise<import("../types").SaveResult[]>;
+    _updateMany: (type: string, records: import("../types").Record[], options: import("../types").DmlOptions) => Promise<import("../types").SaveResult[]>;
+    /**
+     * Upsert records
+     */
+    upsert: Connection<S>['upsert'];
+    /**
+     * Delete records
+     */
+    destroy: Connection<S>['destroy'];
+    _destroySingle: (type: string, id: string, options: import("../types").DmlOptions) => Promise<import("../types").SaveResult>;
+    _destroyParallel: (type: string, ids: string[], options: import("../types").DmlOptions) => Promise<import("../types").SaveResult[]>;
+    _destroyMany: (type: string, ids: string[], options: import("../types").DmlOptions) => Promise<import("../types").SaveResult[]>;
+    /**
+     * Synonym of Tooling#destroy()
+     */
+    delete: {
+        <N extends string>(type: N, ids: string[], options?: import("../types").DmlOptions | undefined): Promise<import("../types").SaveResult[]>;
+        <N_1 extends string>(type: N_1, id: string, options?: import("../types").DmlOptions | undefined): Promise<import("../types").SaveResult>;
+        <N_2 extends string>(type: N_2, ids: string | string[], options?: import("../types").DmlOptions | undefined): Promise<import("../types").SaveResult | import("../types").SaveResult[]>;
+    };
+    /**
+     * Synonym of Tooling#destroy()
+     */
+    del: {
+        <N extends string>(type: N, ids: string[], options?: import("../types").DmlOptions | undefined): Promise<import("../types").SaveResult[]>;
+        <N_1 extends string>(type: N_1, id: string, options?: import("../types").DmlOptions | undefined): Promise<import("../types").SaveResult>;
+        <N_2 extends string>(type: N_2, ids: string | string[], options?: import("../types").DmlOptions | undefined): Promise<import("../types").SaveResult | import("../types").SaveResult[]>;
+    };
+    cache: Cache;
+    /**
+     * Describe SObject metadata
+     */
+    describe: CachedFunction<(type: string) => Promise<DescribeSObjectResult>>;
+    describe$: CachedFunction<(type: string) => Promise<DescribeSObjectResult>>;
+    describe$$: CachedFunction<(name: string) => DescribeSObjectResult>;
+    /**
+     * Synonym of Tooling#describe()
+     */
+    describeSObject: CachedFunction<(type: string) => Promise<DescribeSObjectResult>>;
+    describeSObject$: CachedFunction<(type: string) => Promise<DescribeSObjectResult>>;
+    describeSObject$$: CachedFunction<(name: string) => DescribeSObjectResult>;
+    /**
+     * Describe global SObjects
+     */
+    describeGlobal: CachedFunction<() => Promise<DescribeGlobalResult>>;
+    describeGlobal$: CachedFunction<() => Promise<DescribeGlobalResult>>;
+    describeGlobal$$: CachedFunction<(name: string) => DescribeGlobalResult>;
+    /**
+     * Get SObject instance
+     */
+    sobject: Connection<S>['sobject'];
+    sobjects: {
+        [N in SObjectNames<S>]?: SObject<S, N>;
+    };
+    /**
+     *
+     */
+    constructor(conn: Connection<S>);
+    /**
+     * @private
+     */
+    _establish(): void;
+    /**
+     * @private
+     */
+    _baseUrl(): string;
+    /**
+     * @private
+     */
+    _supports(feature: string): boolean;
+    /**
+     *
+     */
+    request<R = unknown>(request: string | HttpRequest, options?: Object): import("../util/promise").StreamPromise<R>;
+    /**
+     * Executes Apex code anonymously
+     */
+    executeAnonymous(body: string): import("../util/promise").StreamPromise<ExecuteAnonymousResult>;
+    /**
+     * Executes Apex tests asynchronously
+     */
+    runTestsAsynchronous(req: RunTestsAsyncRequest): import("../util/promise").StreamPromise<string | null>;
+    /**
+     * Executes Apex tests synchronously
+     */
+    runTestsSynchronous(req: RunTestsRequest): import("../util/promise").StreamPromise<RunTestsResult | null>;
+    /**
+     * Retrieves available code completions of the referenced type
+     */
+    completions(type?: 'apex' | 'visualforce'): import("../util/promise").StreamPromise<CompletionsResult>;
+}
+export default Tooling;