@heossi/qnsi 0.3.3 → 0.4.0

package/dist/storage.d.ts

@@ -20,7 +20,7 @@ export declare class StorageClient {
     constructor(internal: Internal);
     putObject(bucket: string, key: string, input: PutObjectInput, opts?: Pick<RequestOptions, "idempotencyKey">): Promise<Record<string, unknown>>;
     /**
-     * Returns `[plaintext bytes, descriptor JSON]`. Throws `QnspApiError`
+     * Returns `[plaintext bytes, descriptor JSON]`. Throws `QnsiApiError`
      * if the descriptor is missing the dataB64 field.
      */
     getObject(bucket: string, key: string): Promise<readonly [Uint8Array, GetObjectResponse]>;

package/dist/storage.js

@@ -4,7 +4,7 @@
  * (apps/storage-service/src/routes/bucket-objects.ts) and reached via the edge gateway's
  * `/proxy/storage` prefix (rewritten to `/storage`).
  */
-import { QnspApiError } from "./errors.js";
+import { QnsiApiError } from "./errors.js";
 // Edge gateway rewrites /proxy/storage -> /storage, so this resolves to the backend's
 // /storage/v1/buckets/* routes. (Was /proxy/storage/storage/v1 — a double "storage" that
 // rewrote to /storage/storage/v1, which the backend never served, so every call 404'd.)
@@ -27,13 +27,13 @@ export class StorageClient {
         return this.internal.request("PUT", `${PATH_PREFIX}/buckets/${bucket}/objects/${key}`, body, opts);
     }
     /**
-     * Returns `[plaintext bytes, descriptor JSON]`. Throws `QnspApiError`
+     * Returns `[plaintext bytes, descriptor JSON]`. Throws `QnsiApiError`
      * if the descriptor is missing the dataB64 field.
      */
     async getObject(bucket, key) {
         const resp = await this.internal.request("GET", `${PATH_PREFIX}/buckets/${bucket}/objects/${key}`);
         if (!resp.dataB64) {
-            throw new QnspApiError("storage.getObject: response missing dataB64", 200);
+            throw new QnsiApiError("storage.getObject: response missing dataB64", 200);
         }
         return [decodeB64(resp.dataB64), resp];
     }

package/dist/webhooks.d.ts

@@ -6,7 +6,7 @@
  */
 /** Default replay-protection window — 5 minutes. */
 export declare const MAX_WEBHOOK_SKEW_MS: number;
-export interface QnspWebhookEvent {
+export interface QnsiWebhookEvent {
     readonly eventType: string;
     readonly eventId: string;
     readonly occurredAt: string;
@@ -16,17 +16,17 @@ export interface QnspWebhookEvent {
  * Constant-time HMAC-SHA-256 verification. The header must be of the
  * form `sha256=<hex>`.
  */
-export declare function verifyQnspWebhookSignature(body: Uint8Array | string, signatureHeader: string, secret: string): void;
+export declare function verifyQnsiWebhookSignature(body: Uint8Array | string, signatureHeader: string, secret: string): void;
 /**
  * Verify the HMAC, enforce replay protection, parse the JSON body, and
- * return a typed `QnspWebhookEvent`.
+ * return a typed `QnsiWebhookEvent`.
  */
-export declare function parseQnspWebhook(input: {
+export declare function parseQnsiWebhook(input: {
     readonly body: Uint8Array | string;
     readonly signatureHeader: string;
     readonly timestampHeader?: string;
     readonly secret: string;
     readonly maxSkewMs?: number;
     readonly now?: Date;
-}): QnspWebhookEvent;
+}): QnsiWebhookEvent;
 //# sourceMappingURL=webhooks.d.ts.map

package/dist/webhooks.js

@@ -5,46 +5,46 @@
  * body. Always verify the **raw bytes** before parsing JSON.
  */
 import { createHmac, timingSafeEqual } from "node:crypto";
-import { QnspWebhookError } from "./errors.js";
+import { QnsiWebhookError } from "./errors.js";
 /** Default replay-protection window — 5 minutes. */
 export const MAX_WEBHOOK_SKEW_MS = 5 * 60 * 1000;
 /**
  * Constant-time HMAC-SHA-256 verification. The header must be of the
  * form `sha256=<hex>`.
  */
-export function verifyQnspWebhookSignature(body, signatureHeader, secret) {
+export function verifyQnsiWebhookSignature(body, signatureHeader, secret) {
     if (!signatureHeader.startsWith("sha256=")) {
-        throw new QnspWebhookError("signature header must start with 'sha256='");
+        throw new QnsiWebhookError("signature header must start with 'sha256='");
     }
     const expectedHex = signatureHeader.slice("sha256=".length);
     const expected = Buffer.from(expectedHex, "hex");
     if (expected.length === 0) {
-        throw new QnspWebhookError("signature is not valid hex");
+        throw new QnsiWebhookError("signature is not valid hex");
     }
     const bodyBytes = typeof body === "string" ? Buffer.from(body, "utf8") : Buffer.from(body);
     const actual = createHmac("sha256", secret).update(bodyBytes).digest();
     if (actual.length !== expected.length || !timingSafeEqual(actual, expected)) {
-        throw new QnspWebhookError("signature mismatch");
+        throw new QnsiWebhookError("signature mismatch");
     }
 }
 /**
  * Verify the HMAC, enforce replay protection, parse the JSON body, and
- * return a typed `QnspWebhookEvent`.
+ * return a typed `QnsiWebhookEvent`.
  */
-export function parseQnspWebhook(input) {
-    verifyQnspWebhookSignature(input.body, input.signatureHeader, input.secret);
+export function parseQnsiWebhook(input) {
+    verifyQnsiWebhookSignature(input.body, input.signatureHeader, input.secret);
     const skewMs = input.maxSkewMs ?? MAX_WEBHOOK_SKEW_MS;
     if (input.timestampHeader !== undefined && input.timestampHeader.length > 0) {
         const ts = Date.parse(input.timestampHeader);
         if (Number.isNaN(ts)) {
-            throw new QnspWebhookError("timestamp header is not RFC3339");
+            throw new QnsiWebhookError("timestamp header is not RFC3339");
         }
         const reference = input.now ? input.now.getTime() : Date.now();
         const delta = reference - ts;
         if (delta > skewMs)
-            throw new QnspWebhookError("timestamp is too old");
+            throw new QnsiWebhookError("timestamp is too old");
         if (-delta > skewMs)
-            throw new QnspWebhookError("timestamp is in the future");
+            throw new QnsiWebhookError("timestamp is in the future");
     }
     const text = typeof input.body === "string" ? input.body : Buffer.from(input.body).toString("utf8");
     let raw;
@@ -52,19 +52,19 @@ export function parseQnspWebhook(input) {
         raw = JSON.parse(text);
     }
     catch {
-        throw new QnspWebhookError("body is not valid JSON");
+        throw new QnsiWebhookError("body is not valid JSON");
     }
     if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
-        throw new QnspWebhookError("body is not a JSON object");
+        throw new QnsiWebhookError("body is not a JSON object");
     }
     const obj = raw;
     const eventType = obj["event_type"];
     const eventId = obj["event_id"];
     if (typeof eventType !== "string") {
-        throw new QnspWebhookError("missing event_type");
+        throw new QnsiWebhookError("missing event_type");
     }
     if (typeof eventId !== "string") {
-        throw new QnspWebhookError("missing event_id");
+        throw new QnsiWebhookError("missing event_id");
     }
     const occurredAtRaw = obj["occurred_at"];
     const occurredAt = typeof occurredAtRaw === "string" ? occurredAtRaw : "";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@heossi/qnsi",
-  "version": "0.3.3",
+  "version": "0.4.0",
   "publishConfig": {
     "access": "public"
   },
@@ -96,12 +96,12 @@
   ],
   "repository": {
     "type": "git",
-    "url": "https://github.com/heossi-hq/qnsp-public",
-    "directory": "packages/qnsp"
+    "url": "https://github.com/heossi-hq/qnsi-public",
+    "directory": "packages/qnsi"
   },
-  "homepage": "https://cloud.qnsp.cuilabs.io",
+  "homepage": "https://cloud.qnsi.heossi.com",
   "bugs": {
-    "url": "https://github.com/heossi-hq/qnsp-public/issues"
+    "url": "https://github.com/heossi-hq/qnsi-public/issues"
   },
   "files": [
     "dist/**/*",