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

package/lib/api/bulk.js

@@ -0,0 +1,1372 @@
+"use strict";
+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;
+/**
+ * @file Manages Salesforce Bulk API related operations
+ * @author Shinichi Tomita <shinichi.tomita@gmail.com>
+ */
+const events_1 = require("events");
+const stream_1 = require("stream");
+const multistream_1 = __importDefault(require("multistream"));
+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");
+/**
+ * Class for Bulk API Job
+ */
+class Job extends events_1.EventEmitter {
+    type;
+    operation;
+    options;
+    id;
+    state;
+    _bulk;
+    _batches;
+    _jobInfo;
+    _error;
+    /**
+     *
+     */
+    constructor(bulk, type, operation, options, jobId) {
+        super();
+        this._bulk = bulk;
+        this.type = type;
+        this.operation = operation;
+        this.options = options || {};
+        this.id = jobId ?? null;
+        this.state = this.id ? 'Open' : 'Unknown';
+        this._batches = {};
+        // default error handler to keep the latest error
+        this.on('error', (error) => (this._error = error));
+    }
+    /**
+     * Return latest jobInfo from cache
+     */
+    info() {
+        // if cache is not available, check the latest
+        if (!this._jobInfo) {
+            this._jobInfo = this.check();
+        }
+        return this._jobInfo;
+    }
+    /**
+     * Open new job and get jobinfo
+     */
+    open() {
+        const bulk = this._bulk;
+        const options = this.options;
+        // if sobject type / operation is not provided
+        if (!this.type || !this.operation) {
+            throw new Error('type / operation is required to open a new job');
+        }
+        // if not requested opening job
+        if (!this._jobInfo) {
+            let operation = this.operation.toLowerCase();
+            if (operation === 'harddelete') {
+                operation = 'hardDelete';
+            }
+            if (operation === 'queryall') {
+                operation = 'queryAll';
+            }
+            const body = `
+<?xml version="1.0" encoding="UTF-8"?>
+<jobInfo  xmlns="http://www.force.com/2009/06/asyncapi/dataload">
+  <operation>${operation}</operation>
+  <object>${this.type}</object>
+  ${options.extIdField
+                ? `<externalIdFieldName>${options.extIdField}</externalIdFieldName>`
+                : ''}
+  ${options.concurrencyMode
+                ? `<concurrencyMode>${options.concurrencyMode}</concurrencyMode>`
+                : ''}
+  ${options.assignmentRuleId
+                ? `<assignmentRuleId>${options.assignmentRuleId}</assignmentRuleId>`
+                : ''}
+  <contentType>CSV</contentType>
+</jobInfo>
+      `.trim();
+            this._jobInfo = (async () => {
+                try {
+                    const res = await bulk._request({
+                        method: 'POST',
+                        path: '/job',
+                        body,
+                        headers: {
+                            'Content-Type': 'application/xml; charset=utf-8',
+                        },
+                        responseType: 'application/xml',
+                    });
+                    this.emit('open', res.jobInfo);
+                    this.id = res.jobInfo.id;
+                    this.state = res.jobInfo.state;
+                    return res.jobInfo;
+                }
+                catch (err) {
+                    this.emit('error', err);
+                    throw err;
+                }
+            })();
+        }
+        return this._jobInfo;
+    }
+    /**
+     * Create a new batch instance in the job
+     */
+    createBatch() {
+        const batch = new Batch(this);
+        batch.on('queue', () => {
+            this._batches[batch.id] = batch;
+        });
+        return batch;
+    }
+    /**
+     * Get a batch instance specified by given batch ID
+     */
+    batch(batchId) {
+        let batch = this._batches[batchId];
+        if (!batch) {
+            batch = new Batch(this, batchId);
+            this._batches[batchId] = batch;
+        }
+        return batch;
+    }
+    /**
+     * Check the latest job status from server
+     */
+    check() {
+        const bulk = this._bulk;
+        const logger = bulk._logger;
+        this._jobInfo = (async () => {
+            const jobId = await this.ready();
+            const res = await bulk._request({
+                method: 'GET',
+                path: '/job/' + jobId,
+                responseType: 'application/xml',
+            });
+            logger.debug(res.jobInfo);
+            this.id = res.jobInfo.id;
+            this.type = res.jobInfo.object;
+            this.operation = res.jobInfo.operation;
+            this.state = res.jobInfo.state;
+            return res.jobInfo;
+        })();
+        return this._jobInfo;
+    }
+    /**
+     * Wait till the job is assigned to server
+     */
+    ready() {
+        return this.id
+            ? Promise.resolve(this.id)
+            : this.open().then(({ id }) => id);
+    }
+    /**
+     * List all registered batch info in job
+     */
+    async list() {
+        const bulk = this._bulk;
+        const logger = bulk._logger;
+        const jobId = await this.ready();
+        const res = await bulk._request({
+            method: 'GET',
+            path: '/job/' + jobId + '/batch',
+            responseType: 'application/xml',
+        });
+        logger.debug(res.batchInfoList.batchInfo);
+        const batchInfoList = Array.isArray(res.batchInfoList.batchInfo)
+            ? res.batchInfoList.batchInfo
+            : [res.batchInfoList.batchInfo];
+        return batchInfoList;
+    }
+    /**
+     * Close opened job
+     */
+    async close() {
+        if (!this.id) {
+            return;
+        }
+        try {
+            const jobInfo = await this._changeState('Closed');
+            this.id = null;
+            this.emit('close', jobInfo);
+            return jobInfo;
+        }
+        catch (err) {
+            this.emit('error', err);
+            throw err;
+        }
+    }
+    /**
+     * Set the status to abort
+     */
+    async abort() {
+        if (!this.id) {
+            return;
+        }
+        try {
+            const jobInfo = await this._changeState('Aborted');
+            this.id = null;
+            this.emit('abort', jobInfo);
+            return jobInfo;
+        }
+        catch (err) {
+            this.emit('error', err);
+            throw err;
+        }
+    }
+    /**
+     * @private
+     */
+    async _changeState(state) {
+        const bulk = this._bulk;
+        const logger = bulk._logger;
+        this._jobInfo = (async () => {
+            const jobId = await this.ready();
+            const body = ` 
+<?xml version="1.0" encoding="UTF-8"?>
+  <jobInfo xmlns="http://www.force.com/2009/06/asyncapi/dataload">
+  <state>${state}</state>
+</jobInfo>
+      `.trim();
+            const res = await bulk._request({
+                method: 'POST',
+                path: '/job/' + jobId,
+                body: body,
+                headers: {
+                    'Content-Type': 'application/xml; charset=utf-8',
+                },
+                responseType: 'application/xml',
+            });
+            logger.debug(res.jobInfo);
+            this.state = res.jobInfo.state;
+            return res.jobInfo;
+        })();
+        return this._jobInfo;
+    }
+}
+exports.Job = Job;
+/*--------------------------------------------*/
+class PollingTimeoutError extends Error {
+    jobId;
+    batchId;
+    /**
+     *
+     */
+    constructor(message, jobId, batchId) {
+        super(message);
+        this.name = 'PollingTimeout';
+        this.jobId = jobId;
+        this.batchId = batchId;
+    }
+}
+class JobPollingTimeoutError extends Error {
+    jobId;
+    /**
+     *
+     */
+    constructor(message, jobId) {
+        super(message);
+        this.name = 'JobPollingTimeout';
+        this.jobId = jobId;
+    }
+}
+/*--------------------------------------------*/
+/**
+ * Batch (extends Writable)
+ */
+class Batch extends stream_1.Writable {
+    job;
+    id;
+    _bulk;
+    _uploadStream;
+    _downloadStream;
+    _dataStream;
+    _result;
+    _error;
+    /**
+     *
+     */
+    constructor(job, id) {
+        super({ objectMode: true });
+        this.job = job;
+        this.id = id;
+        this._bulk = job._bulk;
+        // default error handler to keep the latest error
+        this.on('error', (error) => (this._error = error));
+        //
+        // setup data streams
+        //
+        const converterOptions = { nullValue: '#N/A' };
+        const uploadStream = (this._uploadStream = new record_stream_1.Serializable());
+        const uploadDataStream = uploadStream.stream('csv', converterOptions);
+        const downloadStream = (this._downloadStream = new record_stream_1.Parsable());
+        const downloadDataStream = downloadStream.stream('csv', converterOptions);
+        this.on('finish', () => uploadStream.end());
+        uploadDataStream.once('readable', async () => {
+            try {
+                // ensure the job is opened in server or job id is already assigned
+                await this.job.ready();
+                // pipe upload data to batch API request stream
+                uploadDataStream.pipe(this._createRequestStream());
+            }
+            catch (err) {
+                this.emit('error', err);
+            }
+        });
+        // duplex data stream, opened access to API programmers by Batch#stream()
+        this._dataStream = (0, stream_2.concatStreamsAsDuplex)(uploadDataStream, downloadDataStream);
+    }
+    /**
+     * Connect batch API and create stream instance of request/response
+     *
+     * @private
+     */
+    _createRequestStream() {
+        const bulk = this._bulk;
+        const logger = bulk._logger;
+        const req = bulk._request({
+            method: 'POST',
+            path: '/job/' + this.job.id + '/batch',
+            headers: {
+                'Content-Type': 'text/csv',
+            },
+            responseType: 'application/xml',
+        });
+        (async () => {
+            try {
+                const res = await req;
+                logger.debug(res.batchInfo);
+                this.id = res.batchInfo.id;
+                this.emit('queue', res.batchInfo);
+            }
+            catch (err) {
+                this.emit('error', err);
+            }
+        })();
+        return req.stream();
+    }
+    /**
+     * Implementation of Writable
+     */
+    _write(record_, enc, cb) {
+        const { Id, type, attributes, ...rrec } = record_;
+        let record;
+        switch (this.job.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 batch is already executed
+        if (this._result) {
+            throw new Error('Batch already executed.');
+        }
+        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 Batch instance for chaining
+        return this;
+    }
+    run = this.execute;
+    exec = this.execute;
+    /**
+     * Promise/A+ interface
+     * Delegate to promise, return promise instance for batch result
+     */
+    then(onResolved, onReject) {
+        if (!this._result) {
+            this.execute();
+        }
+        return this._result.then(onResolved, onReject);
+    }
+    /**
+     * Check the latest batch status in server
+     */
+    async check() {
+        const bulk = this._bulk;
+        const logger = bulk._logger;
+        const jobId = this.job.id;
+        const batchId = this.id;
+        if (!jobId || !batchId) {
+            throw new Error('Batch not started.');
+        }
+        const res = await bulk._request({
+            method: 'GET',
+            path: '/job/' + jobId + '/batch/' + batchId,
+            responseType: 'application/xml',
+        });
+        logger.debug(res.batchInfo);
+        return res.batchInfo;
+    }
+    /**
+     * Polling the batch result and retrieve
+     */
+    poll(interval, timeout) {
+        const jobId = this.job.id;
+        const batchId = this.id;
+        if (!jobId || !batchId) {
+            throw new Error('Batch not started.');
+        }
+        const startTime = new Date().getTime();
+        const poll = async () => {
+            const now = new Date().getTime();
+            if (startTime + timeout < now) {
+                const err = new PollingTimeoutError('Polling time out. Job Id = ' + jobId + ' , batch Id = ' + batchId, jobId, batchId);
+                this.emit('error', err);
+                return;
+            }
+            let res;
+            try {
+                res = await this.check();
+            }
+            catch (err) {
+                this.emit('error', err);
+                return;
+            }
+            if (res.state === 'Failed') {
+                if (parseInt(res.numberRecordsProcessed, 10) > 0) {
+                    this.retrieve();
+                }
+                else {
+                    this.emit('error', new Error(res.stateMessage));
+                }
+            }
+            else if (res.state === 'Completed') {
+                this.retrieve();
+            }
+            else {
+                this.emit('progress', res);
+                setTimeout(poll, interval);
+            }
+        };
+        setTimeout(poll, interval);
+    }
+    /**
+     * Retrieve batch result
+     */
+    async retrieve() {
+        const bulk = this._bulk;
+        const jobId = this.job.id;
+        const job = this.job;
+        const batchId = this.id;
+        if (!jobId || !batchId) {
+            throw new Error('Batch not started.');
+        }
+        try {
+            const resp = await bulk._request({
+                method: 'GET',
+                path: '/job/' + jobId + '/batch/' + batchId + '/result',
+            });
+            let results;
+            if (job.operation === 'query' || job.operation === 'queryAll') {
+                const res = resp;
+                const resultId = res['result-list'].result;
+                results = (Array.isArray(resultId)
+                    ? resultId
+                    : [resultId]).map((id) => ({ id, batchId, jobId }));
+            }
+            else {
+                const res = resp;
+                results = res.map((ret) => ({
+                    id: ret.Id || null,
+                    success: ret.Success === 'true',
+                    errors: ret.Error ? [ret.Error] : [],
+                }));
+            }
+            this.emit('response', results);
+            return results;
+        }
+        catch (err) {
+            this.emit('error', err);
+            throw err;
+        }
+    }
+    /**
+     * Fetch query result as a record stream
+     * @param {String} resultId - Result id
+     * @returns {RecordStream} - Record stream, convertible to CSV data stream
+     */
+    result(resultId) {
+        const jobId = this.job.id;
+        const batchId = this.id;
+        if (!jobId || !batchId) {
+            throw new Error('Batch not started.');
+        }
+        const resultStream = new record_stream_1.Parsable();
+        const resultDataStream = resultStream.stream('csv');
+        this._bulk
+            ._request({
+            method: 'GET',
+            path: '/job/' + jobId + '/batch/' + batchId + '/result/' + resultId,
+            responseType: 'application/octet-stream',
+        })
+            .stream()
+            .pipe(resultDataStream);
+        return resultStream;
+    }
+}
+exports.Batch = Batch;
+/*--------------------------------------------*/
+/**
+ *
+ */
+class BulkApi extends http_api_1.default {
+    beforeSend(request) {
+        request.headers = {
+            ...request.headers,
+            'X-SFDC-SESSION': this._conn.accessToken ?? '',
+        };
+    }
+    isSessionExpired(response) {
+        return (response.statusCode === 400 &&
+            /<exceptionCode>InvalidSessionId<\/exceptionCode>/.test(response.body));
+    }
+    hasErrorInResponseBody(body) {
+        return !!body.error;
+    }
+    parseError(body) {
+        return {
+            errorCode: body.error.exceptionCode,
+            message: body.error.exceptionMessage,
+        };
+    }
+}
+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
+ *
+ * @class
+ */
+class Bulk {
+    _conn;
+    _logger;
+    /**
+     * Polling interval in milliseconds
+     */
+    pollInterval = 1000;
+    /**
+     * Polling timeout in milliseconds
+     * @type {Number}
+     */
+    pollTimeout = 10000;
+    /**
+     *
+     */
+    constructor(conn) {
+        this._conn = conn;
+        this._logger = conn._logger;
+    }
+    /**
+     *
+     */
+    _request(request_) {
+        const conn = this._conn;
+        const { path, responseType, ...rreq } = request_;
+        const baseUrl = [conn.instanceUrl, 'services/async', conn.version].join('/');
+        const request = {
+            ...rreq,
+            url: baseUrl + path,
+        };
+        return new BulkApi(this._conn, { responseType }).request(request);
+    }
+    load(type, operation, optionsOrInput, input) {
+        let options = {};
+        if (typeof optionsOrInput === 'string' ||
+            Array.isArray(optionsOrInput) ||
+            ((0, function_1.isObject)(optionsOrInput) &&
+                'pipe' in optionsOrInput &&
+                typeof optionsOrInput.pipe === 'function')) {
+            // when options is not plain hash object, it is omitted
+            input = optionsOrInput;
+        }
+        else {
+            options = optionsOrInput;
+        }
+        const job = this.createJob(type, operation, options);
+        const batch = job.createBatch();
+        const cleanup = () => job.close();
+        const cleanupOnError = (err) => {
+            if (err.name !== 'PollingTimeout') {
+                cleanup();
+            }
+        };
+        batch.on('response', cleanup);
+        batch.on('error', cleanupOnError);
+        batch.on('queue', () => {
+            batch?.poll(this.pollInterval, this.pollTimeout);
+        });
+        return batch.execute(input);
+    }
+    /**
+     * Execute bulk query and get record stream
+     */
+    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.');
+        }
+        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);
+            }
+        })();
+        return recordStream;
+    }
+    /**
+     * Create a new job instance
+     */
+    createJob(type, operation, options = {}) {
+        return new Job(this, type, operation, options);
+    }
+    /**
+     * Get a job instance specified by given job ID
+     *
+     * @param {String} jobId - Job ID
+     * @returns {Bulk~Job}
+     */
+    job(jobId) {
+        return new Job(this, null, null, null, jobId);
+    }
+}
+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;