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

package/lib/api/bulk.js

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.IngestJobV2 = exports.QueryJobV2 = exports.BulkV2 = exports.Bulk = exports.Batch = exports.Job = void 0;
+exports.Bulk = exports.Batch = exports.Job = void 0;
 /**
  * @file Manages Salesforce Bulk API related operations
  * @author Shinichi Tomita <shinichi.tomita@gmail.com>
@@ -15,7 +15,7 @@ const record_stream_1 = require("../record-stream");
 const http_api_1 = __importDefault(require("../http-api"));
 const jsforce_1 = require("../jsforce");
 const stream_2 = require("../util/stream");
-const function_1 = require("../util/function");
+const is_1 = __importDefault(require("@sindresorhus/is"));
 /**
  * Class for Bulk API Job
  */
@@ -264,17 +264,6 @@ class PollingTimeoutError extends Error {
         this.batchId = batchId;
     }
 }
-class JobPollingTimeoutError extends Error {
-    jobId;
-    /**
-     *
-     */
-    constructor(message, jobId) {
-        super(message);
-        this.name = 'JobPollingTimeout';
-        this.jobId = jobId;
-    }
-}
 /*--------------------------------------------*/
 /**
  * Batch (extends Writable)
@@ -387,13 +376,14 @@ class Batch extends stream_1.Writable {
             this.once('response', resolve);
             this.once('error', reject);
         });
-        if ((0, function_1.isObject)(input) && 'pipe' in input && (0, function_1.isFunction)(input.pipe)) {
+        if (is_1.default.nodeStream(input)) {
             // if input has stream.Readable interface
             input.pipe(this._dataStream);
         }
         else {
-            if (Array.isArray(input)) {
-                for (const record of input) {
+            const recordData = structuredClone(input);
+            if (Array.isArray(recordData)) {
+                for (const record of recordData) {
                     for (const key of Object.keys(record)) {
                         if (typeof record[key] === 'boolean') {
                             record[key] = String(record[key]);
@@ -403,8 +393,8 @@ class Batch extends stream_1.Writable {
                 }
                 this.end();
             }
-            else if (typeof input === 'string') {
-                this._dataStream.write(input, 'utf8');
+            else if (typeof recordData === 'string') {
+                this._dataStream.write(recordData, 'utf8');
                 this._dataStream.end();
             }
         }
@@ -452,9 +442,13 @@ class Batch extends stream_1.Writable {
             throw new Error('Batch not started.');
         }
         const startTime = new Date().getTime();
+        const endTime = startTime + timeout;
+        if (timeout === 0) {
+            throw new PollingTimeoutError(`Skipping polling because of timeout = 0ms. Job Id = ${jobId} | Batch Id = ${batchId}`, jobId, batchId);
+        }
         const poll = async () => {
             const now = new Date().getTime();
-            if (startTime + timeout < now) {
+            if (endTime < now) {
                 const err = new PollingTimeoutError('Polling time out. Job Id = ' + jobId + ' , batch Id = ' + batchId, jobId, batchId);
                 this.emit('error', err);
                 return;
@@ -479,7 +473,7 @@ class Batch extends stream_1.Writable {
                 this.retrieve();
             }
             else {
-                this.emit('progress', res);
+                this.emit('inProgress', res);
                 setTimeout(poll, interval);
             }
         };
@@ -526,7 +520,8 @@ class Batch extends stream_1.Writable {
         }
     }
     /**
-     * Fetch query result as a record stream
+     * Fetch query batch result as a record stream
+     *
      * @param {String} resultId - Result id
      * @returns {RecordStream} - Record stream, convertible to CSV data stream
      */
@@ -575,22 +570,6 @@ class BulkApi extends http_api_1.default {
         };
     }
 }
