@feelflow/ffid-sdk 0.1.0 → 0.2.0

package/dist/index.d.ts

@@ -1,12 +1,12 @@
 import * as react_jsx_runtime from 'react/jsx-runtime';
 import { ReactNode, ComponentType, FC } from 'react';
-import { F as FFIDConfig, a as FFIDUser, b as FFIDOrganization, c as FFIDError, d as FFIDSubscriptionContextValue } from './index-CtBBLbTn.js';
-export { e as FFIDApiResponse, f as FFIDContextValue, g as FFIDLogger, h as FFIDLoginButton, i as FFIDOrganizationSwitcher, j as FFIDSessionResponse, k as FFIDSubscription, l as FFIDSubscriptionBadge, m as FFIDUserMenu } from './index-CtBBLbTn.js';
+import { F as FFIDConfig, a as FFIDUser, b as FFIDOrganization, c as FFIDError, d as FFIDSubscriptionContextValue, e as FFIDAnnouncementsClientConfig, L as ListAnnouncementsOptions, f as FFIDAnnouncementsApiResponse, A as AnnouncementListResponse, g as FFIDAnnouncementsLogger } from './index-B92_OuFc.js';
+export { h as Announcement, i as AnnouncementStatus, j as AnnouncementType, k as FFIDAnnouncementBadge, l as FFIDAnnouncementList, m as FFIDAnnouncementsError, n as FFIDAnnouncementsErrorCode, o as FFIDAnnouncementsServerResponse, p as FFIDApiResponse, q as FFIDContextValue, r as FFIDLogger, s as FFIDLoginButton, t as FFIDOrganizationSwitcher, u as FFIDSessionResponse, v as FFIDSubscription, w as FFIDSubscriptionBadge, x as FFIDUserMenu, U as UseFFIDAnnouncementsOptions, y as UseFFIDAnnouncementsReturn, z as useFFIDAnnouncements } from './index-B92_OuFc.js';
 
 /**
  * FFID SDK Shared Constants
  *
- * Constants shared across all SDK entry points (main client + legal client).
+ * Constants shared across all SDK entry points.
  * Centralizing these prevents drift during domain/URL changes.
  */
 /** Default FFID API base URL (production) */
