@nibgate/sdk 0.1.8 → 0.2.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nibgate/sdk",
-  "version": "0.1.8",
+  "version": "0.2.0",
   "description": "Framework-agnostic browser and server package for creator-owned gated content, unlock events, and receipts.",
   "type": "module",
   "sideEffects": false,
@@ -28,20 +28,26 @@
       "import": "./src/testing.js",
       "default": "./src/testing.js"
     },
-    "./package.json": "./package.json"
+    "./package.json": "./package.json",
+    "./dist/*": "./dist/*"
   },
   "scripts": {
     "pack:check": "npm pack --dry-run",
-    "prepublishOnly": "npm run pack:check"
+    "build": "node scripts/bundle.mjs",
+    "prepublishOnly": "npm run build && npm run pack:check"
   },
   "publishConfig": {
     "access": "public"
   },
   "files": [
     "src",
+    "dist",
     "README.md",
     "SKILL.md"
   ],
+  "devDependencies": {
+    "esbuild": "^0.25.12"
+  },
   "keywords": [
     "nibgate",
     "creator",

package/src/browser/index.js

@@ -556,6 +556,66 @@ export function createOnchainRating(resource, options = {}) {
   return controller;
 }
 
+export function mountRatingUI(resource, options = {}) {
+  const item = createGate(resource, options.gateOptions || {});
+  const win = browserWindow();
+  if (!win) return null;
+  const target = typeof options.target === 'string' ? win.document.querySelector(options.target) : options.target;
+  if (!target) return null;
+
+  const stars = [1, 2, 3, 4, 5];
+  let selectedRating = 0;
+
+  const container = win.document.createElement('div');
+  container.className = 'nibgate-rating-ui';
+  container.style.cssText = 'display:flex;align-items:center;gap:4px;padding:8px 0';
+
+  const starButtons = stars.map((value) => {
+    const btn = win.document.createElement('button');
+    btn.type = 'button';
+    btn.dataset.nibgateRatingValue = String(value);
+    btn.setAttribute('aria-label', `${value} star${value > 1 ? 's' : ''}`);
+    btn.innerHTML = '☆';
+    btn.style.cssText = 'background:none;border:none;font-size:24px;cursor:pointer;color:#ccc;transition:color 0.15s;padding:2px;line-height:1';
+    btn.addEventListener('mouseenter', () => {
+      starButtons.forEach((b, i) => b.style.color = i < value ? '#f5b342' : '#ccc');
+    });
+    btn.addEventListener('mouseleave', () => {
+      starButtons.forEach((b, i) => b.style.color = i < selectedRating ? '#f5b342' : '#ccc');
+    });
+    btn.addEventListener('click', () => {
+      selectedRating = value;
+      starButtons.forEach((b, i) => b.style.color = i < value ? '#f5b342' : '#ccc');
+      rate(item.resource, { rating: value }).catch(() => {});
+    });
+    container.appendChild(btn);
+    return btn;
+  });
+
+  const statusEl = win.document.createElement('span');
+  statusEl.style.cssText = 'font-size:13px;color:#888;margin-left:8px';
+  statusEl.textContent = options.label || 'Rate this content';
+  container.appendChild(statusEl);
+
+  target.appendChild(container);
+
+  function rate(r, input = {}) {
+    return item.rate({ ...input, rating: r });
+  }
+
+  function setRating(value) {
+    selectedRating = value;
+    starButtons.forEach((b, i) => b.style.color = i < value ? '#f5b342' : '#ccc');
+  }
+
+  return {
+    resource: item.resource,
+    container,
+    setRating,
+    rate
+  };
+}
+
 export async function payAndUnlockResource(resource, options = {}) {
   const item = createGate(resource, options.gateOptions || {});
   const payPath = options.payPath || item.resource.payPath || '/api/nibgate/pay';
@@ -690,6 +750,9 @@ export function createNibgate(defaults = {}) {
     createOnchainRating(resource, options = {}) {
       return createOnchainRating(resourceWithDefaults(resource), options);
     },
+    mountRatingUI(resource, options = {}) {
+      return mountRatingUI(resourceWithDefaults(resource), options);
+    },
     payAndUnlockResource(resource, options = {}) {
       return payAndUnlockResource(resourceWithDefaults(resource), options);
     },

package/src/index.d.ts

@@ -114,6 +114,7 @@ export type NibgateClient = {
   createEvmGatewayUnlock(resource: NibgateResource | string, options?: NibgateEvmGatewayUnlockOptions): NibgateEvmGatewayUnlockController;
   rateContentOnchain(resource: NibgateResource | string, options: NibgateOnchainRatingOptions): Promise<NibgateOnchainRatingResult>;
   createOnchainRating(resource: NibgateResource | string, options?: NibgateOnchainRatingUiOptions): NibgateOnchainRatingController;
+  mountRatingUI(resource: NibgateResource | string, options?: NibgateRatingUiOptions): NibgateRatingUiController | null;
   payAndUnlockResource(resource: NibgateResource | string, options?: NibgatePaymentOptions): Promise<NibgatePaymentResult>;
   setupResourcePage(resource: NibgateResource | string, options?: NibgatePageSetupOptions): NibgateGate;
   ratingMessage(resource: NibgateResource | string, rating?: NibgateRating | number, options?: Record<string, unknown>): string;
@@ -430,5 +431,18 @@ export declare function ratingMessage(resource: NibgateResource | string, rating
 export declare function createNibgate(defaults?: { resource?: NibgateResource }): NibgateClient;
 export declare const nibgate: NibgateClient;
 
+export interface NibgateRatingUiOptions {
+  target?: string | HTMLElement;
+  label?: string;
+  gateOptions?: Record<string, unknown>;
+}
+export interface NibgateRatingUiController {
+  resource: NibgateResource;
+  container: HTMLElement;
+  setRating(value: number): void;
+  rate(resource: NibgateResource | string, input?: Record<string, unknown>): ReturnType<typeof rateContentOnchain>;
+}
+export declare function mountRatingUI(resource: NibgateResource | string, options?: NibgateRatingUiOptions): NibgateRatingUiController | null;
+
 export declare function createTransferCheckout(resource: NibgateResource | string, options: NibgateTransferCheckoutOptions): NibgateTransferCheckout;
 export declare function payWithTransfer(resource: NibgateResource | string, options: NibgateTransferCheckoutOptions & NibgateAccessCheckOptions): Promise<NibgateAccessCheckResult>;

package/src/server/access.js

@@ -215,3 +215,39 @@ export function createNibgateServer(options = {}) {
 export function protect(resource, handler, options = {}) {
   return createNibgateServer(options).protect(resource, handler);
 }
+
+export function verifyPayment(options = {}) {
+  return async function verifyPaymentMiddleware(req, res, next) {
+    const proofHeader = req.headers?.['x-nibgate-payment-proof'] || req.get?.('x-nibgate-payment-proof') || '';
+    if (proofHeader) {
+      const nibgate = createNibgateServer(options);
+      const payload = nibgate.verifyUnlockToken(proofHeader, { id: req.params?.id || req.body?.resourceId || '' });
+      if (payload) {
+        req.nibgate = { unlock: payload, verified: true };
+        return next();
+      }
+    }
+
+    if ((options.paymentMode || process.env.NIBGATE_PAYMENT_MODE) === 'circle-gateway') {
+      const sigHeader = req.headers?.['payment-signature'] || req.get?.('payment-signature') || '';
+      if (sigHeader) {
+        const resource = options.resource || { id: req.params?.id || '', price: req.body?.price || '0' };
+        const gateway = await runCircleGatewayRequirement(
+          { headers: new Map(Object.entries(req.headers || {})), method: req.method, url: req.originalUrl || req.url },
+          resource,
+          options
+        );
+        if (!gateway.handled) {
+          req.nibgate = { payment: gateway.payment, verified: true };
+          return next();
+        }
+        return res.status(402).json({ error: 'Payment verification failed', detail: 'The payment signature could not be verified.' });
+      }
+    }
+
+    return res.status(402).json({
+      error: 'Payment required',
+      challenge: createPaymentChallenge(options.resource || { id: req.params?.id || '', price: req.body?.price || '0' }, options)
+    });
+  };
+}

package/src/server/admin-store.js

@@ -58,3 +58,50 @@ export function createMemoryStore() {
     remove(id) { delete store[id]; return true; }
   };
 }
+
+export function createPostgresStore(pool, options = {}) {
+  const table = options.table || 'nibgate_settings';
+  const idColumn = options.idColumn || 'id';
+
+  async function ensureTable() {
+    await pool.query(`
+      CREATE TABLE IF NOT EXISTS "${table}" (
+        "${idColumn}" TEXT PRIMARY KEY,
+        "settings" JSONB NOT NULL DEFAULT '{}',
+        "updatedAt" TIMESTAMPTZ NOT NULL DEFAULT NOW()
+      )
+    `);
+  }
+
+  async function list() {
+    const { rows } = await pool.query(`SELECT "${idColumn}" as id, settings FROM "${table}" ORDER BY "updatedAt" DESC`);
+    return rows.map((row) => ({ id: row.id, ...row.settings }));
+  }
+
+  async function get(id) {
+    const { rows } = await pool.query(`SELECT settings FROM "${table}" WHERE "${idColumn}" = $1`, [id]);
+    if (!rows.length) return null;
+    return { id, ...rows[0].settings };
+  }
+
+  async function set(id, settings) {
+    const now = new Date().toISOString();
+    const merged = JSON.stringify({ ...settings, updatedAt: now });
+    await pool.query(`
+      INSERT INTO "${table}" ("${idColumn}", "settings", "updatedAt")
+      VALUES ($1, $2::jsonb, $3)
+      ON CONFLICT ("${idColumn}")
+      DO UPDATE SET "settings" = ("${table}"."settings" || $2::jsonb), "updatedAt" = $3
+    `, [id, merged, now]);
+    return { id, ...settings, updatedAt: now };
+  }
+
+  async function remove(id) {
+    await pool.query(`DELETE FROM "${table}" WHERE "${idColumn}" = $1`, [id]);
+    return true;
+  }
+
+  const store = { list, get, set, remove };
+  if (options.autoInit !== false) ensureTable().catch(() => {});
+  return store;
+}

package/src/server/index.js

@@ -6,7 +6,7 @@ export { createManifest, manifestResponse } from './manifest.js';
 export { createUnlockToken, verifyUnlockToken } from './proof.js';
 export { emitHubEvent } from './hub.js';
 export { payWithGateway, createGatewayBuyer, getGatewayBalances, depositToGateway, withdrawFromGateway } from './gateway.js';
-export { createNibgateServer, protect } from './access.js';
+export { createNibgateServer, protect, verifyPayment } from './access.js';
 export { circleGatewayOptions, createCircleGatewayServer } from './presets.js';
 export { normalizeServerResource as normalizeResource, normalizeAccessPolicy, normalizeUnlockPolicy, validateResourceMetadata, UNLOCK_MODES } from '../core/resource.js';
 
@@ -14,4 +14,5 @@ export const server = createNibgateServer();
 export { NIBGATE_CONTENT_SETTING_FIELDS, createNibgateContentSettings, settingsToAccessPolicy, settingsToUnlockPolicy } from '../core/settings.js';
 export { PAYMENT_RAILS, normalizePaymentRail } from '../core/payment.js';
 export { createAdminApi, adminPageHtml } from './admin.js';
-export { createFileStore, createMemoryStore } from './admin-store.js';
+export { createFileStore, createMemoryStore, createPostgresStore } from './admin-store.js';
+export { createWebhookManager, createWebhookApi } from './webhooks.js';

package/src/server/webhooks.js

@@ -0,0 +1,97 @@
+import crypto from 'node:crypto';
+import { serverEnv } from './env.js';
+
+export function createWebhookManager(options = {}) {
+  const webhookUrl = options.webhookUrl || serverEnv('NIBGATE_WEBHOOK_URL') || '';
+  const webhookSecret = options.webhookSecret || serverEnv('NIBGATE_WEBHOOK_SECRET') || '';
+  const subscribers = new Map();
+
+  function sign(payload) {
+    if (!webhookSecret) return '';
+    return crypto.createHmac('sha256', webhookSecret).update(JSON.stringify(payload)).digest('hex');
+  }
+
+  function subscribe(event, url, secret = '') {
+    if (!subscribers.has(event)) subscribers.set(event, []);
+    subscribers.get(event).push({ url, secret });
+    return () => {
+      const list = subscribers.get(event) || [];
+      subscribers.set(event, list.filter((s) => s.url !== url));
+    };
+  }
+
+  async function emit(event, payload) {
+    const body = { event, timestamp: new Date().toISOString(), data: payload };
+    const list = subscribers.get(event) || [];
+    const results = [];
+
+    for (const { url, secret } of list) {
+      try {
+        const sig = secret ? crypto.createHmac('sha256', secret).update(JSON.stringify(body)).digest('hex') : '';
+        const response = await fetch(url, {
+          method: 'POST',
+          headers: {
+            'content-type': 'application/json',
+            ...(sig ? { 'x-nibgate-webhook-signature': sig } : {})
+          },
+          body: JSON.stringify(body)
+        });
+        results.push({ url, ok: response.ok, status: response.status });
+      } catch (err) {
+        results.push({ url, ok: false, error: err.message });
+      }
+    }
+
+    if (webhookUrl) {
+      try {
+        const sig = sign(body);
+        const response = await fetch(webhookUrl, {
+          method: 'POST',
+          headers: {
+            'content-type': 'application/json',
+            ...(sig ? { 'x-nibgate-webhook-signature': sig } : {})
+          },
+          body: JSON.stringify(body)
+        });
+        results.push({ url: webhookUrl, ok: response.ok, status: response.status });
+      } catch (err) {
+        results.push({ url: webhookUrl, ok: false, error: err.message });
+      }
+    }
+
+    return results;
+  }
+
+  return { subscribe, emit, sign };
+}
+
+export function createWebhookApi(manager, options = {}) {
+  const authorize = options.authorize || ((req) => {
+    const key = req.headers?.['x-webhook-key'] || req.query?.key;
+    return key === (options.adminKey || process.env.NIBGATE_WEBHOOK_ADMIN_KEY);
+  });
+
+  async function handleSubscribe(req, res) {
+    if (!authorize(req)) return res.status(403).json({ error: 'Unauthorized' });
+    const { event, url, secret } = req.body || {};
+    if (!event || !url) return res.status(400).json({ error: 'event and url are required' });
+    manager.subscribe(event, url, secret || '');
+    return res.json({ success: true, event, url });
+  }
+
+  async function handleTest(req, res) {
+    if (!authorize(req)) return res.status(403).json({ error: 'Unauthorized' });
+    const results = await manager.emit('webhook_test', { message: 'Webhook test from Nibgate admin' });
+    return res.json({ success: true, results });
+  }
+
+  function router(express) {
+    const Route = express?.Router ? express.Router() : null;
+    if (!Route) return null;
+    Route.post('/admin/nibgate/webhooks/subscribe', handleSubscribe);
+    Route.post('/admin/nibgate/webhooks/test', handleTest);
+    return Route;
+  }
+
+  return { handleSubscribe, handleTest, router, manager };
+}

package/src/server.d.ts

@@ -239,4 +239,8 @@ export interface NibgateAdminApi {
 export declare function createAdminApi(options: { store: NibgateAdminStore; title?: string; authorize?: (req: Request) => boolean }): NibgateAdminApi;
 export declare function createFileStore(options?: { path?: string }): NibgateAdminStore;
 export declare function createMemoryStore(): NibgateAdminStore;
+export declare function createPostgresStore(pool: Record<string, unknown>, options?: { table?: string; idColumn?: string; autoInit?: boolean }): NibgateAdminStore;
 export declare function adminPageHtml(options?: { title?: string; apiBase?: string }): string;
+export declare function verifyPayment(options?: Record<string, unknown>): (req: Record<string, unknown>, res: Record<string, unknown>, next: () => void) => Promise<void>;
+export declare function createWebhookManager(options?: { webhookUrl?: string; webhookSecret?: string }): { subscribe(event: string, url: string, secret?: string): () => void; emit(event: string, payload: Record<string, unknown>): Promise<Record<string, unknown>[]>; sign(payload: Record<string, unknown>): string };
+export declare function createWebhookApi(manager: ReturnType<typeof createWebhookManager>, options?: { authorize?: (req: Record<string, unknown>) => boolean; adminKey?: string }): { handleSubscribe(req: Record<string, unknown>, res: Record<string, unknown>): Promise<Response>; handleTest(req: Record<string, unknown>, res: Record<string, unknown>): Promise<Response>; router(expressModule: Record<string, unknown>): unknown; manager: ReturnType<typeof createWebhookManager> };