@hasna/connectors 0.0.1

package/connectors/connect-wix/src/api/client.ts

@@ -0,0 +1,147 @@
+import type { WixConfig } from '../types';
+import { WixApiError } from '../types';
+
+export interface WixRequestOptions {
+  method?: 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
+  params?: Record<string, string | number | boolean | undefined>;
+  body?: unknown;
+  headers?: Record<string, string>;
+  siteId?: string; // Override site ID for this request
+}
+
+/**
+ * Wix REST API Client
+ * Uses API key authentication with site-level tokens
+ *
+ * Base URL: https://www.wixapis.com
+ * Auth: Authorization header with API key
+ * Site context: wix-site-id header for site-specific calls
+ */
+export class WixClient {
+  private readonly apiKey: string;
+  private readonly siteId?: string;
+  private readonly accountId?: string;
+  private readonly baseUrl = 'https://www.wixapis.com';
+
+  constructor(config: WixConfig) {
+    if (!config.apiKey) {
+      throw new Error('Wix API key is required');
+    }
+
+    this.apiKey = config.apiKey;
+    this.siteId = config.siteId;
+    this.accountId = config.accountId;
+  }
+
+  /**
+   * Make a request to the Wix REST API
+   */
+  async request<T>(endpoint: string, options: WixRequestOptions = {}): Promise<T> {
+    const { method = 'GET', params, body, headers = {}, siteId } = options;
+
+    // Build URL with query params
+    let url = `${this.baseUrl}${endpoint}`;
+    if (params) {
+      const searchParams = new URLSearchParams();
+      Object.entries(params).forEach(([key, value]) => {
+        if (value !== undefined && value !== null && value !== '') {
+          searchParams.append(key, String(value));
+        }
+      });
+      const queryString = searchParams.toString();
+      if (queryString) {
+        url += `?${queryString}`;
+      }
+    }
+
+    // Build headers
+    const requestHeaders: Record<string, string> = {
+      'Authorization': this.apiKey,
+      'Content-Type': 'application/json',
+      'Accept': 'application/json',
+      ...headers,
+    };
+
+    // Add site ID header if available
+    const effectiveSiteId = siteId || this.siteId;
+    if (effectiveSiteId) {
+      requestHeaders['wix-site-id'] = effectiveSiteId;
+    }
+
+    // Add account ID header if available
+    if (this.accountId) {
+      requestHeaders['wix-account-id'] = this.accountId;
+    }
+
+    // Make request
+    const response = await fetch(url, {
+      method,
+      headers: requestHeaders,
+      body: body ? JSON.stringify(body) : undefined,
+    });
+
+    // Handle response
+    if (response.status === 204) {
+      return {} as T;
+    }
+
+    let data: unknown;
+    const contentType = response.headers.get('content-type') || '';
+
+    if (contentType.includes('application/json')) {
+      const text = await response.text();
+      if (text) {
+        try {
+          data = JSON.parse(text);
+        } catch {
+          data = text;
+        }
+      }
+    } else {
+      data = await response.text();
+    }
+
+    if (!response.ok) {
+      let errorMessage = `Wix API Error: ${response.status} ${response.statusText}`;
+      let details: Record<string, unknown> | undefined;
+
+      if (typeof data === 'object' && data !== null) {
+        const errData = data as Record<string, unknown>;
+        if (errData.message) {
+          errorMessage = String(errData.message);
+        }
+        if (errData.details) {
+          details = errData.details as Record<string, unknown>;
+        }
+      }
+
+      throw new WixApiError(errorMessage, response.status, details);
+    }
+
+    return data as T;
+  }
+
+  /**
+   * Get site ID
+   */
+  getSiteId(): string | undefined {
+    return this.siteId;
+  }
+
+  /**
+   * Get account ID
+   */
+  getAccountId(): string | undefined {
+    return this.accountId;
+  }
+
+  /**
+   * Get a preview of the API key (for display/debugging)
+   */
+  getApiKeyPreview(): string {
+    if (this.apiKey.length > 12) {
+      return `${this.apiKey.substring(0, 6)}...${this.apiKey.substring(this.apiKey.length - 4)}`;
+    }
+    return '***';
+  }
+}

package/connectors/connect-wix/src/api/contacts.ts

