@geekapps/post-nextjs 0.1.1

package/src/resources/domains.ts

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

package/src/resources/history.ts

@@ -0,0 +1,22 @@
+import type { HttpClient, RequestOptions } from "../http.js";
+import type { ListHistoryParams, MessageLog, MessageLogDetail, PaginatedResult } from "../types.js";
+
+export class HistoryResource {
+  constructor(private readonly http: HttpClient) {}
+
+  list(params?: ListHistoryParams, opts?: RequestOptions): 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}` : ""}`, opts);
+  }
+
+  get(id: string, opts?: RequestOptions): Promise<MessageLogDetail> {
+    return this.http.get<MessageLogDetail>(`/history/${id}`, opts);
+  }
+}

package/src/resources/managed-numbers.ts

@@ -0,0 +1,47 @@
+import type { HttpClient, RequestOptions } 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(opts?: RequestOptions): Promise<AreaCode[]> {
+    return this.http.get<AreaCode[]>("/managed-numbers/area-codes", opts);
+  }
+
+  list(opts?: RequestOptions): Promise<ManagedNumber[]> {
+    return this.http.get<ManagedNumber[]>("/managed-numbers", opts);
+  }
+
+  get(id: string, opts?: RequestOptions): Promise<ManagedNumber> {
+    return this.http.get<ManagedNumber>(`/managed-numbers/${id}`, opts);
+  }
+
+  provision(input: ProvisionManagedNumberInput, opts?: RequestOptions): Promise<ManagedNumber> {
+    return this.http.post<ManagedNumber>("/managed-numbers", input, opts);
+  }
+
+  retryVerification(id: string, input?: RetryVerificationInput, opts?: RequestOptions): Promise<ManagedNumber> {
+    return this.http.post<ManagedNumber>(`/managed-numbers/${id}/retry-verification`, input, opts);
+  }
+
+  cancel(id: string, opts?: RequestOptions): Promise<ManagedNumber> {
+    return this.http.post<ManagedNumber>(`/managed-numbers/${id}/cancel`, undefined, opts);
+  }
+}

package/src/resources/messages.ts

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

package/src/resources/plans.ts

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

package/src/resources/smtp.ts

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

package/src/resources/statistics.ts

@@ -0,0 +1,15 @@
+import type { HttpClient, RequestOptions } from "../http.js";
+import type { StatisticsParams, StatisticsResult } from "../types.js";
+
+export class StatisticsResource {
+  constructor(private readonly http: HttpClient) {}
+
+  get(params?: StatisticsParams, opts?: RequestOptions): 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}` : ""}`, opts);
+  }
+}

package/src/resources/templates.ts

@@ -0,0 +1,44 @@
+import type { HttpClient, RequestOptions } 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 }, opts?: RequestOptions): 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}` : ""}`, opts);
+  }
+
+  get(id: string, opts?: RequestOptions): Promise<MessageTemplate> {
+    return this.http.get<MessageTemplate>(`/templates/${id}`, opts);
+  }
+
+  create(input: CreateTemplateInput, opts?: RequestOptions): Promise<MessageTemplate> {
+    return this.http.post<MessageTemplate>("/templates", input, opts);
+  }
+
+  update(id: string, input: UpdateTemplateInput, opts?: RequestOptions): Promise<MessageTemplate> {
+    return this.http.put<MessageTemplate>(`/templates/${id}`, input, opts);
+  }
+
+  saveDraft(id: string, input: SaveDraftInput, opts?: RequestOptions): Promise<MessageTemplate> {
+    return this.http.patch<MessageTemplate>(`/templates/${id}/draft`, input, opts);
+  }
+
+  publish(id: string, opts?: RequestOptions): Promise<MessageTemplate> {
+    return this.http.post<MessageTemplate>(`/templates/${id}/publish`, undefined, opts);
+  }
+
+  delete(id: string, opts?: RequestOptions): Promise<void> {
+    return this.http.delete(`/templates/${id}`, opts);
+  }
+}

package/src/resources/webhooks.ts

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

package/src/resources/whatsapp-numbers.ts

