@keystrokehq/salesforce 0.0.1

package/README.md

@@ -0,0 +1,205 @@
+# @keystrokehq/salesforce
+
+Salesforce CRM and platform integration for Keystroke workflows.
+
+## Overview
+
+This package provides:
+
+- Explicit support surfaces for `connection`, `client`, `schemas`, `triggers`, and CRM domain modules
+- CRUD-backed Salesforce record operations for accounts, contacts, leads, opportunities, cases, tasks, campaigns, campaign members, opportunity line items, and notes
+- Focused Salesforce helpers for contact-account associations, ownership transfer, current-user identity, SOQL pagination, reports, and dashboards
+- Direct-binding polling triggers for common Salesforce record activity with stable `eventType` payloads
+- A thin JSforce client wrapper for resolved OAuth credentials
+
+The package root is intentionally non-canonical. Import from explicit subpaths instead of `@keystrokehq/salesforce`.
+
+## Installation
+
+```bash
+pnpm add @keystrokehq/salesforce
+```
+
+## Credentials
+
+The public Salesforce connection exposes two OAuth credentials to workflow authors:
+
+- `SALESFORCE_ACCESS_TOKEN`
+- `SALESFORCE_INSTANCE_URL`
+
+```ts
+import { salesforce } from '@keystrokehq/salesforce/connection';
+```
+
+The internal Salesforce Connected App credential set stores `clientId` and `clientSecret` separately from the public runtime auth contract.
+
+For sandbox tenants, the provider app metadata can set either:
+
+- `environment: "sandbox"`
+- `loginBaseUrl: "https://test.salesforce.com"`
+
+## Operations
+
+Operations are regular Keystroke steps, so call them with `.run(...)` inside workflow code.
+
+```ts
+import { Workflow } from '@keystrokehq/core';
+import { z } from 'zod';
+import { getAccount } from '@keystrokehq/salesforce/accounts';
+import { associateContactToAccount } from '@keystrokehq/salesforce/associations';
+import { createLead } from '@keystrokehq/salesforce/leads';
+import { queryMore, runSoqlQuery } from '@keystrokehq/salesforce/soql';
+
+export const salesforceFollowUpWorkflow = new Workflow({
+  id: 'salesforce-follow-up',
+  name: 'Salesforce Follow Up',
+  input: z.object({ accountId: z.string() }),
+  output: z.object({ success: z.boolean() }),
+  run: async (input) => {
+    const account = await getAccount.run({
+      id: input.accountId,
+      fields: ['Id', 'Name', 'Industry', 'LastModifiedDate'],
+    });
+
+    await createLead.run({
+      fields: {
+        FirstName: 'Avery',
+        LastName: 'Stone',
+        Company: account.Name ?? 'Unknown',
+        Status: 'Open - Not Contacted',
+      },
+      returnFields: ['Id', 'FirstName', 'LastName', 'Company', 'Status'],
+    });
+
+    const recentContacts = await runSoqlQuery.run({
+      query:
+        "SELECT Id, FirstName, LastName, Email FROM Contact WHERE AccountId != NULL ORDER BY LastModifiedDate DESC LIMIT 10",
+    });
+
+    if (recentContacts.records[0]?.Id) {
+      await associateContactToAccount.run({
+        contactId: recentContacts.records[0].Id,
+        accountId: input.accountId,
+      });
+    }
+
+    if (recentContacts.nextRecordsUrl) {
+      await queryMore.run({ nextRecordsUrl: recentContacts.nextRecordsUrl });
+    }
+
+    return { success: recentContacts.records.length >= 0 };
+  },
+});
+```
+
+Additional helpers are available from:
+
+- `@keystrokehq/salesforce/associations`
+- `@keystrokehq/salesforce/campaign-members`
+- `@keystrokehq/salesforce/opportunity-line-items`
+- `@keystrokehq/salesforce/ownership`
+- `@keystrokehq/salesforce/users`
+
+## Triggers
+
+Salesforce trigger helpers are direct-binding only. Call the helper once with optional `name`, `description`, `schedule`, `filter`, or `transform` fields and use the returned bound trigger in your workflow.
+
+Every mapped trigger payload includes:
+
+- `eventType`: a stable event identifier such as `lead.created` or `task.completed`
+- `objectName`: the Salesforce object being polled
+- `records`: normalized Salesforce records
+- `taskEventType`: present for task triggers so created vs. completed is explicit in filters and transforms
+
+```ts
+import { polling } from '@keystrokehq/salesforce/triggers';
+
+const newLeadTrigger = polling.newLead({
+  name: 'Salesforce New Lead',
+  schedule: '*/10 * * * *',
+  transform: (payload) => ({
+    eventType: payload.eventType,
+    leadIds: payload.records
+      .map((record) => (typeof record.Id === 'string' ? record.Id : undefined))
+      .filter((value): value is string => value !== undefined),
+    count: payload.records.length,
+  }),
+});
+
+const opportunityTrigger = polling.opportunityCreatedOrUpdated({
+  stages: ['Prospecting', 'Closed Won'],
+  schedule: '15m',
+});
+
+void newLeadTrigger;
+void opportunityTrigger;
+```
+
+Use `polling.sObjectRecordUpdated(...)` when you need a generic object poller with custom `fields`, `watermarkField`, and `where` filters.
+
+## Analytics
+
+Analytics helpers expose low-risk report and dashboard endpoints:
+
+- `listReports`, `listReportTypes`, `getReportMetadata`, `runReport`
+- `listDashboards`, `getDashboard`, `refreshDashboard`
+
+The `refreshDashboard` operation is marked `needsApproval: true` because it triggers a dashboard refresh job.
+
+## Testing
+
+This package now uses the repo’s two-project Vitest layout:
+
+- `pnpm test:unit` for deterministic unit tests
+- `pnpm test:int` for deterministic integration tests and env-gated live Salesforce smoke tests
+
+The package coverage inventory lives in `TEST_MATRIX.md`.
+
+Deterministic integration coverage does not require live Salesforce credentials. It uses package-local `*.int.test.ts` files to exercise:
+
+- every exported operation in `src/operations.ts`
+- trigger polling behavior with realistic mapped payloads
+- client error normalization and auth failure handling
+- schema and shared query/mutation helpers
+
+Live Salesforce tests are opt-in and stay skipped unless all required env values exist in `.env.test`:
+
+- `RUN_LIVE_INT="true"`
+- `SALESFORCE_ACCESS_TOKEN`
+- `SALESFORCE_INSTANCE_URL`
+
+Optional live analytics and line-item smoke tests also use:
+
+- `SALESFORCE_TEST_REPORT_ID`
+- `SALESFORCE_TEST_DASHBOARD_ID`
+- `SALESFORCE_TEST_PRICEBOOK_ENTRY_ID`
+
+Use a Salesforce sandbox or scratch org only.
+
+## High-Risk Follow-Ups
+
+The initial package intentionally leaves a few Salesforce-specific behaviors as separately scoped follow-up work. See `HIGH_RISK_BEHAVIORS.md` for the current decision notes around assignment rules, cloning, outbound email, and richer trigger semantics.
+
+## Canonical Imports
+
+- `@keystrokehq/salesforce/connection`
+- `@keystrokehq/salesforce/client`
+- `@keystrokehq/salesforce/schemas`
+- `@keystrokehq/salesforce/triggers`
+- `@keystrokehq/salesforce/accounts`
+- `@keystrokehq/salesforce/associations`
+- `@keystrokehq/salesforce/campaign-members`
+- `@keystrokehq/salesforce/contacts`
+- `@keystrokehq/salesforce/leads`
+- `@keystrokehq/salesforce/opportunities`
+- `@keystrokehq/salesforce/opportunity-line-items`
+- `@keystrokehq/salesforce/ownership`
+- `@keystrokehq/salesforce/cases`
+- `@keystrokehq/salesforce/tasks`
+- `@keystrokehq/salesforce/campaigns`
+- `@keystrokehq/salesforce/notes`
+- `@keystrokehq/salesforce/users`
+- `@keystrokehq/salesforce/soql`
+- `@keystrokehq/salesforce/objects`
+- `@keystrokehq/salesforce/reports`
+- `@keystrokehq/salesforce/dashboards`

