fdbck-node 0.1.0

package/dist/index.mjs

@@ -0,0 +1,362 @@
+// src/errors.ts
+var FdbckError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "FdbckError";
+  }
+};
+var FdbckApiError = class extends FdbckError {
+  status;
+  code;
+  details;
+  constructor(status, code, message, details) {
+    super(message);
+    this.name = "FdbckApiError";
+    this.status = status;
+    this.code = code;
+    this.details = details;
+  }
+};
+var FdbckNetworkError = class extends FdbckError {
+  constructor(message, options) {
+    super(message);
+    this.name = "FdbckNetworkError";
+    if (options?.cause) {
+      this.cause = options.cause;
+    }
+  }
+};
+
+// src/utils.ts
+function mapKeys(obj, fieldMap) {
+  const result = {};
+  for (const [key, value] of Object.entries(obj)) {
+    const mappedKey = fieldMap[key] ?? key;
+    result[mappedKey] = value;
+  }
+  return result;
+}
+var questionFieldsToApi = {
+  ratingConfig: "rating_config",
+  expiresAt: "expires_at",
+  maxResponses: "max_responses",
+  webhookUrl: "webhook_url",
+  webhookTrigger: "webhook_trigger",
+  themeColor: "theme_color",
+  themeMode: "theme_mode",
+  hideBranding: "hide_branding",
+  welcomeMessage: "welcome_message",
+  thankYouMessage: "thank_you_message"
+};
+var questionFieldsFromApi = {
+  expires_at: "expiresAt",
+  max_responses: "maxResponses",
+  webhook_url: "webhookUrl",
+  webhook_trigger: "webhookTrigger",
+  webhook_secret: "webhookSecret",
+  theme_color: "themeColor",
+  theme_mode: "themeMode",
+  hide_branding: "hideBranding",
+  welcome_message: "welcomeMessage",
+  thank_you_message: "thankYouMessage",
+  total_responses: "totalResponses",
+  created_at: "createdAt",
+  updated_at: "updatedAt"
+};
+var ratingConfigFieldsToApi = {
+  minLabel: "min_label",
+  maxLabel: "max_label"
+};
+var ratingConfigFieldsFromApi = {
+  min_label: "minLabel",
+  max_label: "maxLabel"
+};
+var responseFieldsFromApi = {
+  question_id: "questionId",
+  created_at: "createdAt"
+};
+var tokenFieldsFromApi = {
+  respond_url: "respondUrl",
+  expires_at: "expiresAt"
+};
+var webhookDeliveryFieldsFromApi = {
+  status_code: "statusCode",
+  next_retry_at: "nextRetryAt",
+  created_at: "createdAt"
+};
+var paginationFieldsFromApi = {
+  next_cursor: "nextCursor",
+  has_more: "hasMore"
+};
+var accountOrgFieldsFromApi = {
+  responses_used: "responsesUsed",
+  responses_limit: "responsesLimit",
+  period_starts_at: "periodStartsAt",
+  period_ends_at: "periodEndsAt",
+  consecutive_overage_months: "consecutiveOverageMonths",
+  has_billing: "hasBilling"
+};
+var accountUserFieldsFromApi = {
+  avatar_url: "avatarUrl"
+};
+var resultsFieldsFromApi = {
+  question_id: "questionId",
+  total_responses: "totalResponses"
+};
+function computeExpiresAt(seconds) {
+  return new Date(Date.now() + seconds * 1e3).toISOString();
+}
+
+// src/resources/questions.ts
+function mapQuestionFromApi(raw) {
+  const mapped = mapKeys(raw, questionFieldsFromApi);
+  if (mapped.ratingConfig && typeof mapped.ratingConfig === "object") {
+    mapped.ratingConfig = mapKeys(
+      mapped.ratingConfig,
+      ratingConfigFieldsFromApi
+    );
+  }
+  return mapped;
+}
+function mapResponseFromApi(raw) {
+  return mapKeys(raw, responseFieldsFromApi);
+}
+function mapWebhookDeliveryFromApi(raw) {
+  return mapKeys(raw, webhookDeliveryFieldsFromApi);
+}
+function mapPagination(raw) {
+  return mapKeys(raw, paginationFieldsFromApi);
+}
+var QuestionsResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /** Create a new question. */
+  async create(opts) {
+    const { expiresIn, ratingConfig, ...rest } = opts;
+    if (expiresIn !== void 0 && opts.expiresAt !== void 0) {
+      throw new Error("Provide either expiresIn or expiresAt, not both");
+    }
+    if (expiresIn === void 0 && opts.expiresAt === void 0) {
+      throw new Error("Either expiresIn or expiresAt is required");
+    }
+    const body = { ...rest };
+    if (expiresIn !== void 0) {
+      body.expiresAt = computeExpiresAt(expiresIn);
+    }
+    if (ratingConfig) {
+      body.ratingConfig = mapKeys(
+        ratingConfig,
+        ratingConfigFieldsToApi
+      );
+    }
+    const apiBody = mapKeys(body, questionFieldsToApi);
+    const raw = await this.client.request("POST", "/v1/questions", {
+      body: apiBody
+    });
+    return mapQuestionFromApi(raw);
+  }
+  /** Get a question by ID. */
+  async get(id) {
+    const raw = await this.client.request("GET", `/v1/questions/${id}`);
+    return mapQuestionFromApi(raw);
+  }
+  /** List questions with pagination. */
+  async list(opts) {
+    const query = {};
+    if (opts?.cursor) query.cursor = opts.cursor;
+    if (opts?.limit) query.limit = String(opts.limit);
+    if (opts?.status) query.status = opts.status;
+    if (opts?.sort) query.sort = opts.sort;
+    if (opts?.order) query.order = opts.order;
+    if (opts?.createdAfter) query.created_after = opts.createdAfter;
+    if (opts?.createdBefore) query.created_before = opts.createdBefore;
+    const raw = await this.client.request("GET", "/v1/questions", {
+      query
+    });
+    const data = raw.data.map(mapQuestionFromApi);
+    const pagination = mapPagination(raw.pagination);
+    return { data, pagination };
+  }
+  /** Auto-paginate through all questions. */
+  async *listAll(opts) {
+    let cursor;
+    do {
+      const page = await this.list({ ...opts, cursor });
+      for (const question of page.data) {
+        yield question;
+      }
+      cursor = page.pagination.nextCursor ?? void 0;
+    } while (cursor);
+  }
+  /** Get responses for a question with aggregated results. */
+  async results(id, opts) {
+    const query = {};
+    if (opts?.cursor) query.cursor = opts.cursor;
+    if (opts?.limit) query.limit = String(opts.limit);
+    const raw = await this.client.request(
+      "GET",
+      `/v1/questions/${id}/responses`,
+      { query }
+    );
+    const envelope = mapKeys(raw, resultsFieldsFromApi);
+    const data = raw.data.map(mapResponseFromApi);
+    const pagination = mapPagination(raw.pagination);
+    return {
+      questionId: envelope.questionId,
+      type: envelope.type,
+      status: envelope.status,
+      totalResponses: envelope.totalResponses,
+      results: envelope.results,
+      data,
+      pagination
+    };
+  }
+  /** Cancel (delete) a question. */
+  async cancel(id) {
+    const raw = await this.client.request("DELETE", `/v1/questions/${id}`);
+    return mapQuestionFromApi(raw);
+  }
+  /** Get webhook delivery logs for a question. */
+  async webhooks(id, opts) {
+    const query = {};
+    if (opts?.cursor) query.cursor = opts.cursor;
+    if (opts?.limit) query.limit = String(opts.limit);
+    const raw = await this.client.request(
+      "GET",
+      `/v1/questions/${id}/webhooks`,
+      { query }
+    );
+    const data = raw.data.map(mapWebhookDeliveryFromApi);
+    const pagination = mapPagination(raw.pagination);
+    return { data, pagination };
+  }
+};
+
+// src/resources/tokens.ts
+var TokensResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /** Create a respondent token for a question. */
+  async create(questionId, opts) {
+    const raw = await this.client.request(
+      "POST",
+      `/v1/questions/${questionId}/token`,
+      { body: opts ?? {} }
+    );
+    return mapKeys(raw, tokenFieldsFromApi);
+  }
+};
+
+// src/webhook.ts
+import { createHmac, timingSafeEqual } from "crypto";
+function verifyWebhook(rawBody, signature, secret) {
+  const expected = createHmac("sha256", secret).update(rawBody).digest("hex");
+  if (expected.length !== signature.length) {
+    return false;
+  }
+  return timingSafeEqual(
+    Buffer.from(expected, "hex"),
+    Buffer.from(signature, "hex")
+  );
+}
+
+// src/client.ts
+var DEFAULT_BASE_URL = "https://api.fdbck.sh";
+var DEFAULT_TIMEOUT = 3e4;
+var SDK_VERSION = "0.1.0";
+var Fdbck = class {
+  apiKey;
+  baseUrl;
+  timeout;
+  questions;
+  tokens;
+  constructor(apiKey, options) {
+    if (!apiKey.startsWith("sk_fdbck_")) {
+      throw new Error('Invalid API key: must start with "sk_fdbck_"');
+    }
+    this.apiKey = apiKey;
+    this.baseUrl = (options?.baseUrl ?? DEFAULT_BASE_URL).replace(/\/+$/, "");
+    this.timeout = options?.timeout ?? DEFAULT_TIMEOUT;
+    this.questions = new QuestionsResource(this);
+    this.tokens = new TokensResource(this);
+  }
+  /** Make an authenticated request to the fdbck API. */
+  async request(method, path, options) {
+    const url = new URL(path, this.baseUrl);
+    if (options?.query) {
+      for (const [key, value] of Object.entries(options.query)) {
+        url.searchParams.set(key, value);
+      }
+    }
+    const headers = {
+      Authorization: `Bearer ${this.apiKey}`,
+      "User-Agent": `@fdbck/node/${SDK_VERSION}`
+    };
+    const fetchOptions = {
+      method,
+      headers
+    };
+    if (options?.body) {
+      headers["Content-Type"] = "application/json";
+      fetchOptions.body = JSON.stringify(options.body);
+    }
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+    fetchOptions.signal = controller.signal;
+    let response;
+    try {
+      response = await fetch(url.toString(), fetchOptions);
+    } catch (error) {
+      clearTimeout(timeoutId);
+      throw new FdbckNetworkError(
+        error instanceof Error ? error.message : "Network request failed",
+        { cause: error }
+      );
+    } finally {
+      clearTimeout(timeoutId);
+    }
+    if (response.status === 204) {
+      return void 0;
+    }
+    let data;
+    try {
+      data = await response.json();
+    } catch {
+      throw new FdbckApiError(response.status, "parse_error", "Failed to parse response body");
+    }
+    if (!response.ok) {
+      const err = data?.error;
+      throw new FdbckApiError(
+        response.status,
+        err?.code ?? "unknown_error",
+        err?.message ?? `Request failed with status ${response.status}`,
+        err?.details
+      );
+    }
+    return data;
+  }
+  /** Get current account info. */
+  async me() {
+    const raw = await this.request("GET", "/v1/me");
+    const rawUser = raw.user;
+    const rawOrg = raw.organization;
+    return {
+      user: rawUser ? mapKeys(rawUser, accountUserFieldsFromApi) : null,
+      organization: rawOrg ? mapKeys(rawOrg, accountOrgFieldsFromApi) : null
+    };
+  }
+  /** Verify a webhook signature. */
+  verifyWebhook(rawBody, signature, secret) {
+    return verifyWebhook(rawBody, signature, secret);
+  }
+};
+export {
+  Fdbck,
+  FdbckApiError,
+  FdbckError,
+  FdbckNetworkError,
+  Fdbck as default,
+  verifyWebhook
+};

package/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "fdbck-node",
+  "version": "0.1.0",
+  "description": "Official Node.js SDK for the fdbck API",
+  "license": "MIT",
+  "author": "fdbck",
+  "homepage": "https://fdbck.sh",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/fdbck-sh/fdbck-node"
+  },
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.js"
+      },
+      "require": {
+        "types": "./dist/index.d.cts",
+        "default": "./dist/index.cjs"
+      }
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "scripts": {
+    "build": "tsup",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "typecheck": "tsc --noEmit"
+  },
+  "devDependencies": {
+    "@types/node": "^25.5.0",
+    "tsup": "^8.0.0",
+    "typescript": "^5.4.0",
+    "vitest": "^1.6.0"
+  }
+}