@geekapps/post-fastify 0.1.0

package/src/resources/domains.ts

@@ -0,0 +1,26 @@
+import type { HttpClient } from "../http.js";
+import type { CreateDomainInput, CreateDomainResult, OrgDomain } from "../types.js";
+
+export class DomainsResource {
+  constructor(private readonly http: HttpClient) {}
+
+  list(): Promise<OrgDomain[]> {
+    return this.http.get<OrgDomain[]>("/domains");
+  }
+
+  get(id: string): Promise<OrgDomain> {
+    return this.http.get<OrgDomain>(`/domains/${id}`);
+  }
+
+  create(input: CreateDomainInput): Promise<CreateDomainResult> {
+    return this.http.post<CreateDomainResult>("/domains", input);
+  }
+
+  verify(id: string): Promise<{ status: "verified" | "failed" }> {
+    return this.http.post<{ status: "verified" | "failed" }>(`/domains/${id}/verify`);
+  }
+
+  delete(id: string): Promise<void> {
+    return this.http.delete(`/domains/${id}`);
+  }
+}

package/src/resources/history.ts

@@ -0,0 +1,22 @@
+import type { HttpClient } from "../http.js";
+import type { ListHistoryParams, MessageLog, MessageLogDetail, PaginatedResult } from "../types.js";
+
+export class HistoryResource {
+  constructor(private readonly http: HttpClient) {}
+
+  list(params?: ListHistoryParams): Promise<PaginatedResult<MessageLog>> {
+    const qs = new URLSearchParams();
+    if (params?.type) qs.set("type", params.type);
+    if (params?.status) qs.set("status", params.status);
+    if (params?.from) qs.set("from", params.from);
+    if (params?.to) qs.set("to", params.to);
+    if (params?.page !== undefined) qs.set("page", String(params.page));
+    if (params?.limit !== undefined) qs.set("limit", String(params.limit));
+    const query = qs.toString();
+    return this.http.get<PaginatedResult<MessageLog>>(`/history${query ? `?${query}` : ""}`);
+  }
+
+  get(id: string): Promise<MessageLogDetail> {
+    return this.http.get<MessageLogDetail>(`/history/${id}`);
+  }
+}

package/src/resources/managed-numbers.ts

@@ -0,0 +1,47 @@
+import type { HttpClient } from "../http.js";
+import type { AreaCode, ManagedNumber } from "../types.js";
+
+export interface ProvisionManagedNumberInput {
+  areaCode: number;
+  name?: string;
+  displayName: string;
+  otpMethod?: "SMS" | "VOICE";
+  otpLanguage?: string;
+  pin?: string;
+  orgWabaId?: string;
+  wabaId?: string;
+  accessToken?: string;
+}
+
+export interface RetryVerificationInput {
+  otpMethod?: "SMS" | "VOICE";
+  otpLanguage?: string;
+}
+
+export class ManagedNumbersResource {
+  constructor(private readonly http: HttpClient) {}
+
+  listAreaCodes(): Promise<AreaCode[]> {
+    return this.http.get<AreaCode[]>("/managed-numbers/area-codes");
+  }
+
+  list(): Promise<ManagedNumber[]> {
+    return this.http.get<ManagedNumber[]>("/managed-numbers");
+  }
+
+  get(id: string): Promise<ManagedNumber> {
+    return this.http.get<ManagedNumber>(`/managed-numbers/${id}`);
+  }
+
+  provision(input: ProvisionManagedNumberInput): Promise<ManagedNumber> {
+    return this.http.post<ManagedNumber>("/managed-numbers", input);
+  }
+
+  retryVerification(id: string, input?: RetryVerificationInput): Promise<ManagedNumber> {
+    return this.http.post<ManagedNumber>(`/managed-numbers/${id}/retry-verification`, input);
+  }
+
+  cancel(id: string): Promise<ManagedNumber> {
+    return this.http.post<ManagedNumber>(`/managed-numbers/${id}/cancel`);
+  }
+}

package/src/resources/messages.ts

@@ -0,0 +1,10 @@
+import type { HttpClient } from "../http.js";
+import type { SendMessageInput, SendMessageResult } from "../types.js";
+
+export class MessagesResource {
+  constructor(private readonly http: HttpClient) {}
+
+  send(input: SendMessageInput): Promise<SendMessageResult> {
+    return this.http.post<SendMessageResult>("/messages", input);
+  }
+}

package/src/resources/plans.ts

