contiguity 0.0.1

package/dist/types/base.js

@@ -0,0 +1,32 @@
+import { ContiguityResponse, ContiguityRawResponse } from "@/types/response";
+/**
+ * Base response builder that automatically creates flattened and raw response types
+ * This eliminates the need to manually define *ResponseFlattened and *ResponseRaw for each service
+ */
+export class BaseResponseBuilder {
+    schema;
+    constructor(schema) {
+        this.schema = schema;
+    }
+    get response() {
+        return this.schema;
+    }
+    get flattened() {
+        return ContiguityResponse.extend(this.schema.shape);
+    }
+    get raw() {
+        return ContiguityRawResponse.extend({
+            data: this.schema,
+        });
+    }
+    get all() {
+        return {
+            response: this.response,
+            flattened: this.flattened,
+            raw: this.raw,
+        };
+    }
+}
+export function createResponse(schema) {
+    return new BaseResponseBuilder(schema);
+}

package/dist/types/common.d.ts

@@ -0,0 +1,56 @@
+import { z } from "zod";
+/**
+ * Common validation schemas used across multiple services
+ */
+export declare const E164PhoneNumber: z.ZodString;
+export declare const MessageContent: z.ZodString;
+export declare const OptionalSenderNumber: z.ZodOptional<z.ZodString>;
+export declare const AttachmentList: z.ZodOptional<z.ZodArray<z.ZodString>>;
+export declare const SingleOrMultipleEmails: (maxCount?: number, fieldName?: string) => z.ZodUnion<readonly [z.ZodEmail, z.ZodArray<z.ZodEmail>]>;
+export declare const TypingAction: z.ZodEnum<{
+    start: "start";
+    stop: "stop";
+}>;
+export declare const NumberStatus: z.ZodEnum<{
+    available: "available";
+    "g-available": "g-available";
+    leased: "leased";
+    unavailable: "unavailable";
+}>;
+export declare const LeaseStatus: z.ZodEnum<{
+    active: "active";
+    expired: "expired";
+    terminated: "terminated";
+}>;
+export declare const BillingMethod: z.ZodEnum<{
+    monthly: "monthly";
+    service_contract: "service_contract";
+    goodwill: "goodwill";
+}>;
+export declare const Currency: z.ZodEnum<{
+    USD: "USD";
+    EUR: "EUR";
+    GBP: "GBP";
+    CAD: "CAD";
+    AUD: "AUD";
+}>;
+export declare const Carrier: z.ZodEnum<{
+    "T-Mobile": "T-Mobile";
+    "AT&T": "AT&T";
+    Verizon: "Verizon";
+    Contiguity: "Contiguity";
+    "International Partner": "International Partner";
+}>;
+export declare const MessageChannel: z.ZodEnum<{
+    sms: "sms";
+    mms: "mms";
+    rcs: "rcs";
+    imessage: "imessage";
+    whatsapp: "whatsapp";
+}>;
+export declare const createFallbackSchema: <T extends string>(serviceType: T, fallbackConditions: readonly [T, ...T[]]) => z.ZodOptional<z.ZodObject<{
+    when: z.ZodArray<z.ZodEnum<{ [k_1 in T]: k_1; } extends infer T_1 ? { [k in keyof T_1]: T_1[k]; } : never>>;
+    from: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>>;
+export type RequestFunction<TParams, TResponse> = (this: any, params: TParams) => Promise<TResponse>;
+//# sourceMappingURL=common.d.ts.map

package/dist/types/common.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"common.d.ts","sourceRoot":"","sources":["../../src/types/common.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB;;GAEG;AAGH,eAAO,MAAM,eAAe,aAAgF,CAAC;AAG7G,eAAO,MAAM,cAAc,aAA+C,CAAC;AAG3E,eAAO,MAAM,oBAAoB,4BAAwB,CAAC;AAG1D,eAAO,MAAM,cAAc,wCAGZ,CAAC;AAGhB,eAAO,MAAM,sBAAsB,GAAI,WAAU,MAAW,EAAE,YAAW,MAAgB,8DAKnF,CAAC;AAGP,eAAO,MAAM,YAAY;;;EAAgF,CAAC;AAG1G,eAAO,MAAM,YAAY;;;;;EAAgE,CAAC;AAE1F,eAAO,MAAM,WAAW;;;;EAA8C,CAAC;AAEvE,eAAO,MAAM,aAAa;;;;EAAsD,CAAC;AAEjF,eAAO,MAAM,QAAQ;;;;;;EAA8C,CAAC;AAEpE,eAAO,MAAM,OAAO;;;;;;EAMlB,CAAC;AAEH,eAAO,MAAM,cAAc;;;;;;EAMzB,CAAC;AAEH,eAAO,MAAM,oBAAoB,GAAI,CAAC,SAAS,MAAM,EACjD,aAAa,CAAC,EACd,oBAAoB,SAAS,CAAC,CAAC,EAAE,GAAG,CAAC,EAAE,CAAC;;;kBAM/B,CAAC;AAGd,MAAM,MAAM,eAAe,CAAC,OAAO,EAAE,SAAS,IAAI,CAC9C,IAAI,EAAE,GAAG,EACT,MAAM,EAAE,OAAO,KACd,OAAO,CAAC,SAAS,CAAC,CAAC"}

package/dist/types/common.js

@@ -0,0 +1,48 @@
+import { z } from "zod";
+/**
+ * Common validation schemas used across multiple services
+ */
+// Phone number validation - used in text, iMessage, WhatsApp, and lease services
+export const E164PhoneNumber = z.string().regex(/^\+[1-9]\d{1,14}$/, "Phone number must be in E.164 format");
+// Message validation - used across messaging services
+export const MessageContent = z.string().min(1, "Message cannot be empty");
+// Optional sender number - used across messaging services
+export const OptionalSenderNumber = z.string().optional();
+// Attachment validation - used in iMessage and WhatsApp
+export const AttachmentList = z
+    .array(z.string().min(1, "Attachment cannot be empty"))
+    .max(10, "Maximum 10 attachments allowed")
+    .optional();
+// Email validation patterns - used in email service
+export const SingleOrMultipleEmails = (maxCount = 10, fieldName = "email") => z.union([
+    z.email(`Must be a valid ${fieldName} address`),
+    z.array(z.email(`Must be a valid ${fieldName} address`))
+        .max(maxCount, `Maximum ${maxCount} ${fieldName} addresses allowed`)
+]);
+// Typing action validation - used in iMessage and WhatsApp typing
+export const TypingAction = z.enum(["start", "stop"]).describe("Action must be either 'start' or 'stop'");
+// Common status enums
+export const NumberStatus = z.enum(["available", "g-available", "leased", "unavailable"]);
+export const LeaseStatus = z.enum(["active", "expired", "terminated"]);
+export const BillingMethod = z.enum(["monthly", "service_contract", "goodwill"]);
+export const Currency = z.enum(["USD", "EUR", "GBP", "CAD", "AUD"]);
+export const Carrier = z.enum([
+    "T-Mobile",
+    "AT&T",
+    "Verizon",
+    "Contiguity",
+    "International Partner"
+]);
+export const MessageChannel = z.enum([
+    "sms",
+    "mms",
+    "rcs",
+    "imessage",
+    "whatsapp"
+]);
+export const createFallbackSchema = (serviceType, fallbackConditions) => z.object({
+    /** When to fallback to SMS/RCS */
+    when: z.array(z.enum(fallbackConditions)).min(1, "At least one fallback condition must be specified"),
+    /** Fallback sender number */
+    from: OptionalSenderNumber
+}).optional();

package/dist/types/error.d.ts

@@ -0,0 +1,37 @@
+import { z } from "zod";
+export declare const ContiguityAPIError: z.ZodObject<{
+    id: z.ZodString;
+    timestamp: z.ZodNumber;
+    api_version: z.ZodString;
+    object: z.ZodString;
+    data: z.ZodObject<{
+        status: z.ZodNumber;
+        error: z.ZodString;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export interface ContiguityErrorData {
+    data: {
+        status: number;
+        error: string;
+    };
+}
+export declare class ContiguityError extends Error {
+    readonly status: number;
+    constructor(response: ContiguityErrorData);
+    static fromError(error: any): ContiguityError;
+    toString(): string;
+    toJSON(): {
+        message: string;
+        status: number;
+    };
+}
+export declare class ContiguitySDKError extends Error {
+    readonly status: string;
+    constructor(message: string, status?: string);
+    toString(): string;
+    toJSON(): {
+        message: string;
+        status: string;
+    };
+}
+//# sourceMappingURL=error.d.ts.map

package/dist/types/error.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"error.d.ts","sourceRoot":"","sources":["../../src/types/error.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,kBAAkB;;;;;;;;;iBAS7B,CAAC;AAEH,MAAM,WAAW,mBAAmB;IAChC,IAAI,EAAE;QACF,MAAM,EAAE,MAAM,CAAC;QACf,KAAK,EAAE,MAAM,CAAC;KACjB,CAAC;CACL;AAED,qBAAa,eAAgB,SAAQ,KAAK;IACtC,SAAgB,MAAM,EAAE,MAAM,CAAC;gBAEnB,QAAQ,EAAE,mBAAmB;IAMzC,MAAM,CAAC,SAAS,CAAC,KAAK,EAAE,GAAG;IASlB,QAAQ;IAIjB,MAAM;;;;CAMT;AAED,qBAAa,kBAAmB,SAAQ,KAAK;IACzC,SAAgB,MAAM,EAAE,MAAM,CAAC;gBAEnB,OAAO,EAAE,MAAM,EAAE,MAAM,GAAE,MAAoB;IAOhD,QAAQ;IAIjB,MAAM;;;;CAMT"}

package/dist/types/error.js

@@ -0,0 +1,54 @@
+import { z } from "zod";
+export const ContiguityAPIError = z.object({
+    id: z.string(),
+    timestamp: z.number(),
+    api_version: z.string(),
+    object: z.string(),
+    data: z.object({
+        status: z.number(),
+        error: z.string(),
+    }),
+});
+export class ContiguityError extends Error {
+    status;
+    constructor(response) {
+        super(response.data.error);
+        this.message = response.data.error;
+        this.status = response.data.status;
+    }
+    static fromError(error) {
+        return new ContiguityError({
+            data: {
+                error: error.message || "Unknown error",
+                status: error.status || 500,
+            }
+        });
+    }
+    toString() {
+        return `[Contiguity Error]: ${this.message} (status: ${this.status})`;
+    }
+    toJSON() {
+        return {
+            message: this.message,
+            status: this.status,
+        };
+    }
+}
+export class ContiguitySDKError extends Error {
+    status;
+    constructor(message, status = 'sdk_error') {
+        super(message);
+        this.message = message;
+        this.status = status;
+        this.name = '[Contiguity SDK Error]';
+    }
+    toString() {
+        return `[Contiguity SDK Error]: ${this.message} (status: ${this.status})`;
+    }
+    toJSON() {
+        return {
+            message: this.message,
+            status: this.status,
+        };
+    }
+}

package/dist/types/metadata.d.ts

@@ -0,0 +1,10 @@
+export interface ContiguityMetadata {
+    id: string;
+    timestamp: number;
+    api_version: string;
+    object: string;
+}
+export type WithMetadata<T> = T & {
+    metadata: ContiguityMetadata;
+};
+//# sourceMappingURL=metadata.d.ts.map

package/dist/types/metadata.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"metadata.d.ts","sourceRoot":"","sources":["../../src/types/metadata.ts"],"names":[],"mappings":"AACA,MAAM,WAAW,kBAAkB;IAC/B,EAAE,EAAE,MAAM,CAAC;IACX,SAAS,EAAE,MAAM,CAAC;IAClB,WAAW,EAAE,MAAM,CAAC;IACpB,MAAM,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,MAAM,YAAY,CAAC,CAAC,IAAI,CAAC,GAAG;IAC9B,QAAQ,EAAE,kBAAkB,CAAC;CAChC,CAAC"}

package/dist/types/metadata.js

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

package/dist/types/response.d.ts

@@ -0,0 +1,17 @@
+import { z } from "zod";
+export declare const ContiguityRawResponse: z.ZodObject<{
+    id: z.ZodString;
+    timestamp: z.ZodNumber;
+    api_version: z.ZodString;
+    object: z.ZodString;
+    data: z.ZodAny;
+}, z.core.$strip>;
+export declare const ContiguityResponse: z.ZodObject<{
+    metadata: z.ZodObject<{
+        id: z.ZodString;
+        timestamp: z.ZodNumber;
+        api_version: z.ZodString;
+        object: z.ZodString;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+//# sourceMappingURL=response.d.ts.map

package/dist/types/response.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"response.d.ts","sourceRoot":"","sources":["../../src/types/response.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,qBAAqB;;;;;;iBAMhC,CAAC;AAGH,eAAO,MAAM,kBAAkB;;;;;;;iBAQ7B,CAAC"}

package/dist/types/response.js

@@ -0,0 +1,17 @@
+import { z } from "zod";
+export const ContiguityRawResponse = z.object({
+    id: z.string(),
+    timestamp: z.number(),
+    api_version: z.string(),
+    object: z.string(),
+    data: z.any(),
+});
+export const ContiguityResponse = z.object({
+    metadata: z.object({
+        id: z.string(),
+        timestamp: z.number(),
+        api_version: z.string(),
+        object: z.string(),
+    }),
+    // we run zod.extend with data here.
+});

package/dist/utils/parse.d.ts

@@ -0,0 +1,8 @@
+import { z } from "zod";
+/**
+ * Normalizes API responses to either raw or flattened format
+ * This utility handles the complex logic of parsing different response formats
+ * from the Contiguity API and normalizing them consistently.
+ */
+export declare function parseContiguityResponse<T extends z.ZodType, R extends z.ZodType>(response: any, dataSchema: T, rawResponseSchema: R, returnRaw?: boolean): any;
+//# sourceMappingURL=parse.d.ts.map

package/dist/utils/parse.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse.d.ts","sourceRoot":"","sources":["../../src/utils/parse.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB;;;;GAIG;AACH,wBAAgB,uBAAuB,CAAC,CAAC,SAAS,CAAC,CAAC,OAAO,EAAE,CAAC,SAAS,CAAC,CAAC,OAAO,EAC5E,QAAQ,EAAE,GAAG,EACb,UAAU,EAAE,CAAC,EACb,iBAAiB,EAAE,CAAC,EACpB,SAAS,GAAE,OAAe,GAC3B,GAAG,CAiCL"}

package/dist/utils/parse.js

@@ -0,0 +1,36 @@
+/**
+ * Normalizes API responses to either raw or flattened format
+ * This utility handles the complex logic of parsing different response formats
+ * from the Contiguity API and normalizing them consistently.
+ */
+export function parseContiguityResponse(response, dataSchema, rawResponseSchema, returnRaw = false) {
+    // Handle different response formats:
+    // 1. Already wrapped in response format (response.object === "response")
+    // 2. Direct data that needs wrapping
+    // 3. Fallback to raw parsing
+    const validatedResponse = response.object === "response"
+        ? rawResponseSchema.parse(response)
+        : dataSchema.safeParse(response).success
+            ? {
+                id: response.id || "unknown",
+                timestamp: response.timestamp || Date.now(),
+                api_version: response.api_version || "unknown",
+                object: response.object || "unknown",
+                data: dataSchema.parse(response),
+            }
+            : rawResponseSchema.parse(response);
+    if (returnRaw) {
+        return validatedResponse;
+    }
+    // For flattened responses, we need to handle both formats
+    const rawData = rawResponseSchema.parse(validatedResponse);
+    return {
+        ...rawData.data,
+        metadata: {
+            id: rawData.id,
+            timestamp: rawData.timestamp,
+            api_version: rawData.api_version,
+            object: rawData.object,
+        },
+    };
+}

package/dist/utils/request.d.ts

@@ -0,0 +1,6 @@
+import { z } from "zod";
+/**
+ * Standard request function factory - reduces duplication across services
+ */
+export declare function createRequestFunction<TRequest extends z.ZodType, TResponse extends z.ZodType, TRawResponse extends z.ZodType>(requestSchema: TRequest, responseSchema: TResponse, rawResponseSchema: TRawResponse, endpoint: string, method?: 'GET' | 'POST' | 'PUT' | 'DELETE'): (this: any, params?: z.infer<TRequest>) => Promise<any>;
+//# sourceMappingURL=request.d.ts.map

package/dist/utils/request.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"request.d.ts","sourceRoot":"","sources":["../../src/utils/request.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB;;GAEG;AACH,wBAAgB,qBAAqB,CAAC,QAAQ,SAAS,CAAC,CAAC,OAAO,EAAE,SAAS,SAAS,CAAC,CAAC,OAAO,EAAE,YAAY,SAAS,CAAC,CAAC,OAAO,EACzH,aAAa,EAAE,QAAQ,EACvB,cAAc,EAAE,SAAS,EACzB,iBAAiB,EAAE,YAAY,EAC/B,QAAQ,EAAE,MAAM,EAChB,MAAM,GAAE,KAAK,GAAG,MAAM,GAAG,KAAK,GAAG,QAAiB,IAE5B,MAAM,GAAG,EAAE,SAAS,CAAC,CAAC,KAAK,CAAC,QAAQ,CAAC,KAAG,OAAO,CAAC,GAAG,CAAC,CA8C7E"}

package/dist/utils/request.js

@@ -0,0 +1,47 @@
+/**
+ * Standard request function factory - reduces duplication across services
+ */
+export function createRequestFunction(requestSchema, responseSchema, rawResponseSchema, endpoint, method = 'POST') {
+    return async function (params) {
+        let validatedParams;
+        let url = endpoint;
+        let body;
+        if (params !== undefined) {
+            validatedParams = requestSchema.parse(params);
+            // Handle path parameters (for endpoints with {param})
+            if (endpoint.includes('{') && endpoint.includes('}')) {
+                // Extract path parameter name (e.g., "{number}" -> "number")
+                const pathParamMatch = endpoint.match(/\{(\w+)\}/);
+                if (pathParamMatch && pathParamMatch[1] && validatedParams && typeof validatedParams === 'object') {
+                    const pathParam = pathParamMatch[1];
+                    const pathValue = validatedParams[pathParam];
+                    if (pathValue) {
+                        url = endpoint.replace(`{${pathParam}}`, encodeURIComponent(pathValue));
+                        // Remove path param from body
+                        const bodyParams = { ...validatedParams };
+                        delete bodyParams[pathParam];
+                        // Only set body if there are remaining params and not GET/DELETE
+                        if (Object.keys(bodyParams).length > 0 && method !== 'GET' && method !== 'DELETE') {
+                            body = JSON.stringify(bodyParams);
+                        }
+                    }
+                }
+            }
+            else if (method !== 'GET' && method !== 'DELETE') {
+                // For non-path-param endpoints, use all params as body
+                body = JSON.stringify(validatedParams);
+            }
+        }
+        const response = await this.request(url, {
+            method,
+            ...(body && { body })
+        });
+        return this.parse({
+            response,
+            schemas: {
+                sdk: responseSchema,
+                raw: rawResponseSchema
+            }
+        });
+    };
+}

package/package.json

@@ -0,0 +1,46 @@
+{
+    "name": "contiguity",
+    "version": "0.0.1",
+    "type": "module",
+    "description": "Contiguity's official JavaScript SDK",
+    "author": "Contiguity",
+    "license": "MIT",
+    "main": "./dist/index.js",
+    "module": "./dist/index.js",
+    "types": "./dist/index.d.ts",
+    "files": [
+        "dist/**/*",
+        "README.md",
+        "LICENSE.md"
+    ],
+    "keywords": [
+        "contiguity",
+        "sms",
+        "email",
+        "whatsapp",
+        "imessage",
+        "otp",
+        "domains"
+    ],
+    "homepage": "https://contiguity.com",
+    "bugs": {
+        "url": "https://github.com/contiguity/javascript/issues"
+    },
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/contiguity/javascript.git"
+    },
+    "scripts": {
+        "publish": "bun publish --access public",
+        "dev": "bun run src/index.ts",
+        "build": "bunx tsc && bun build src/index.ts --outdir=dist --format=esm --target=node",
+        "typecheck": "bunx tsc --noEmit",
+        "update-deps": "npx npm-check-updates"
+    },
+    "dependencies": {
+        "zod": "^4.0.17"
+    },
+    "devDependencies": {
+        "typescript": "^5.9.2"
+    }
+}