@@ -0,0 +1,80 @@
+import type { HttpClient, RequestOptions } 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) {}
+
+  listWabas(opts?: RequestOptions): Promise<OrgWaba[]> {
+    return this.http.get<OrgWaba[]>("/whatsapp/wabas", opts);
+  }
+
+  connectWaba(input: ConnectWabaInput, opts?: RequestOptions): Promise<OrgWaba> {
+    return this.http.post<OrgWaba>("/whatsapp/wabas/connect", input, opts);
+  }
+
+  reconnectWaba(id: string, opts?: RequestOptions): Promise<OrgWaba> {
+    return this.http.post<OrgWaba>(`/whatsapp/wabas/${id}/reconnect`, undefined, opts);
+  }
+
+  disconnectWaba(id: string, opts?: RequestOptions): Promise<void> {
+    return this.http.delete(`/whatsapp/wabas/${id}`, opts);
+  }
+
+  getWabaHealth(id: string, opts?: RequestOptions): Promise<WabaHealthResult> {
+    return this.http.get<WabaHealthResult>(`/whatsapp/wabas/${id}/health`, opts);
+  }
+
+  listNumbers(opts?: RequestOptions): Promise<WhatsappNumber[]> {
+    return this.http.get<WhatsappNumber[]>("/whatsapp/numbers", opts);
+  }
+
+  connectNumber(input: ConnectWhatsappNumberInput, opts?: RequestOptions): Promise<WhatsappNumber> {
+    return this.http.post<WhatsappNumber>("/whatsapp/numbers/connect", input, opts);
+  }
+
+  registerNumber(input: RegisterWhatsappNumberInput, opts?: RequestOptions): Promise<WhatsappNumber> {
+    return this.http.post<WhatsappNumber>("/whatsapp/numbers", input, opts);
+  }
+
+  verifyCode(id: string, code: string, opts?: RequestOptions): Promise<WhatsappNumber> {
+    return this.http.post<WhatsappNumber>(`/whatsapp/numbers/${id}/verify-code`, { code }, opts);
+  }
+
+  resendCode(id: string, opts?: RequestOptions): Promise<void> {
+    return this.http.post(`/whatsapp/numbers/${id}/resend-code`, undefined, opts);
+  }
+
+  getProfile(id: string, opts?: RequestOptions): Promise<WhatsappNumberProfile> {
+    return this.http.get<WhatsappNumberProfile>(`/whatsapp/numbers/${id}/profile`, opts);
+  }
+
+  updateProfile(id: string, input: UpdateWhatsappProfileInput, opts?: RequestOptions): Promise<WhatsappNumberProfile> {
+    return this.http.patch<WhatsappNumberProfile>(`/whatsapp/numbers/${id}/profile`, input, opts);
+  }
+
+  updateDisplayName(id: string, displayName: string, opts?: RequestOptions): Promise<WhatsappNumber> {
+    return this.http.patch<WhatsappNumber>(`/whatsapp/numbers/${id}`, { displayName }, opts);
+  }
+
+  getStatus(id: string, opts?: RequestOptions): Promise<PhoneNumberStatusResult> {
+    return this.http.get<PhoneNumberStatusResult>(`/whatsapp/numbers/${id}/status`, opts);
+  }
+
+  refreshNumbers(opts?: RequestOptions): Promise<WhatsappNumber[]> {
+    return this.http.post<WhatsappNumber[]>("/whatsapp/numbers/refresh", undefined, opts);
+  }
+
+  deleteNumber(id: string, opts?: RequestOptions): Promise<void> {
+    return this.http.delete(`/whatsapp/numbers/${id}`, opts);
+  }
+}

package/src/resources/whatsapp-templates.ts

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

package/src/server-exports.ts

@@ -0,0 +1,8 @@
+export { createPostClient } from "./server.js";
+export type { PostNextjsOptions, PostNextjsServiceAccountOptions, CreatePostClientOptions } from "./server.js";
+
+export { PostClient } from "./client.js";
+export { PostApiError } from "./errors.js";
+export type { HttpClientOptions, TokenResolver } from "./http.js";
+export { ServiceAccountTokenProvider, createServiceAccountToken } from "./service-account.js";
+export type { ServiceAccountOptions } from "./service-account.js";

package/src/server.ts