@@ -0,0 +1,18 @@
+import type { HttpClient } from "../http.js";
+import type { AvailablePlan, OrgPlan, PlansResult, UpdatePlanInput } from "../types.js";
+
+export class PlansResource {
+  constructor(private readonly http: HttpClient) {}
+
+  get(): Promise<PlansResult> {
+    return this.http.get<PlansResult>("/plans");
+  }
+
+  update(input: UpdatePlanInput): Promise<OrgPlan> {
+    return this.http.put<OrgPlan>("/plans", input);
+  }
+
+  listAvailable(): Promise<AvailablePlan[]> {
+    return this.http.get<AvailablePlan[]>("/plans/available");
+  }
+}

package/src/resources/smtp.ts

@@ -0,0 +1,22 @@
+import type { HttpClient } from "../http.js";
+import type { SmtpConfig, UpsertSmtpConfigInput } from "../types.js";
+
+export class SmtpResource {
+  constructor(private readonly http: HttpClient) {}
+
+  get(): Promise<SmtpConfig> {
+    return this.http.get<SmtpConfig>("/smtp-config");
+  }
+
+  upsert(input: UpsertSmtpConfigInput): Promise<SmtpConfig> {
+    return this.http.put<SmtpConfig>("/smtp-config", input);
+  }
+
+  delete(): Promise<void> {
+    return this.http.delete("/smtp-config");
+  }
+
+  test(to: string): Promise<{ success: boolean; error?: string }> {
+    return this.http.post<{ success: boolean; error?: string }>("/smtp-config/test", { to });
+  }
+}

package/src/resources/statistics.ts

@@ -0,0 +1,15 @@
+import type { HttpClient } from "../http.js";
+import type { StatisticsParams, StatisticsResult } from "../types.js";
+
+export class StatisticsResource {
+  constructor(private readonly http: HttpClient) {}
+
+  get(params?: StatisticsParams): Promise<StatisticsResult> {
+    const qs = new URLSearchParams();
+    if (params?.from) qs.set("from", params.from);
+    if (params?.to) qs.set("to", params.to);
+    if (params?.groupBy) qs.set("groupBy", params.groupBy);
+    const query = qs.toString();
+    return this.http.get<StatisticsResult>(`/statistics${query ? `?${query}` : ""}`);
+  }
+}

package/src/resources/templates.ts

@@ -0,0 +1,44 @@
+import type { HttpClient } from "../http.js";
+import type {
+  CreateTemplateInput,
+  MessageTemplate,
+  MessageType,
+  SaveDraftInput,
+  UpdateTemplateInput,
+} from "../types.js";
+
+export class TemplatesResource {
+  constructor(private readonly http: HttpClient) {}
+
+  list(params?: { type?: MessageType; isActive?: boolean }): Promise<MessageTemplate[]> {
+    const qs = new URLSearchParams();
+    if (params?.type) qs.set("type", params.type);
+    if (params?.isActive !== undefined) qs.set("isActive", String(params.isActive));
+    const query = qs.toString();
+    return this.http.get<MessageTemplate[]>(`/templates${query ? `?${query}` : ""}`);
+  }
+
+  get(id: string): Promise<MessageTemplate> {
+    return this.http.get<MessageTemplate>(`/templates/${id}`);
+  }
+
+  create(input: CreateTemplateInput): Promise<MessageTemplate> {
+    return this.http.post<MessageTemplate>("/templates", input);
+  }
+
+  update(id: string, input: UpdateTemplateInput): Promise<MessageTemplate> {
+    return this.http.put<MessageTemplate>(`/templates/${id}`, input);
+  }
+
+  saveDraft(id: string, input: SaveDraftInput): Promise<MessageTemplate> {
+    return this.http.patch<MessageTemplate>(`/templates/${id}/draft`, input);
+  }
+
+  publish(id: string): Promise<MessageTemplate> {
+    return this.http.post<MessageTemplate>(`/templates/${id}/publish`);
+  }
+
+  delete(id: string): Promise<void> {
+    return this.http.delete(`/templates/${id}`);
+  }
+}

package/src/resources/webhooks.ts

@@ -0,0 +1,37 @@
+import type { HttpClient } from "../http.js";
+import type {
+  CreateWebhookInput,
+  OrgWebhook,
+  OrgWebhookWithSecret,
+  RotateSecretResult,
+  UpdateWebhookInput,
+  WebhookDelivery,
+} from "../types.js";
+
+export class WebhooksResource {
+  constructor(private readonly http: HttpClient) {}
+
+  list(): Promise<OrgWebhook[]> {
+    return this.http.get<OrgWebhook[]>("/webhooks");
+  }
+
+  create(input: CreateWebhookInput): Promise<OrgWebhookWithSecret> {
+    return this.http.post<OrgWebhookWithSecret>("/webhooks", input);
+  }
+
+  update(id: string, input: UpdateWebhookInput): Promise<OrgWebhook> {
+    return this.http.put<OrgWebhook>(`/webhooks/${id}`, input);
+  }
+
+  delete(id: string): Promise<void> {
+    return this.http.delete(`/webhooks/${id}`);
+  }
+
+  listDeliveries(id: string): Promise<WebhookDelivery[]> {
+    return this.http.get<WebhookDelivery[]>(`/webhooks/${id}/deliveries`);
+  }
+
+  rotateSecret(id: string): Promise<RotateSecretResult> {
+    return this.http.post<RotateSecretResult>(`/webhooks/${id}/rotate-secret`);
+  }
+}

