@nibgate/sdk 0.1.9 → 0.2.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nibgate/sdk",
-  "version": "0.1.9",
+  "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/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> };