@sentroy-co/client-sdk 2.5.0 → 2.6.1

package/src/react/lib/use-upload-queue.ts

@@ -66,6 +66,22 @@ export function useUploadQueue(
   // Worker pump — queued entry varsa ve aktif < concurrency ise başlat.
   const pumpRef = useRef<() => void>(() => {})
 
+  /**
+   * Aktif (in-flight) upload sayısını synchronous olarak takip eden ref.
+   * `entries` state setEntries ile async güncellendiğinden, recursive
+   * `pump` çağrılarında `entries.filter(e => e.status === "uploading")`
+   * eski listeyi görür → aynı queued entry birden çok kez başlatılır
+   * (Chrome side `ERR_INSUFFICIENT_RESOURCES`). Ref ile incre/decre
+   * synchronous; concurrency limiti gerçekten devreye girer.
+   */
+  const inFlightRef = useRef(0)
+  /**
+   * Henüz başlatılmamış queued entry id'lerinin sıralı listesi. setEntries
+   * async olduğu için listeden seçim yapmak yarış koşulu üretir; ref
+   * üzerinden FIFO push/shift hem deterministik hem hızlı.
+   */
+  const queueRef = useRef<string[]>([])
+
   const updateEntry = useCallback(
     (id: string, patch: Partial<UploadEntry>) => {
       setEntries((prev) =>
@@ -76,65 +92,77 @@ export function useUploadQueue(
   )
 
   pumpRef.current = () => {
-    const list = entriesRef.current
-    const active = list.filter((e) => e.status === "uploading").length
-    if (active >= concurrency) return
-    const next = list.find((e) => e.status === "queued")
-    if (!next) return
+    // Slot doluysa veya queue boşsa erken dön.
+    if (inFlightRef.current >= concurrency) return
+    const nextId = queueRef.current.shift()
+    if (!nextId) return
+
+    // Slot'u synchronously rezerve et — bir sonraki pump çağrısı bu
+    // entry'i tekrar shift edemez.
+    inFlightRef.current++
+
+    const entry = entriesRef.current.find((e) => e.id === nextId)
+    if (!entry) {
+      // Cancel öncesi remove edilmiş; slot'u iade et ve pump'a devam.
+      inFlightRef.current--
+      pumpRef.current?.()
+      return
+    }
 
     // Mark uploading
-    updateEntry(next.id, { status: "uploading" })
+    updateEntry(entry.id, { status: "uploading" })
 
-    // Bucket slug entry içine save edilemiyor (entry shape'i bilmesi
-    // gerekmez); enqueue closure'unda capture edilir, ayrı bucket map.
-    const bucketSlug = bucketMapRef.current[next.id]
+    const bucketSlug = bucketMapRef.current[entry.id]
     if (!bucketSlug) {
-      updateEntry(next.id, { status: "error", error: "No bucket" })
+      updateEntry(entry.id, { status: "error", error: "No bucket" })
+      inFlightRef.current--
       pumpRef.current?.()
       return
     }
 
     const controller = new AbortController()
-    cancelMapRef.current[next.id] = () => controller.abort()
+    cancelMapRef.current[entry.id] = () => controller.abort()
 
     client.media
       .upload(
         bucketSlug,
-        { body: next.file, filename: next.file.name },
+        { body: entry.file, filename: entry.file.name },
         {
           onProgress: (loaded, total) => {
-            updateEntry(next.id, { loaded, total })
+            updateEntry(entry.id, { loaded, total })
           },
           signal: controller.signal,
         },
       )
       .then((media) => {
-        updateEntry(next.id, {
+        updateEntry(entry.id, {
           status: "done",
           media,
-          loaded: next.file.size,
-          total: next.file.size,
+          loaded: entry.file.size,
+          total: entry.file.size,
         })
         onUploadedRef.current?.(media)
       })
       .catch((err: unknown) => {
         const aborted =
           (err as { message?: string })?.message === "Upload aborted"
-        updateEntry(next.id, {
+        updateEntry(entry.id, {
           status: aborted ? "canceled" : "error",
           error: aborted
             ? undefined
-            : (err as Error)?.message ?? "Upload failed",
+            : ((err as Error)?.message ?? "Upload failed"),
         })
       })
       .finally(() => {
-        delete cancelMapRef.current[next.id]
-        // Yeni slot açıldı; başka queued varsa al.
+        delete cancelMapRef.current[entry.id]
+        inFlightRef.current--
+        // Slot açıldı, sıradakini başlat.
         pumpRef.current?.()
       })
 
-    // Aynı tick'te birden fazla slot doldur.
-    if (active + 1 < concurrency) pumpRef.current?.()
+    // Aynı tick'te kalan slot'ları doldur — concurrency artık
+    // synchronously inFlightRef ile guard'lı, çift başlatma yok.
+    if (inFlightRef.current < concurrency) pumpRef.current?.()
   }
 
   const bucketMapRef = useRef<Record<string, string>>({})
@@ -146,6 +174,9 @@ export function useUploadQueue(
       const newEntries: UploadEntry[] = files.map((file) => {
         const id = `up-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`
         bucketMapRef.current[id] = bucketSlug
+        // FIFO queue — pump bu sıradan shift eder; setEntries async
+        // güncellemesinden bağımsız synchronous source-of-truth.
+        queueRef.current.push(id)
         return {
           id,
           file,
@@ -155,7 +186,8 @@ export function useUploadQueue(
           cancel: () => {
             const c = cancelMapRef.current[id]
             if (c) c()
-            else
+            else {
+              queueRef.current = queueRef.current.filter((qid) => qid !== id)
               setEntries((prev) =>
                 prev.map((e) =>
                   e.id === id && e.status === "queued"
@@ -163,11 +195,15 @@ export function useUploadQueue(
                     : e,
                 ),
               )
+            }
           },
         }
       })
       setEntries((prev) => [...prev, ...newEntries])
-      // pump on next tick — state update'ten sonra entriesRef güncel olsun
+      // pump on next tick — state update'ten sonra entriesRef güncel olsun.
+      // pumpRef kendi içinde sequential pump zincirini sürdürür (her
+      // başarılı slot rezervasyonundan sonra bir dahaki pump'ı çağırır),
+      // dolayısıyla burada tek tetikleme yeterli.
       Promise.resolve().then(() => pumpRef.current?.())
     },
     [],
@@ -176,7 +212,8 @@ export function useUploadQueue(
   const cancel = useCallback((id: string) => {
     const c = cancelMapRef.current[id]
     if (c) c()
-    else
+    else {
+      queueRef.current = queueRef.current.filter((qid) => qid !== id)
       setEntries((prev) =>
         prev.map((e) =>
           e.id === id && e.status === "queued"
@@ -184,10 +221,12 @@ export function useUploadQueue(
             : e,
         ),
       )
+    }
   }, [])
 
   const remove = useCallback((id: string) => {
     setEntries((prev) => prev.filter((e) => e.id !== id))
+    queueRef.current = queueRef.current.filter((qid) => qid !== id)
     delete bucketMapRef.current[id]
     delete cancelMapRef.current[id]
   }, [])

package/src/resources/audience.ts

@@ -0,0 +1,139 @@
+import type { HttpClient } from "../http"
+import type {
+  Contact,
+  ContactList,
+  ContactListParams,
+  ContactListResult,
+  CreateAudienceListParams,
+  CreateContactParams,
+  UpdateContactParams,
+} from "../types"
+
+class AudienceListMembers {
+  constructor(
+    private http: HttpClient,
+    private listId: string,
+  ) {}
+
+  /** List all contacts in this audience list. */
+  async list(): Promise<Contact[]> {
+    return this.http.get<Contact[]>(
+      `/audience/lists/${encodeURIComponent(this.listId)}/members`,
+    )
+  }
+
+  /** Add a contact to the list by id. */
+  async add(contactId: string): Promise<void> {
+    await this.http.post<{ message: string }>(
+      `/audience/lists/${encodeURIComponent(this.listId)}/members`,
+      { contactId },
+    )
+  }
+
+  /** Remove a contact from the list. The contact record itself is preserved. */
+  async remove(contactId: string): Promise<void> {
+    await this.http.delWithBody<{ message: string }>(
+      `/audience/lists/${encodeURIComponent(this.listId)}/members`,
+      { contactId },
+    )
+  }
+}
+
+class AudienceLists {
+  constructor(private http: HttpClient) {}
+
+  /** List every audience list in the company. */
+  async list(): Promise<ContactList[]> {
+    return this.http.get<ContactList[]>("/audience/lists")
+  }
+
+  /** Get a single audience list by id. */
+  async get(id: string): Promise<ContactList> {
+    return this.http.get<ContactList>(
+      `/audience/lists/${encodeURIComponent(id)}`,
+    )
+  }
+
+  /** Create a new audience list. */
+  async create(params: CreateAudienceListParams): Promise<ContactList> {
+    return this.http.post<ContactList>("/audience/lists", params)
+  }
+
+  /** Delete an audience list. Contacts stay in the company; only the grouping is removed. */
+  async delete(id: string): Promise<void> {
+    await this.http.del<{ message: string }>(
+      `/audience/lists/${encodeURIComponent(id)}`,
+    )
+  }
+
+  /** Membership operations scoped to a list id. */
+  members(listId: string): AudienceListMembers {
+    return new AudienceListMembers(this.http, listId)
+  }
+}
+
+class AudienceContacts {
+  constructor(private http: HttpClient) {}
+
+  /**
+   * Paginated list of contacts. Filter by status or tag set; tags are
+   * sent as a comma-joined query param.
+   */
+  async list(params?: ContactListParams): Promise<ContactListResult> {
+    const query: Record<string, unknown> = {}
+    if (params?.page !== undefined) query.page = params.page
+    if (params?.limit !== undefined) query.limit = params.limit
+    if (params?.status) query.status = params.status
+    if (params?.tags?.length) query.tags = params.tags.join(",")
+    return this.http.get<ContactListResult>("/audience/contacts", query)
+  }
+
+  /**
+   * Email-prefix autocomplete. Capped server-side at 10 results — use
+   * `list` for paginated browsing.
+   */
+  async search(q: string): Promise<Contact[]> {
+    return this.http.get<Contact[]>("/audience/contacts", { q })
+  }
+
+  /** Get a single contact by id. */
+  async get(id: string): Promise<Contact> {
+    return this.http.get<Contact>(
+      `/audience/contacts/${encodeURIComponent(id)}`,
+    )
+  }
+
+  /** Create a contact. Defaults to status: "active". */
+  async create(params: CreateContactParams): Promise<Contact> {
+    return this.http.post<Contact>("/audience/contacts", params)
+  }
+
+  /** Patch any contact field. Pass `status` to mark unsubscribed/bounced. */
+  async update(id: string, params: UpdateContactParams): Promise<Contact> {
+    return this.http.patch<Contact>(
+      `/audience/contacts/${encodeURIComponent(id)}`,
+      params,
+    )
+  }
+
+  /**
+   * Soft-delete: marks the contact as `unsubscribed`. The record stays so
+   * historical mail-log foreign keys keep resolving and the email won't
+   * accidentally be re-added.
+   */
+  async delete(id: string): Promise<void> {
+    await this.http.del<{ message: string }>(
+      `/audience/contacts/${encodeURIComponent(id)}`,
+    )
+  }
+}
+
+export class Audience {
+  public readonly lists: AudienceLists
+  public readonly contacts: AudienceContacts
+
+  constructor(http: HttpClient) {
+    this.lists = new AudienceLists(http)
+    this.contacts = new AudienceContacts(http)
+  }
+}

package/src/resources/logs.ts

@@ -0,0 +1,27 @@
+import type { HttpClient } from "../http"
+import type { LogListParams, MailLog } from "../types"
+
+export class Logs {
+  constructor(private http: HttpClient) {}
+
+  /**
+   * List mail-log entries. Filter by status, domain, and ISO timestamp
+   * range (`from` / `to`). Results are paginated server-side; pass `page`
+   * and `limit` to walk a large window.
+   */
+  async list(params?: LogListParams): Promise<MailLog[]> {
+    const query: Record<string, unknown> = {}
+    if (params?.page !== undefined) query.page = params.page
+    if (params?.limit !== undefined) query.limit = params.limit
+    if (params?.status) query.status = params.status
+    if (params?.domainId) query.domainId = params.domainId
+    if (params?.from) query.from = params.from
+    if (params?.to) query.to = params.to
+    return this.http.get<MailLog[]>("/logs", query)
+  }
+
+  /** Get a single mail-log entry by id. */
+  async get(id: string): Promise<MailLog> {
+    return this.http.get<MailLog>(`/logs/${encodeURIComponent(id)}`)
+  }
+}

package/src/resources/suppressions.ts

@@ -0,0 +1,39 @@
+import type { HttpClient } from "../http"
+import type {
+  AddSuppressionParams,
+  Suppression,
+  SuppressionListParams,
+} from "../types"
+
+export class Suppressions {
+  constructor(private http: HttpClient) {}
+
+  /**
+   * List suppressions across the company (or a single domain). Suppressed
+   * recipients are skipped at send time — every entry here is one address
+   * that will not receive mail until removed.
+   */
+  async list(params?: SuppressionListParams): Promise<Suppression[]> {
+    const query: Record<string, unknown> = {}
+    if (params?.page !== undefined) query.page = params.page
+    if (params?.limit !== undefined) query.limit = params.limit
+    if (params?.domainId) query.domainId = params.domainId
+    if (params?.reason) query.reason = params.reason
+    return this.http.get<Suppression[]>("/suppressions", query)
+  }
+
+  /**
+   * Manually suppress an address (e.g. honoring an off-platform opt-out).
+   * Bounces and complaints are added automatically by the mail server.
+   */
+  async add(params: AddSuppressionParams): Promise<Suppression> {
+    return this.http.post<Suppression>("/suppressions", params)
+  }
+
+  /** Remove a suppression — the address will be eligible to receive mail again. */
+  async remove(id: string): Promise<void> {
+    await this.http.del<{ message: string }>(
+      `/suppressions/${encodeURIComponent(id)}`,
+    )
+  }
+}

package/src/resources/webhooks.ts

@@ -0,0 +1,47 @@
+import type { HttpClient } from "../http"
+import type {
+  CreateWebhookParams,
+  UpdateWebhookParams,
+  Webhook,
+} from "../types"
+
+export class Webhooks {
+  constructor(private http: HttpClient) {}
+
+  /** List webhooks across the company, or scoped to a single domain. */
+  async list(domainId?: string): Promise<Webhook[]> {
+    return this.http.get<Webhook[]>(
+      "/webhooks",
+      domainId ? { domainId } : undefined,
+    )
+  }
+
+  /** Get a single webhook by id. */
+  async get(id: string): Promise<Webhook> {
+    return this.http.get<Webhook>(`/webhooks/${encodeURIComponent(id)}`)
+  }
+
+  /**
+   * Register a webhook for one or more events on a domain. The response
+   * includes a `secret` — store it now; subsequent reads only return the
+   * webhook config without the secret.
+   */
+  async create(params: CreateWebhookParams): Promise<Webhook> {
+    return this.http.post<Webhook>("/webhooks", params)
+  }
+
+  /** Patch URL, event list, or `active` flag. */
+  async update(id: string, params: UpdateWebhookParams): Promise<Webhook> {
+    return this.http.patch<Webhook>(
+      `/webhooks/${encodeURIComponent(id)}`,
+      params,
+    )
+  }
+
+  /** Delete a webhook. In-flight deliveries are not retried. */
+  async delete(id: string): Promise<void> {
+    await this.http.del<{ message: string }>(
+      `/webhooks/${encodeURIComponent(id)}`,
+    )
+  }
+}

package/src/types.ts

@@ -322,3 +322,164 @@ export interface StorageUsage {
   buckets: StorageUsageBucket[]
   byType: StorageUsageByType[]
 }
+
+// ── Audience / Contacts ───────────────────────────────────────────────────
+
+export type ContactStatus = "active" | "unsubscribed" | "bounced"
+
+export interface Contact {
+  id: string
+  companyId: string
+  email: string
+  name?: string
+  tags: string[]
+  status: ContactStatus
+  metadata: Record<string, unknown>
+  lastEmailedAt?: string | null
+  createdAt: string
+  updatedAt: string
+}
+
+export interface ContactList {
+  id: string
+  companyId: string
+  name: string
+  description?: string
+  memberCount?: number
+  createdAt: string
+  updatedAt: string
+}
+
+export interface CreateContactParams {
+  email: string
+  name?: string
+  tags?: string[]
+  metadata?: Record<string, unknown>
+}
+
+export interface UpdateContactParams {
+  email?: string
+  name?: string
+  tags?: string[]
+  status?: ContactStatus
+  metadata?: Record<string, unknown>
+}
+
+export interface ContactListParams {
+  page?: number
+  limit?: number
+  status?: ContactStatus
+  /** Comma-joined when sent over the wire — pass an array, the SDK joins. */
+  tags?: string[]
+}
+
+export interface ContactListResult {
+  contacts: Contact[]
+  total: number
+  page: number
+  limit: number
+}
+
+export interface CreateAudienceListParams {
+  name: string
+  description?: string
+}
+
+// ── Suppressions ──────────────────────────────────────────────────────────
+
+export interface Suppression {
+  id: string
+  email: string
+  reason: string
+  domainId: string
+  createdAt: string
+  domain?: { domain: string }
+}
+
+export interface AddSuppressionParams {
+  email: string
+  /** Free-form label (e.g. "manual", "complaint"). Defaults backend-side. */
+  reason?: string
+  domainId: string
+}
+
+export interface SuppressionListParams {
+  page?: number
+  limit?: number
+  domainId?: string
+  reason?: string
+}
+
+// ── Webhooks ──────────────────────────────────────────────────────────────
+
+export type WebhookEvent =
+  | "sent"
+  | "bounced"
+  | "failed"
+  | "opened"
+  | "clicked"
+  | "unsubscribed"
+
+export interface Webhook {
+  id: string
+  url: string
+  events: string[]
+  active: boolean
+  domainId: string
+  /** Returned only on create — used to verify HMAC signatures of deliveries. */
+  secret?: string
+  createdAt: string
+  updatedAt: string
+}
+
+export interface CreateWebhookParams {
+  url: string
+  events: WebhookEvent[] | string[]
+  domainId: string
+}
+
+export interface UpdateWebhookParams {
+  url?: string
+  events?: WebhookEvent[] | string[]
+  active?: boolean
+}
+
+// ── Logs ──────────────────────────────────────────────────────────────────
+
+export type MailLogStatus =
+  | "queued"
+  | "processing"
+  | "sent"
+  | "bounced"
+  | "failed"
+
+export interface MailLog {
+  id: string
+  to: string
+  from: string
+  subject: string
+  status: MailLogStatus
+  messageId: string | null
+  domainId: string
+  domain?: { domain: string }
+  templateId: string | null
+  variables: Record<string, unknown> | null
+  scheduledAt?: string | null
+  sentAt: string | null
+  bouncedAt: string | null
+  openedAt?: string | null
+  clickedAt?: string | null
+  error: string | null
+  createdAt: string
+}
+
+export interface LogListParams {
+  page?: number
+  limit?: number
+  status?: MailLogStatus
+  domainId?: string
+  /** ISO timestamp lower bound (inclusive). */
+  from?: string
+  /** ISO timestamp upper bound (inclusive). */
+  to?: string
+}