package/src/resources/whatsapp-numbers.ts

@@ -0,0 +1,84 @@
+import type { HttpClient } from "../http.js";
+import type {
+  ConnectWabaInput,
+  ConnectWhatsappNumberInput,
+  OrgWaba,
+  PhoneNumberStatusResult,
+  RegisterWhatsappNumberInput,
+  UpdateWhatsappProfileInput,
+  WabaHealthResult,
+  WhatsappNumber,
+  WhatsappNumberProfile,
+} from "../types.js";
+
+export class WhatsappNumbersResource {
+  constructor(private readonly http: HttpClient) {}
+
+  // ── WABAs ────────────────────────────────────────────────────────────────
+
+  listWabas(): Promise<OrgWaba[]> {
+    return this.http.get<OrgWaba[]>("/whatsapp/wabas");
+  }
+
+  connectWaba(input: ConnectWabaInput): Promise<OrgWaba> {
+    return this.http.post<OrgWaba>("/whatsapp/wabas/connect", input);
+  }
+
+  reconnectWaba(id: string): Promise<OrgWaba> {
+    return this.http.post<OrgWaba>(`/whatsapp/wabas/${id}/reconnect`);
+  }
+
+  disconnectWaba(id: string): Promise<void> {
+    return this.http.delete(`/whatsapp/wabas/${id}`);
+  }
+
+  getWabaHealth(id: string): Promise<WabaHealthResult> {
+    return this.http.get<WabaHealthResult>(`/whatsapp/wabas/${id}/health`);
+  }
+
+  // ── Numbers ──────────────────────────────────────────────────────────────
+
+  listNumbers(): Promise<WhatsappNumber[]> {
+    return this.http.get<WhatsappNumber[]>("/whatsapp/numbers");
+  }
+
+  connectNumber(input: ConnectWhatsappNumberInput): Promise<WhatsappNumber> {
+    return this.http.post<WhatsappNumber>("/whatsapp/numbers/connect", input);
+  }
+
+  registerNumber(input: RegisterWhatsappNumberInput): Promise<WhatsappNumber> {
+    return this.http.post<WhatsappNumber>("/whatsapp/numbers", input);
+  }
+
+  verifyCode(id: string, code: string): Promise<WhatsappNumber> {
+    return this.http.post<WhatsappNumber>(`/whatsapp/numbers/${id}/verify-code`, { code });
+  }
+
+  resendCode(id: string): Promise<void> {
+    return this.http.post(`/whatsapp/numbers/${id}/resend-code`);
+  }
+
+  getProfile(id: string): Promise<WhatsappNumberProfile> {
+    return this.http.get<WhatsappNumberProfile>(`/whatsapp/numbers/${id}/profile`);
+  }
+
+  updateProfile(id: string, input: UpdateWhatsappProfileInput): Promise<WhatsappNumberProfile> {
+    return this.http.patch<WhatsappNumberProfile>(`/whatsapp/numbers/${id}/profile`, input);
+  }
+
+  updateDisplayName(id: string, displayName: string): Promise<WhatsappNumber> {
+    return this.http.patch<WhatsappNumber>(`/whatsapp/numbers/${id}`, { displayName });
+  }
+
+  getStatus(id: string): Promise<PhoneNumberStatusResult> {
+    return this.http.get<PhoneNumberStatusResult>(`/whatsapp/numbers/${id}/status`);
+  }
+
+  refreshNumbers(): Promise<WhatsappNumber[]> {
+    return this.http.post<WhatsappNumber[]>("/whatsapp/numbers/refresh");
+  }
+
+  deleteNumber(id: string): Promise<void> {
+    return this.http.delete(`/whatsapp/numbers/${id}`);
+  }
+}

package/src/resources/whatsapp-templates.ts

