@qnsp/storage-sdk 0.3.0 → 0.3.1

package/src/index.test.ts

@@ -1,3 +1,4 @@
+import { clearActivationCache } from "@qnsp/sdk-activation";
 import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
 import { StorageClient, StorageEventsClient } from "./index.js";
 
@@ -10,6 +11,24 @@ const mockUploadId2 = "22222222-2222-4222-a222-222222222222";
 const mockUploadIdErr = "33333333-3333-4333-a333-333333333333";
 const mockDocumentId = "44444444-4444-4444-a444-444444444444";
 
+const MOCK_ACTIVATION_RESPONSE = {
+	activated: true,
+	tenantId: "a1b2c3d4-e5f6-4789-8abc-def012345678",
+	tier: "dev-pro",
+	activationToken: "tok_test",
+	expiresInSeconds: 3600,
+	activatedAt: new Date().toISOString(),
+	limits: {
+		storageGB: 50,
+		apiCalls: 100_000,
+		enclavesEnabled: false,
+		aiTrainingEnabled: false,
+		aiInferenceEnabled: true,
+		sseEnabled: true,
+		vaultEnabled: true,
+	},
+};
+
 function jsonResponse(payload: unknown, init?: ResponseInit): Response {
 	return new Response(JSON.stringify(payload), {
 		status: 200,
@@ -49,6 +68,7 @@ async function collectStream(stream: ReadableStream<Uint8Array>): Promise<Uint8A
 
 describe("StorageClient", () => {
 	beforeEach(() => {
+		clearActivationCache();
 		vi.stubGlobal("fetch", vi.fn());
 	});
 
@@ -82,9 +102,9 @@ describe("StorageClient", () => {
 			},
 		};
 
-		(globalThis.fetch as unknown as ReturnType<typeof vi.fn>).mockResolvedValue(
-			jsonResponse(expectedResponse),
-		);
+		(globalThis.fetch as unknown as ReturnType<typeof vi.fn>)
+			.mockResolvedValueOnce(jsonResponse(MOCK_ACTIVATION_RESPONSE))
+			.mockResolvedValueOnce(jsonResponse(expectedResponse));
 
 		const result = await client.initiateUpload({
 			name: "contract.pdf",
@@ -94,8 +114,8 @@ describe("StorageClient", () => {
 		});
 
 		expect(result).toEqual(expectedResponse);
-		expect(globalThis.fetch).toHaveBeenCalledTimes(1);
-		const call = (globalThis.fetch as unknown as ReturnType<typeof vi.fn>).mock.calls.at(0);
+		expect(globalThis.fetch).toHaveBeenCalledTimes(2);
+		const call = (globalThis.fetch as unknown as ReturnType<typeof vi.fn>).mock.calls.at(1);
 		expect(call).toBeDefined();
 		if (!call) throw new Error("fetch not invoked");
 		const [url, init] = call;
@@ -137,16 +157,16 @@ describe("StorageClient", () => {
 			resumeToken: null,
 		};
 
-		(globalThis.fetch as unknown as ReturnType<typeof vi.fn>).mockResolvedValue(
-			jsonResponse(expectedPayload),
-		);
+		(globalThis.fetch as unknown as ReturnType<typeof vi.fn>)
+			.mockResolvedValueOnce(jsonResponse(MOCK_ACTIVATION_RESPONSE))
+			.mockResolvedValueOnce(jsonResponse(expectedPayload));
 
 		const source = Buffer.from([0xde, 0xad, 0xbe]);
 
 		const result = await client.uploadPart(mockUploadId, 1, source);
 		expect(result).toEqual(expectedPayload);
-		expect(globalThis.fetch).toHaveBeenCalledTimes(1);
-		const uploadCall = (globalThis.fetch as unknown as ReturnType<typeof vi.fn>).mock.calls.at(0);
+		expect(globalThis.fetch).toHaveBeenCalledTimes(2);
+		const uploadCall = (globalThis.fetch as unknown as ReturnType<typeof vi.fn>).mock.calls.at(1);
 		expect(uploadCall).toBeDefined();
 		if (!uploadCall) throw new Error("fetch not invoked");
 		const [, init] = uploadCall;
@@ -184,7 +204,9 @@ describe("StorageClient", () => {
 			},
 		});
 
-		(globalThis.fetch as unknown as ReturnType<typeof vi.fn>).mockResolvedValue(response);
+		(globalThis.fetch as unknown as ReturnType<typeof vi.fn>)
+			.mockResolvedValueOnce(jsonResponse(MOCK_ACTIVATION_RESPONSE))
+			.mockResolvedValueOnce(response);
 
 		const result = await client.downloadStream(mockDocumentId, 2, {
 			range: "bytes=0-2",
@@ -236,9 +258,9 @@ describe("StorageClient", () => {
 			lastPartNumber: 1,
 		};
 
-		(globalThis.fetch as unknown as ReturnType<typeof vi.fn>).mockResolvedValue(
-			jsonResponse(statusResponse),
-		);
+		(globalThis.fetch as unknown as ReturnType<typeof vi.fn>)
+			.mockResolvedValueOnce(jsonResponse(MOCK_ACTIVATION_RESPONSE))
+			.mockResolvedValueOnce(jsonResponse(statusResponse));
 
 		await client.getUploadStatus(mockUploadId2);
 
@@ -261,9 +283,9 @@ describe("StorageClient", () => {
 			telemetry,
 		});
 
-		(globalThis.fetch as unknown as ReturnType<typeof vi.fn>).mockResolvedValue(
-			new Response("boom", { status: 500, statusText: "error" }),
-		);
+		(globalThis.fetch as unknown as ReturnType<typeof vi.fn>)
+			.mockResolvedValueOnce(jsonResponse(MOCK_ACTIVATION_RESPONSE))
+			.mockResolvedValueOnce(new Response("boom", { status: 500, statusText: "error" }));
 
 		await expect(client.completeUpload(mockUploadIdErr)).rejects.toThrow(/Storage API error/);
 
@@ -299,9 +321,9 @@ describe("StorageClient", () => {
 			resumeToken: null,
 		};
 
-		(globalThis.fetch as unknown as ReturnType<typeof vi.fn>).mockResolvedValue(
-			jsonResponse(expectedPayload),
-		);
+		(globalThis.fetch as unknown as ReturnType<typeof vi.fn>)
+			.mockResolvedValueOnce(jsonResponse(MOCK_ACTIVATION_RESPONSE))
+			.mockResolvedValueOnce(jsonResponse(expectedPayload));
 
 		await client.uploadPart(mockUploadId, 1, Buffer.from([1, 2, 3]));
 
@@ -322,6 +344,8 @@ describe("StorageClient", () => {
 		});
 
 		(globalThis.fetch as unknown as ReturnType<typeof vi.fn>)
+			// activation
+			.mockResolvedValueOnce(jsonResponse(MOCK_ACTIVATION_RESPONSE))
 			// PATCH response
 			.mockResolvedValueOnce(
 				jsonResponse({
@@ -361,7 +385,7 @@ describe("StorageClient", () => {
 		});
 		expect(updated.documentId).toBe(mockDocumentId);
 		const patchCall = (globalThis.fetch as unknown as ReturnType<typeof vi.fn>).mock
-			.calls[0] as unknown as [string, RequestInit];
+			.calls[1] as unknown as [string, RequestInit];
 		expect(patchCall[0]).toBe(
 			`https://storage.qnsp.example/storage/v1/documents/${mockDocumentId}/policies`,
 		);
@@ -374,7 +398,7 @@ describe("StorageClient", () => {
 		const policies = await client.getDocumentPolicies(mockDocumentId);
 		expect(policies.tenantId).toBe(mockTenantId);
 		const getCall = (globalThis.fetch as unknown as ReturnType<typeof vi.fn>).mock
-			.calls[1] as unknown as [string, RequestInit];
+			.calls[2] as unknown as [string, RequestInit];
 		expect(getCall[0]).toBe(
 			`https://storage.qnsp.example/storage/v1/documents/${mockDocumentId}/policies`,
 		);
@@ -393,6 +417,8 @@ describe("StorageClient", () => {
 		});
 
 		(globalThis.fetch as unknown as ReturnType<typeof vi.fn>)
+			// activation
+			.mockResolvedValueOnce(jsonResponse(MOCK_ACTIVATION_RESPONSE))
 			// apply
 			.mockResolvedValueOnce(
 				jsonResponse({
@@ -407,7 +433,7 @@ describe("StorageClient", () => {
 		const applied = await client.applyLegalHold(mockDocumentId, { holdId: "hold-9" });
 		expect(applied.legalHolds).toContain("hold-9");
 		const postCall = (globalThis.fetch as unknown as ReturnType<typeof vi.fn>).mock
-			.calls[0] as unknown as [string, RequestInit];
+			.calls[1] as unknown as [string, RequestInit];
 		expect(postCall[0]).toBe(
 			`https://storage.qnsp.example/storage/v1/documents/${mockDocumentId}/legal-holds`,
 		);
@@ -418,7 +444,7 @@ describe("StorageClient", () => {
 
 		await client.releaseLegalHold(mockDocumentId, "hold-9");
 		const delCall = (globalThis.fetch as unknown as ReturnType<typeof vi.fn>).mock
-			.calls[1] as unknown as [string, RequestInit];
+			.calls[2] as unknown as [string, RequestInit];
 		expect(delCall[0]).toBe(
 			`https://storage.qnsp.example/storage/v1/documents/${mockDocumentId}/legal-holds/hold-9`,
 		);

package/src/index.ts

@@ -1,3 +1,5 @@
+import { activateSdk, type SdkActivationConfig } from "@qnsp/sdk-activation";
+
 import type {
 	StorageClientTelemetry,
 	StorageClientTelemetryConfig,
@@ -286,26 +288,48 @@ export class StorageClient {
 	private readonly config: InternalStorageClientConfig;
 	private readonly telemetry: StorageClientTelemetry | null;
 	private readonly targetService: string;
+	private activationPromise: Promise<void> | null = null;
+	private readonly activationConfig: SdkActivationConfig;
+
+	private async ensureActivated(): Promise<void> {
+		if (!this.activationPromise) {
+			this.activationPromise = activateSdk(this.activationConfig).then(() => undefined);
+		}
+		return this.activationPromise;
+	}
 
 	constructor(config: StorageClientConfig) {
 		if (!config.apiKey || config.apiKey.trim().length === 0) {
 			throw new Error(
 				"QNSP Storage SDK: apiKey is required. " +
 					"Get your free API key at https://cloud.qnsp.cuilabs.io/signup — " +
-					"no credit card required (FREE tier: 5 GB storage, 2,000 API calls/month). " +
+					"no credit card required (FREE tier: 10 GB storage, 50,000 API calls/month). " +
 					"Docs: https://docs.qnsp.cuilabs.io/sdk/storage-sdk",
 			);
 		}
 
 		const baseUrl = config.baseUrl.replace(/\/$/, "");
 
-		// Enforce HTTPS in production (allow HTTP only for localhost in development)
+		// Enforce HTTPS in production (allow HTTP for localhost in development and
+		// for internal service-mesh hostnames — e.g. *.internal — which are on a
+		// private VPC network and do not require TLS termination at the transport layer).
 		if (!baseUrl.startsWith("https://")) {
 			const isLocalhost =
 				baseUrl.startsWith("http://localhost") || baseUrl.startsWith("http://127.0.0.1");
+			let isInternalService = false;
+			try {
+				const parsed = new URL(baseUrl);
+				isInternalService =
+					parsed.protocol === "http:" &&
+					(parsed.hostname.endsWith(".internal") ||
+						parsed.hostname === "localhost" ||
+						parsed.hostname === "127.0.0.1");
+			} catch {
+				// ignore; invalid URL will be caught later by fetch
+			}
 			const isDevelopment =
 				process.env["NODE_ENV"] === "development" || process.env["NODE_ENV"] === "test";
-			if (!isLocalhost || !isDevelopment) {
+			if ((!isLocalhost || !isDevelopment) && !isInternalService) {
 				throw new Error(
 					"baseUrl must use HTTPS in production. HTTP is only allowed for localhost in development.",
 				);
@@ -332,6 +356,13 @@ export class StorageClient {
 		} catch {
 			this.targetService = "storage-service";
 		}
+
+		this.activationConfig = {
+			apiKey: config.apiKey,
+			sdkId: "storage-sdk",
+			sdkVersion: "0.3.0",
+			platformUrl: config.baseUrl,
+		};
 	}
 
 	private async request<T>(method: string, path: string, options?: RequestOptions): Promise<T> {
@@ -454,6 +485,7 @@ export class StorageClient {
 		readonly resumeToken: string | null;
 		readonly pqc: PqcMetadata;
 	}> {
+		await this.ensureActivated();
 		const result = await this.request<{
 			uploadId: string;
 			documentId: string;
@@ -496,6 +528,7 @@ export class StorageClient {
 		partId: number,
 		data: ReadableStream<Uint8Array> | Buffer | Uint8Array,
 	): Promise<UploadPartResult> {
+		await this.ensureActivated();
 		const url = `${this.config.baseUrl}/storage/v1/uploads/${uploadId}/parts/${partId}`;
 		const headers: Record<string, string> = {
 			"Content-Type": "application/octet-stream",
@@ -579,6 +612,7 @@ export class StorageClient {
 
 	async getUploadStatus(uploadId: string): Promise<UploadStatus> {
 		validateUUID(uploadId, "uploadId");
+		await this.ensureActivated();
 		// Use GET since we need the full status object
 		return this.request<UploadStatus>("GET", `/storage/v1/uploads/${uploadId}`, {
 			operation: "getUploadStatus",
@@ -588,6 +622,7 @@ export class StorageClient {
 
 	async completeUpload(uploadId: string): Promise<CompleteUploadResult> {
 		validateUUID(uploadId, "uploadId");
+		await this.ensureActivated();
 		return this.request("POST", `/storage/v1/uploads/${uploadId}/complete`, {
 			operation: "completeUpload",
 			telemetryRoute: "/storage/v1/uploads/:uploadId/complete",
@@ -603,6 +638,7 @@ export class StorageClient {
 			readonly signature?: string | null;
 		},
 	): Promise<DownloadDescriptor> {
+		await this.ensureActivated();
 		const params = new URLSearchParams({
 			tenantId: this.config.tenantId,
 		});
@@ -644,6 +680,7 @@ export class StorageClient {
 		readonly range?: { readonly start: number; readonly end: number };
 		readonly checksumSha3: string;
 	}> {
+		await this.ensureActivated();
 		const params = new URLSearchParams({
 			tenantId: this.config.tenantId,
 		});
@@ -768,6 +805,7 @@ export class StorageClient {
 	 */
 	async getDocumentPolicies(documentId: string): Promise<DocumentPolicies> {
 		validateUUID(documentId, "documentId");
+		await this.ensureActivated();
 		return this.request("GET", `/storage/v1/documents/${documentId}/policies`, {
 			operation: "getDocumentPolicies",
 			telemetryRoute: "/storage/v1/documents/:documentId/policies",
@@ -786,6 +824,7 @@ export class StorageClient {
 		input: UpdatePoliciesRequest,
 	): Promise<DocumentPolicies> {
 		validateUUID(documentId, "documentId");
+		await this.ensureActivated();
 		return this.request("PATCH", `/storage/v1/documents/${documentId}/policies`, {
 			body: input,
 			operation: "updateDocumentPolicies",
@@ -809,6 +848,7 @@ export class StorageClient {
 		readonly legalHolds: readonly string[];
 	}> {
 		validateUUID(documentId, "documentId");
+		await this.ensureActivated();
 		return this.request("POST", `/storage/v1/documents/${documentId}/legal-holds`, {
 			body: request,
 			operation: "applyLegalHold",
@@ -825,6 +865,7 @@ export class StorageClient {
 	 */
 	async releaseLegalHold(documentId: string, holdId: string): Promise<void> {
 		validateUUID(documentId, "documentId");
+		await this.ensureActivated();
 		return this.request("DELETE", `/storage/v1/documents/${documentId}/legal-holds/${holdId}`, {
 			operation: "releaseLegalHold",
 			telemetryRoute: "/storage/v1/documents/:documentId/legal-holds/:holdId",
@@ -851,6 +892,7 @@ export class StorageClient {
 		};
 	}> {
 		validateUUID(documentId, "documentId");
+		await this.ensureActivated();
 		return this.request("POST", `/storage/v1/documents/${documentId}/lifecycle/transitions`, {
 			body: request,
 			operation: "scheduleLifecycleTransition",