@heroku/applink 1.0.0-ea

package/CHANGELOG.md

@@ -0,0 +1,16 @@
+# Changelog
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+
+## [0.1.0-ea] - 2024-08-12
+
+- Initial
+
+## [1.0.0-ea] - 2025-6-05
+- Update CODEOWNERS
+- Updated `getAuthorization` to use the correct API URL.
+- Rename `getConnection(name: string)` -> `getAuthorization(developerName: string, attachmentNameOrColorUrl = "HEROKU_APPLINK")`, accepting a new attachmentNameOrColorOrUrl to use a specific Applink addon's config.
+- Remove node-fetch in favor of native fetch, add `HTTPResponseError`

package/LICENSE

@@ -0,0 +1,29 @@
+BSD 3-Clause License
+
+Copyright (c) 2024, Salesforce.com, Inc.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice, this
+list of conditions and the following disclaimer in the documentation and/or other
+materials provided with the distribution.
+
+3. Neither the name of Salesforce.com nor the names of its contributors may be used
+to endorse or promote products derived from this software without specific prior
+written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

package/README.md

@@ -0,0 +1,62 @@
+# Node.js SDK for Heroku AppLink
+
+Use the Node.js SDK for Heroku AppLink to develop [Heroku AppLink](https://devcenter.heroku.com/articles/applink) managed apps that interact with Salesforce and Data Cloud orgs.
+
+ Node.js SDK for Heroku AppLink provides:
+- Utilities to parse requests from Salesforce Heroku-type [External Services](https://help.salesforce.com/s/articleView?id=sf.external_services.htm&type=5) and Data Cloud [Data Action Targets](https://help.salesforce.com/s/articleView?id=sf.c360_a_create_a_data_action_target_of_webhook_type.htm&type=5) 
+hydrating SDK objects that response the request: [InvocationEvent](docs/interfaces/InvocationEvent.md) and [Context](docs/interfaces/Context.md).
+- Objects that encapsulate the requesting Salesforce or Data Cloud [Org](docs/interfaces/Org.md) and [User](docs/interfaces/User.md).
+- Utility objects that wrap Salesforce and Data Cloud APIs to perform simple CRUD operations and complex record manipulations. 
+
+And much more!
+
+## Documentation
+For more information, see [API docs](docs/README.md).
+
+## Example
+Example use of the Node.js SDK for Heroku AppLink provided as part of the [Heroku AppLink CLI Plugin's](https://github.com/heroku/heroku-cli-plugin-applnk) `applink:project` template:  
+```javascript
+fastify.get('/accounts', async function (request, reply) {
+    const {event, context, logger} = request.sdk;
+
+    logger.info(`GET /accounts: ${JSON.stringify(event.data || {})}`);
+
+    const query = 'SELECT Id, Name FROM Account';
+
+    if (process.env.SALESFORCE_ORG_NAME) {
+        // If an org reference is set, query Accounts in that org
+        const orgName = process.env.SALESFORCE_ORG_NAME;
+        const applinkAddon = request.sdk.addons.applink;
+
+        logger.info(`Getting org '${orgName}' connection from Heroku Applink add-on...`);
+        const anotherOrg = await applinkAddon.getAuthorization(orgName);
+
+        logger.info(`Querying org '${orgName}' (${anotherOrg.id}) Accounts...`);
+        try {
+            const result = await anotherOrg.dataApi.query(query);
+            const accounts = result.records.map(rec => rec.fields);
+            logger.info(`For org '${orgName}' (${anotherOrg.id}), found ${accounts.length} Accounts`);
+        } catch (err) {
+            logger.error(err.message);
+        }
+    }
+
+    // Query invoking org's Accounts
+    const org = context.org;
+    logger.info(`Querying invoking org (${org.id}) Accounts...`);
+    const result = await org.dataApi.query(query);
+    const accounts = result.records.map(rec => rec.fields);
+    logger.info(`For invoking org (${org.id}), found the following Accounts: ${JSON.stringify(accounts || {})}`);
+    return accounts;
+});
+```
+
+## Configuration
+* `HEROKU_APPLINK_ADDON_NAME` - For development, configures the SDK to use a different addon name in place of "HEROKU_APPLINK". Used when fetching config vars.
+
+## Testing
+### Dependency
+You will need java installed to run wiremock.
+
+### Running tests
+To test with coverage run `yarn test:coverage`

package/SECURITY.md

@@ -0,0 +1,7 @@
+## Security
+
+Please report any security issue to [security@salesforce.com](mailto:security@salesforce.com)
+as soon as it is discovered. This library limits its runtime dependencies in
+order to reduce the total cost of ownership as much as can be, but all consumers
+should remain vigilant and have their security stakeholders review all third-party
+products (3PP) like this one and their dependencies.

package/TERMS_OF_USE.md

@@ -0,0 +1,24 @@
+Copyright 2024 [salesforce.com](https://app.salesforceiq.com/r?target=5aa041084cedfd007a609a0c&t=AFwhZf0GOvrkITUEGk_9Frn8rtTOQ_JcR3V1bPtHyKCQMx9cWuf92b6O6w9dz1LpYaK8lPgjNZvweaqC9W9fv2K3zv4BJWd_VftkdaL13QYpqzPyITBhy9poAZwbKc3bge5ItzFU2Lwc), inc. All rights reserved.
+
+These Terms of Use are between **You** (being the Customer that purchased the Services) and [salesforce.com](salesforce.com), inc. or its Affiliate (“**SFDC**”) that entered into an agreement with You that governs Your purchase of the Services (the “**Agreement**”). Capitalized terms not defined herein shall have the meaning defined in the Agreement.
+
+These Terms of Use were last updated on October 1, 2024, and constitute a legally binding agreement between You and SFDC effective upon Your first download, installation or use of the Software Development Kit (SDK), whichever is earliest. If You do not have authority to bind the Customer that entered into the Agreement or You do not agree to these Terms of Use, do not install or use the SDK.
+
+SFDC grants You a limited non-exclusive, non­transferable, non-sublicensable, revocable license to use the Services in a manner consistent with the Documentation, and subject to the terms of the Agreement.
+
+Use, modification, reproduction, and distribution of components of the SDK are licensed under an open source software license and are governed by the terms of that open source software license and not the Agreement. Some of the software required by or included in the SDK may be offered under other open source licenses. Open source licenses constitute separate written agreements.
+
+Subject to the limited rights expressly granted hereunder, SFDC reserves all rights, title and interest in and to all intellectual property subsisting in the SDK as provided to You. No rights are granted to You hereunder other than as expressly set forth herein. Users residing in countries on the United States Office of Foreign Assets Control sanction list, or which are otherwise subject to a US export embargo, may not use the SDK.
+
+The SDK is not part of the Services. Implementation of the SDK may require development work for which You are responsible. The SDK may contain bugs, errors and incompatibilities with Your configuration of the Services and is made available on an AS IS basis without support, updates, or service level commitments.
+
+SFDC reserves the right at any time to modify, suspend or discontinue, the SDK (or any part thereof) with or without notice. You agree that SFDC shall not be liable to You or to any third party for any modification, suspension or discontinuance.
+
+You agree to defend SFDC against any claim, demand, suit or proceeding made or brought against SFDC by a third party arising out of or accruing from (a) your use of the SDK, (b) any application you develop on the SDK that infringes any copyright, trademark, trade secret, trade dress, patent or other intellectual property right of any person or defames any person or violates their rights of publicity or privacy, and (c) any non-compliance by you with the Agreement, each to the extent allowable by applicable law (each a “Claim Against SFDC”), and will indemnify SFDC from any damages, attorney fees and costs finally awarded against SFDC as a result of, or for any amounts paid by SFDC under a settlement approved by You in writing of, a Claim Against SFDC, provided SFDC (a) promptly gives You written notice of the Claim Against SFDC, (b) gives You sole control of the defense and settlement of the Claim Against SFDC (except that You may not settle any Claim Against SFDC unless it unconditionally releases SFDC of all liability), and (c) gives You all reasonable assistance, at Your expense.
+
+WITHOUT LIMITING THE GENERALITY OF THE FOREGOING, THE SDK IS NOT SUPPORTED, AND IS PROVIDED "AS IS," WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED. IN NO EVENT SHALL SFDC HAVE ANY LIABILITY FOR ANY DAMAGES, INCLUDING BUT NOT LIMITED TO, DIRECT, INDIRECT, SPECIAL, INCIDENTAL, PUNITIVE, OR CONSEQUENTIAL DAMAGES, OR DAMAGES BASED ON LOST PROFITS, DATA OR USE, IN CONNECTION WITH THE SDK, HOWEVER CAUSED AND WHETHER IN CONTRACT, TORT OR UNDER ANY OTHER THEORY OF LIABILITY, WHETHER OR NOT YOU HAVE BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+
+These Terms of Use shall be governed exclusively by the internal laws of the State of California, without regard to its conflicts of laws rules. Each party hereby consents to the exclusive jurisdiction of the state and federal courts located in San Francisco County, California to adjudicate any dispute arising out of or relating to these Terms of Use. Except as expressly stated in these Terms of Use, these Terms of Use constitute the entire agreement between the parties, and supersede all prior and contemporaneous agreements, proposals or representations, written or oral, concerning their subject matter. No modification, amendment, or waiver of any provision of these Terms of Use shall be effective unless it is by an update to these Terms of Use that SFDC makes available on this website, or is in writing and signed by the party against whom the modification, amendment or waiver is to be asserted.
+
+#### Data Privacy:
+SFDC may collect, process and store device, system, and other information related to Your use of the SDK. This includes, but is not limited to, IP address, user metrics, and other data (“**Usage Data**”). SFDC may use Usage Data for analytics, product development and marketing purposes. You acknowledge that files generated in conjunction with the SDK may contain sensitive or confidential data, and You are solely responsible for anonymizing and protecting such data.

package/dist/add-ons/heroku-applink.d.ts

@@ -0,0 +1,2 @@
+import { Org } from "../index";
+export declare function getAuthorization(developerName: string, attachmentNameOrColorOrUrl?: string): Promise<Org>;

package/dist/add-ons/heroku-applink.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAuthorization = getAuthorization;
+const request_1 = require("../utils/request");
+const org_1 = require("../sdk/org");
+const addon_config_1 = require("../utils/addon-config");
+const HTTP_REQUEST = new request_1.HttpRequestUtil();
+async function getAuthorization(developerName, attachmentNameOrColorOrUrl = process.env.HEROKU_APPLINK_ADDON_NAME ||
+    "HEROKU_APPLINK") {
+    if (!developerName) {
+        throw Error(`Developer name not provided`);
+    }
+    let resolveConfigByUrl = false;
+    try {
+        new URL(attachmentNameOrColorOrUrl);
+        resolveConfigByUrl = true;
+    }
+    catch {
+        resolveConfigByUrl = false;
+    }
+    const config = resolveConfigByUrl
+        ? (0, addon_config_1.resolveAddonConfigByUrl)(attachmentNameOrColorOrUrl)
+        : (0, addon_config_1.resolveAddonConfigByAttachmentOrColor)(attachmentNameOrColorOrUrl);
+    const authUrl = `${config.apiUrl}/authorizations/${developerName}`;
+    const opts = {
+        method: "GET",
+        headers: {
+            Authorization: `Bearer ${config.token}`,
+            "Content-Type": "application/json",
+        },
+        retry: {
+            limit: 1,
+        },
+    };
+    let response;
+    try {
+        response = await HTTP_REQUEST.request(authUrl, opts);
+    }
+    catch (err) {
+        if (err instanceof request_1.HTTPResponseError) {
+            let errorResponse;
+            try {
+                errorResponse = await err.response.json();
+            }
+            catch (jsonError) {
+            }
+            if (errorResponse?.title && errorResponse?.detail) {
+                throw new Error(`${errorResponse.title} - ${errorResponse.detail}`);
+            }
+        }
+        throw new Error(`Unable to get connection ${developerName}: ${err.message}`);
+    }
+    return new org_1.OrgImpl(response.org.user_auth.access_token, response.org.api_version, null, response.org.id, response.org.instance_url, response.org.user_auth.user_id, response.org.user_auth.username, response.org.type);
+}

package/dist/index.d.ts

@@ -0,0 +1,268 @@
+import { QueryOperation } from "jsforce/lib/api/bulk";
+import { getAuthorization } from "./add-ons/heroku-applink.js";
+import { HTTPResponseError } from "./utils/request.js";
+export declare function init(): {
+    addons: {
+        applink: {
+            getAuthorization: typeof getAuthorization;
+        };
+    };
+    dataCloud: {
+        parseDataActionEvent: typeof parseDataActionEvent;
+    };
+    salesforce: {
+        parseRequest: typeof parseRequest;
+    };
+};
+export declare function parseRequest(headers: any, body: any, log: any): {
+    event: InvocationEvent<any>;
+    context: Context;
+    logger: Logger;
+};
+export declare function parseDataActionEvent(payload: any): DataCloudActionEvent;
+export { HTTPResponseError };
+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>;
+}

package/dist/index.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HTTPResponseError = void 0;
+exports.init = init;
+exports.parseRequest = parseRequest;
+exports.parseDataActionEvent = parseDataActionEvent;
+const context_js_1 = require("./sdk/context.js");
+const invocation_event_js_1 = require("./sdk/invocation-event.js");
+const logger_js_1 = require("./sdk/logger.js");
+const heroku_applink_js_1 = require("./add-ons/heroku-applink.js");
+const request_js_1 = require("./utils/request.js");
+Object.defineProperty(exports, "HTTPResponseError", { enumerable: true, get: function () { return request_js_1.HTTPResponseError; } });
+const CONTENT_TYPE_HEADER = "Content-Type";
+const X_CLIENT_CONTEXT_HEADER = "x-client-context";
+function init() {
+    return {
+        addons: {
+            applink: {
+                getAuthorization: heroku_applink_js_1.getAuthorization,
+            },
+        },
+        dataCloud: {
+            parseDataActionEvent,
+        },
+        salesforce: {
+            parseRequest,
+        },
+    };
+}
+function parseRequest(headers, body, log) {
+    if (!headers) {
+        throw Error(`Request headers not provided`);
+    }
+    const encodedClientContext = headers[X_CLIENT_CONTEXT_HEADER];
+    if (!encodedClientContext) {
+        throw Error(`Required ${X_CLIENT_CONTEXT_HEADER} header not found`);
+    }
+    const clientContext = JSON.parse(Buffer.from(encodedClientContext, "base64").toString("utf8"));
+    if (!clientContext.userContext) {
+        throw Error(`Required UserContext not found on ${X_CLIENT_CONTEXT_HEADER}`);
+    }
+    const context = new context_js_1.ContextImpl(clientContext.accessToken, clientContext.apiVersion, clientContext.requestId, clientContext.namespace, clientContext.orgId, clientContext.orgDomainUrl, clientContext.userContext.userId, clientContext.userContext.username, "SalesforceOrg");
+    const invocationEvent = new invocation_event_js_1.InvocationEventImpl(body || "", headers[CONTENT_TYPE_HEADER] || "application/json", context.id, new Date().getTime() + "");
+    return {
+        event: invocationEvent,
+        context,
+        logger: log || new logger_js_1.LoggerImpl(context.id),
+    };
+}
+function parseDataActionEvent(payload) {
+    return payload;
+}

package/dist/sdk/bulk-api.d.ts

@@ -0,0 +1,3 @@
+import { BulkApi } from "../index";
+import { CreateConnectionOptions } from "../utils/create-connections";
+export declare function createBulkApi(clientOptions: CreateConnectionOptions): BulkApi;