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

package/lib/api/bulk.d.ts

@@ -9,45 +9,21 @@ import { EventEmitter } from 'events';
 import { Duplex, Readable, Writable } from 'stream';
 import Connection from '../connection';
 import { Serializable, Parsable } from '../record-stream';
-import { StreamPromise } from '../util/promise';
 import { Logger } from '../util/logger';
-import { HttpMethods, Record, Schema, Optional } from '../types';
+import { HttpMethods, Record, Schema } from '../types';
 export type BulkOperation = 'insert' | 'update' | 'upsert' | 'delete' | 'hardDelete' | 'query' | 'queryAll';
-export type IngestOperation = Exclude<BulkOperation, 'query' | 'queryAll'>;
-export type QueryOperation = Extract<BulkOperation, 'query' | 'queryAll'>;
 export type BulkOptions = {
     extIdField?: string;
     concurrencyMode?: 'Serial' | 'Parallel';
     assignmentRuleId?: string;
 };
 export type JobState = 'Open' | 'Closed' | 'Aborted' | 'Failed' | 'Unknown';
-export type JobStateV2 = Exclude<JobState, 'Closed' | 'Unknown'> | 'UploadComplete' | 'InProgress' | 'JobComplete';
 export type JobInfo = {
     id: string;
     object: string;
     operation: BulkOperation;
     state: JobState;
 };