-class BulkApiV2 extends http_api_1.default {
-    hasErrorInResponseBody(body) {
-        return (Array.isArray(body) &&
-            typeof body[0] === 'object' &&
-            'errorCode' in body[0]);
-    }
-    isSessionExpired(response) {
-        return (response.statusCode === 401 && /INVALID_SESSION_ID/.test(response.body));
-    }
-    parseError(body) {
-        return {
-            errorCode: body[0].errorCode,
-            message: body[0].message,
-        };
-    }
-}
 /*--------------------------------------------*/
 /**
  * Class for Bulk API
@@ -602,13 +581,16 @@ class Bulk {
     _logger;
     /**
      * Polling interval in milliseconds
+     *
+     * Default: 1000 (1 second)
      */
     pollInterval = 1000;
     /**
      * Polling timeout in milliseconds
-     * @type {Number}
+     *
+     * Default: 30000 (30 seconds)
      */
-    pollTimeout = 10000;
+    pollTimeout = 30000;
     /**
      *
      */
@@ -633,9 +615,7 @@ class Bulk {
         let options = {};
         if (typeof optionsOrInput === 'string' ||
             Array.isArray(optionsOrInput) ||
-            ((0, function_1.isObject)(optionsOrInput) &&
-                'pipe' in optionsOrInput &&
-                typeof optionsOrInput.pipe === 'function')) {
+            is_1.default.nodeStream(optionsOrInput)) {
             // when options is not plain hash object, it is omitted
             input = optionsOrInput;
         }
@@ -660,7 +640,7 @@ class Bulk {
     /**
      * Execute bulk query and get record stream
      */
-    query(soql) {
+    async query(soql) {
         const m = soql.replace(/\([\s\S]+\)/g, '').match(/FROM\s+(\w+)/i);
         if (!m) {
             throw new Error('No sobject type found in query, maybe caused by invalid SOQL.');
@@ -668,19 +648,9 @@ class Bulk {
         const type = m[1];
         const recordStream = new record_stream_1.Parsable();
         const dataStream = recordStream.stream('csv');
-        (async () => {
-            try {
-                const results = await this.load(type, 'query', soql);
-                const streams = results.map((result) => this.job(result.jobId)
-                    .batch(result.batchId)
-                    .result(result.id)
-                    .stream());
-                (0, multistream_1.default)(streams).pipe(dataStream);
-            }
-            catch (err) {
-                recordStream.emit('error', err);
-            }
-        })();
+        const results = await this.load(type, 'query', soql);
+        const streams = results.map((result) => this.job(result.jobId).batch(result.batchId).result(result.id).stream());
+        (0, multistream_1.default)(streams).pipe(dataStream);
         return recordStream;
     }
     /**
@@ -700,673 +670,9 @@ class Bulk {
     }
 }
 exports.Bulk = Bulk;
-class BulkV2 {
-    #connection;
-    /**
-     * Polling interval in milliseconds
-     */
-    pollInterval = 1000;
-    /**
-     * Polling timeout in milliseconds
-     * @type {Number}
-     */
-    pollTimeout = 10000;
-    constructor(connection) {
-        this.#connection = connection;
-    }
-    /**
-     * Create an instance of an ingest job object.
-     *
-     * @params {NewIngestJobOptions} options object
-     * @returns {IngestJobV2} An ingest job instance
-     * @example
-     * // Upsert records to the Account object.
-     *
-     * const job = connection.bulk2.createJob({
-     *   operation: 'insert'
-     *   object: 'Account',
-     * });
-     *
-     * // create the job in the org
-     * await job.open()
-     *
-     * // upload data
-     * await job.uploadData(csvFile)
-     *
-     * // finished uploading data, mark it as ready for processing
-     * await job.close()
-     */
-    createJob(options) {
-        return new IngestJobV2({
-            connection: this.#connection,
-            jobInfo: options,
-            pollingOptions: this,
-        });
-    }
-    /**
-     * Get a ingest job instance specified by a given job ID
-     *
-     * @param options Options object with a job ID
-     * @returns IngestJobV2 An ingest job
-     */
-    job(options) {
-        return new IngestJobV2({
-            connection: this.#connection,
-            jobInfo: options,
-            pollingOptions: this,
-        });
-    }
-    /**
-     * Create, upload, and start bulkload job
-     */
-    async loadAndWaitForResults(options) {
-        if (!options.pollTimeout)
-            options.pollTimeout = this.pollTimeout;
-        if (!options.pollInterval)
-            options.pollInterval = this.pollInterval;
-        const job = this.createJob(options);
-        try {
-            await job.open();
-            await job.uploadData(options.input);
-            await job.close();
-            await job.poll(options.pollInterval, options.pollTimeout);
-            return await job.getAllResults();
-        }
-        catch (error) {
-            const err = error;
-            if (err.name !== 'JobPollingTimeoutError') {
-                // fires off one last attempt to clean up and ignores the result | error
-                job.delete().catch((ignored) => ignored);
-            }
-            throw err;
-        }
-    }
-    /**
-     * Execute bulk query and get records
-     *
-     * Default timeout: 10000ms
-     *
-     * @param soql SOQL query
-     * @param BulkV2PollingOptions options object
-     *
-     * @returns Record[]
-     */
-    async query(soql, options) {
-        const queryJob = new QueryJobV2({
-            connection: this.#connection,
-            operation: options?.scanAll ? 'queryAll' : 'query',
-            query: soql,
-            pollingOptions: this,
-        });
-        try {
-            await queryJob.open();
-            await queryJob.poll(options?.pollInterval, options?.pollTimeout);
-            return await queryJob.getResults();
-        }
-        catch (error) {
-            const err = error;
-            if (err.name !== 'JobPollingTimeoutError') {
-                // fires off one last attempt to clean up and ignores the result | error
-                queryJob.delete().catch((ignored) => ignored);
-            }
-            throw err;
-        }
-    }
-}
-exports.BulkV2 = BulkV2;
-class QueryJobV2 extends events_1.EventEmitter {
-    #connection;
-    #operation;
-    #query;
-    #pollingOptions;
-    #queryResults;
-    #error;
-    jobInfo;
-    locator;
-    finished = false;
-    constructor(options) {
-        super();
-        this.#connection = options.connection;
-        this.#operation = options.operation;
-        this.#query = options.query;
-        this.#pollingOptions = options.pollingOptions;
-        // default error handler to keep the latest error
-        this.on('error', (error) => (this.#error = error));
-    }
-    /**
-     * Creates a query job
-     */
-    async open() {
-        try {
-            this.jobInfo = await this.createQueryRequest({
-                method: 'POST',
-                path: '',
-                body: JSON.stringify({
-                    operation: this.#operation,
-                    query: this.#query,
-                }),
-                headers: {
-                    'Content-Type': 'application/json; charset=utf-8',
-                },
-                responseType: 'application/json',
-            });
-            this.emit('open');
-        }
-        catch (err) {
-            this.emit('error', err);
-            throw err;
-        }
-    }
-    /**
-     * Set the status to abort
-     */
-    async abort() {
-        try {
-            const state = 'Aborted';
-            this.jobInfo = await this.createQueryRequest({
-                method: 'PATCH',
-                path: `/${this.jobInfo?.id}`,
-                body: JSON.stringify({ state }),
-                headers: { 'Content-Type': 'application/json; charset=utf-8' },
-                responseType: 'application/json',
-            });
-            this.emit('aborted');
-        }
-        catch (err) {
-            this.emit('error', err);
-            throw err;
-        }
-    }
-    /**
-     * Poll for the state of the processing for the job.
-     *
-     * This method will only throw after a timeout. To capture a
-     * job failure while polling you must set a listener for the
-     * `failed` event before calling it:
-     *
-     * job.on('failed', (err) => console.error(err))
-     * await job.poll()
-     *
-     * @param interval Polling interval in milliseconds
-     * @param timeout Polling timeout in milliseconds
-     * @returns {Promise<Record[]>} A promise that resolves to an array of records
-     */
-    async poll(interval = this.#pollingOptions.pollInterval, timeout = this.#pollingOptions.pollTimeout) {
-        const jobId = getJobIdOrError(this.jobInfo);
-        const startTime = Date.now();
-        while (startTime + timeout > Date.now()) {
-            try {
-                const res = await this.check();
-                switch (res.state) {
-                    case 'Open':
-                        throw new Error('Job has not been started');
-                    case 'Aborted':
-                        throw new Error('Job has been aborted');
-                    case 'UploadComplete':
-                    case 'InProgress':
-                        await delay(interval);
-                        break;
-                    case 'Failed':
-                        // unlike ingest jobs, the API doesn't return an error msg:
-                        // https://developer.salesforce.com/docs/atlas.en-us.api_asynch.meta/api_asynch/query_get_one_job.htm
-                        this.emit('failed', new Error('Query job failed to complete.'));
-                        return;
-                    case 'JobComplete':
-                        this.emit('jobcomplete');
-                        return;
-                }
-            }
-            catch (err) {
-                this.emit('error', err);
-                throw err;
-            }
-        }
-        const timeoutError = new JobPollingTimeoutError(`Polling timed out after ${timeout}ms. Job Id = ${jobId}`, jobId);
-        this.emit('error', timeoutError);
-        throw timeoutError;
-    }
-    /**
-     * Check the latest batch status in server
-     */
-    async check() {
-        try {
-            const jobInfo = await this.createQueryRequest({
-                method: 'GET',
-                path: `/${getJobIdOrError(this.jobInfo)}`,
-                responseType: 'application/json',
-            });
-            this.jobInfo = jobInfo;
-            return jobInfo;
-        }
-        catch (err) {
-            this.emit('error', err);
-            throw err;
-        }
-    }
-    request(request, options = {}) {
-        // if request is simple string, regard it as url in GET method
-        const request_ = typeof request === 'string' ? { method: 'GET', url: request } : request;
-        const httpApi = new http_api_1.default(this.#connection, options);
-        httpApi.on('response', (response) => {
-            this.locator = response.headers['sforce-locator'];
-        });
-        return httpApi.request(request_);
-    }
-    getResultsUrl() {
-        const url = `${this.#connection.instanceUrl}/services/data/v${this.#connection.version}/jobs/query/${getJobIdOrError(this.jobInfo)}/results`;
-        return this.locator ? `${url}?locator=${this.locator}` : url;
-    }
-    /**
-     * Get the results for a query job.
-     *
-     * @returns {Promise<Record[]>} A promise that resolves to an array of records
-     */
-    async getResults() {
-        if (this.finished && this.#queryResults) {
-            return this.#queryResults;
-        }
-        this.#queryResults = [];
-        while (this.locator !== 'null') {
-            const nextResults = await this.request({
-                method: 'GET',
-                url: this.getResultsUrl(),
-                headers: {
-                    Accept: 'text/csv',
-                },
-            });
-            this.#queryResults = this.#queryResults.concat(nextResults);
-        }
-        this.finished = true;
-        return this.#queryResults;
-    }
-    /**
-     * Deletes a query job.
-     */
-    async delete() {
-        return this.createQueryRequest({
-            method: 'DELETE',
-            path: `/${getJobIdOrError(this.jobInfo)}`,
-        });
-    }
-    createQueryRequest(request) {
-        const { path, responseType } = request;
-        const baseUrl = [
-            this.#connection.instanceUrl,
-            'services/data',
-            `v${this.#connection.version}`,
-            'jobs/query',
-        ].join('/');
-        return new BulkApiV2(this.#connection, { responseType }).request({
-            ...request,
-            url: baseUrl + path,
-        });
-    }
-}
-exports.QueryJobV2 = QueryJobV2;
-/**
- * Class for Bulk API V2 Ingest Job
- */
-class IngestJobV2 extends events_1.EventEmitter {
-    #connection;
-    #pollingOptions;
-    #jobData;
-    #bulkJobSuccessfulResults;
-    #bulkJobFailedResults;
-    #bulkJobUnprocessedRecords;
-    #error;
-    jobInfo;
-    /**
-     *
-     */
-    constructor(options) {
-        super();
-        this.#connection = options.connection;
-        this.#pollingOptions = options.pollingOptions;
-        this.jobInfo = options.jobInfo;
-        this.#jobData = new JobDataV2({
-            createRequest: (request) => this.createIngestRequest(request),
-            job: this,
-        });
-        // default error handler to keep the latest error
-        this.on('error', (error) => (this.#error = error));
-    }
-    get id() {
-        return this.jobInfo.id;
-    }
-    /**
-     * Create a job representing a bulk operation in the org
-     */
-    async open() {
-        try {
-            this.jobInfo = await this.createIngestRequest({
-                method: 'POST',
-                path: '',
-                body: JSON.stringify({
-                    assignmentRuleId: this.jobInfo?.assignmentRuleId,
-                    externalIdFieldName: this.jobInfo?.externalIdFieldName,
-                    object: this.jobInfo?.object,
-                    operation: this.jobInfo?.operation,
-                    lineEnding: this.jobInfo?.lineEnding,
-                }),
-                headers: {
-                    'Content-Type': 'application/json; charset=utf-8',
-                },
-                responseType: 'application/json',
-            });
-            this.emit('open');
-        }
-        catch (err) {
-            this.emit('error', err);
-            throw err;
-        }
-    }
-    /** Upload data for a job in CSV format
-     *
-     *  @param input CSV as a string, or array of records or readable stream
-     */
-    async uploadData(input) {
-        await this.#jobData.execute(input);
-    }
-    async getAllResults() {
-        const [successfulResults, failedResults, unprocessedRecords,] = await Promise.all([
-            this.getSuccessfulResults(),
-            this.getFailedResults(),
-            this.getUnprocessedRecords(),
-        ]);
-        return { successfulResults, failedResults, unprocessedRecords };
-    }
-    /**
-     * Close opened job
-     */
-    async close() {
-        try {
-            const state = 'UploadComplete';
-            this.jobInfo = await this.createIngestRequest({
-                method: 'PATCH',
-                path: `/${this.jobInfo.id}`,
-                body: JSON.stringify({ state }),
-                headers: { 'Content-Type': 'application/json; charset=utf-8' },
-                responseType: 'application/json',
-            });
-            this.emit('uploadcomplete');
-        }
-        catch (err) {
-            this.emit('error', err);
-            throw err;
-        }
-    }
-    /**
-     * Set the status to abort
-     */
-    async abort() {
-        try {
-            const state = 'Aborted';
-            this.jobInfo = await this.createIngestRequest({
-                method: 'PATCH',
-                path: `/${this.jobInfo.id}`,
-                body: JSON.stringify({ state }),
-                headers: { 'Content-Type': 'application/json; charset=utf-8' },
-                responseType: 'application/json',
-            });
-            this.emit('aborted');
-        }
-        catch (err) {
-            this.emit('error', err);
-            throw err;
-        }
-    }
-    /**
-     * Poll for the state of the processing for the job.
-     *
-     * This method will only throw after a timeout. To capture a
-     * job failure while polling you must set a listener for the
-     * `failed` event before calling it:
-     *
-     * job.on('failed', (err) => console.error(err))
-     * await job.poll()
-     *
-     * @param interval Polling interval in milliseconds
-     * @param timeout Polling timeout in milliseconds
-     * @returns {Promise<void>} A promise that resolves when the job finishes successfully
-     */
-    async poll(interval = this.#pollingOptions.pollInterval, timeout = this.#pollingOptions.pollTimeout) {
-        const jobId = getJobIdOrError(this.jobInfo);
-        const startTime = Date.now();
-        while (startTime + timeout > Date.now()) {
-            try {
-                const res = await this.check();
-                switch (res.state) {
-                    case 'Open':
-                        throw new Error('Job has not been started');
-                    case 'Aborted':
-                        throw new Error('Job has been aborted');
-                    case 'UploadComplete':
-                    case 'InProgress':
-                        await delay(interval);
-                        break;
-                    case 'Failed':
-                        this.emit('failed', new Error('Ingest job failed to complete.'));
-                        return;
-                    case 'JobComplete':
-                        this.emit('jobcomplete');
-                        return;
-                }
-            }
-            catch (err) {
-                this.emit('error', err);
-                throw err;
-            }
-        }
-        const timeoutError = new JobPollingTimeoutError(`Polling timed out after ${timeout}ms. Job Id = ${jobId}`, jobId);
-        this.emit('error', timeoutError);
-        throw timeoutError;
-    }
-    /**
-     * Check the latest batch status in server
-     */
-    async check() {
-        try {
-            const jobInfo = await this.createIngestRequest({
-                method: 'GET',
-                path: `/${getJobIdOrError(this.jobInfo)}`,
-                responseType: 'application/json',
-            });
-            this.jobInfo = jobInfo;
-            return jobInfo;
-        }
-        catch (err) {
-            this.emit('error', err);
-            throw err;
-        }
-    }
-    async getSuccessfulResults() {
-        if (this.#bulkJobSuccessfulResults) {
-            return this.#bulkJobSuccessfulResults;
-        }
-        const results = await this.createIngestRequest({
-            method: 'GET',
-            path: `/${getJobIdOrError(this.jobInfo)}/successfulResults`,
-            responseType: 'text/csv',
-        });
-        this.#bulkJobSuccessfulResults = results ?? [];
-        return this.#bulkJobSuccessfulResults;
-    }
-    async getFailedResults() {
-        if (this.#bulkJobFailedResults) {
-            return this.#bulkJobFailedResults;
-        }
-        const results = await this.createIngestRequest({
-            method: 'GET',
-            path: `/${getJobIdOrError(this.jobInfo)}/failedResults`,
-            responseType: 'text/csv',
-        });
-        this.#bulkJobFailedResults = results ?? [];
-        return this.#bulkJobFailedResults;
-    }
-    async getUnprocessedRecords() {
-        if (this.#bulkJobUnprocessedRecords) {
-            return this.#bulkJobUnprocessedRecords;
-        }
-        const results = await this.createIngestRequest({
-            method: 'GET',
-            path: `/${getJobIdOrError(this.jobInfo)}/unprocessedrecords`,
-            responseType: 'text/csv',
-        });
-        this.#bulkJobUnprocessedRecords = results ?? [];
-        return this.#bulkJobUnprocessedRecords;
-    }
-    /**
-     * Deletes an ingest job.
-     */
-    async delete() {
-        return this.createIngestRequest({
-            method: 'DELETE',
-            path: `/${getJobIdOrError(this.jobInfo)}`,
-        });
-    }
-    createIngestRequest(request) {
-        const { path, responseType } = request;
-        const baseUrl = [
-            this.#connection.instanceUrl,
-            'services/data',
-            `v${this.#connection.version}`,
-            'jobs/ingest',
-        ].join('/');
-        return new BulkApiV2(this.#connection, { responseType }).request({
-            ...request,
-            url: baseUrl + path,
-        });
-    }
-}
-exports.IngestJobV2 = IngestJobV2;
-class JobDataV2 extends stream_1.Writable {
-    #job;
-    #uploadStream;
-    #downloadStream;
-    #dataStream;
-    #result;
-    /**
-     *
-     */
-    constructor(options) {
-        super({ objectMode: true });
-        const createRequest = options.createRequest;
-        this.#job = options.job;
-        this.#uploadStream = new record_stream_1.Serializable();
-        this.#downloadStream = new record_stream_1.Parsable();
-        const converterOptions = { nullValue: '#N/A' };
-        const uploadDataStream = this.#uploadStream.stream('csv', converterOptions);
-        const downloadDataStream = this.#downloadStream.stream('csv', converterOptions);
-        this.#dataStream = (0, stream_2.concatStreamsAsDuplex)(uploadDataStream, downloadDataStream);
-        this.on('finish', () => this.#uploadStream.end());
-        uploadDataStream.once('readable', () => {
-            try {
-                // pipe upload data to batch API request stream
-                const req = createRequest({
-                    method: 'PUT',
-                    path: `/${this.#job.jobInfo?.id}/batches`,
-                    headers: {
-                        'Content-Type': 'text/csv',
-                    },
-                    responseType: 'application/json',
-                });
-                (async () => {
-                    try {
-                        const res = await req;
-                        this.emit('response', res);
-                    }
-                    catch (err) {
-                        this.emit('error', err);
-                    }
-                })();
-                uploadDataStream.pipe(req.stream());
-            }
-            catch (err) {
-                this.emit('error', err);
-            }
-        });
-    }
-    _write(record_, enc, cb) {
-        const { Id, type, attributes, ...rrec } = record_;
-        let record;
-        switch (this.#job.jobInfo.operation) {
-            case 'insert':
-                record = rrec;
-                break;
-            case 'delete':
-            case 'hardDelete':
-                record = { Id };
-                break;
-            default:
-                record = { Id, ...rrec };
-        }
-        this.#uploadStream.write(record, enc, cb);
-    }
-    /**
-     * Returns duplex stream which accepts CSV data input and batch result output
-     */
-    stream() {
-        return this.#dataStream;
-    }
-    /**
-     * Execute batch operation
-     */
-    execute(input) {
-        if (this.#result) {
-            throw new Error('Data can only be uploaded to a job once.');
-        }
-        this.#result = new Promise((resolve, reject) => {
-            this.once('response', () => resolve());
-            this.once('error', reject);
-        });
-        if ((0, function_1.isObject)(input) && 'pipe' in input && (0, function_1.isFunction)(input.pipe)) {
-            // if input has stream.Readable interface
-            input.pipe(this.#dataStream);
-        }
-        else {
-            if (Array.isArray(input)) {
-                for (const record of input) {
-                    for (const key of Object.keys(record)) {
-                        if (typeof record[key] === 'boolean') {
-                            record[key] = String(record[key]);
-                        }
-                    }
-                    this.write(record);
-                }
-                this.end();
-            }
-            else if (typeof input === 'string') {
-                this.#dataStream.write(input, 'utf8');
-                this.#dataStream.end();
-            }
-        }
-        return this;
-    }
-    /**
-     * Promise/A+ interface
-     * Delegate to promise, return promise instance for batch result
-     */
-    then(onResolved, onReject) {
-        if (this.#result === undefined) {
-            this.execute();
-        }
-        return this.#result.then(onResolved, onReject);
-    }
-}
-function getJobIdOrError(jobInfo) {
-    const jobId = jobInfo?.id;
-    if (jobId === undefined) {
-        throw new Error('No job id, maybe you need to call `job.open()` first.');
-    }
-    return jobId;
-}
-function delay(ms) {
-    return new Promise((resolve) => setTimeout(resolve, ms));
-}
 /*--------------------------------------------*/
 /*
  * Register hook in connection instantiation for dynamically adding this API module features
  */
 (0, jsforce_1.registerModule)('bulk', (conn) => new Bulk(conn));
-(0, jsforce_1.registerModule)('bulk2', (conn) => new BulkV2(conn));
 exports.default = Bulk;