package/dist/_official/index.d.mts

@@ -0,0 +1,42 @@
+import { i as salesforceOfficialIntegration, r as salesforceBundle } from "../integration-CGYEE2Ge.mjs";
+import { z } from "zod";
+import { CredentialSet } from "@keystrokehq/core";
+import * as _keystrokehq_core_credential_set0 from "@keystrokehq/core/credential-set";
+import { InferCredentialSetAuth } from "@keystrokehq/core/credential-set";
+
+//#region src/_official/provider-app.d.ts
+declare const salesforceAppCredentialSet: CredentialSet<"salesforce-app", z.ZodObject<{
+  clientId: z.ZodString;
+  clientSecret: z.ZodString;
+}, z.core.$strip>, readonly _keystrokehq_core_credential_set0.CredentialConnection<z.ZodObject<{
+  clientId: z.ZodString;
+  clientSecret: z.ZodString;
+}, z.core.$strip>>[] | undefined>;
+declare const salesforcePlatformProviderSeed: {
+  readonly provider: "salesforce";
+  readonly appRef: "salesforce-platform";
+  readonly displayName: "Salesforce Platform";
+  readonly credentialSetName: "Keystroke Salesforce Platform App";
+  readonly envShape: {
+    readonly KEYSTROKE_PLATFORM_SALESFORCE_CLIENT_ID: z.ZodOptional<z.ZodString>;
+    readonly KEYSTROKE_PLATFORM_SALESFORCE_CLIENT_SECRET: z.ZodOptional<z.ZodString>;
+    readonly KEYSTROKE_PLATFORM_SALESFORCE_ENVIRONMENT: z.ZodOptional<z.ZodEnum<{
+      production: "production";
+      sandbox: "sandbox";
+    }>>;
+    readonly KEYSTROKE_PLATFORM_SALESFORCE_LOGIN_BASE_URL: z.ZodOptional<z.ZodString>;
+  };
+  readonly requiredEnvKeys: readonly ["KEYSTROKE_PLATFORM_SALESFORCE_CLIENT_ID", "KEYSTROKE_PLATFORM_SALESFORCE_CLIENT_SECRET"];
+  readonly externalAppIdEnvKey: "KEYSTROKE_PLATFORM_SALESFORCE_CLIENT_ID";
+  readonly buildCredentials: (env: Record<string, string | undefined>) => {
+    clientId: string | undefined;
+    clientSecret: string | undefined;
+  };
+  readonly buildMetadata: (env: Record<string, string | undefined>) => {
+    loginBaseUrl?: string | undefined;
+    environment?: string | undefined;
+  } | undefined;
+};
+type SalesforceAppCredentials = InferCredentialSetAuth<typeof salesforceAppCredentialSet>;
+//#endregion
+export { SalesforceAppCredentials, salesforceAppCredentialSet, salesforceBundle, salesforceOfficialIntegration, salesforcePlatformProviderSeed };