-export type JobInfoV2 = {
-    apiVersion: string;
-    assignmentRuleId?: string;
-    columnDelimiter: 'BACKQUOTE' | 'CARET' | 'COMMA' | 'PIPE' | 'SEMICOLON' | 'TAB';
-    concurrencyMode: 'Parallel';
-    contentType: 'CSV';
-    contentUrl: string;
-    createdById: string;
-    createdDate: string;
-    externalIdFieldName?: string;
-    id: string;
-    jobType: 'BigObjectIngest' | 'Classic' | 'V2Ingest';
-    lineEnding: 'LF' | 'CRLF';
-    object: string;
-    operation: BulkOperation;
-    state: JobStateV2;
-    systemModstamp: string;
-    numberRecordsProcessed?: number;
-    numberRecordsFailed?: number;
-};
 export type BatchState = 'Queued' | 'InProgress' | 'Completed' | 'Failed' | 'NotProcessed';
 export type BatchInfo = {
     id: string;
@@ -69,46 +45,15 @@ export type BulkIngestBatchResult = Array<{
     errors: string[];
 }>;
 export type BatchResult<Opr extends BulkOperation> = Opr extends 'query' | 'queryAll' ? BulkQueryBatchResult : BulkIngestBatchResult;
-type BulkRequest = {
+export type BulkRequest = {
     method: HttpMethods;
-    path: string;
+    path?: string;
     body?: string;
     headers?: {
         [name: string]: string;
     };
     responseType?: string;
 };
-export type IngestJobV2SuccessfulResults<S extends Schema> = Array<{
-    sf__Created: 'true' | 'false';
-    sf__Id: string;
-} & S>;
-export type IngestJobV2FailedResults<S extends Schema> = Array<{
-    sf__Error: string;
-    sf__Id: string;
-} & S>;
-export type IngestJobV2UnprocessedRecords<S extends Schema> = Array<S>;
-export type IngestJobV2Results<S extends Schema> = {
-    successfulResults: IngestJobV2SuccessfulResults<S>;
-    failedResults: IngestJobV2FailedResults<S>;
-    unprocessedRecords: IngestJobV2UnprocessedRecords<S>;
-};
-type NewIngestJobOptions = Required<Pick<JobInfoV2, 'object' | 'operation'>> & Partial<Pick<JobInfoV2, 'assignmentRuleId' | 'externalIdFieldName' | 'lineEnding'>>;
-type ExistingIngestJobOptions = Pick<JobInfoV2, 'id'>;
-type CreateIngestJobV2Options<S extends Schema> = {
-    connection: Connection<S>;
-    jobInfo: NewIngestJobOptions | ExistingIngestJobOptions;
-    pollingOptions: BulkV2PollingOptions;
-};
-type CreateQueryJobV2Options<S extends Schema> = {
-    connection: Connection<S>;
-    operation: QueryOperation;
-    query: string;
-    pollingOptions: BulkV2PollingOptions;
-};
-type BulkV2PollingOptions = {
-    pollInterval: number;
-    pollTimeout: number;
-};
 /**
  * Class for Bulk API Job
  */
@@ -223,7 +168,8 @@ export declare class Batch<S extends Schema, Opr extends BulkOperation> extends
      */
     retrieve(): Promise<BulkQueryBatchResult | BulkIngestBatchResult>;
     /**
-     * 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
      */
@@ -235,15 +181,18 @@ export declare class Batch<S extends Schema, Opr extends BulkOperation> extends
  * @class
  */
 export declare class Bulk<S extends Schema> {
-    _conn: Connection<S>;
-    _logger: Logger;
+    private readonly _conn;
+    readonly _logger: Logger;
     /**
      * Polling interval in milliseconds
+     *
+     * Default: 1000 (1 second)
      */
     pollInterval: number;
     /**
      * Polling timeout in milliseconds
-     * @type {Number}
+     *
+     * Default: 30000 (30 seconds)
      */
     pollTimeout: number;
     /**
@@ -253,192 +202,52 @@ export declare class Bulk<S extends Schema> {
     /**
      *
      */
-    _request<T>(request_: BulkRequest): StreamPromise<T>;
+    _request<T>(request_: BulkRequest): import("../util/promise").StreamPromise<T>;
     /**
      * Create and start bulkload job and batch
-     */
-    load<Opr extends BulkOperation>(type: string, operation: Opr, input?: Record[] | Readable | string): Batch<S, Opr>;
-    load<Opr extends BulkOperation>(type: string, operation: Opr, optionsOrInput?: BulkOptions | Record[] | Readable | string, input?: Record[] | Readable | string): Batch<S, Opr>;
-    /**
-     * Execute bulk query and get record stream
-     */
-    query(soql: string): Parsable<Record>;
-    /**
-     * Create a new job instance
-     */
-    createJob<Opr extends BulkOperation>(type: string, operation: Opr, options?: BulkOptions): Job<S, Opr>;
-    /**
-     * Get a job instance specified by given job ID
-     *
-     * @param {String} jobId - Job ID
-     * @returns {Bulk~Job}
-     */
-    job<Opr extends BulkOperation>(jobId: string): Job<S, Opr>;
-}
-export declare class BulkV2<S extends Schema> {
-    #private;
-    /**
-     * Polling interval in milliseconds
-     */
-    pollInterval: number;
-    /**
-     * Polling timeout in milliseconds
-     * @type {Number}
-     */
-    pollTimeout: number;
-    constructor(connection: Connection<S>);
-    /**
-     * 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<Opr extends IngestOperation>(options: NewIngestJobOptions): IngestJobV2<S, Opr>;
-    /**
-     * 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<Opr extends IngestOperation>(options: ExistingIngestJobOptions): IngestJobV2<S, Opr>;
-    /**
-     * Create, upload, and start bulkload job
-     */
-    loadAndWaitForResults(options: NewIngestJobOptions & Partial<BulkV2PollingOptions> & {
-        input: Record[] | Readable | string;
-    }): Promise<IngestJobV2Results<S>>;
-    /**
-     * Execute bulk query and get records
+     * This method will return a Batch instance (writable stream)
+     * which you can write records into as a CSV string.
      *
-     * Default timeout: 10000ms
+     * Batch also implements the a promise interface so you can `await` this method to get the job results.
      *
-     * @param soql SOQL query
-     * @param BulkV2PollingOptions options object
+     * @example
+     * // Insert an array of records and get the job results
      *
-     * @returns Record[]
-     */
-    query(soql: string, options?: Partial<BulkV2PollingOptions> & {
-        scanAll?: boolean;
-    }): Promise<Record[]>;
-}
-export declare class QueryJobV2<S extends Schema> extends EventEmitter {
-    #private;
-    jobInfo: Partial<JobInfoV2> | undefined;
-    locator: Optional<string>;
-    finished: boolean;
-    constructor(options: CreateQueryJobV2Options<S>);
-    /**
-     * Creates a query job
-     */
-    open(): Promise<void>;
-    /**
-     * Set the status to abort
-     */
-    abort(): Promise<void>;
-    /**
-     * Poll for the state of the processing for the job.
+     * const res = await connection.bulk.load('Account', 'insert', accounts)
      *
-     * 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:
+     * @example
+     * // Insert records from a csv file using the returned batch stream
      *
-     * job.on('failed', (err) => console.error(err))
-     * await job.poll()
+     * const csvFile = fs.createReadStream('accounts.csv')
      *
-     * @param interval Polling interval in milliseconds
-     * @param timeout Polling timeout in milliseconds
-     * @returns {Promise<Record[]>} A promise that resolves to an array of records
-     */
-    poll(interval?: number, timeout?: number): Promise<void>;
-    /**
-     * Check the latest batch status in server
-     */
-    check(): Promise<JobInfoV2>;
-    private request;
-    private getResultsUrl;
-    /**
-     * Get the results for a query job.
+     * const batch = conn.bulk.load('Account', 'insert')
      *
-     * @returns {Promise<Record[]>} A promise that resolves to an array of records
-     */
-    getResults(): Promise<Record[]>;
-    /**
-     * Deletes a query job.
-     */
-    delete(): Promise<void>;
-    private createQueryRequest;
-}
-/**
- * Class for Bulk API V2 Ingest Job
- */
-export declare class IngestJobV2<S extends Schema, Opr extends IngestOperation> extends EventEmitter {
-    #private;
-    jobInfo: Partial<JobInfoV2>;
-    /**
+     * // The `response` event is emitted when the job results are retrieved
+     * batch.on('response', res => {
+     *   console.log(res)
+     * })
+  
+     * csvFile.pipe(batch.stream())
      *
-     */
-    constructor(options: CreateIngestJobV2Options<S>);
-    get id(): string | undefined;
-    /**
-     * Create a job representing a bulk operation in the org
-     */
-    open(): Promise<void>;
-    /** Upload data for a job in CSV format
      *
-     *  @param input CSV as a string, or array of records or readable stream
      */
-    uploadData(input: string | Record[] | Readable): Promise<void>;
-    getAllResults(): Promise<IngestJobV2Results<S>>;
+    load<Opr extends BulkOperation>(type: string, operation: Opr, input?: Record[] | Readable | string): Batch<S, Opr>;
+    load<Opr extends BulkOperation>(type: string, operation: Opr, optionsOrInput?: BulkOptions | Record[] | Readable | string, input?: Record[] | Readable | string): Batch<S, Opr>;
     /**
-     * Close opened job
+     * Execute bulk query and get record stream
      */
-    close(): Promise<void>;
+    query(soql: string): Promise<Parsable<Record>>;
     /**
-     * Set the status to abort
+     * Create a new job instance
      */
-    abort(): Promise<void>;
+    createJob<Opr extends BulkOperation>(type: string, operation: Opr, options?: BulkOptions): Job<S, Opr>;
     /**
-     * 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()
+     * Get a job instance specified by given job ID
      *
-     * @param interval Polling interval in milliseconds
-     * @param timeout Polling timeout in milliseconds
-     * @returns {Promise<void>} A promise that resolves when the job finishes successfully
-     */
-    poll(interval?: number, timeout?: number): Promise<void>;
-    /**
-     * Check the latest batch status in server
-     */
-    check(): Promise<JobInfoV2>;
-    getSuccessfulResults(): Promise<IngestJobV2SuccessfulResults<S>>;
-    getFailedResults(): Promise<IngestJobV2FailedResults<S>>;
-    getUnprocessedRecords(): Promise<IngestJobV2UnprocessedRecords<S>>;
-    /**
-     * Deletes an ingest job.
+     * @param {String} jobId - Job ID
+     * @returns {Bulk~Job}
      */
-    delete(): Promise<void>;
-    private createIngestRequest;
+    job<Opr extends BulkOperation>(jobId: string): Job<S, Opr>;
 }
 export default Bulk;