@automate.ax/integration-contracts 0.105.0 → 0.109.0

package/dist/close/schemas.d.ts

@@ -838,12 +838,12 @@ export declare const CLOSE_CALL_SCHEMA: z.ZodObject<{
     status: z.ZodEnum<{
         failed: "failed";
         completed: "completed";
+        timeout: "timeout";
         created: "created";
         busy: "busy";
         cancel: "cancel";
         "in-progress": "in-progress";
         "no-answer": "no-answer";
-        timeout: "timeout";
     }>;
     type: z.ZodLiteral<"Call">;
     userId: z.ZodNullable<z.ZodString>;
@@ -905,11 +905,11 @@ export declare const CLOSE_EMAIL_SCHEMA: z.ZodObject<{
     sequenceSubscriptionId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
     status: z.ZodEnum<{
         error: "error";
+        sent: "sent";
         inbox: "inbox";
         draft: "draft";
         outbox: "outbox";
         scheduled: "scheduled";
-        sent: "sent";
     }>;
     subject: z.ZodNullable<z.ZodString>;
     templateId: z.ZodNullable<z.ZodString>;
@@ -960,11 +960,11 @@ export declare const CLOSE_SMS_SCHEMA: z.ZodObject<{
     }>;
     status: z.ZodEnum<{
         error: "error";
+        sent: "sent";
         inbox: "inbox";
         draft: "draft";
         outbox: "outbox";
         scheduled: "scheduled";
-        sent: "sent";
     }>;
     templateId: z.ZodNullable<z.ZodString>;
     text: z.ZodNullable<z.ZodString>;
@@ -1068,12 +1068,12 @@ export declare const CLOSE_ACTIVITY_SCHEMA: z.ZodDiscriminatedUnion<[z.ZodObject
     status: z.ZodEnum<{
         failed: "failed";
         completed: "completed";
+        timeout: "timeout";
         created: "created";
         busy: "busy";
         cancel: "cancel";
         "in-progress": "in-progress";
         "no-answer": "no-answer";
-        timeout: "timeout";
     }>;
     type: z.ZodLiteral<"Call">;
     userId: z.ZodNullable<z.ZodString>;
@@ -1127,11 +1127,11 @@ export declare const CLOSE_ACTIVITY_SCHEMA: z.ZodDiscriminatedUnion<[z.ZodObject
     sequenceSubscriptionId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
     status: z.ZodEnum<{
         error: "error";
+        sent: "sent";
         inbox: "inbox";
         draft: "draft";
         outbox: "outbox";
         scheduled: "scheduled";
-        sent: "sent";
     }>;
     subject: z.ZodNullable<z.ZodString>;
     templateId: z.ZodNullable<z.ZodString>;
@@ -1269,11 +1269,11 @@ export declare const CLOSE_ACTIVITY_SCHEMA: z.ZodDiscriminatedUnion<[z.ZodObject
     }>;
     status: z.ZodEnum<{
         error: "error";
+        sent: "sent";
         inbox: "inbox";
         draft: "draft";
         outbox: "outbox";
         scheduled: "scheduled";
-        sent: "sent";
     }>;
     templateId: z.ZodNullable<z.ZodString>;
     text: z.ZodNullable<z.ZodString>;
@@ -1409,11 +1409,11 @@ export declare const CLOSE_ACTIVITY_SCHEMA: z.ZodDiscriminatedUnion<[z.ZodObject
         sequenceSubscriptionId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
         status: z.ZodEnum<{
             error: "error";
+            sent: "sent";
             inbox: "inbox";
             draft: "draft";
             outbox: "outbox";
             scheduled: "scheduled";
-            sent: "sent";
         }>;
         subject: z.ZodNullable<z.ZodString>;
         templateId: z.ZodNullable<z.ZodString>;
@@ -1505,11 +1505,11 @@ export declare const CLOSE_ACTIVITY_SCHEMA: z.ZodDiscriminatedUnion<[z.ZodObject
         sender: z.ZodNullable<z.ZodString>;
         status: z.ZodEnum<{
             error: "error";
+            sent: "sent";
             inbox: "inbox";
             draft: "draft";
             outbox: "outbox";
             scheduled: "scheduled";
-            sent: "sent";
         }>;
         subject: z.ZodNullable<z.ZodString>;
         to: z.ZodArray<z.ZodString>;
@@ -1862,10 +1862,10 @@ export declare const CLOSE_SEQUENCE_SUBSCRIPTION_SCHEMA: z.ZodObject<{
     startDate: z.ZodNullable<z.ZodPipe<z.ZodUnion<readonly [z.ZodDate, z.ZodString]>, z.ZodTransform<Date, string | Date>>>;
     status: z.ZodEnum<{
         error: "error";
+        paused: "paused";
         active: "active";
         finished: "finished";
         goal: "goal";
-        paused: "paused";
     }>;
     statusReason: z.ZodNullable<z.ZodString>;
     updatedAt: z.ZodPipe<z.ZodUnion<readonly [z.ZodDate, z.ZodString]>, z.ZodTransform<Date, string | Date>>;

package/dist/cloudflare/api.d.ts

@@ -0,0 +1,93 @@
+import type { Encodable } from "@automate.ax/codec";
+import * as z from "zod";
+declare const CLOUDFLARE_RESPONSE_INFO_SCHEMA: z.ZodObject<{
+    code: z.ZodOptional<z.ZodNumber>;
+    documentation_url: z.ZodOptional<z.ZodString>;
+    message: z.ZodString;
+    source: z.ZodOptional<z.ZodObject<{
+        pointer: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$loose>;
+/** Scalar query value supported by the Cloudflare client. */
+type CloudflareQueryValue = boolean | number | string | undefined;
+/** Resolved Cloudflare account accepted by the shared API client. */
+export interface CloudflareResolvedAccount {
+    connectionMethodId: string;
+    secret: Record<string, unknown>;
+    serviceId: "cloudflare";
+}
+/** Options for one authenticated Cloudflare REST request. */
+export interface CloudflareRequestOptions<TSchema extends z.ZodType> {
+    /** Public camelCase JSON body. */
+    body?: Encodable;
+    /** HTTP verb. Defaults to `GET`. */
+    method?: "DELETE" | "GET" | "PATCH" | "POST" | "PUT";
+    /** Public camelCase query parameters. */
+    query?: Record<string, CloudflareQueryValue>;
+    /** Schema for the normalized provider result. */
+    responseSchema: TSchema;
+}
+/** One normalized Cloudflare result page. */
+export interface CloudflarePage<T> {
+    result: T;
+    resultInfo?: {
+        count?: number;
+        page?: number;
+        perPage?: number;
+        totalCount?: number;
+        totalPages?: number;
+    };
+}
+/** Structured Cloudflare REST error. */
+export declare class CloudflareApiError extends Error {
+    /** Provider error records. */
+    readonly errors: z.output<typeof CLOUDFLARE_RESPONSE_INFO_SCHEMA>[];
+    /** Parsed Cloudflare rate-limit header, when present. */
+    readonly rateLimit?: string;
+    /** Parsed Cloudflare rate-limit policy header, when present. */
+    readonly rateLimitPolicy?: string;
+    /** Retry delay in seconds, when Cloudflare returned one. */
+    readonly retryAfter?: number;
+    /** HTTP status returned by Cloudflare. */
+    readonly status: number;
+    /**
+     * Creates a structured error from one Cloudflare response.
+     *
+     * @param options - Response status, provider errors, and limit metadata.
+     * @param options.errors - Provider error records.
+     * @param options.rateLimit - Current rate-limit header.
+     * @param options.rateLimitPolicy - Current rate-limit policy header.
+     * @param options.retryAfter - Retry delay in seconds.
+     * @param options.status - HTTP response status.
+     */
+    constructor(options: {
+        errors?: z.output<typeof CLOUDFLARE_RESPONSE_INFO_SCHEMA>[];
+        rateLimit?: string;
+        rateLimitPolicy?: string;
+        retryAfter?: number;
+        status: number;
+    });
+}
+/**
+ * Creates an authenticated Cloudflare REST client.
+ *
+ * @param account - Resolved OAuth or API-token account.
+ * @throws When the connection method or secret shape is unsupported.
+ */
+export declare function getCloudflareApi(account: CloudflareResolvedAccount): {
+    request: <TSchema extends z.ZodType>(path: string, options: CloudflareRequestOptions<TSchema>) => Promise<z.output<TSchema>>;
+    requestPage: <TSchema extends z.ZodType>(path: string, options: CloudflareRequestOptions<TSchema>) => Promise<CloudflarePage<z.output<TSchema>>>;
+};
+/**
+ * Converts public camelCase JSON to Cloudflare wire keys.
+ *
+ * @param value - Codec-safe public value.
+ */
+export declare function toCloudflare(value: Encodable): Encodable;
+/**
+ * Converts Cloudflare wire JSON to public camelCase keys.
+ *
+ * @param value - Untrusted provider JSON value.
+ */
+export declare function fromCloudflare(value: unknown): Encodable;
+export {};

package/dist/cloudflare/api.js

@@ -0,0 +1,250 @@
+import * as z from "zod";
+const CLOUDFLARE_API_BASE_URL = "https://api.cloudflare.com/client/v4/";
+const CLOUDFLARE_API_ORIGIN = new URL(CLOUDFLARE_API_BASE_URL).origin;
+const CLOUDFLARE_API_TOKEN_SECRET_SCHEMA = z.object({
+    apiKey: z.string().min(1),
+});
+const CLOUDFLARE_OAUTH_SECRET_SCHEMA = z.object({
+    accessToken: z.string().min(1),
+});
+const CLOUDFLARE_RESPONSE_INFO_SCHEMA = z.looseObject({
+    code: z.number().optional(),
+    documentation_url: z.string().optional(),
+    message: z.string(),
+    source: z.object({ pointer: z.string().optional() }).optional(),
+});
+const CLOUDFLARE_ENVELOPE_SCHEMA = z.looseObject({
+    errors: CLOUDFLARE_RESPONSE_INFO_SCHEMA.array().default([]),
+    messages: CLOUDFLARE_RESPONSE_INFO_SCHEMA.array().default([]),
+    result: z.unknown().optional(),
+    result_info: z
+        .looseObject({
+        count: z.number().int().nonnegative().optional(),
+        page: z.number().int().positive().optional(),
+        per_page: z.number().int().positive().optional(),
+        total_count: z.number().int().nonnegative().optional(),
+        total_pages: z.number().int().nonnegative().optional(),
+    })
+        .optional(),
+    success: z.boolean(),
+});
+const CLOUDFLARE_RESULT_INFO_SCHEMA = z.looseObject({
+    count: z.number().int().nonnegative().optional(),
+    page: z.number().int().positive().optional(),
+    perPage: z.number().int().positive().optional(),
+    totalCount: z.number().int().nonnegative().optional(),
+    totalPages: z.number().int().nonnegative().optional(),
+});
+/** Structured Cloudflare REST error. */
+export class CloudflareApiError extends Error {
+    /** Provider error records. */
+    errors;
+    /** Parsed Cloudflare rate-limit header, when present. */
+    rateLimit;
+    /** Parsed Cloudflare rate-limit policy header, when present. */
+    rateLimitPolicy;
+    /** Retry delay in seconds, when Cloudflare returned one. */
+    retryAfter;
+    /** HTTP status returned by Cloudflare. */
+    status;
+    /**
+     * Creates a structured error from one Cloudflare response.
+     *
+     * @param options - Response status, provider errors, and limit metadata.
+     * @param options.errors - Provider error records.
+     * @param options.rateLimit - Current rate-limit header.
+     * @param options.rateLimitPolicy - Current rate-limit policy header.
+     * @param options.retryAfter - Retry delay in seconds.
+     * @param options.status - HTTP response status.
+     */
+    constructor(options) {
+        const errors = options.errors ?? [];
+        super(errors[0]?.message
+            ? `Cloudflare API error (${options.status}): ${errors[0].message}`
+            : `Cloudflare API request failed with status ${options.status}.`);
+        this.name = "CloudflareApiError";
+        this.errors = errors;
+        this.rateLimit = options.rateLimit;
+        this.rateLimitPolicy = options.rateLimitPolicy;
+        this.retryAfter = options.retryAfter;
+        this.status = options.status;
+    }
+}
+/**
+ * Creates an authenticated Cloudflare REST client.
+ *
+ * @param account - Resolved OAuth or API-token account.
+ * @throws When the connection method or secret shape is unsupported.
+ */
+export function getCloudflareApi(account) {
+    const accessToken = account.connectionMethodId === "oauth"
+        ? CLOUDFLARE_OAUTH_SECRET_SCHEMA.parse(account.secret).accessToken
+        : account.connectionMethodId === "api-token"
+            ? CLOUDFLARE_API_TOKEN_SECRET_SCHEMA.parse(account.secret).apiKey
+            : undefined;
+    if (!accessToken) {
+        throw new Error(`Unsupported Cloudflare connection method: ${account.connectionMethodId}`);
+    }
+    /**
+     * Runs one request and returns its normalized result.
+     *
+     * @param path - Cloudflare API path relative to the v4 root.
+     * @param options - Method, parameters, and response schema.
+     */
+    async function request(path, options) {
+        return (await requestPage(path, options)).result;
+    }
+    /**
+     * Runs one request and preserves Cloudflare page metadata.
+     *
+     * @param path - Cloudflare API path relative to the v4 root.
+     * @param options - Method, parameters, and response schema.
+     */
+    async function requestPage(path, options) {
+        const url = new URL(path.replace(/^\//, ""), CLOUDFLARE_API_BASE_URL);
+        if (url.origin !== CLOUDFLARE_API_ORIGIN) {
+            throw new Error("Cloudflare API paths must use the Cloudflare API origin.");
+        }
+        for (const [name, value] of Object.entries(options.query ?? {})) {
+            if (value !== undefined)
+                url.searchParams.set(toSnakeCase(name), String(value));
+        }
+        const response = await fetch(url, {
+            body: options.body === undefined
+                ? undefined
+                : JSON.stringify(toCloudflare(options.body)),
+            headers: {
+                Accept: "application/json",
+                Authorization: `Bearer ${accessToken}`,
+                ...(options.body === undefined
+                    ? {}
+                    : { "Content-Type": "application/json" }),
+            },
+            method: options.method ?? "GET",
+        });
+        const parsed = CLOUDFLARE_ENVELOPE_SCHEMA.safeParse(parseJson(await response.text()));
+        if (!response.ok || !parsed.success || !parsed.data.success) {
+            throw new CloudflareApiError({
+                errors: parsed.success ? parsed.data.errors : undefined,
+                rateLimit: response.headers.get("Ratelimit") ?? undefined,
+                rateLimitPolicy: response.headers.get("Ratelimit-Policy") ?? undefined,
+                retryAfter: parseFiniteNumber(response.headers.get("Retry-After")),
+                status: response.status,
+            });
+        }
+        return {
+            result: options.responseSchema.parse(fromCloudflare(parsed.data.result)),
+            ...(parsed.data.result_info && {
+                resultInfo: CLOUDFLARE_RESULT_INFO_SCHEMA.parse(fromCloudflare(parsed.data.result_info)),
+            }),
+        };
+    }
+    return { request, requestPage };
+}
+/**
+ * Converts public camelCase JSON to Cloudflare wire keys.
+ *
+ * @param value - Codec-safe public value.
+ */
+export function toCloudflare(value) {
+    return convertToCloudflare(value, false);
+}
+/**
+ * Converts one value while optionally preserving object keys.
+ *
+ * @param value - Public value to convert.
+ * @param preserveKeys - Whether this object is a provider-defined map.
+ */
+function convertToCloudflare(value, preserveKeys) {
+    if (value instanceof Date)
+        return value.toISOString();
+    if (Array.isArray(value))
+        return value.map((item) => convertToCloudflare(item, preserveKeys));
+    if (!isPlainObject(value))
+        return value;
+    return Object.fromEntries(Object.entries(value).map(([key, item]) => [
+        preserveKeys ? key : toSnakeCase(key),
+        convertToCloudflare(item, key === "header" || key === "headers"),
+    ]));
+}
+/**
+ * Converts Cloudflare wire JSON to public camelCase keys.
+ *
+ * @param value - Untrusted provider JSON value.
+ */
+export function fromCloudflare(value) {
+    return convertFromCloudflare(value, false);
+}
+/**
+ * Converts one provider value while optionally preserving object keys.
+ *
+ * @param value - Provider value to convert.
+ * @param preserveKeys - Whether this object is a provider-defined map.
+ */
+function convertFromCloudflare(value, preserveKeys) {
+    if (Array.isArray(value))
+        return value.map((item) => convertFromCloudflare(item, preserveKeys));
+    if (!isPlainObject(value))
+        return CLOUDFLARE_VALUE_SCHEMA.parse(value);
+    return Object.fromEntries(Object.entries(value).map(([key, item]) => [
+        preserveKeys ? key : toCamelCase(key),
+        convertFromCloudflare(item, key === "header" || key === "headers"),
+    ]));
+}
+const CLOUDFLARE_VALUE_SCHEMA = z.union([
+    z.boolean(),
+    z.number(),
+    z.string(),
+    z.null(),
+    z.undefined(),
+]);
+/**
+ * Returns whether a value is a plain JSON object.
+ *
+ * @param value - Candidate value.
+ */
+function isPlainObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+/**
+ * Parses JSON without obscuring the eventual structured API error.
+ *
+ * @param value - Raw response text.
+ */
+function parseJson(value) {
+    try {
+        return JSON.parse(value);
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * Parses a finite numeric response header.
+ *
+ * @param value - Header value.
+ */
+function parseFiniteNumber(value) {
+    if (value === null)
+        return undefined;
+    const number = Number(value);
+    return Number.isFinite(number) ? number : undefined;
+}
+/**
+ * Converts one Cloudflare snake_case key to camelCase.
+ *
+ * @param value - Provider key.
+ */
+function toCamelCase(value) {
+    return value.replace(/_([a-z0-9])/g, (_match, character) => character.toUpperCase());
+}
+/**
+ * Converts one public camelCase key to snake_case.
+ *
+ * @param value - Public key.
+ */
+function toSnakeCase(value) {
+    return value
+        .replace(/([a-zA-Z])([0-9])/g, "$1_$2")
+        .replace(/[A-Z]/g, (character) => `_${character.toLowerCase()}`);
+}