package/dist/_official/index.mjs

@@ -0,0 +1,3 @@
+import { a as salesforcePlatformProviderSeed, i as salesforceAppCredentialSet, n as salesforceBundle, r as salesforceOfficialIntegration } from "../integration-C_hbWu9t.mjs";
+
+export { salesforceAppCredentialSet, salesforceBundle, salesforceOfficialIntegration, salesforcePlatformProviderSeed };

package/dist/_runtime/index.d.mts

@@ -0,0 +1,6 @@
+import { AnyOperation } from "@keystrokehq/core/operation";
+
+//#region src/operations.d.ts
+declare const salesforceOperations: Readonly<Record<string, AnyOperation>>;
+//#endregion
+export { salesforceOperations };

package/dist/_runtime/index.mjs

@@ -0,0 +1,89 @@
+import { createAccount, deleteAccount, getAccount, listAccounts, updateAccount } from "../accounts.mjs";
+import { associateContactToAccount, dissociateContactFromAccount } from "../associations.mjs";
+import { createCampaignMember, deleteCampaignMember, getCampaignMember, listCampaignMembers, updateCampaignMember } from "../campaign-members.mjs";
+import { createCampaign, deleteCampaign, getCampaign, listCampaigns, updateCampaign } from "../campaigns.mjs";
+import { createCase, deleteCase, getCase, listCases, updateCase } from "../cases.mjs";
+import { createContact, deleteContact, getContact, listContacts, updateContact } from "../contacts.mjs";
+import { getDashboard, listDashboards, refreshDashboard } from "../dashboards.mjs";
+import { createLead, deleteLead, getLead, listLeads, updateLead } from "../leads.mjs";
+import { createNote, deleteNote, getNote, listNotes, updateNote } from "../notes.mjs";
+import { describeObject, listObjects } from "../objects.mjs";
+import { createOpportunity, deleteOpportunity, getOpportunity, listOpportunities, updateOpportunity } from "../opportunities.mjs";
+import { createOpportunityLineItem, deleteOpportunityLineItem, getOpportunityLineItem, listOpportunityLineItems, updateOpportunityLineItem } from "../opportunity-line-items.mjs";
+import { transferRecordOwnership } from "../ownership.mjs";
+import { getReportMetadata, listReportTypes, listReports, runReport } from "../reports.mjs";
+import { queryMore, runSoqlQuery } from "../soql.mjs";
+import { createTask, deleteTask, getTask, listTasks, updateTask } from "../tasks.mjs";
+import { getCurrentUserInfo } from "../users.mjs";
+
+//#region src/operations.ts
+const salesforceOperations = {
+	get_account: getAccount,
+	list_accounts: listAccounts,
+	create_account: createAccount,
+	update_account: updateAccount,
+	delete_account: deleteAccount,
+	get_campaign: getCampaign,
+	list_campaigns: listCampaigns,
+	create_campaign: createCampaign,
+	update_campaign: updateCampaign,
+	delete_campaign: deleteCampaign,
+	get_campaign_member: getCampaignMember,
+	list_campaign_members: listCampaignMembers,
+	create_campaign_member: createCampaignMember,
+	update_campaign_member: updateCampaignMember,
+	delete_campaign_member: deleteCampaignMember,
+	get_contact: getContact,
+	list_contacts: listContacts,
+	create_contact: createContact,
+	update_contact: updateContact,
+	delete_contact: deleteContact,
+	associate_contact_to_account: associateContactToAccount,
+	dissociate_contact_from_account: dissociateContactFromAccount,
+	get_lead: getLead,
+	list_leads: listLeads,
+	create_lead: createLead,
+	update_lead: updateLead,
+	delete_lead: deleteLead,
+	get_opportunity: getOpportunity,
+	list_opportunities: listOpportunities,
+	create_opportunity: createOpportunity,
+	update_opportunity: updateOpportunity,
+	delete_opportunity: deleteOpportunity,
+	get_opportunity_line_item: getOpportunityLineItem,
+	list_opportunity_line_items: listOpportunityLineItems,
+	create_opportunity_line_item: createOpportunityLineItem,
+	update_opportunity_line_item: updateOpportunityLineItem,
+	delete_opportunity_line_item: deleteOpportunityLineItem,
+	get_case: getCase,
+	list_cases: listCases,
+	create_case: createCase,
+	update_case: updateCase,
+	delete_case: deleteCase,
+	get_note: getNote,
+	list_notes: listNotes,
+	create_note: createNote,
+	update_note: updateNote,
+	delete_note: deleteNote,
+	get_task: getTask,
+	list_tasks: listTasks,
+	create_task: createTask,
+	update_task: updateTask,
+	delete_task: deleteTask,
+	transfer_record_ownership: transferRecordOwnership,
+	get_current_user_info: getCurrentUserInfo,
+	run_soql_query: runSoqlQuery,
+	query_more: queryMore,
+	list_objects: listObjects,
+	describe_object: describeObject,
+	list_reports: listReports,
+	list_report_types: listReportTypes,
+	get_report_metadata: getReportMetadata,
+	run_report: runReport,
+	list_dashboards: listDashboards,
+	get_dashboard: getDashboard,
+	refresh_dashboard: refreshDashboard
+};
+
+//#endregion
+export { salesforceOperations };