@@ -0,0 +1,308 @@
+import type { WixClient } from './client';
+import type { Contact, CreateContactRequest, UpdateContactRequest, ContactInfo, ContactName, ContactEmail, ContactPhone, ContactAddress, Address, StreetAddress, PrimaryContactInfo, ContactSource, ContactActivity } from '../types';
+
+export interface ListContactsOptions {
+  limit?: number;
+  offset?: number;
+  sort?: { fieldName: string; order?: 'ASC' | 'DESC' }[];
+}
+
+export interface SearchContactsOptions extends ListContactsOptions {
+  search?: string;
+  filter?: Record<string, unknown>;
+}
+
+/**
+ * Wix Contacts API
+ * Endpoint: /contacts/v4/contacts
+ */
+export class ContactsApi {
+  constructor(private readonly client: WixClient) {}
+
+  /**
+   * List contacts
+   */
+  async list(options: ListContactsOptions = {}): Promise<Contact[]> {
+    const response = await this.client.request<{ contacts: Record<string, unknown>[] }>(
+      '/contacts/v4/contacts/query',
+      {
+        method: 'POST',
+        body: {
+          query: {
+            paging: {
+              limit: options.limit || 50,
+              offset: options.offset || 0,
+            },
+            sort: options.sort,
+          },
+        },
+      }
+    );
+
+    return this.transformContacts(response.contacts || []);
+  }
+
+  /**
+   * Search contacts
+   */
+  async search(options: SearchContactsOptions = {}): Promise<Contact[]> {
+    const body: Record<string, unknown> = {
+      query: {
+        paging: {
+          limit: options.limit || 50,
+          offset: options.offset || 0,
+        },
+        sort: options.sort,
+      },
+    };
+
+    if (options.search) {
+      body.search = { expression: options.search };
+    }
+
+    if (options.filter) {
+      (body.query as Record<string, unknown>).filter = options.filter;
+    }
+
+    const response = await this.client.request<{ contacts: Record<string, unknown>[] }>(
+      '/contacts/v4/contacts/query',
+      { method: 'POST', body }
+    );
+
+    return this.transformContacts(response.contacts || []);
+  }
+
+  /**
+   * Get a single contact by ID
+   */
+  async get(contactId: string): Promise<Contact> {
+    const response = await this.client.request<{ contact: Record<string, unknown> }>(
+      `/contacts/v4/contacts/${contactId}`
+    );
+
+    return this.transformContact(response.contact);
+  }
+
+  /**
+   * Create a new contact
+   */
+  async create(contact: CreateContactRequest): Promise<Contact> {
+    const body = {
+      info: this.prepareContactInfo(contact.info),
+      allowDuplicates: contact.allowDuplicates ?? false,
+    };
+
+    const response = await this.client.request<{ contact: Record<string, unknown> }>(
+      '/contacts/v4/contacts',
+      { method: 'POST', body }
+    );
+
+    return this.transformContact(response.contact);
+  }
+
+  /**
+   * Update a contact
+   */
+  async update(contactId: string, contact: UpdateContactRequest): Promise<Contact> {
+    const body = {
+      info: this.prepareContactInfo(contact.info),
+      revision: contact.revision,
+    };
+
+    const response = await this.client.request<{ contact: Record<string, unknown> }>(
+      `/contacts/v4/contacts/${contactId}`,
+      { method: 'PATCH', body }
+    );
+
+    return this.transformContact(response.contact);
+  }
+
+  /**
+   * Delete a contact
+   */
+  async delete(contactId: string): Promise<void> {
+    await this.client.request<void>(
+      `/contacts/v4/contacts/${contactId}`,
+      { method: 'DELETE' }
+    );
+  }
+
+  /**
+   * Get contact count
+   */
+  async count(): Promise<number> {
+    const response = await this.client.request<{ contacts: Record<string, unknown>[]; pagingMetadata?: { total?: number } }>(
+      '/contacts/v4/contacts/query',
+      {
+        method: 'POST',
+        body: {
+          query: {
+            paging: { limit: 1, offset: 0 },
+          },
+        },
+      }
+    );
+
+    return response.pagingMetadata?.total || response.contacts?.length || 0;
+  }
+
+  /**
+   * Prepare contact info for API request
+   */
+  private prepareContactInfo(info?: ContactInfo): Record<string, unknown> | undefined {
+    if (!info) return undefined;
+
+    return {
+      name: info.name ? { first: info.name.first, last: info.name.last } : undefined,
+      emails: info.emails?.map(e => ({
+        tag: e.tag,
+        email: e.email,
+        primary: e.primary,
+      })),
+      phones: info.phones?.map(p => ({
+        tag: p.tag,
+        countryCode: p.countryCode,
+        phone: p.phone,
+        primary: p.primary,
+      })),
+      addresses: info.addresses?.map(a => ({
+        tag: a.tag,
+        address: a.address,
+      })),
+      company: info.company,
+      jobTitle: info.jobTitle,
+      birthdate: info.birthdate,
+      locale: info.locale,
+      labelKeys: info.labelKeys,
+      extendedFields: info.extendedFields,
+    };
+  }
+
+  /**
+   * Transform API response to our types
+   */
+  private transformContact(contact: Record<string, unknown>): Contact {
+    const source = contact.source as Record<string, unknown> | undefined;
+    const lastActivity = contact.lastActivity as Record<string, unknown> | undefined;
+    const primaryInfo = contact.primaryInfo as Record<string, unknown> | undefined;
+    const info = contact.info as Record<string, unknown> | undefined;
+
+    return {
+      id: contact.id as string,
+      revision: contact.revision as number || 0,
+      source: this.transformSource(source),
+      createdDate: contact.createdDate as string || '',
+      updatedDate: contact.updatedDate as string || '',
+      lastActivity: lastActivity ? this.transformActivity(lastActivity) : undefined,
+      primaryInfo: primaryInfo ? this.transformPrimaryInfo(primaryInfo) : undefined,
+      info: info ? this.transformInfo(info) : undefined,
+      picture: contact.picture as string | undefined,
+    };
+  }
+
+  private transformContacts(contacts: Record<string, unknown>[]): Contact[] {
+    return contacts.map(c => this.transformContact(c));
+  }
+
+  private transformSource(source?: Record<string, unknown>): ContactSource {
+    if (!source) {
+      return { sourceType: 'UNKNOWN' };
+    }
+    return {
+      sourceType: source.sourceType as string || 'UNKNOWN',
+      appId: source.appId as string | undefined,
+      wixAppType: source.wixAppType as string | undefined,
+    };
+  }
+
+  private transformActivity(activity: Record<string, unknown>): ContactActivity {
+    return {
+      activityDate: activity.activityDate as string || '',
+      activityType: activity.activityType as string || '',
+    };
+  }
+
+  private transformPrimaryInfo(info: Record<string, unknown>): PrimaryContactInfo {
+    return {
+      email: info.email as string | undefined,
+      phone: info.phone as string | undefined,
+    };
+  }
+
+  private transformInfo(info: Record<string, unknown>): ContactInfo {
+    const name = info.name as Record<string, unknown> | undefined;
+    const emails = info.emails as Record<string, unknown>[] | undefined;
+    const phones = info.phones as Record<string, unknown>[] | undefined;
+    const addresses = info.addresses as Record<string, unknown>[] | undefined;
+
+    return {
+      name: name ? this.transformName(name) : undefined,
+      emails: emails?.map(e => this.transformEmail(e)),
+      phones: phones?.map(p => this.transformPhone(p)),
+      addresses: addresses?.map(a => this.transformContactAddress(a)),
+      company: info.company as string | undefined,
+      jobTitle: info.jobTitle as string | undefined,
+      birthdate: info.birthdate as string | undefined,
+      locale: info.locale as string | undefined,
+      labelKeys: info.labelKeys as string[] | undefined,
+      extendedFields: info.extendedFields as Record<string, unknown> | undefined,
+    };
+  }
+
+  private transformName(name: Record<string, unknown>): ContactName {
+    return {
+      first: name.first as string | undefined,
+      last: name.last as string | undefined,
+    };
+  }
+
+  private transformEmail(email: Record<string, unknown>): ContactEmail {
+    return {
+      id: email.id as string | undefined,
+      tag: email.tag as string | undefined,
+      email: email.email as string || '',
+      primary: email.primary as boolean | undefined,
+    };
+  }
+
+  private transformPhone(phone: Record<string, unknown>): ContactPhone {
+    return {
+      id: phone.id as string | undefined,
+      tag: phone.tag as string | undefined,
+      countryCode: phone.countryCode as string | undefined,
+      phone: phone.phone as string || '',
+      e164Phone: phone.e164Phone as string | undefined,
+      primary: phone.primary as boolean | undefined,
+    };
+  }
+
+  private transformContactAddress(addr: Record<string, unknown>): ContactAddress {
+    const address = addr.address as Record<string, unknown> | undefined;
+    return {
+      id: addr.id as string | undefined,
+      tag: addr.tag as string | undefined,
+      address: address ? this.transformAddress(address) : undefined,
+    };
+  }
+
+  private transformAddress(address: Record<string, unknown>): Address {
+    const streetAddress = address.streetAddress as Record<string, unknown> | undefined;
+    return {
+      country: address.country as string | undefined,
+      subdivision: address.subdivision as string | undefined,
+      city: address.city as string | undefined,
+      postalCode: address.postalCode as string | undefined,
+      addressLine: address.addressLine as string | undefined,
+      addressLine2: address.addressLine2 as string | undefined,
+      streetAddress: streetAddress ? this.transformStreetAddress(streetAddress) : undefined,
+    };
+  }
+
+  private transformStreetAddress(street: Record<string, unknown>): StreetAddress {
+    return {
+      number: street.number as string | undefined,
+      name: street.name as string | undefined,
+      apt: street.apt as string | undefined,
+    };
+  }
+}