@@ -0,0 +1,31 @@
+import type { HttpClient } from "../http.js";
+import type {
+  CreateWhatsappTemplateInput,
+  SyncWhatsappTemplatesResult,
+  UpdateWhatsappTemplateInput,
+  WhatsappTemplate,
+} from "../types.js";
+
+export class WhatsappTemplatesResource {
+  constructor(private readonly http: HttpClient) {}
+
+  list(): Promise<WhatsappTemplate[]> {
+    return this.http.get<WhatsappTemplate[]>("/whatsapp/templates");
+  }
+
+  create(input: CreateWhatsappTemplateInput): Promise<WhatsappTemplate> {
+    return this.http.post<WhatsappTemplate>("/whatsapp/templates", input);
+  }
+
+  update(id: string, input: UpdateWhatsappTemplateInput): Promise<WhatsappTemplate> {
+    return this.http.put<WhatsappTemplate>(`/whatsapp/templates/${id}`, input);
+  }
+
+  sync(): Promise<SyncWhatsappTemplatesResult> {
+    return this.http.post<SyncWhatsappTemplatesResult>("/whatsapp/templates/sync");
+  }
+
+  delete(id: string): Promise<void> {
+    return this.http.delete(`/whatsapp/templates/${id}`);
+  }
+}

package/src/service-account.ts

@@ -0,0 +1,112 @@
+import type { TokenResolver } from "./http.js";
+
+export interface ServiceAccountOptions {
+  /** Geekapps Auth issuer base URL (e.g. https://auth.geekapps.com.br) */
+  issuerUrl: string;
+  clientId: string;
+  clientSecret: string;
+  /** Seconds before expiry to proactively refresh. Defaults to 30. */
+  refreshBeforeExpirySeconds?: number;
+}
+
+interface CachedToken {
+  value: string;
+  expiresAt: number; // ms epoch
+}
+
+/**
+ * Fetches a short-lived token from the Geekapps Auth service using
+ * client_credentials grant and caches it until near expiry.
+ *
+ * Tokens are valid for ~7 min. A new one is fetched 30 s before that.
+ */
+export class ServiceAccountTokenProvider {
+  private readonly issuerUrl: string;
+  private readonly clientId: string;
+  private readonly clientSecret: string;
+  private readonly refreshBeforeMs: number;
+  private cached: CachedToken | null = null;
+  private inflight: Promise<string> | null = null;
+
+  constructor(options: ServiceAccountOptions) {
+    this.issuerUrl = options.issuerUrl.replace(/\/$/, "");
+    this.clientId = options.clientId;
+    this.clientSecret = options.clientSecret;
+    this.refreshBeforeMs = (options.refreshBeforeExpirySeconds ?? 30) * 1000;
+  }
+
+  /** Returns a valid token, fetching a new one if necessary. */
+  getToken(): Promise<string> {
+    const now = Date.now();
+
+    if (this.cached && this.cached.expiresAt - now > this.refreshBeforeMs) {
+      return Promise.resolve(this.cached.value);
+    }
+
+    // Deduplicate concurrent calls — only one fetch in flight at a time
+    if (this.inflight) return this.inflight;
+
+    this.inflight = this.fetchToken().finally(() => {
+      this.inflight = null;
+    });
+
+    return this.inflight;
+  }
+
+  private async fetchToken(): Promise<string> {
+    const body = new URLSearchParams();
+    body.set("grant_type", "client_credentials");
+    body.set("client_id", this.clientId);
+    body.set("client_secret", this.clientSecret);
+
+    const res = await fetch(`${this.issuerUrl}/auth/token`, {
+      method: "POST",
+      headers: { "Content-Type": "application/x-www-form-urlencoded" },
+      body,
+    });
+
+    if (!res.ok) {
+      const err = await res.json().catch(() => ({})) as { error?: string };
+      throw new Error(
+        `ServiceAccount token fetch failed (${res.status}): ${err.error ?? "unknown error"}`,
+      );
+    }
+
+    const data = await res.json() as { access_token: string; expires_in?: number };
+
+    const expiresInMs = (data.expires_in ?? 420) * 1000;
+    this.cached = {
+      value: data.access_token,
+      expiresAt: Date.now() + expiresInMs,
+    };
+
+    return this.cached.value;
+  }
+
+  /** Returns this provider as a TokenResolver to pass directly to PostClient. */
+  asTokenResolver(): TokenResolver {
+    return () => this.getToken();
+  }
+}
+
+/**
+ * Convenience factory. Returns a TokenResolver ready for use in PostClient.
+ *
+ * @example
+ * ```ts
+ * const post = new PostClient({
+ *   baseUrl: process.env.POST_API_URL!,
+ *   token: createServiceAccountToken({
+ *     issuerUrl: process.env.GEEKAPPS_AUTH_ISSUER!,
+ *     clientId: process.env.GEEKAPPS_SERVICE_ACCOUNT_CLIENT_ID!,
+ *     clientSecret: process.env.GEEKAPPS_SERVICE_ACCOUNT_CLIENT_SECRET!,
+ *   }),
+ *   organizationId: process.env.POST_ORGANIZATION_ID!,
+ * });
+ * ```
+ */
+export function createServiceAccountToken(
+  options: ServiceAccountOptions,
+): TokenResolver {
+  return new ServiceAccountTokenProvider(options).asTokenResolver();
+}