package/dist/accounts.d.mts

@@ -0,0 +1,97 @@
+import * as zod from "zod";
+import * as _keystrokehq_core0 from "@keystrokehq/core";
+import * as _keystrokehq_core_credential_set0 from "@keystrokehq/core/credential-set";
+import * as zod_v4_core0 from "zod/v4/core";
+
+//#region src/accounts.d.ts
+declare const getAccount: _keystrokehq_core0.Operation<zod.ZodObject<{
+  id: zod.ZodString;
+  fields: zod.ZodOptional<zod.ZodArray<zod.ZodString>>;
+}, zod_v4_core0.$strip>, zod.ZodObject<{
+  Id: zod.ZodOptional<zod.ZodString>;
+  attributes: zod.ZodOptional<zod.ZodObject<{
+    type: zod.ZodString;
+    url: zod.ZodString;
+  }, zod_v4_core0.$strip>>;
+}, zod_v4_core0.$catchall<zod.ZodUnknown>>, readonly [_keystrokehq_core0.CredentialSet<"salesforce", zod.ZodObject<{
+  SALESFORCE_ACCESS_TOKEN: zod.ZodString;
+  SALESFORCE_INSTANCE_URL: zod.ZodURL;
+}, zod_v4_core0.$strip>, readonly _keystrokehq_core_credential_set0.CredentialConnection<zod.ZodObject<{
+  SALESFORCE_ACCESS_TOKEN: zod.ZodString;
+  SALESFORCE_INSTANCE_URL: zod.ZodURL;
+}, zod_v4_core0.$strip>>[] | undefined>], undefined>;
+declare const listAccounts: _keystrokehq_core0.Operation<zod.ZodObject<{
+  fields: zod.ZodOptional<zod.ZodArray<zod.ZodString>>;
+  where: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnion<readonly [zod.ZodString, zod.ZodNumber, zod.ZodBoolean, zod.ZodNull]>>>;
+  orderBy: zod.ZodOptional<zod.ZodString>;
+  orderDirection: zod.ZodOptional<zod.ZodEnum<{
+    ASC: "ASC";
+    DESC: "DESC";
+  }>>;
+  limit: zod.ZodOptional<zod.ZodNumber>;
+}, zod_v4_core0.$strip>, zod.ZodObject<{
+  totalSize: zod.ZodNumber;
+  done: zod.ZodBoolean;
+  nextRecordsUrl: zod.ZodOptional<zod.ZodString>;
+  records: zod.ZodArray<zod.ZodObject<{
+    Id: zod.ZodOptional<zod.ZodString>;
+    attributes: zod.ZodOptional<zod.ZodObject<{
+      type: zod.ZodString;
+      url: zod.ZodString;
+    }, zod_v4_core0.$strip>>;
+  }, zod_v4_core0.$catchall<zod.ZodUnknown>>>;
+}, zod_v4_core0.$strip>, readonly [_keystrokehq_core0.CredentialSet<"salesforce", zod.ZodObject<{
+  SALESFORCE_ACCESS_TOKEN: zod.ZodString;
+  SALESFORCE_INSTANCE_URL: zod.ZodURL;
+}, zod_v4_core0.$strip>, readonly _keystrokehq_core_credential_set0.CredentialConnection<zod.ZodObject<{
+  SALESFORCE_ACCESS_TOKEN: zod.ZodString;
+  SALESFORCE_INSTANCE_URL: zod.ZodURL;
+}, zod_v4_core0.$strip>>[] | undefined>], undefined>;
+declare const createAccount: _keystrokehq_core0.Operation<zod.ZodObject<{
+  fields: zod.ZodRecord<zod.ZodString, zod.ZodUnknown>;
+  returnFields: zod.ZodOptional<zod.ZodArray<zod.ZodString>>;
+}, zod_v4_core0.$strip>, zod.ZodObject<{
+  Id: zod.ZodOptional<zod.ZodString>;
+  attributes: zod.ZodOptional<zod.ZodObject<{
+    type: zod.ZodString;
+    url: zod.ZodString;
+  }, zod_v4_core0.$strip>>;
+}, zod_v4_core0.$catchall<zod.ZodUnknown>>, readonly [_keystrokehq_core0.CredentialSet<"salesforce", zod.ZodObject<{
+  SALESFORCE_ACCESS_TOKEN: zod.ZodString;
+  SALESFORCE_INSTANCE_URL: zod.ZodURL;
+}, zod_v4_core0.$strip>, readonly _keystrokehq_core_credential_set0.CredentialConnection<zod.ZodObject<{
+  SALESFORCE_ACCESS_TOKEN: zod.ZodString;
+  SALESFORCE_INSTANCE_URL: zod.ZodURL;
+}, zod_v4_core0.$strip>>[] | undefined>], undefined>;
+declare const updateAccount: _keystrokehq_core0.Operation<zod.ZodObject<{
+  id: zod.ZodString;
+  fields: zod.ZodRecord<zod.ZodString, zod.ZodUnknown>;
+  returnFields: zod.ZodOptional<zod.ZodArray<zod.ZodString>>;
+}, zod_v4_core0.$strip>, zod.ZodObject<{
+  Id: zod.ZodOptional<zod.ZodString>;
+  attributes: zod.ZodOptional<zod.ZodObject<{
+    type: zod.ZodString;
+    url: zod.ZodString;
+  }, zod_v4_core0.$strip>>;
+}, zod_v4_core0.$catchall<zod.ZodUnknown>>, readonly [_keystrokehq_core0.CredentialSet<"salesforce", zod.ZodObject<{
+  SALESFORCE_ACCESS_TOKEN: zod.ZodString;
+  SALESFORCE_INSTANCE_URL: zod.ZodURL;
+}, zod_v4_core0.$strip>, readonly _keystrokehq_core_credential_set0.CredentialConnection<zod.ZodObject<{
+  SALESFORCE_ACCESS_TOKEN: zod.ZodString;
+  SALESFORCE_INSTANCE_URL: zod.ZodURL;
+}, zod_v4_core0.$strip>>[] | undefined>], undefined>;
+declare const deleteAccount: _keystrokehq_core0.Operation<zod.ZodObject<{
+  id: zod.ZodString;
+}, zod_v4_core0.$strip>, zod.ZodObject<{
+  success: zod.ZodBoolean;
+  id: zod.ZodOptional<zod.ZodString>;
+  errors: zod.ZodOptional<zod.ZodArray<zod.ZodString>>;
+}, zod_v4_core0.$strip>, readonly [_keystrokehq_core0.CredentialSet<"salesforce", zod.ZodObject<{
+  SALESFORCE_ACCESS_TOKEN: zod.ZodString;
+  SALESFORCE_INSTANCE_URL: zod.ZodURL;
+}, zod_v4_core0.$strip>, readonly _keystrokehq_core_credential_set0.CredentialConnection<zod.ZodObject<{
+  SALESFORCE_ACCESS_TOKEN: zod.ZodString;
+  SALESFORCE_INSTANCE_URL: zod.ZodURL;
+}, zod_v4_core0.$strip>>[] | undefined>], undefined>;
+//#endregion
+export { createAccount, deleteAccount, getAccount, listAccounts, updateAccount };

