@heroku/salesforce-sdk-nodejs/dist/index.d.ts

Salesforce SDK for Heroku Apps.

import { QueryOperation } from "jsforce/lib/api/bulk";
import * as herokuIntegration from "./add-ons/heroku-integration.js";
import * as dataCloud from "./sdk/data-cloud-api.js";
export declare function init(): {
    addons: {
        herokuIntegration: typeof herokuIntegration;
    };
    dataCloud: typeof dataCloud;
    salesforce: {
        parseRequest: typeof parseRequest;
    };
};
export declare function parseRequest(headers: any, body: any, log: any): any;
export interface InvocationEvent<A> {
    readonly data: A;
    readonly dataContentType?: string;
    readonly id: string;
    readonly time?: string;
}
export interface Context {
    readonly id: string;
    readonly org?: Org;
}
export interface Org {
    readonly apiVersion: string;
    readonly dataApi: DataApi;
    readonly dataCloudApi?: DataCloudApi;
    readonly domainUrl: string;
    readonly id: string;
    readonly namespace: string;
    readonly user: User;
    request(fullUrlOrUrlPart: string, opts: any, json: boolean): any;
}
export interface RecordQueryResult {
    readonly done: boolean;
    readonly totalSize: number;
    readonly records: QueriedRecord[];
    readonly nextRecordsUrl?: string;
}
export type Record = {
    readonly type: string;
    readonly fields: {
        [key: string]: unknown;
    };
    readonly binaryFields?: {
        [key: string]: Buffer;
    };
};
export type QueriedRecord = Record & {
    readonly subQueryResults: {
        [sObjectName: string]: RecordQueryResult;
    };
};
export interface RecordModificationResult {
    readonly id: string;
}
export interface ReferenceId {
    toString(): string;
    toApiString(): string;
}
export type RecordForCreate = {
    type: string;
    fields: {
        [key: string]: unknown;
    };
    binaryFields?: {
        [key: string]: Buffer;
    };
};
export type RecordForUpdate = {
    type: string;
    fields: {
        id: string;
        [key: string]: unknown;
    };
    binaryFields?: {
        [key: string]: Buffer;
    };
};
export interface UnitOfWork {
    registerCreate(record: RecordForCreate): ReferenceId;
    registerUpdate(record: RecordForUpdate): ReferenceId;
    registerDelete(type: string, id: string): ReferenceId;
}
export interface DataApi {
    readonly accessToken: string;
    query(soql: string): Promise<RecordQueryResult>;
    queryMore(recordQueryResult: RecordQueryResult): Promise<RecordQueryResult>;
    create(record: RecordForCreate): Promise<RecordModificationResult>;
    update(update: RecordForUpdate): Promise<RecordModificationResult>;
    delete(type: string, id: string): Promise<RecordModificationResult>;
    newUnitOfWork(): UnitOfWork;
    commitUnitOfWork(unitOfWork: UnitOfWork): Promise<Map<ReferenceId, RecordModificationResult>>;
}
export interface User {
    readonly id: string;
    readonly username: string;
}
export interface Logger {
    error(message: string): void;
    warn(message: string): void;
    info(message: string): void;
    debug(message: string): void;
    trace(message: string): void;
}
export interface BulkApi {
    abort(jobReference: IngestJobReference | QueryJobReference): Promise<void>;
    createDataTableBuilder(columns: [string, ...string[]]): DataTableBuilder;
    delete(jobReference: IngestJobReference | QueryJobReference): Promise<void>;
    formatNullValue(): string;
    formatDate(value: Date): string;
    formatDateTime(value: Date): string;
    getFailedResults(jobReference: IngestJobReference): Promise<DataTable>;
    getInfo(jobReference: IngestJobReference | QueryJobReference): Promise<IngestJobInfo | QueryJobInfo>;
    getMoreQueryResults(queryJobResults: QueryJobResults, getQueryJobResultsOptions?: GetQueryJobResultsOptions): Promise<QueryJobResults>;
    getQueryResults(jobReference: QueryJobReference, getQueryJobResultsOptions?: GetQueryJobResultsOptions): Promise<QueryJobResults>;
    getSuccessfulResults(jobReference: IngestJobReference): Promise<DataTable>;
    getUnprocessedRecords(jobReference: IngestJobReference): Promise<DataTable>;
    ingest(ingestJobOptions: IngestJobOptions): Promise<Array<IngestJobReference | IngestJobFailure>>;
    query(options: QueryJobOptions): Promise<QueryJobReference>;
    splitDataTable(dataTable: DataTable): DataTable[];
}
export interface IngestJobOptions {
    dataTable: DataTable;
    object: string;
    operation: IngestJobOperation;
    externalIdFieldName?: string;
    assignmentRuleId?: string;
}
export interface QueryJobOptions {
    soql: string;
    operation?: QueryJobOperation;
}
export interface IngestJobReference {
    id: string;
    type: "ingestJob";
}
export interface QueryJobReference {
    id: string;
    type: "queryJob";
}
export interface GetQueryJobResultsOptions {
    maxRecords: number;
}
interface JobInfo {
    apexProcessingTime?: number;
    apiActiveProcessingTime?: number;
    apiVersion: number;
    columnDelimiter: "COMMA";
    concurrencyMode: "Parallel";
    contentType: "CSV";
    contentUrl?: string;
    createdById: string;
    createdDate: string;
    id: string;
    jobType: "V2Ingest" | "V2Query";
    lineEnding: "LF";
    object: string;
    operation: IngestJobOperation | QueryOperation;
    retries?: number;
    state: IngestJobState | QueryJobState;
    systemModstamp: string;
    totalProcessingTime?: number;
    assignmentRuleId?: string;
    externalIdFieldName?: string;
    numberRecordsFailed?: number;
    numberRecordsProcessed?: number;
}
export interface IngestJobInfo extends JobInfo {
    jobType: "V2Ingest";
    operation: IngestJobOperation;
    state: IngestJobState;
    assignmentRuleId?: string;
    externalIdFieldName?: string;
    numberRecordsFailed?: number;
    numberRecordsProcessed?: number;
}
export interface QueryJobInfo extends JobInfo {
    jobType: "V2Query";
    operation: QueryJobOperation;
    state: QueryJobState;
}
export type IngestJobState = "Open" | "UploadComplete" | "InProgress" | "Aborted" | "JobComplete" | "Failed";
export type QueryJobState = "UploadComplete" | "InProgress" | "Aborted" | "JobComplete" | "Failed";
export type IngestJobOperation = "insert" | "delete" | "hardDelete" | "update" | "upsert";
export type QueryJobOperation = "query" | "queryAll";
export interface QueryJobResults {
    readonly dataTable: DataTable;
    readonly done: boolean;
    readonly locator?: string;
    readonly numberOfRecords: number;
    readonly jobReference: QueryJobReference;
}
export interface DataTable extends Array<Map<string, string>> {
    columns: [string, ...string[]];
}
export type DataTableFieldValueExtractor<T> = (data: T, columnName: string) => string;
export interface DataTableBuilder {
    addRow(row: string[] | Map<string, string>): DataTableBuilder;
    addRow<T>(value: T, fieldValueExtractor: DataTableFieldValueExtractor<T>): any;
    addRows(rows: Array<string[] | Map<string, string>>): DataTableBuilder;
    addRows<T>(values: Array<T>, fieldValueExtractor: DataTableFieldValueExtractor<T>): DataTableBuilder;
    build(): DataTable;
}
export interface IngestJobFailure {
    error: BulkApiError;
    unprocessedRecords: DataTable;
    jobReference?: IngestJobReference;
}
export interface BulkApiError extends Error {
    errorCode: string;
}
export interface DataCloudActionEventSchema {
    schemaId: string;
    schema: string;
}
export interface DataObjectDataChgEvent {
    ActionDeveloperName: string;
    EventCreationDateTime: string;
    EventPrompt: string;
    EventPublishDateTime: string;
    EventSchemaVersion: string;
    EventType: string;
    EventUuid: string;
    Offset: string;
    PayloadCurrentValue: string;
    PayloadPrevValue: string;
    PayloadMetadata: string;
    ReplayId: string;
    SourceObjectDeveloperName: string;
}
export interface DataCloudActionEvent {
    creationDateTime: string;
    count: number;
    schemas: DataCloudActionEventSchema[];
    events: DataObjectDataChgEvent[];
}
export interface DataCloudQuery {
    sql: string;
}
export interface DataCloudQueryResponse {
    data: Array<any>;
    startTime: string;
    endTime: string;
    rowCount: number;
    queryId: string;
    nextBatchId: string;
    done: boolean;
    metadata: any;
}
export interface DataCloudUpsertResponse {
    accepted: boolean;
}
export interface DataCloudApi {
    query(sql: DataCloudQuery): Promise<DataCloudQueryResponse>;
    queryNextBatch(nextBatchId: string): Promise<DataCloudQueryResponse>;
    upsert(name: string, objectName: string, data: any): Promise<DataCloudUpsertResponse>;
}
export {};