@useairfoil/producer-salesforce 0.0.1 → 0.0.3

package/LICENSE.txt

@@ -0,0 +1,201 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+    Copyright 2026 GNC Labs Limited
+
+    Licensed under the Apache License, Version 2.0 (the "License"); you may not use
+    this file except in compliance with the License. You may obtain a copy of the
+    License at
+
+        http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software distributed
+    under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
+    CONDITIONS OF ANY KIND, either express or implied. See the License for the
+    specific language governing permissions and limitations under the License.

package/README.md

@@ -0,0 +1,102 @@
+# Salesforce producer
+
+Syncs Salesforce records from one org: standard objects, custom objects, field
+history, and field definitions. It backfills each table, then polls business
+objects every 10 minutes and setup objects every hour. Salesforce has no signed
+webhooks, so there are none.
+
+| Resource                                                                                                                                                                                                                                                                    | What                                     |
+| --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------- |
+| `accounts`, `account_contact_relations`, `account_team_members`, `contacts`, `leads`, `opportunities`, `opportunity_line_items`, `opportunity_contact_roles`, `opportunity_competitors`, `opportunity_team_members`, `opportunity_splits`, `partners`, `forecasting_quotas` | Sales                                    |
+| `quotes`, `quote_line_items`, `contracts`, `contract_contact_roles`, `orders`, `order_items`                                                                                                                                                                                | Quotes and orders                        |
+| `products`, `pricebooks`, `pricebook_entries`, `assets`, `asset_relationships`                                                                                                                                                                                              | Catalog and assets                       |
+| `campaigns`, `campaign_members`, `campaign_member_statuses`, `individuals`, `contact_point_emails`, `contact_point_phones`                                                                                                                                                  | Marketing                                |
+| `cases`, `case_comments`, `case_contact_roles`, `case_team_members`, `entitlements`, `service_contracts`, `contract_line_items`, `solutions`, `email_messages`, `email_message_relations`, `live_chat_transcripts`, `messaging_sessions`, `macros`, `quick_texts`           | Service                                  |
+| `work_orders`, `work_order_line_items`, `service_appointments`, `service_resources`, `service_territories`, `assigned_resources`, `resource_absences`, `locations`, `product_items`                                                                                         | Field Service                            |
+| `tasks`, `task_relations`, `events`, `event_relations`, `notes`, `attachments`, `feed_items`, `feed_comments`, `topics`, `topic_assignments`                                                                                                                                | Activities                               |
+| `account_history`, `contact_history`, `lead_history`, `case_history`, `opportunity_history`, `opportunity_field_history`                                                                                                                                                    | Field history                            |
+| `users`, `user_roles`, `profiles`, `permission_sets`, `permission_set_assignments`, `groups`, `group_members`, `collaboration_groups`, `collaboration_group_members`, `record_types`, `business_hours`, `holidays`, `periods`, `organization`, `folders`, `documents`       | Users and setup                          |
+| `duplicate_record_sets`, `duplicate_record_items`                                                                                                                                                                                                                           | Duplicate rules                          |
+| `custom_objects`                                                                                                                                                                                                                                                            | Records of every custom object (`*__c`)  |
+| `object_fields`                                                                                                                                                                                                                                                             | Field definitions, to name `fields` keys |
+
+## Config
+
+| Variable                   | Required | Default |
+| -------------------------- | -------- | ------- |
+| `SALESFORCE_DOMAIN`        | yes      | none    |
+| `SALESFORCE_CLIENT_ID`     | yes      | none    |
+| `SALESFORCE_CLIENT_SECRET` | yes      | none    |
+
+`SALESFORCE_DOMAIN` is the org's My Domain host, such as
+`acme.my.salesforce.com`. Sandboxes work too.
+
+## Setup
+
+1. Pick the user the connector runs as. A user with the Salesforce Integration
+   license works. Give it API Enabled, read access to the synced objects, and
+   View All Data. Without View All Data, records outside its sharing are
+   missed.
+2. In Setup, open **External Client App Manager → New External Client App**.
+   Turn on OAuth with the `api` scope and **Enable Client Credentials Flow**.
+   The callback URL isn't used.
+3. In the app's **Policies → OAuth Policies**, turn on the client credentials
+   flow and set **Run As** to the user from step 1.
+4. Under **Settings → OAuth Settings → Consumer Key and Secret**, copy the key
+   and secret to `SALESFORCE_CLIENT_ID` and `SALESFORCE_CLIENT_SECRET`.
+
+One app and domain read one org, so run one connector per org.
+
+## API version
+
+The connector uses REST API `v68.0` (Winter '27).
+
+## Data
+
+- Object tables keep every non-null field the user can read in `fields`, by API
+  name, as strings: text as is, numbers and booleans as JSON text, and dates as
+  Salesforce sends them. New custom fields show up on their own.
+  `object_fields` has each field's label, type, and picklist values.
+- Address and location fields are left out, because their parts (such as
+  `BillingCity`) are fields too. So are binary fields, such as attachment
+  bodies.
+- `created_at` is `CreatedDate` and `updated_at` is `SystemModstamp`. Both are
+  null on objects without them, such as history objects.
+- `custom_objects` holds every custom object. `object` says which, such as
+  `Invoice__c`.
+- A deleted or merged-away record gets `_deleted`. A restored record comes
+  back.
+- Contacts, leads, users, individuals, contact points, cases, emails, chat and
+  messaging transcripts, feed items, notes, tasks, and events hold names,
+  emails, phone numbers, addresses, and message bodies. Treat them as customer
+  data.
+
+## Demo data
+
+`pnpm demo --size 128MiB` writes made-up Salesforce data without Salesforce
+credentials. See the Connector Kit README for the flags and the variables it
+needs.
+
+Each account has contacts, opportunities with products, quotes, history, and
+splits, and, once won, a contract, an order, assets, a service contract with
+entitlements, an install visit, and an onboarding project in `custom_objects`.
+Customers open cases with comments, emails, and chats. Accounts also get tasks,
+events, notes, Chatter posts, and a lead. The org setup is written once and
+doesn't grow with the size: users, roles, profiles, permissions, groups, the
+catalog and price book, campaigns, service resources, and `object_fields`.
+
+## Limits
+
+- Salesforce lists changes for the last 30 days and deletes for the last 15.
+  A connector stopped for more than 15 days fails, and those tables need a new
+  backfill.
+- Formula fields that read other records only change in a row when the record
+  itself changes.
+- `permission_sets`, `permission_set_assignments`, and `collaboration_groups`
+  can't be replicated, so they're read in full every hour, and removed rows
+  stay.
+- An org without a feature, such as Quotes or Field Service, or a user without
+  access, leaves that table in error. The other tables keep syncing.
+- Every table costs at least 2 API calls per poll. With every table on, that's
+  about 23,000 calls a day. A Developer Edition org has 15,000, so turn on only
+  the tables you need there.

package/dist/index.d.mts

@@ -0,0 +1,228 @@
+import { ObjectSpec, SalesforceConfig, SalesforceConfigDef, manifest, objects } from "./manifest.mjs";
+import { Auth, ConnectorError } from "@useairfoil/connector-kit";
+import { Config, Context, Effect, Layer, Schema } from "effect";
+import { HttpClient } from "effect/http";
+declare namespace auth_d_exports {
+  export { SalesforceAuth, SalesforceAuthService, layer$2 as layer, make$2 as make };
+}
+type SalesforceAuthConfig = Pick<SalesforceConfig, "domain" | "clientId" | "clientSecret">;
+type SalesforceAuthService = Auth.TokenCache<ConnectorError>;
+declare const SalesforceAuth_base: Context.ServiceClass<SalesforceAuth, "@useairfoil/producer-salesforce/SalesforceAuth", SalesforceAuthService>;
+declare class SalesforceAuth extends SalesforceAuth_base {}
+declare const make$2: (config: SalesforceAuthConfig) => Effect.Effect<Auth.TokenCache<ConnectorError>, never, HttpClient.HttpClient>;
+declare const layer$2: (config: SalesforceAuthConfig) => Layer.Layer<SalesforceAuth, never, HttpClient.HttpClient>;
+declare namespace client_d_exports {
+  export { SALESFORCE_API_VERSION, SalesforceClient, SalesforceClientService, SalesforceResponse, layer$1 as layer, layerConfig$1 as layerConfig, make$1 as make };
+}
+declare const SALESFORCE_API_VERSION = "68.0";
+type SalesforceResponse<A> = {
+  readonly body: A;
+  /** When the response arrived. Used as the row version. */
+  readonly fetchedAt: Date;
+};
+type SalesforceClientService = {
+  /** Paths are relative to `/services/data/v68.0`. */
+  readonly get: <A>(schema: Schema.Decoder<A>, path: string, params?: Readonly<Record<string, string>>) => Effect.Effect<SalesforceResponse<A>, ConnectorError>;
+  readonly post: <A>(schema: Schema.Decoder<A>, path: string, body: unknown) => Effect.Effect<SalesforceResponse<A>, ConnectorError>;
+};
+declare const SalesforceClient_base: Context.ServiceClass<SalesforceClient, "@useairfoil/producer-salesforce/SalesforceClient", SalesforceClientService>;
+declare class SalesforceClient extends SalesforceClient_base {}
+declare const make$1: (config: {
+  readonly domain: string;
+  readonly clientId: string;
+  readonly clientSecret: import("effect/Redacted").Redacted<string>;
+}) => Effect.Effect<SalesforceClientService, never, SalesforceAuth | HttpClient.HttpClient>;
+declare const layer$1: (config: SalesforceConfig) => Layer.Layer<SalesforceClient, never, HttpClient.HttpClient>;
+declare const layerConfig$1: (config: Config.Wrap<SalesforceConfig>) => Layer.Layer<SalesforceClient, Config.ConfigError, HttpClient.HttpClient>;
+declare namespace connector_d_exports {
+  export { SalesforceConfig, SalesforceConfigDef, SalesforceConnector, SalesforceConnectorRuntime, layer, layerConfig, make, manifest };
+}
+declare const make: () => Effect.Effect<import("@useairfoil/connector-kit").ConnectorDefinition<readonly [...import("@useairfoil/connector-kit").ResourceDefinition<import("effect/Schema").Struct<{
+  id: import("effect/Schema").String;
+  version: import("effect/Schema").Date;
+  created_at: import("effect/Schema").NullOr<import("effect/Schema").Date>;
+  updated_at: import("effect/Schema").NullOr<import("effect/Schema").Date>;
+  fields: import("effect/Schema").$ReadonlyMap<import("effect/Schema").String, import("effect/Schema").String>;
+  _deleted: import("effect/Schema").optional<import("effect/Schema").Boolean>;
+}> & import("@useairfoil/connector-kit").Identified<"id">, never, never, string, "version">[], import("@useairfoil/connector-kit").ResourceDefinition<import("effect/Schema").Struct<{
+  readonly object: import("effect/Schema").String;
+  readonly id: import("effect/Schema").String;
+  readonly version: import("effect/Schema").Date;
+  readonly created_at: import("effect/Schema").NullOr<import("effect/Schema").Date>;
+  readonly updated_at: import("effect/Schema").NullOr<import("effect/Schema").Date>;
+  readonly fields: import("effect/Schema").$ReadonlyMap<import("effect/Schema").String, import("effect/Schema").String>;
+  readonly _deleted: import("effect/Schema").optional<import("effect/Schema").Boolean>;
+}> & import("@useairfoil/connector-kit").Identified<"id">, never, never, "custom_objects", "version">, import("@useairfoil/connector-kit").ResourceDefinition<import("effect/Schema").Struct<{
+  readonly id: import("effect/Schema").String;
+  readonly version: import("effect/Schema").Date;
+  readonly object: import("effect/Schema").String;
+  readonly name: import("effect/Schema").String;
+  readonly label: import("effect/Schema").String;
+  readonly type: import("effect/Schema").String;
+  readonly custom: import("effect/Schema").Boolean;
+  readonly calculated: import("effect/Schema").Boolean;
+  readonly nillable: import("effect/Schema").Boolean;
+  readonly length: import("effect/Schema").BigInt;
+  readonly precision: import("effect/Schema").BigInt;
+  readonly scale: import("effect/Schema").BigInt;
+  readonly reference_to: import("effect/Schema").$Array<import("effect/Schema").String>;
+  readonly picklist_values: import("effect/Schema").$Array<import("effect/Schema").Struct<{
+    readonly value: import("effect/Schema").String;
+    readonly label: import("effect/Schema").NullOr<import("effect/Schema").String>;
+    readonly active: import("effect/Schema").Boolean;
+  }>>;
+}> & import("@useairfoil/connector-kit").Identified<"id">, never, never, "object_fields", "version">], readonly [...import("@useairfoil/connector-kit").ResourceDefinition<import("effect/Schema").Struct<{
+  id: import("effect/Schema").String;
+  version: import("effect/Schema").Date;
+  created_at: import("effect/Schema").NullOr<import("effect/Schema").Date>;
+  updated_at: import("effect/Schema").NullOr<import("effect/Schema").Date>;
+  fields: import("effect/Schema").$ReadonlyMap<import("effect/Schema").String, import("effect/Schema").String>;
+  _deleted: import("effect/Schema").optional<import("effect/Schema").Boolean>;
+}> & import("@useairfoil/connector-kit").Identified<"id">, never, never, string, "version">[], import("@useairfoil/connector-kit").ResourceDefinition<import("effect/Schema").Struct<{
+  readonly object: import("effect/Schema").String;
+  readonly id: import("effect/Schema").String;
+  readonly version: import("effect/Schema").Date;
+  readonly created_at: import("effect/Schema").NullOr<import("effect/Schema").Date>;
+  readonly updated_at: import("effect/Schema").NullOr<import("effect/Schema").Date>;
+  readonly fields: import("effect/Schema").$ReadonlyMap<import("effect/Schema").String, import("effect/Schema").String>;
+  readonly _deleted: import("effect/Schema").optional<import("effect/Schema").Boolean>;
+}> & import("@useairfoil/connector-kit").Identified<"id">, never, never, "custom_objects", "version">, import("@useairfoil/connector-kit").ResourceDefinition<import("effect/Schema").Struct<{
+  readonly id: import("effect/Schema").String;
+  readonly version: import("effect/Schema").Date;
+  readonly object: import("effect/Schema").String;
+  readonly name: import("effect/Schema").String;
+  readonly label: import("effect/Schema").String;
+  readonly type: import("effect/Schema").String;
+  readonly custom: import("effect/Schema").Boolean;
+  readonly calculated: import("effect/Schema").Boolean;
+  readonly nillable: import("effect/Schema").Boolean;
+  readonly length: import("effect/Schema").BigInt;
+  readonly precision: import("effect/Schema").BigInt;
+  readonly scale: import("effect/Schema").BigInt;
+  readonly reference_to: import("effect/Schema").$Array<import("effect/Schema").String>;
+  readonly picklist_values: import("effect/Schema").$Array<import("effect/Schema").Struct<{
+    readonly value: import("effect/Schema").String;
+    readonly label: import("effect/Schema").NullOr<import("effect/Schema").String>;
+    readonly active: import("effect/Schema").Boolean;
+  }>>;
+}> & import("@useairfoil/connector-kit").Identified<"id">, never, never, "object_fields", "version">]>, never, SalesforceClient>;
+type SalesforceConnectorRuntime = Effect.Success<ReturnType<typeof make>>;
+declare const SalesforceConnector_base: Context.ServiceClass<SalesforceConnector, "@useairfoil/producer-salesforce/SalesforceConnector", import("@useairfoil/connector-kit").ConnectorDefinition<readonly [...import("@useairfoil/connector-kit").ResourceDefinition<import("effect/Schema").Struct<{
+  id: import("effect/Schema").String;
+  version: import("effect/Schema").Date;
+  created_at: import("effect/Schema").NullOr<import("effect/Schema").Date>;
+  updated_at: import("effect/Schema").NullOr<import("effect/Schema").Date>;
+  fields: import("effect/Schema").$ReadonlyMap<import("effect/Schema").String, import("effect/Schema").String>;
+  _deleted: import("effect/Schema").optional<import("effect/Schema").Boolean>;
+}> & import("@useairfoil/connector-kit").Identified<"id">, never, never, string, "version">[], import("@useairfoil/connector-kit").ResourceDefinition<import("effect/Schema").Struct<{
+  readonly object: import("effect/Schema").String;
+  readonly id: import("effect/Schema").String;
+  readonly version: import("effect/Schema").Date;
+  readonly created_at: import("effect/Schema").NullOr<import("effect/Schema").Date>;
+  readonly updated_at: import("effect/Schema").NullOr<import("effect/Schema").Date>;
+  readonly fields: import("effect/Schema").$ReadonlyMap<import("effect/Schema").String, import("effect/Schema").String>;
+  readonly _deleted: import("effect/Schema").optional<import("effect/Schema").Boolean>;
+}> & import("@useairfoil/connector-kit").Identified<"id">, never, never, "custom_objects", "version">, import("@useairfoil/connector-kit").ResourceDefinition<import("effect/Schema").Struct<{
+  readonly id: import("effect/Schema").String;
+  readonly version: import("effect/Schema").Date;
+  readonly object: import("effect/Schema").String;
+  readonly name: import("effect/Schema").String;
+  readonly label: import("effect/Schema").String;
+  readonly type: import("effect/Schema").String;
+  readonly custom: import("effect/Schema").Boolean;
+  readonly calculated: import("effect/Schema").Boolean;
+  readonly nillable: import("effect/Schema").Boolean;
+  readonly length: import("effect/Schema").BigInt;
+  readonly precision: import("effect/Schema").BigInt;
+  readonly scale: import("effect/Schema").BigInt;
+  readonly reference_to: import("effect/Schema").$Array<import("effect/Schema").String>;
+  readonly picklist_values: import("effect/Schema").$Array<import("effect/Schema").Struct<{
+    readonly value: import("effect/Schema").String;
+    readonly label: import("effect/Schema").NullOr<import("effect/Schema").String>;
+    readonly active: import("effect/Schema").Boolean;
+  }>>;
+}> & import("@useairfoil/connector-kit").Identified<"id">, never, never, "object_fields", "version">], readonly [...import("@useairfoil/connector-kit").ResourceDefinition<import("effect/Schema").Struct<{
+  id: import("effect/Schema").String;
+  version: import("effect/Schema").Date;
+  created_at: import("effect/Schema").NullOr<import("effect/Schema").Date>;
+  updated_at: import("effect/Schema").NullOr<import("effect/Schema").Date>;
+  fields: import("effect/Schema").$ReadonlyMap<import("effect/Schema").String, import("effect/Schema").String>;
+  _deleted: import("effect/Schema").optional<import("effect/Schema").Boolean>;
+}> & import("@useairfoil/connector-kit").Identified<"id">, never, never, string, "version">[], import("@useairfoil/connector-kit").ResourceDefinition<import("effect/Schema").Struct<{
+  readonly object: import("effect/Schema").String;
+  readonly id: import("effect/Schema").String;
+  readonly version: import("effect/Schema").Date;
+  readonly created_at: import("effect/Schema").NullOr<import("effect/Schema").Date>;
+  readonly updated_at: import("effect/Schema").NullOr<import("effect/Schema").Date>;
+  readonly fields: import("effect/Schema").$ReadonlyMap<import("effect/Schema").String, import("effect/Schema").String>;
+  readonly _deleted: import("effect/Schema").optional<import("effect/Schema").Boolean>;
+}> & import("@useairfoil/connector-kit").Identified<"id">, never, never, "custom_objects", "version">, import("@useairfoil/connector-kit").ResourceDefinition<import("effect/Schema").Struct<{
+  readonly id: import("effect/Schema").String;
+  readonly version: import("effect/Schema").Date;
+  readonly object: import("effect/Schema").String;
+  readonly name: import("effect/Schema").String;
+  readonly label: import("effect/Schema").String;
+  readonly type: import("effect/Schema").String;
+  readonly custom: import("effect/Schema").Boolean;
+  readonly calculated: import("effect/Schema").Boolean;
+  readonly nillable: import("effect/Schema").Boolean;
+  readonly length: import("effect/Schema").BigInt;
+  readonly precision: import("effect/Schema").BigInt;
+  readonly scale: import("effect/Schema").BigInt;
+  readonly reference_to: import("effect/Schema").$Array<import("effect/Schema").String>;
+  readonly picklist_values: import("effect/Schema").$Array<import("effect/Schema").Struct<{
+    readonly value: import("effect/Schema").String;
+    readonly label: import("effect/Schema").NullOr<import("effect/Schema").String>;
+    readonly active: import("effect/Schema").Boolean;
+  }>>;
+}> & import("@useairfoil/connector-kit").Identified<"id">, never, never, "object_fields", "version">]>>;
+declare class SalesforceConnector extends SalesforceConnector_base {}
+declare const layer: (config: SalesforceConfig) => Layer.Layer<SalesforceConnector, never, import("effect/http/HttpClient").HttpClient>;
+declare const layerConfig: (config: Config.Wrap<SalesforceConfig>) => Layer.Layer<SalesforceConnector, Config.ConfigError, import("effect/http/HttpClient").HttpClient>;
+//#endregion
+//#region src/schemas/object-fields.d.ts
+export declare const ObjectFieldSchema: Schema.Struct<{
+  readonly id: Schema.String;
+  readonly version: Schema.Date;
+  readonly object: Schema.String;
+  readonly name: Schema.String;
+  readonly label: Schema.String;
+  readonly type: Schema.String;
+  readonly custom: Schema.Boolean;
+  readonly calculated: Schema.Boolean;
+  readonly nillable: Schema.Boolean;
+  readonly length: Schema.BigInt;
+  readonly precision: Schema.BigInt;
+  readonly scale: Schema.BigInt;
+  readonly reference_to: Schema.$Array<Schema.String>;
+  readonly picklist_values: Schema.$Array<Schema.Struct<{
+    readonly value: Schema.String;
+    readonly label: Schema.NullOr<Schema.String>;
+    readonly active: Schema.Boolean;
+  }>>;
+}> & import("@useairfoil/connector-kit").Identified<"id">;
+type ObjectField = Schema.Schema.Type<typeof ObjectFieldSchema>;
+//#endregion
+//#region src/schemas/objects.d.ts
+export declare const objectSchema: (object: string) => Schema.Struct<{
+  id: Schema.String;
+  version: Schema.Date;
+  created_at: Schema.NullOr<Schema.Date>;
+  updated_at: Schema.NullOr<Schema.Date>;
+  fields: Schema.$ReadonlyMap<Schema.String, Schema.String>;
+  _deleted: Schema.optional<Schema.Boolean>;
+}> & import("@useairfoil/connector-kit").Identified<"id">;
+type ObjectRow = Schema.Schema.Type<ReturnType<typeof objectSchema>>;
+export declare const CustomObjectSchema: Schema.Struct<{
+  readonly object: Schema.String;
+  readonly id: Schema.String;
+  readonly version: Schema.Date;
+  readonly created_at: Schema.NullOr<Schema.Date>;
+  readonly updated_at: Schema.NullOr<Schema.Date>;
+  readonly fields: Schema.$ReadonlyMap<Schema.String, Schema.String>;
+  readonly _deleted: Schema.optional<Schema.Boolean>;
+}> & import("@useairfoil/connector-kit").Identified<"id">;
+type CustomObject = Schema.Schema.Type<typeof CustomObjectSchema>;
+//#endregion
+export { type CustomObject, type ObjectField, type ObjectRow, type ObjectSpec, client_d_exports as SalesforceClient, type SalesforceConfig, connector_d_exports as SalesforceConnector, manifest, objects };
+//# sourceMappingURL=index.d.mts.map

package/dist/index.mjs

@@ -0,0 +1,3 @@
+import { manifest, objects } from "./manifest.mjs";
+import { a as CustomObjectSchema, i as ObjectFieldSchema, n as connector_exports, o as objectSchema, s as client_exports } from "./src-D7c3ea3B.mjs";
+export { CustomObjectSchema, ObjectFieldSchema, client_exports as SalesforceClient, connector_exports as SalesforceConnector, manifest, objectSchema, objects };

package/dist/main.d.mts

@@ -0,0 +1 @@
+export {}