@zackbart/connecta 0.35.0 → 0.36.1

package/dist/providers/overflow/api.js

@@ -314,7 +314,7 @@ export const getContributions = get("getContributions", "/contributions", {
     },
     success: GetContributionsResponse,
 }).annotate(Summary, "List contributions (gifts), filtered by campaign, campus, status and dates");
-export const chargeCashPaymentMethod = post("chargeCashPaymentMethod", "/contributions", {
+const chargeCashPaymentMethod = post("chargeCashPaymentMethod", "/contributions", {
     payload: ChargeCashPaymentMethodParams,
     success: ChargeCashPaymentMethodResponse,
 }).annotate(Summary, "Charge a donor's saved card, bank or wallet payment method for a cash gift");
@@ -322,7 +322,7 @@ export const getContributionById = get("getContributionById", "/contributions/:c
     params: { "contributionId": Schema.String.pipe(Schema.annotateKey({ description: "contribution id." })) },
     success: GetContributionResponse,
 }).annotate(Summary, "Retrieve one contribution (gift) and its donor, campaign and settlement status");
-export const initiateRefund = post("initiateRefund", "/contributions/:contributionId/initiate-refund", {
+const initiateRefund = post("initiateRefund", "/contributions/:contributionId/initiate-refund", {
     params: {
         "contributionId": Schema.String.pipe(Schema.annotateKey({ description: "The Id of the contribution to refund." })),
     },
@@ -372,7 +372,7 @@ export const getRefunds = get("getRefunds", "/refunds", {
     },
     success: GetRefundsResponse,
 }).annotate(Summary, "List refunds with contribution and deposit joins and cent amounts");
-export const getRefundById = get("getRefundById", "/refunds/:refundId", {
+const getRefundById = get("getRefundById", "/refunds/:refundId", {
     params: { "refundId": Schema.String.pipe(Schema.annotateKey({ description: "refund id." })) },
     success: GetRefundResponse,
 }).annotate(Summary, "Retrieve one refund and its contribution, status and cent amounts");
@@ -387,11 +387,11 @@ export const getChargebacks = get("getChargebacks", "/chargebacks", {
     },
     success: GetChargebacksResponse,
 }).annotate(Summary, "List card disputes and ACH returns (chargebacks)");
-export const getChargebackById = get("getChargebackById", "/chargebacks/:chargebackId", {
+const getChargebackById = get("getChargebackById", "/chargebacks/:chargebackId", {
     params: { "chargebackId": Schema.String.pipe(Schema.annotateKey({ description: "chargeback id." })) },
     success: GetChargebackResponse,
 }).annotate(Summary, "Retrieve one chargeback (card dispute or ACH return)");
-export const getWebhooks = get("getWebhooks", "/webhooks", {
+const getWebhooks = get("getWebhooks", "/webhooks", {
     query: {
         "limit": Schema.optionalKey(Schema.Finite.check(Schema.isGreaterThanOrEqualTo(1), Schema.isLessThanOrEqualTo(100))).pipe(Schema.annotateKey({ description: "The number of webhook subscriptions to return." })),
         "page": Schema.optionalKey(Schema.Finite.check(Schema.isGreaterThanOrEqualTo(1))).pipe(Schema.annotateKey({ description: "The page number of webhook subscriptions to return." })),
@@ -402,11 +402,11 @@ export const getWebhooks = get("getWebhooks", "/webhooks", {
     },
     success: GetWebhooksResponse,
 }).annotate(Summary, "List webhook subscriptions, destinations and enabled event names");
-export const getWebhookById = get("getWebhookById", "/webhooks/:webhookId", {
+const getWebhookById = get("getWebhookById", "/webhooks/:webhookId", {
     params: { "webhookId": Schema.String.pipe(Schema.annotateKey({ description: "webhook id." })) },
     success: GetWebhookResponse,
 }).annotate(Summary, "Retrieve one webhook subscription and its delivery destination");
-export const getWebhookEventLogs = get("getWebhookEventLogs", "/webhooks/:webhookId/event-logs", {
+const getWebhookEventLogs = get("getWebhookEventLogs", "/webhooks/:webhookId/event-logs", {
     params: { "webhookId": Schema.String.pipe(Schema.annotateKey({ description: "webhook id." })) },
     query: {
         "limit": Schema.optionalKey(Schema.Finite.check(Schema.isGreaterThanOrEqualTo(1), Schema.isLessThanOrEqualTo(50))).pipe(Schema.annotateKey({ description: "The number of webhook event logs to return." })),
@@ -467,7 +467,7 @@ export const getDonorProfiles = get("getDonorProfiles", "/donors", {
     },
     success: GetDonorsResponse,
 }).annotate(Summary, "List donor profiles, contact information and giving counts");
-export const createDonorProfile = post("createDonorProfile", "/donors", {
+const createDonorProfile = post("createDonorProfile", "/donors", {
     payload: CreateDonorProfileParams,
     success: CreateDonorProfileResponse,
 }).annotate(Summary, "Create a donor profile for a nonprofit");
@@ -475,12 +475,12 @@ export const getDonorProfile = get("getDonorProfile", "/donors/:donorId", {
     params: { "donorId": Schema.String.pipe(Schema.annotateKey({ description: "The ID of the donor to fetch." })) },
     success: GetDonorResponse,
 }).annotate(Summary, "Retrieve a donor profile, phone, address and giving counts");
-export const updateDonorProfile = patch("updateDonorProfile", "/donors/:donorId", {
+const updateDonorProfile = patch("updateDonorProfile", "/donors/:donorId", {
     params: { "donorId": Schema.String.pipe(Schema.annotateKey({ description: "The ID of the donor to update." })) },
     payload: UpdateDonorProfileParams,
     success: Schema.Unknown,
 }).annotate(Summary, "Update (edit) a donor's name, email or phone");
-export const createSubscription = post("createSubscription", "/subscriptions/:donorId", {
+const createSubscription = post("createSubscription", "/subscriptions/:donorId", {
     params: {
         "donorId": Schema.String.pipe(Schema.annotateKey({ description: "The Id of the donor to create the subscription for." })),
     },
@@ -526,14 +526,14 @@ export const getSubscriptions = get("getSubscriptions", "/subscriptions", {
     },
     success: GetSubscriptionsResponse,
 }).annotate(Summary, "List recurring gifts (subscriptions) across donors");
-export const getSubscriptionById = get("getSubscriptionById", "/subscriptions/:donorId/:subscriptionId", {
+const getSubscriptionById = get("getSubscriptionById", "/subscriptions/:donorId/:subscriptionId", {
     params: {
         "donorId": Schema.String.pipe(Schema.annotateKey({ description: "The Id of the donor to get the subscription for." })),
         "subscriptionId": Schema.String.pipe(Schema.annotateKey({ description: "The Id of the subscription to get." })),
     },
     success: GetSubscriptionResponse,
 }).annotate(Summary, "Retrieve one donor's recurring gift and payment schedule");
-export const updateSubscriptionById = patch("updateSubscriptionById", "/subscriptions/:donorId/:subscriptionId", {
+const updateSubscriptionById = patch("updateSubscriptionById", "/subscriptions/:donorId/:subscriptionId", {
     params: {
         "donorId": Schema.String.pipe(Schema.annotateKey({ description: "The Id of the donor to update the subscription for." })),
         "subscriptionId": Schema.String.pipe(Schema.annotateKey({ description: "The Id of the subscription to update." })),
@@ -541,7 +541,7 @@ export const updateSubscriptionById = patch("updateSubscriptionById", "/subscrip
     payload: UpdateSubscriptionRequest,
     success: Schema.Unknown,
 }).annotate(Summary, "Update a recurring gift, payment method, schedule or dollar amount");
-export const cancelSubscription = del("cancelSubscription", "/subscriptions/:donorId/:subscriptionId", {
+const cancelSubscription = del("cancelSubscription", "/subscriptions/:donorId/:subscriptionId", {
     params: {
         "donorId": Schema.String.pipe(Schema.annotateKey({ description: "The Id of the donor to cancel the subscription for." })),
         "subscriptionId": Schema.String.pipe(Schema.annotateKey({ description: "The Id of the subscription to cancel." })),
@@ -584,7 +584,7 @@ export const getCampaigns = get("getCampaigns", "/campaigns", {
     },
     success: GetCampaignsResponse,
 }).annotate(Summary, "List campaigns and subcampaigns, with parent and giving relationships");
-export const getCampaignById = get("getCampaignById", "/campaigns/:campaignId", {
+const getCampaignById = get("getCampaignById", "/campaigns/:campaignId", {
     params: {
         "campaignId": Schema.String.pipe(Schema.annotateKey({ description: "The Id of the campaign/subcampaign to get." })),
     },
@@ -600,15 +600,15 @@ export const getLocations = get("getLocations", "/locations", {
     },
     success: GetLocationsResponse,
 }).annotate(Summary, "List nonprofit locations (campuses)");
-export const getLocationById = get("getLocationById", "/locations/:locationId", {
+const getLocationById = get("getLocationById", "/locations/:locationId", {
     params: { "locationId": Schema.String.pipe(Schema.annotateKey({ description: "The Id of the location to get." })) },
     success: GetLocationByIdResponse,
 }).annotate(Summary, "Retrieve a nonprofit location (campus)");
-export const authorizePayment = post("authorizePayment", "/payments/authorize", {
+const authorizePayment = post("authorizePayment", "/payments/authorize", {
     payload: AuthorizePaymentRequest,
     success: AuthorizePaymentResponse,
 }).annotate(Summary, "Authorize a payment, or save a payment method with zero amountInCents");
-export const getDestinations = get("getDestinations", "/tap/destinations", {
+const getDestinations = get("getDestinations", "/tap/destinations", {
     query: {
         "limit": Schema.optionalKey(Schema.Finite.check(Schema.isGreaterThanOrEqualTo(1), Schema.isLessThanOrEqualTo(100))).pipe(Schema.annotateKey({ description: "The number of tap destinations to return." })),
         "page": Schema.optionalKey(Schema.Finite.check(Schema.isGreaterThanOrEqualTo(1))).pipe(Schema.annotateKey({ description: "The page number of the tap destinations to return." })),
@@ -620,13 +620,13 @@ export const getDestinations = get("getDestinations", "/tap/destinations", {
     },
     success: GetTapDestinationsResponse,
 }).annotate(Summary, "List Tap-to-give destinations and configured URLs or messages");
-export const getDestinationById = get("getDestinationById", "/tap/destinations/:destinationId", {
+const getDestinationById = get("getDestinationById", "/tap/destinations/:destinationId", {
     params: {
         "destinationId": Schema.String.pipe(Schema.annotateKey({ description: "The ID of the tap destination." })),
     },
     success: GetTapDestinationByIdResponse,
 }).annotate(Summary, "Retrieve a Tap-to-give destination URL or message");
-export const getDevices = get("getDevices", "/tap/devices", {
+const getDevices = get("getDevices", "/tap/devices", {
     query: {
         "limit": Schema.optionalKey(Schema.Finite.check(Schema.isGreaterThanOrEqualTo(1), Schema.isLessThanOrEqualTo(100))).pipe(Schema.annotateKey({ description: "The number of tap devices to return." })),
         "page": Schema.optionalKey(Schema.Finite.check(Schema.isGreaterThanOrEqualTo(1))).pipe(Schema.annotateKey({ description: "The page number of the tap devices to return." })),
@@ -657,11 +657,11 @@ export const getDevices = get("getDevices", "/tap/devices", {
     },
     success: GetTapDevicesResponse,
 }).annotate(Summary, "List Tap-to-give devices, groups and current destinations");
-export const getDeviceById = get("getDeviceById", "/tap/devices/:deviceId", {
+const getDeviceById = get("getDeviceById", "/tap/devices/:deviceId", {
     params: { "deviceId": Schema.String.pipe(Schema.annotateKey({ description: "The ID of the tap device." })) },
     success: GetTapDeviceByIdResponse,
 }).annotate(Summary, "Retrieve a Tap-to-give device and its current destination");
-export const getEvents = get("getEvents", "/tap/events", {
+const getEvents = get("getEvents", "/tap/events", {
     query: {
         "limit": Schema.optionalKey(Schema.Finite.check(Schema.isGreaterThanOrEqualTo(1), Schema.isLessThanOrEqualTo(100))).pipe(Schema.annotateKey({ description: "The number of tap events to return." })),
         "page": Schema.optionalKey(Schema.Finite.check(Schema.isGreaterThanOrEqualTo(1))).pipe(Schema.annotateKey({ description: "The page number of the tap events to return." })),
@@ -682,7 +682,7 @@ export const getEvents = get("getEvents", "/tap/events", {
     },
     success: GetTapEventsResponse,
 }).annotate(Summary, "List Tap-to-give engagement events (taps, not donations)");
-export const getGroups = get("getGroups", "/tap/groups", {
+const getGroups = get("getGroups", "/tap/groups", {
     query: {
         "limit": Schema.optionalKey(Schema.Finite.check(Schema.isGreaterThanOrEqualTo(1), Schema.isLessThanOrEqualTo(100))).pipe(Schema.annotateKey({ description: "The number of tap groups to return." })),
         "page": Schema.optionalKey(Schema.Finite.check(Schema.isGreaterThanOrEqualTo(1))).pipe(Schema.annotateKey({ description: "The page number of the tap groups to return." })),
@@ -693,11 +693,11 @@ export const getGroups = get("getGroups", "/tap/groups", {
     },
     success: GetTapGroupsResponse,
 }).annotate(Summary, "List Tap-to-give device groups");
-export const getGroupById = get("getGroupById", "/tap/groups/:groupId", {
+const getGroupById = get("getGroupById", "/tap/groups/:groupId", {
     params: { "groupId": Schema.String.pipe(Schema.annotateKey({ description: "The ID of the tap group." })) },
     success: GetTapGroupByIdResponse,
 }).annotate(Summary, "Retrieve a Tap-to-give group and its devices and destination");
-export const health = get("health", "/health", {
+const health = get("health", "/health", {
     success: Schema.String,
 }).annotate(Summary, "Read the API health text (not an authenticated credential check)");
 export const OverflowApi = {
@@ -808,7 +808,7 @@ function pageNumber(value) {
         throw new ConnectorCallError("invalid_args", "This Overflow cursor contains no valid page number.");
     return page;
 }
-export const overflowPage = {
+const overflowPage = {
     param: "page",
     in: "query",
     decode: pageNumber,
@@ -823,7 +823,7 @@ export const overflowPage = {
         return more ? current + 1 : null;
     },
 };
-export const overflowEventPage = {
+const overflowEventPage = {
     param: "cursor",
     in: "query",
     decode(cursor) {

package/dist/providers/planning-center/api.js

@@ -13,7 +13,7 @@ import { TABLE } from "./safety.js";
 import { excludedApps, series } from "./lib/guide.js";
 import { asRecord, asArray, resources, attribute, pageOf } from "./lib/json-api.js";
 import { PLANNING_CENTER_API_BASE_URL, PLANNING_CENTER_APPS, PLANNING_CENTER_API_VERSIONS, DEFAULT_USER_AGENT, } from "./lib/constants.js";
-export { PLANNING_CENTER_API_BASE_URL, PLANNING_CENTER_APPS, PLANNING_CENTER_API_VERSIONS, MAX_PAGE_SIZE, DEFAULT_PAGE_SIZE, PLANNING_CENTER_MAX_RESPONSE_BYTES, PLANNING_CENTER_ADMISSION, DEFAULT_USER_AGENT, } from "./lib/constants.js";
+export { PLANNING_CENTER_API_BASE_URL, PLANNING_CENTER_APPS, PLANNING_CENTER_API_VERSIONS, MAX_PAGE_SIZE, DEFAULT_PAGE_SIZE, PLANNING_CENTER_MAX_RESPONSE_BYTES, PLANNING_CENTER_ADMISSION, } from "./lib/constants.js";
 export const CREDENTIAL = {
     label: "Planning Center personal access token",
     description: "Create one at api.planningcenteronline.com/oauth/applications → Personal Access Tokens. It acts with the permissions of the user who creates it, in every product that user can open, so create it as a user whose access matches this connection's purpose.",
@@ -59,7 +59,7 @@ export function isApp(value) {
  * normalization the guarded transport applies — so `..` cannot carry a request
  * from `/people/v2` to `/oauth` or anywhere else outside a product.
  */
-export function appForPath(path, apps) {
+function appForPath(path, apps) {
     let normalized;
     if (path.startsWith("/") && !path.startsWith("//")) {
         try {
@@ -269,7 +269,7 @@ export const errors = {
 /** All ten product pins retain their own public URL and version. */
 export const PCO_PREFIX = "pco";
 export const PCO_INDEX = new PlanningCenterIndex(openapi);
-export const getPeopleMe = get("getPeopleMe", "/people/v2/me", {
+const getPeopleMe = get("getPeopleMe", "/people/v2/me", {
     success: Schema.Unknown,
     query: { include: Schema.String },
     headers: { "X-PCO-API-Version": Schema.String },
@@ -317,7 +317,7 @@ export const PCO_NAMED = {
     "POST /people/v2/people/{person_id}/workflow_cards/{workflow_card_id}/restore": "apply_workflow_card_action",
 };
 /** Native collection offset metadata, read only after response safety. */
-export const pcoPage = {
+const pcoPage = {
     param: "offset",
     in: "query",
     total: (data) => pageOf(asRecord(data)).totalCount ?? undefined,

package/dist/providers/planning-center/lib/constants.d.ts

@@ -55,4 +55,4 @@ export declare const PLANNING_CENTER_MAX_RESPONSE_BYTES: number;
  */
 export declare const PLANNING_CENTER_ADMISSION: ConnectorCallAdmissionPolicy;
 /** Planning Center refuses a request without a descriptive one (HTTP 403). */
-export declare const DEFAULT_USER_AGENT = "connecta/0.35.0 (+https://github.com/zackbart/connecta)";
+export declare const DEFAULT_USER_AGENT = "connecta/0.36.1 (+https://github.com/zackbart/connecta)";

package/dist/providers/planning-center/lib/json-api.js

@@ -8,7 +8,7 @@ export function asArray(value) {
 export function compact(value) {
     return Object.fromEntries(Object.entries(value).filter(([, entry]) => entry !== undefined));
 }
-export function isResource(value) {
+function isResource(value) {
     const record = asRecord(value);
     return typeof record["id"] === "string" && typeof record["type"] === "string";
 }
@@ -22,7 +22,7 @@ export function indexIncluded(document) {
     }
     return index;
 }
-export function relationshipData(resource, name) {
+function relationshipData(resource, name) {
     return resource.relationships?.[name]?.data;
 }
 /** The related id, `null` when Planning Center says there is none. */

package/dist/providers/quickbooks/api.js

@@ -0,0 +1,299 @@
+import { Effect, Schema } from "effect";
+import { StatusFailure } from "../../http/errors.js";
+import { get, post, Summary, vendor } from "../../http/vendor.js";
+import { vendorIndex } from "../../http/vendor-index.js";
+import { RecordShape, CompanyShape, ReportShape, object } from "./safety.js";
+import { matches, reportProblem, reportQuery } from "./lib/query.js";
+export const ENTITIES = {
+    customers: "Customer",
+    vendors: "Vendor",
+    accounts: "Account",
+    items: "Item",
+    invoices: "Invoice",
+    bills: "Bill",
+    payments: "Payment",
+    bill_payments: "BillPayment",
+};
+export const REPORTS = ["ProfitAndLoss", "BalanceSheet", "CashFlow", "AgedReceivables", "AgedPayables"];
+const version = { minorversion: Schema.optionalKey(Schema.Literal("75")) };
+const id = { id: Schema.String.check(matches("^[1-9]\\d{0,30}$")) };
+export const companyInfo = get("companyInfo", "/companyinfo/:id", {
+    params: id,
+    query: version,
+    success: Schema.Struct({ CompanyInfo: CompanyShape }),
+}).annotate(Summary, "Get the configured company identity");
+export const queryRecords = get("queryRecords", "/query", {
+    query: { ...version, query: Schema.String },
+    success: Schema.Struct({ QueryResponse: Schema.Unknown }),
+}).annotate(Summary, "Structured accounting searches through search_records only; raw SQL refused");
+export const recordReads = Object.fromEntries(Object.entries(ENTITIES).map(([key, entity]) => [
+    key,
+    get(`get${entity}`, `/${entity.toLowerCase()}/:id`, {
+        params: id,
+        query: version,
+        success: Schema.Struct({ [entity]: RecordShape }),
+    }).annotate(Summary, `Read one ${entity} accounting record`),
+]));
+export const reportReads = Object.fromEntries(REPORTS.map((name) => [
+    name,
+    get(`report${name}`, `/reports/${name}`, {
+        query: { ...version, ...reportQuery(name) },
+        success: ReportShape,
+    }).annotate(Summary, `Read the ${name} financial report`),
+]));
+// Closed named-write bodies. POSTs are indexed for safety, but refused by the hatch.
+export const PublicId = Schema.String.check(matches("^[1-9]\\d{0,30}$"));
+export const SyncToken = Schema.String.check(matches("^(?:0|[1-9]\\d{0,30})$"));
+const Name = Schema.String.check(matches("^\\S(?:[^\\r\\n]{0,498}\\S)?$"));
+export const CustomerNames = { DisplayName: Name, CompanyName: Schema.optionalKey(Name) };
+export const customerWrite = post("writeCustomer", "/customer", {
+    query: { minorversion: Schema.Literal("75"), requestid: Schema.String },
+    payload: Schema.Struct({
+        ...CustomerNames,
+        Id: Schema.optionalKey(PublicId),
+        SyncToken: Schema.optionalKey(SyncToken),
+        sparse: Schema.optionalKey(Schema.Literal(true)),
+    }),
+    success: Schema.Struct({ Customer: RecordShape }),
+}).annotate(Summary, "Create a customer or sparsely update naming fields through named tools only");
+export const invoiceWrite = post("createInvoice", "/invoice", {
+    query: { minorversion: Schema.Literal("75"), requestid: Schema.String },
+    payload: Schema.Struct({
+        CustomerRef: Schema.Struct({ value: PublicId }),
+        CurrencyRef: Schema.Struct({ value: Schema.String }),
+        ExchangeRate: Schema.Number,
+        TxnDate: Schema.String,
+        DueDate: Schema.String,
+        DocNumber: Schema.String,
+        Line: Schema.Array(Schema.Struct({
+            Amount: Schema.Number,
+            DetailType: Schema.Literal("SalesItemLineDetail"),
+            SalesItemLineDetail: Schema.Struct({
+                ItemRef: Schema.Struct({ value: PublicId }),
+                Qty: Schema.Literal(1),
+                UnitPrice: Schema.Number,
+            }),
+        })),
+        EmailStatus: Schema.Literal("NotSet"),
+        AllowIPNPayment: Schema.Literal(false),
+        AllowOnlinePayment: Schema.Literal(false),
+        AllowOnlineCreditCardPayment: Schema.Literal(false),
+        AllowOnlineACHPayment: Schema.Literal(false),
+        AllowOnlinePayPalPayment: Schema.Literal(false),
+        AllowOnlineAffirmPayment: Schema.Literal(false),
+    }),
+    success: Schema.Struct({ Invoice: RecordShape }),
+}).annotate(Summary, "Create a real unsent service invoice through create_invoice only");
+export const QuickBooksApi = vendor("QuickBooks Online", companyInfo, queryRecords, customerWrite, invoiceWrite, ...Object.values(recordReads), ...Object.values(reportReads));
+export const QUICKBOOKS_INDEX = vendorIndex(QuickBooksApi, {
+    prefix: "quickbooks",
+    title: "QuickBooks Online",
+    revision: "v3-minor75",
+});
+export const QUICKBOOKS_VERDICTS = {
+    "GET /companyinfo/{id}": "read",
+    "GET /query": "refuse",
+    "POST /customer": "refuse",
+    "POST /invoice": "refuse",
+    ...Object.fromEntries(Object.values(ENTITIES).map((entity) => [`GET /${entity.toLowerCase()}/{id}`, "read"])),
+    ...Object.fromEntries(REPORTS.map((name) => [`GET /reports/${name}`, "read"])),
+};
+export const QUICKBOOKS_NAMED = {
+    "GET /companyinfo/{id}": "get_company_info",
+    "GET /query": "search_records",
+    ...Object.fromEntries(Object.values(ENTITIES).map((entity) => [`GET /${entity.toLowerCase()}/{id}`, "get_record"])),
+    ...Object.fromEntries(REPORTS.map((name) => [`GET /reports/${name}`, "get_report"])),
+};
+export const apiOrigin = (options) => options.environment === "sandbox" ? "https://sandbox-quickbooks.api.intuit.com" : "https://quickbooks.api.intuit.com";
+export function oauth(options) {
+    return {
+        authorizationEndpoint: "https://appcenter.intuit.com/connect/oauth2",
+        tokenEndpoint: "https://oauth.platform.intuit.com/oauth2/v1/tokens/bearer",
+        revocationEndpoint: "https://developer.api.intuit.com/v2/oauth2/tokens/revoke",
+        revocationRequestFormat: "json",
+        clientId: options.clientId,
+        clientSecret: options.clientSecret,
+        scope: "com.intuit.quickbooks.accounting",
+        pkce: false,
+        expectedCallbackParameters: { realmId: options.realmId },
+        apiOrigins: [apiOrigin(options)],
+    };
+}
+export function quickbooksBinding({ connection, options, }) {
+    return {
+        review: "Fixed company/environment, indexed GETs only, minorversion 75; query SQL is reserved for the named structured builder.",
+        cursorScope: { realmId: options.realmId, environment: options.environment },
+        refuse: (call) => {
+            // The indexed refusal owns /query, including its discovery/details reason.
+            if (call.op.path === "/query")
+                return undefined;
+            if (call.op.path === "/companyinfo/{id}" && call.path !== `/companyinfo/${options.realmId}`)
+                return "Company info must name this connector's configured realmId.";
+            if (!/^\/(?:[a-z]+\/[1-9]\d{0,30}|reports\/[A-Za-z]+)$/.test(call.path))
+                return "Use a canonical reviewed QuickBooks path.";
+            if (call.op.path.startsWith("/reports/"))
+                return reportProblem(call.path.split("/").at(-1), call.query);
+            if (Object.keys(call.query).some((key) => key !== "minorversion"))
+                return "This record read accepts no extra query parameters.";
+            return undefined;
+        },
+        send: (call, settings) => connection.sendPath({
+            method: "GET",
+            path: call.path,
+            template: call.op.path,
+            query: Object.entries({ ...call.query, minorversion: "75" }).map(([key, value]) => [
+                key,
+                String(value),
+            ]),
+        }, settings),
+    };
+}
+export const errors = {
+    provider: "QuickBooks Online",
+    meanings: {
+        unknownId: "connector_call_failed",
+        provesAbsence: false,
+        conflicts: ["Intuit fault 5010 for a stale SyncToken", "Intuit fault 6240 for a duplicate DisplayName"],
+    },
+    facts: (body) => {
+        const rows = object(object(body)["Fault"])["Error"];
+        const code = Array.isArray(rows) ? object(rows[0])["code"] : undefined;
+        return { faultCode: typeof code === "string" && ["610", "5010", "6240"].includes(code) ? code : "" };
+    },
+    factVocabulary: { faultCode: ["610", "5010", "6240"] },
+    detail: ({ status }) => `QuickBooks Online returned HTTP ${status}.`,
+    unreadable: "QuickBooks Online returned a successful response that is not JSON.",
+    numericFacts: {
+        retryAfterMs: { header: "retry-after", format: "retry-after", review: "Standard HTTP Retry-After delay." },
+    },
+    statuses: {
+        200: () => ({
+            code: "connector_call_failed",
+            retryable: false,
+            words: (detail) => `${detail} The accounting response was incomplete or invalid.`,
+        }),
+        400: ({ facts }) => ({
+            code: facts["faultCode"] === "610"
+                ? "connector_call_failed"
+                : ["5010", "6240"].includes(String(facts["faultCode"]))
+                    ? "conflict"
+                    : "invalid_args",
+            words: (detail) => facts["faultCode"] === "5010"
+                ? `${detail} The observed SyncToken is stale; reread and review the change.`
+                : facts["faultCode"] === "6240"
+                    ? `${detail} The DisplayName is already in use by a customer, vendor or employee.`
+                    : detail,
+            retryable: false,
+        }),
+        401: () => ({ code: "auth_required" }),
+        403: () => ({ code: "provider_permission_denied", retryable: false }),
+        404: () => ({ code: "connector_call_failed", retryable: false }),
+        429: ({ retryAfterMs }) => ({
+            code: "rate_limited",
+            retryAfterMs: Math.max(60_000, retryAfterMs ?? 0),
+            words: (detail) => `${detail} Intuit documents a wait of at least 60 seconds after throttling.`,
+        }),
+    },
+};
+/** Missing data is a failure, never a fabricated record/report/search or confirmed write. */
+const container = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
+const cells = (value) => Array.isArray(value) && value.every((cell) => container(cell) && typeof cell["value"] === "string");
+function reportRows(value, depth = 0) {
+    if (!container(value) || depth > 32)
+        return false;
+    if (value["Row"] === undefined)
+        return Object.keys(value).length === 0;
+    return (Array.isArray(value["Row"]) &&
+        value["Row"].every((row) => {
+            if (!container(row))
+                return false;
+            if (!["Header", "Summary", "ColData", "Rows"].some((key) => row[key] !== undefined))
+                return false;
+            for (const key of ["Header", "Summary"]) {
+                if (row[key] !== undefined && (!container(row[key]) || !cells(row[key]["ColData"])))
+                    return false;
+            }
+            return ((row["ColData"] === undefined || cells(row["ColData"])) &&
+                (row["Rows"] === undefined || reportRows(row["Rows"], depth + 1)));
+        }));
+}
+export const result = (body, answer) => {
+    const root = object(body);
+    const path = answer.operation.template;
+    let valid;
+    if (answer.operation.method === "POST") {
+        const key = path === "/customer" ? "Customer" : path === "/invoice" ? "Invoice" : undefined;
+        const record = key === undefined ? {} : object(root[key]);
+        const numericId = (value) => typeof value === "string" && /^[1-9]\d{0,30}$/.test(value);
+        const amount = (value) => typeof value === "number" && Number.isFinite(value) && value >= 0;
+        valid =
+            key !== undefined &&
+                numericId(record["Id"]) &&
+                typeof record["SyncToken"] === "string" &&
+                /^(?:0|[1-9]\d{0,30})$/.test(record["SyncToken"]) &&
+                (key === "Customer"
+                    ? typeof record["DisplayName"] === "string" && record["DisplayName"].trim() !== ""
+                    : (record["EmailStatus"] === undefined || record["EmailStatus"] === "NotSet") &&
+                        [
+                            "AllowIPNPayment",
+                            "AllowOnlinePayment",
+                            "AllowOnlineCreditCardPayment",
+                            "AllowOnlineACHPayment",
+                            "AllowOnlinePayPalPayment",
+                            "AllowOnlineAffirmPayment",
+                        ].every((key) => record[key] === undefined || record[key] === false) &&
+                        amount(record["TotalAmt"]) &&
+                        ["Balance", "HomeTotalAmt", "HomeBalance"].every((key) => record[key] === undefined || amount(record[key])) &&
+                        (record["ExchangeRate"] === undefined ||
+                            (typeof record["ExchangeRate"] === "number" &&
+                                Number.isFinite(record["ExchangeRate"]) &&
+                                record["ExchangeRate"] > 0)) &&
+                        typeof record["DocNumber"] === "string" &&
+                        record["DocNumber"].trim() !== "" &&
+                        numericId(object(record["CustomerRef"])["value"]) &&
+                        typeof object(record["CurrencyRef"])["value"] === "string" &&
+                        /^[A-Z]{3}$/.test(String(object(record["CurrencyRef"])["value"])) &&
+                        Array.isArray(record["Line"]) &&
+                        record["Line"].length > 0 &&
+                        record["Line"].every((line) => container(line) && amount(line["Amount"])) &&
+                        record["Line"].some((line) => object(line)["DetailType"] === "SalesItemLineDetail" &&
+                            numericId(object(object(object(line)["SalesItemLineDetail"])["ItemRef"])["value"])));
+    }
+    else if (path === "/query") {
+        const rows = root["QueryResponse"];
+        valid =
+            container(rows) &&
+                Object.entries(rows).every(([key, value]) => (["startPosition", "maxResults", "totalCount"].includes(key) &&
+                    typeof value === "number" &&
+                    Number.isSafeInteger(value) &&
+                    value >= (key === "startPosition" ? 1 : 0)) ||
+                    (answer.operation.flags?.[key] === true &&
+                        Array.isArray(value) &&
+                        (rows["totalCount"] === undefined ||
+                            (typeof rows["totalCount"] === "number" && rows["totalCount"] >= value.length)) &&
+                        (value.length > 0 ||
+                            ((rows["totalCount"] === undefined || rows["totalCount"] === 0) &&
+                                (rows["maxResults"] === undefined || rows["maxResults"] === 0))) &&
+                        value.every((row) => typeof object(row)["Id"] === "string" && object(row)["Id"] !== ""))) &&
+                (Object.keys(rows).some((key) => answer.operation.flags?.[key] === true) ||
+                    ((rows["totalCount"] === undefined || rows["totalCount"] === 0) &&
+                        (rows["maxResults"] === undefined || rows["maxResults"] === 0)));
+    }
+    else if (path.startsWith("/reports/")) {
+        const columns = object(root["Columns"])["Column"];
+        valid =
+            typeof object(root["Header"])["ReportName"] === "string" &&
+                Array.isArray(columns) &&
+                columns.every((column) => container(column)) &&
+                reportRows(root["Rows"]);
+    }
+    else {
+        const key = path.startsWith("/companyinfo/")
+            ? "CompanyInfo"
+            : Object.values(ENTITIES).find((entity) => path.startsWith(`/${entity.toLowerCase()}/`));
+        valid = key !== undefined && typeof object(root[key])["Id"] === "string";
+    }
+    return valid && root["Fault"] === undefined
+        ? Effect.succeed(body)
+        : Effect.fail(new StatusFailure({ status: answer.status, headers: answer.headers, body, operation: answer.operation }));
+};

package/dist/providers/quickbooks/index.d.ts

@@ -0,0 +1,13 @@
+import type { ProviderOptions } from "../../provider.js";
+/** One fixed QuickBooks Online company, using the deployment's own Intuit app. */
+export interface QuickBooksOptions extends ProviderOptions {
+    realmId: string;
+    environment: "sandbox" | "production";
+    clientId: string;
+    clientSecret: string;
+    /** Default rows per search: 25, at most 100. */
+    defaultPageSize?: number;
+    /** Defaults to true. Explicit false enables the bounded named writes. */
+    readOnly?: boolean;
+}
+export declare const quickbooks: import("../../provider.js").ProviderFactory<QuickBooksOptions>;