package/connectors/connect-wix/src/api/index.ts

@@ -0,0 +1,90 @@
+import type { WixConfig } from '../types';
+import { WixClient } from './client';
+import { SitesApi } from './sites';
+import { ContactsApi } from './contacts';
+import { MembersApi } from './members';
+import { ProductsApi } from './products';
+import { OrdersApi } from './orders';
+import { InventoryApi } from './inventory';
+import { BookingsApi } from './bookings';
+
+/**
+ * Main Wix Connector class
+ * Provides access to Sites, Contacts, Members, Products, Orders, Inventory, and Bookings APIs
+ */
+export class Wix {
+  private readonly client: WixClient;
+
+  // Service APIs
+  public readonly sites: SitesApi;
+  public readonly contacts: ContactsApi;
+  public readonly members: MembersApi;
+  public readonly products: ProductsApi;
+  public readonly orders: OrdersApi;
+  public readonly inventory: InventoryApi;
+  public readonly bookings: BookingsApi;
+
+  constructor(config: WixConfig) {
+    this.client = new WixClient(config);
+    this.sites = new SitesApi(this.client);
+    this.contacts = new ContactsApi(this.client);
+    this.members = new MembersApi(this.client);
+    this.products = new ProductsApi(this.client);
+    this.orders = new OrdersApi(this.client);
+    this.inventory = new InventoryApi(this.client);
+    this.bookings = new BookingsApi(this.client);
+  }
+
+  /**
+   * Create a client from environment variables
+   * Looks for WIX_API_KEY, WIX_SITE_ID, and WIX_ACCOUNT_ID
+   */
+  static fromEnv(): Wix {
+    const apiKey = process.env.WIX_API_KEY;
+    const siteId = process.env.WIX_SITE_ID;
+    const accountId = process.env.WIX_ACCOUNT_ID;
+
+    if (!apiKey) {
+      throw new Error('WIX_API_KEY environment variable is required');
+    }
+
+    return new Wix({ apiKey, siteId, accountId });
+  }
+
+  /**
+   * Get a preview of the API key (for debugging)
+   */
+  getApiKeyPreview(): string {
+    return this.client.getApiKeyPreview();
+  }
+
+  /**
+   * Get site ID
+   */
+  getSiteId(): string | undefined {
+    return this.client.getSiteId();
+  }
+
+  /**
+   * Get account ID
+   */
+  getAccountId(): string | undefined {
+    return this.client.getAccountId();
+  }
+
+  /**
+   * Get the underlying client for direct API access
+   */
+  getClient(): WixClient {
+    return this.client;
+  }
+}
+
+export { WixClient } from './client';
+export { SitesApi } from './sites';
+export { ContactsApi } from './contacts';
+export { MembersApi } from './members';
+export { ProductsApi } from './products';
+export { OrdersApi } from './orders';
+export { InventoryApi } from './inventory';
+export { BookingsApi } from './bookings';