@@ -0,0 +1,42 @@
+import { PostClient } from "./client.js";
+import { ServiceAccountTokenProvider, type ServiceAccountOptions } from "./service-account.js";
+import type { TokenResolver } from "./http.js";
+
+export interface PostNextjsServiceAccountOptions {
+  baseUrl?: string;
+  serviceAccount: ServiceAccountOptions;
+}
+
+export interface PostNextjsOptions {
+  baseUrl?: string;
+}
+
+export type CreatePostClientOptions = PostNextjsServiceAccountOptions | PostNextjsOptions;
+
+function isServiceAccountOptions(opts: CreatePostClientOptions): opts is PostNextjsServiceAccountOptions {
+  return "serviceAccount" in opts;
+}
+
+/**
+ * Creates a PostClient for use in Server Components, Route Handlers, and Server Actions.
+ *
+ * Two modes:
+ * - Service account: pass `serviceAccount` credentials, the SDK handles token acquisition internally
+ * - Token per request: call with no token config, pass `{ token }` in each method call
+ */
+export function createPostClient(options?: CreatePostClientOptions): PostClient {
+  const baseUrl = options?.baseUrl ?? process.env.POST_API_URL ?? "https://api.usepost.com.br";
+
+  if (options && isServiceAccountOptions(options)) {
+    const provider = new ServiceAccountTokenProvider(options.serviceAccount);
+    return new PostClient({
+      baseUrl,
+      token: () => provider.getToken(),
+      organizationId: () => provider.getOrganizationId() as Promise<string>,
+    });
+  }
+
+  return new PostClient({ baseUrl });
+}
+
+export type { TokenResolver, ServiceAccountOptions };

package/src/service-account.ts

@@ -0,0 +1,97 @@
+import type { TokenResolver } from "./http.js";
+
+export interface ServiceAccountOptions {
+  issuerUrl: string;
+  clientId: string;
+  clientSecret: string;
+  refreshBeforeExpirySeconds?: number;
+}
+
+interface CachedToken {
+  value: string;
+  expiresAt: number;
+  organizationId: string | undefined;
+}
+
+function decodeJwtPayload(token: string): Record<string, unknown> {
+  try {
+    const [, payload] = token.split(".");
+    if (!payload) return {};
+    const json = atob(payload.replace(/-/g, "+").replace(/_/g, "/"));
+    return JSON.parse(json) as Record<string, unknown>;
+  } catch {
+    return {};
+  }
+}
+
+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<CachedToken> | null = null;
+
+  constructor(options: ServiceAccountOptions) {
+    this.issuerUrl = options.issuerUrl.replace(/\/$/, "");
+    this.clientId = options.clientId;
+    this.clientSecret = options.clientSecret;
+    this.refreshBeforeMs = (options.refreshBeforeExpirySeconds ?? 30) * 1000;
+  }
+
+  private async ensureFresh(): Promise<CachedToken> {
+    const now = Date.now();
+    if (this.cached && this.cached.expiresAt - now > this.refreshBeforeMs) {
+      return this.cached;
+    }
+    if (this.inflight) return this.inflight;
+    this.inflight = this.fetchToken().finally(() => { this.inflight = null; });
+    return this.inflight;
+  }
+
+  getToken(): Promise<string> {
+    return this.ensureFresh().then((c) => c.value);
+  }
+
+  getOrganizationId(): Promise<string | undefined> {
+    return this.ensureFresh().then((c) => c.organizationId);
+  }
+
+  private async fetchToken(): Promise<CachedToken> {
+    const credentials = btoa(`${this.clientId}:${this.clientSecret}`);
+
+    const res = await fetch(`${this.issuerUrl}/auth/token`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Basic ${credentials}`,
+      },
+      body: JSON.stringify({ grant_type: "service_account" }),
+      cache: "no-store" as RequestCache,
+    });
+
+    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 claims = decodeJwtPayload(data.access_token);
+    const organizationId =
+      typeof claims.organizationId === "string" ? claims.organizationId :
+      typeof claims.organization_id === "string" ? claims.organization_id :
+      undefined;
+
+    const expiresInMs = (data.expires_in ?? 420) * 1000;
+    this.cached = { value: data.access_token, expiresAt: Date.now() + expiresInMs, organizationId };
+    return this.cached;
+  }
+
+  asTokenResolver(): TokenResolver {
+    return () => this.getToken();
+  }
+}
+
+export function createServiceAccountToken(options: ServiceAccountOptions): TokenResolver {
+  return new ServiceAccountTokenProvider(options).asTokenResolver();
+}