package/dist/accounts.mjs

@@ -0,0 +1,30 @@
+import { n as createSalesforceCrudOperations } from "./shared-B8YQavkg.mjs";
+
+//#region src/accounts.ts
+const accountCrud = createSalesforceCrudOperations({
+	objectName: "Account",
+	singularName: "Account",
+	pluralName: "Accounts",
+	operationPrefix: "account",
+	defaultFields: [
+		"Id",
+		"Name",
+		"Type",
+		"Industry",
+		"Phone",
+		"Website",
+		"BillingCity",
+		"BillingState",
+		"BillingCountry",
+		"CreatedDate",
+		"LastModifiedDate"
+	]
+});
+const getAccount = accountCrud.getRecord;
+const listAccounts = accountCrud.listRecords;
+const createAccount = accountCrud.createRecord;
+const updateAccount = accountCrud.updateRecord;
+const deleteAccount = accountCrud.deleteRecord;
+
+//#endregion
+export { createAccount, deleteAccount, getAccount, listAccounts, updateAccount };

package/dist/associations.d.mts

@@ -0,0 +1,40 @@
+import { z } from "zod";
+import * as _keystrokehq_core0 from "@keystrokehq/core";
+import * as _keystrokehq_core_credential_set0 from "@keystrokehq/core/credential-set";
+
+//#region src/associations.d.ts
+declare const associateContactToAccount: _keystrokehq_core0.Operation<z.ZodObject<{
+  contactId: z.ZodString;
+  accountId: z.ZodString;
+  returnFields: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>, z.ZodObject<{
+  Id: z.ZodOptional<z.ZodString>;
+  attributes: z.ZodOptional<z.ZodObject<{
+    type: z.ZodString;
+    url: z.ZodString;
+  }, z.core.$strip>>;
+}, z.core.$catchall<z.ZodUnknown>>, readonly [_keystrokehq_core0.CredentialSet<"salesforce", z.ZodObject<{
+  SALESFORCE_ACCESS_TOKEN: z.ZodString;
+  SALESFORCE_INSTANCE_URL: z.ZodURL;
+}, z.core.$strip>, readonly _keystrokehq_core_credential_set0.CredentialConnection<z.ZodObject<{
+  SALESFORCE_ACCESS_TOKEN: z.ZodString;
+  SALESFORCE_INSTANCE_URL: z.ZodURL;
+}, z.core.$strip>>[] | undefined>], undefined>;
+declare const dissociateContactFromAccount: _keystrokehq_core0.Operation<z.ZodObject<{
+  contactId: z.ZodString;
+  returnFields: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>, z.ZodObject<{
+  Id: z.ZodOptional<z.ZodString>;
+  attributes: z.ZodOptional<z.ZodObject<{
+    type: z.ZodString;
+    url: z.ZodString;
+  }, z.core.$strip>>;
+}, z.core.$catchall<z.ZodUnknown>>, readonly [_keystrokehq_core0.CredentialSet<"salesforce", z.ZodObject<{
+  SALESFORCE_ACCESS_TOKEN: z.ZodString;
+  SALESFORCE_INSTANCE_URL: z.ZodURL;
+}, z.core.$strip>, readonly _keystrokehq_core_credential_set0.CredentialConnection<z.ZodObject<{
+  SALESFORCE_ACCESS_TOKEN: z.ZodString;
+  SALESFORCE_INSTANCE_URL: z.ZodURL;
+}, z.core.$strip>>[] | undefined>], undefined>;
+//#endregion
+export { associateContactToAccount, dissociateContactFromAccount };

package/dist/associations.mjs

@@ -0,0 +1,70 @@
+import { createSalesforceClient } from "./client.mjs";
+import { i as salesforceIdSchema, s as salesforceRecordSchema } from "./common-BUAhHMqn.mjs";
+import { t as salesforceOperation } from "./factory-BBQAdBIT.mjs";
+import { a as normalizeSalesforceQueryResult, i as getSelectFields, o as salesforceFieldListSchema, r as ensureMutationSuccess, t as buildSelectQuery } from "./shared-B8YQavkg.mjs";
+import { z } from "zod";
+
+//#region src/associations.ts
+const defaultContactFields = [
+	"Id",
+	"AccountId",
+	"FirstName",
+	"LastName",
+	"Email",
+	"LastModifiedDate"
+];
+function getClient(credentials) {
+	return createSalesforceClient(credentials);
+}
+async function getContactRecord(client, contactId, returnFields) {
+	const record = normalizeSalesforceQueryResult(await client.query(buildSelectQuery({
+		objectName: "Contact",
+		fields: getSelectFields(returnFields, defaultContactFields),
+		where: { Id: contactId },
+		limit: 1
+	}))).records[0];
+	if (!record) throw new Error(`Salesforce Contact record ${contactId} was not found.`);
+	return salesforceRecordSchema.parse(record);
+}
+const associateContactToAccount = salesforceOperation({
+	id: "associate_contact_to_account",
+	name: "Associate Salesforce Contact To Account",
+	description: "Associate a Salesforce contact to an account by setting AccountId",
+	input: z.object({
+		contactId: salesforceIdSchema,
+		accountId: salesforceIdSchema,
+		returnFields: salesforceFieldListSchema.optional()
+	}),
+	output: salesforceRecordSchema,
+	needsApproval: true,
+	run: async (input, credentials) => {
+		const client = getClient(credentials);
+		ensureMutationSuccess("update", "Contact", await client.sobject("Contact").update({
+			Id: input.contactId,
+			AccountId: input.accountId
+		}));
+		return getContactRecord(client, input.contactId, input.returnFields);
+	}
+});
+const dissociateContactFromAccount = salesforceOperation({
+	id: "dissociate_contact_from_account",
+	name: "Dissociate Salesforce Contact From Account",
+	description: "Remove the account association from a Salesforce contact by clearing AccountId",
+	input: z.object({
+		contactId: salesforceIdSchema,
+		returnFields: salesforceFieldListSchema.optional()
+	}),
+	output: salesforceRecordSchema,
+	needsApproval: true,
+	run: async (input, credentials) => {
+		const client = getClient(credentials);
+		ensureMutationSuccess("update", "Contact", await client.sobject("Contact").update({
+			Id: input.contactId,
+			AccountId: null
+		}));
+		return getContactRecord(client, input.contactId, input.returnFields);
+	}
+});
+
+//#endregion
+export { associateContactToAccount, dissociateContactFromAccount };