@@ -178,4 +178,59 @@ interface WithFFIDAuthOptions {
  */
 declare function withFFIDAuth<P extends object>(Component: ComponentType<P>, options?: WithFFIDAuthOptions): FC<P>;
 
-export { DEFAULT_API_BASE_URL, FFIDConfig, FFIDError, FFIDOrganization, FFIDProvider, type FFIDProviderProps, FFIDSubscriptionContextValue, FFIDUser, type UseFFIDReturn, type WithFFIDAuthOptions, type WithSubscriptionOptions, useFFID, useSubscription, withFFIDAuth, withSubscription };
+/**
+ * FFID Announcements API Client
+ *
+ * Handles API communication for public announcements.
+ * No authentication required - this is a public endpoint.
+ *
+ * @example
+ * ```typescript
+ * import { createFFIDAnnouncementsClient } from '@feelflow/ffid-sdk/announcements'
+ *
+ * const client = createFFIDAnnouncementsClient({
+ *   apiBaseUrl: 'https://id.feelflow.co.jp',
+ * })
+ *
+ * const { data, error } = await client.listAnnouncements({ limit: 10 })
+ * if (data) {
+ *   console.log(`Found ${data.total} announcements`)
+ * }
+ * ```
+ */
+
+/**
+ * Error codes used by the Announcements SDK
+ */
+declare const FFID_ANNOUNCEMENTS_ERROR_CODES: {
+    /** Network request failed (fetch threw) */
+    readonly NETWORK_ERROR: "NETWORK_ERROR";
+    /** Failed to parse server response as JSON */
+    readonly PARSE_ERROR: "PARSE_ERROR";
+    /** Server returned error without structured error body */
+    readonly UNKNOWN_ERROR: "UNKNOWN_ERROR";
+};
+/**
+ * Creates an FFID Announcements API client instance
+ *
+ * @param config - Client configuration (optional, uses defaults)
+ * @returns Announcements client instance
+ *
+ * @example
+ * ```typescript
+ * const client = createFFIDAnnouncementsClient()
+ * const { data, error } = await client.listAnnouncements()
+ * ```
+ */
+declare function createFFIDAnnouncementsClient(config?: FFIDAnnouncementsClientConfig): {
+    /** List published announcements */
+    listAnnouncements: (options?: ListAnnouncementsOptions) => Promise<FFIDAnnouncementsApiResponse<AnnouncementListResponse>>;
+    /** Resolved logger instance */
+    logger: FFIDAnnouncementsLogger;
+    /** API base URL */
+    baseUrl: string;
+};
+/** Type of the FFID Announcements client */
+type FFIDAnnouncementsClient = ReturnType<typeof createFFIDAnnouncementsClient>;
+
+export { AnnouncementListResponse, DEFAULT_API_BASE_URL, FFIDAnnouncementsApiResponse, type FFIDAnnouncementsClient, FFIDAnnouncementsClientConfig, FFIDAnnouncementsLogger, FFIDConfig, FFIDError, FFIDOrganization, FFIDProvider, type FFIDProviderProps, FFIDSubscriptionContextValue, FFIDUser, FFID_ANNOUNCEMENTS_ERROR_CODES, ListAnnouncementsOptions, type UseFFIDReturn, type WithFFIDAuthOptions, type WithSubscriptionOptions, createFFIDAnnouncementsClient, useFFID, useSubscription, withFFIDAuth, withSubscription };

package/dist/index.js

@@ -1,5 +1,5 @@
-import { useFFIDContext } from './chunk-A63MX52D.js';
-export { DEFAULT_API_BASE_URL, FFIDLoginButton, FFIDOrganizationSwitcher, FFIDProvider, FFIDSubscriptionBadge, FFIDUserMenu, useFFID, useSubscription, withSubscription } from './chunk-A63MX52D.js';
+import { useFFIDContext } from './chunk-VXBUXOLF.js';
+export { DEFAULT_API_BASE_URL, FFIDAnnouncementBadge, FFIDAnnouncementList, FFIDLoginButton, FFIDOrganizationSwitcher, FFIDProvider, FFIDSubscriptionBadge, FFIDUserMenu, FFID_ANNOUNCEMENTS_ERROR_CODES, createFFIDAnnouncementsClient, useFFID, useFFIDAnnouncements, useSubscription, withSubscription } from './chunk-VXBUXOLF.js';
 import { useRef, useEffect } from 'react';
 import { jsx, Fragment } from 'react/jsx-runtime';
 

package/dist/legal/index.cjs

@@ -1,7 +1,6 @@
 'use strict';
 
-// src/constants.ts
-var DEFAULT_API_BASE_URL = "https://id.feelflow.co.jp";
+var chunkP5PPUZGX_cjs = require('../chunk-P5PPUZGX.cjs');
 
 // src/legal/ffid-legal-client.ts
 var API_PREFIX = "/api/v1/legal/ext";
@@ -38,7 +37,7 @@ function createFFIDLegalClient(config) {
   if (!config.apiKey) {
     throw new Error("FFID Legal Client: apiKey \u304C\u672A\u8A2D\u5B9A\u3067\u3059");
   }
-  const baseUrl = config.apiBaseUrl ?? DEFAULT_API_BASE_URL;
+  const baseUrl = config.apiBaseUrl ?? chunkP5PPUZGX_cjs.DEFAULT_API_BASE_URL;
   const logger = config.logger ?? (config.debug ? consoleLogger : noopLogger);
   async function fetchWithApiKey(endpoint, options = {}) {
     const url = `${baseUrl}${API_PREFIX}${endpoint}`;
@@ -175,6 +174,9 @@ function createFFIDLegalClient(config) {
   };
 }
 
-exports.DEFAULT_API_BASE_URL = DEFAULT_API_BASE_URL;
+Object.defineProperty(exports, "DEFAULT_API_BASE_URL", {
+  enumerable: true,
+  get: function () { return chunkP5PPUZGX_cjs.DEFAULT_API_BASE_URL; }
+});
 exports.FFID_LEGAL_ERROR_CODES = FFID_LEGAL_ERROR_CODES;
 exports.createFFIDLegalClient = createFFIDLegalClient;

package/dist/legal/index.d.cts

@@ -1,7 +1,7 @@
 /**
  * FFID SDK Shared Constants
  *
- * Constants shared across all SDK entry points (main client + legal client).
+ * Constants shared across all SDK entry points.
  * Centralizing these prevents drift during domain/URL changes.
  */
 /** Default FFID API base URL (production) */

package/dist/legal/index.d.ts

@@ -1,7 +1,7 @@
 /**
  * FFID SDK Shared Constants
  *
- * Constants shared across all SDK entry points (main client + legal client).
+ * Constants shared across all SDK entry points.
  * Centralizing these prevents drift during domain/URL changes.
  */
 /** Default FFID API base URL (production) */

package/dist/legal/index.js

@@ -1,5 +1,5 @@
-// src/constants.ts
-var DEFAULT_API_BASE_URL = "https://id.feelflow.co.jp";
+import { DEFAULT_API_BASE_URL } from '../chunk-P4MLCG4T.js';
+export { DEFAULT_API_BASE_URL } from '../chunk-P4MLCG4T.js';
 
 // src/legal/ffid-legal-client.ts
 var API_PREFIX = "/api/v1/legal/ext";
@@ -173,4 +173,4 @@ function createFFIDLegalClient(config) {
   };
 }
 
-export { DEFAULT_API_BASE_URL, FFID_LEGAL_ERROR_CODES, createFFIDLegalClient };
+export { FFID_LEGAL_ERROR_CODES, createFFIDLegalClient };

package/dist/webhooks/index.cjs

@@ -0,0 +1,251 @@
+'use strict';
+
+var crypto = require('crypto');
+
+// src/webhooks/constants.ts
+var FFID_WEBHOOK_SIGNATURE_HEADER = "X-FFID-Signature";
+var FFID_WEBHOOK_TIMESTAMP_HEADER = "X-FFID-Timestamp";
+var FFID_WEBHOOK_EVENT_ID_HEADER = "X-FFID-Event-ID";
+var FFID_WEBHOOK_SIGNATURE_VERSION = "v1";
+var DEFAULT_TOLERANCE_SECONDS = 300;
+var MILLISECONDS_PER_SECOND = 1e3;
+
+// src/webhooks/errors.ts
+var FFIDWebhookError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "FFIDWebhookError";
+  }
+};
+var FFIDWebhookSignatureError = class extends FFIDWebhookError {
+  constructor(message = "Webhook signature verification failed") {
+    super(message);
+    this.name = "FFIDWebhookSignatureError";
+  }
+};
+var FFIDWebhookTimestampError = class extends FFIDWebhookError {
+  constructor(message = "Webhook timestamp is outside tolerance window") {
+    super(message);
+    this.name = "FFIDWebhookTimestampError";
+  }
+};
+var FFIDWebhookPayloadError = class extends FFIDWebhookError {
+  constructor(message = "Webhook payload is not valid JSON") {
+    super(message);
+    this.name = "FFIDWebhookPayloadError";
+  }
+};
+function parseSignatureHeader(header) {
+  const parts = header.split(",");
+  let timestamp = null;
+  let signature = null;
+  for (const part of parts) {
+    const [key, value] = part.split("=", 2);
+    if (key === "t" && value) {
+      timestamp = parseInt(value, 10);
+    } else if (key === FFID_WEBHOOK_SIGNATURE_VERSION && value) {
+      signature = value;
+    }
+  }
+  if (timestamp === null || isNaN(timestamp) || !signature) {
+    return null;
+  }
+  return { timestamp, signature };
+}
+function computeSignature(secret, timestamp, body) {
+  const signedContent = `${timestamp}.${body}`;
+  return crypto.createHmac("sha256", secret).update(signedContent).digest("hex");
+}
+function verifyWebhookSignature(rawBody, signatureHeader, secret, toleranceSeconds = DEFAULT_TOLERANCE_SECONDS) {
+  const parsed = parseSignatureHeader(signatureHeader);
+  if (!parsed) {
+    throw new FFIDWebhookSignatureError("Invalid signature header format");
+  }
+  const { timestamp, signature } = parsed;
+  const now = Math.floor(Date.now() / MILLISECONDS_PER_SECOND);
+  if (Math.abs(now - timestamp) > toleranceSeconds) {
+    throw new FFIDWebhookTimestampError(
+      `Webhook timestamp is outside tolerance window (${toleranceSeconds}s)`
+    );
+  }
+  const expected = computeSignature(secret, timestamp, rawBody);
+  const HEX_REGEX = /^[0-9a-f]+$/i;
+  if (!HEX_REGEX.test(signature)) {
+    throw new FFIDWebhookSignatureError("Webhook signature verification failed");
+  }
+  const sigBuffer = Buffer.from(signature, "hex");
+  const expectedBuffer = Buffer.from(expected, "hex");
+  if (sigBuffer.length !== expectedBuffer.length) {
+    throw new FFIDWebhookSignatureError("Webhook signature verification failed");
+  }
+  if (!crypto.timingSafeEqual(sigBuffer, expectedBuffer)) {
+    throw new FFIDWebhookSignatureError("Webhook signature verification failed");
+  }
+  try {
+    return JSON.parse(rawBody);
+  } catch {
+    throw new FFIDWebhookPayloadError("Webhook payload is not valid JSON");
+  }
+}
+
+// src/webhooks/handler.ts
+var SDK_LOG_PREFIX = "[FFID Webhook SDK]";
+var HTTP_OK = 200;
+var HTTP_BAD_REQUEST = 400;
+var noopLogger = {
+  debug: () => {
+  },
+  info: () => {
+  },
+  warn: () => {
+  },
+  error: (...args) => console.error(SDK_LOG_PREFIX, ...args)
+};
+function createFFIDWebhookHandler(config) {
+  if (!config.secret) {
+    throw new Error("FFID Webhook Handler: secret is required");
+  }
+  const logger = config.logger ?? noopLogger;
+  const toleranceSeconds = config.toleranceSeconds;
+  const handlers = /* @__PURE__ */ new Map();
+  const allHandlers = /* @__PURE__ */ new Set();
+  function on(eventType, handler) {
+    if (!handlers.has(eventType)) {
+      handlers.set(eventType, /* @__PURE__ */ new Set());
+    }
+    handlers.get(eventType).add(handler);
+    logger.debug(`Registered handler for ${eventType}`);
+  }
+  function onAll(handler) {
+    allHandlers.add(handler);
+    logger.debug("Registered catch-all handler");
+  }
+  function off(eventType, handler) {
+    const set = handlers.get(eventType);
+    if (set) {
+      set.delete(handler);
+      if (set.size === 0) {
+        handlers.delete(eventType);
+      }
+    }
+  }
+  async function dispatchEvent(event) {
+    const typeHandlers = handlers.get(event.type);
+    const promises = [];
+    if (typeHandlers) {
+      for (const handler of typeHandlers) {
+        promises.push(Promise.resolve(handler(event)));
+      }
+    }
+    for (const handler of allHandlers) {
+      promises.push(Promise.resolve(handler(event)));
+    }
+    await Promise.all(promises);
+  }
+  async function handleEvent(rawBody, signatureHeader) {
+    const event = verifyWebhookSignature(
+      rawBody,
+      signatureHeader,
+      config.secret,
+      toleranceSeconds
+    );
+    logger.info(`Received event: ${event.type} (${event.id})`);
+    await dispatchEvent(event);
+    return event;
+  }
+  async function handleRaw(rawBody, headers) {
+    const headerLower = FFID_WEBHOOK_SIGNATURE_HEADER.toLowerCase();
+    let signatureHeader;
+    for (const [key, value] of Object.entries(headers)) {
+      if (key.toLowerCase() === headerLower) {
+        signatureHeader = value;
+        break;
+      }
+    }
+    if (!signatureHeader) {
+      throw new FFIDWebhookError(
+        `Missing ${FFID_WEBHOOK_SIGNATURE_HEADER} header`
+      );
+    }
+    return handleEvent(rawBody, signatureHeader);
+  }
+  function expressMiddleware() {
+    return (req, res, _next) => {
+      const rawBody = typeof req.body === "string" ? req.body : Buffer.isBuffer(req.body) ? req.body.toString("utf-8") : JSON.stringify(req.body);
+      const signatureHeader = req.headers[FFID_WEBHOOK_SIGNATURE_HEADER.toLowerCase()];
+      if (!signatureHeader) {
+        res.status(HTTP_BAD_REQUEST).json({
+          error: `Missing ${FFID_WEBHOOK_SIGNATURE_HEADER} header`
+        });
+        return;
+      }
+      handleEvent(rawBody, signatureHeader).then((event) => {
+        res.status(HTTP_OK).json({ received: true, eventId: event.id });
+      }).catch((error) => {
+        logger.error("Webhook processing failed:", error);
+        const message = error instanceof Error ? error.message : "Webhook processing failed";
+        res.status(HTTP_BAD_REQUEST).json({ error: message });
+      });
+    };
+  }
+  function nextHandler() {
+    return async (request) => {
+      try {
+        const rawBody = await request.text();
+        const signatureHeader = request.headers.get(
+          FFID_WEBHOOK_SIGNATURE_HEADER
+        );
+        if (!signatureHeader) {
+          return new Response(
+            JSON.stringify({
+              error: `Missing ${FFID_WEBHOOK_SIGNATURE_HEADER} header`
+            }),
+            { status: HTTP_BAD_REQUEST, headers: { "Content-Type": "application/json" } }
+          );
+        }
+        const event = await handleEvent(rawBody, signatureHeader);
+        return new Response(
+          JSON.stringify({ received: true, eventId: event.id }),
+          { status: HTTP_OK, headers: { "Content-Type": "application/json" } }
+        );
+      } catch (error) {
+        logger.error("Webhook processing failed:", error);
+        const message = error instanceof Error ? error.message : "Webhook processing failed";
+        return new Response(
+          JSON.stringify({ error: message }),
+          { status: HTTP_BAD_REQUEST, headers: { "Content-Type": "application/json" } }
+        );
+      }
+    };
+  }
+  return {
+    /** Register a handler for a specific event type */
+    on,
+    /** Register a handler that receives all events */
+    onAll,
+    /** Unregister a handler for a specific event type */
+    off,
+    /** Verify signature and dispatch event (core method) */
+    handleEvent,
+    /** Process webhook from raw body + headers object */
+    handleRaw,
+    /** Express/Connect middleware */
+    expressMiddleware,
+    /** Next.js App Router route handler */
+    nextHandler
+  };
+}
+
+exports.DEFAULT_TOLERANCE_SECONDS = DEFAULT_TOLERANCE_SECONDS;
+exports.FFIDWebhookError = FFIDWebhookError;
+exports.FFIDWebhookPayloadError = FFIDWebhookPayloadError;
+exports.FFIDWebhookSignatureError = FFIDWebhookSignatureError;
+exports.FFIDWebhookTimestampError = FFIDWebhookTimestampError;
+exports.FFID_WEBHOOK_EVENT_ID_HEADER = FFID_WEBHOOK_EVENT_ID_HEADER;
+exports.FFID_WEBHOOK_SIGNATURE_HEADER = FFID_WEBHOOK_SIGNATURE_HEADER;
+exports.FFID_WEBHOOK_SIGNATURE_VERSION = FFID_WEBHOOK_SIGNATURE_VERSION;
+exports.FFID_WEBHOOK_TIMESTAMP_HEADER = FFID_WEBHOOK_TIMESTAMP_HEADER;
+exports.computeSignature = computeSignature;
+exports.createFFIDWebhookHandler = createFFIDWebhookHandler;
+exports.parseSignatureHeader = parseSignatureHeader;
+exports.verifyWebhookSignature = verifyWebhookSignature;