@storacha/encrypt-upload-client 1.1.56 → 1.1.58

package/dist/test/mocks/key-manager.d.ts

@@ -9,42 +9,70 @@
  * @param {Function} [options.onKeyDecrypt] - Optional callback for decrypt calls
  */
 export function createMockKeyManagerService(options: {
-    mockPublicKey: string;
-    mockProvider?: string | undefined;
-    mockAlgorithm?: string | undefined;
-    onEncryptionSetup?: Function | undefined;
-    onKeyDecrypt?: Function | undefined;
+  mockPublicKey: string
+  mockProvider?: string | undefined
+  mockAlgorithm?: string | undefined
+  onEncryptionSetup?: Function | undefined
+  onKeyDecrypt?: Function | undefined
 }): {
-    space: {
-        encryption: {
-            setup: Server.ServiceMethod<Server.API.Capability<"space/encryption/setup", `did:key:${string}` & `did:${string}` & Server.API.Phantom<{
-                protocol: "did:";
-            }>, Partial<Pick<{
-                location: string | undefined;
-                keyring: string | undefined;
-            }, "location" | "keyring">>>, {
-                publicKey: string;
-                provider: string;
-                algorithm: string;
-            }, Server.API.Failure & {
-                name: string;
-                message: string;
-            }>;
-            key: {
-                decrypt: Server.ServiceMethod<Server.API.Capability<"space/encryption/key/decrypt", `did:key:${string}` & `did:${string}` & Server.API.Phantom<{
-                    protocol: "did:";
-                }>, Pick<{
-                    key: Uint8Array<ArrayBufferLike>;
-                }, "key">>, {
-                    decryptedSymmetricKey: string;
-                }, Server.API.Failure & {
-                    name: string;
-                    message: string;
-                }>;
-            };
-        };
-    };
-};
+  space: {
+    encryption: {
+      setup: Server.ServiceMethod<
+        Server.API.Capability<
+          'space/encryption/setup',
+          `did:key:${string}` &
+            `did:${string}` &
+            Server.API.Phantom<{
+              protocol: 'did:'
+            }>,
+          Partial<
+            Pick<
+              {
+                location: string | undefined
+                keyring: string | undefined
+              },
+              'location' | 'keyring'
+            >
+          >
+        >,
+        {
+          publicKey: string
+          provider: string
+          algorithm: string
+        },
+        Server.API.Failure & {
+          name: string
+          message: string
+        }
+      >
+      key: {
+        decrypt: Server.ServiceMethod<
+          Server.API.Capability<
+            'space/encryption/key/decrypt',
+            `did:key:${string}` &
+              `did:${string}` &
+              Server.API.Phantom<{
+                protocol: 'did:'
+              }>,
+            Pick<
+              {
+                key: Uint8Array<ArrayBufferLike>
+              },
+              'key'
+            >
+          >,
+          {
+            decryptedSymmetricKey: string
+          },
+          Server.API.Failure & {
+            name: string
+            message: string
+          }
+        >
+      }
+    }
+  }
+}
 /**
  * Create a mock key manager service server
  *
@@ -53,6 +81,11 @@ export function createMockKeyManagerService(options: {
  * @param {number} port - The port to listen on
  * @param {boolean} [useHttps] - Whether to use HTTPS URLs (testing HTTPS scenarios)
  */
-export function createMockKeyManagerServer(service: object, keyManagerServiceDID: any, port: number, useHttps?: boolean): Promise<any>;
-import * as Server from '@ucanto/server';
-//# sourceMappingURL=key-manager.d.ts.map
+export function createMockKeyManagerServer(
+  service: object,
+  keyManagerServiceDID: any,
+  port: number,
+  useHttps?: boolean
+): Promise<any>
+import * as Server from '@ucanto/server'
+//# sourceMappingURL=key-manager.d.ts.map

package/dist/test/mocks/key-manager.js

@@ -1,8 +1,8 @@
-import { createServer } from 'node:http';
-import * as Server from '@ucanto/server';
-import { CAR } from '@ucanto/transport';
-import * as Space from '@storacha/capabilities/space';
-import { base64 } from 'multiformats/bases/base64';
+import { createServer } from 'node:http'
+import * as Server from '@ucanto/server'
+import { CAR } from '@ucanto/transport'
+import * as Space from '@storacha/capabilities/space'
+import { base64 } from 'multiformats/bases/base64'
 /**
  * Create mock KMS service with proper capability handlers
  *
@@ -14,62 +14,68 @@ import { base64 } from 'multiformats/bases/base64';
  * @param {Function} [options.onKeyDecrypt] - Optional callback for decrypt calls
  */
 export function createMockKeyManagerService(options) {
-    const { mockPublicKey, mockProvider = 'google-kms', mockAlgorithm = 'RSA-OAEP-2048-SHA256', onEncryptionSetup, onKeyDecrypt, } = options;
-    return {
-        space: {
-            encryption: {
-                setup: Server.provide(Space.EncryptionSetup, async (input) => {
-                    // Call optional callback for testing
-                    if (onEncryptionSetup) {
-                        onEncryptionSetup(input);
-                    }
-                    // Validate the space DID format
-                    if (!input.capability.with.startsWith('did:key:')) {
-                        return Server.error({
-                            name: 'InvalidSpace',
-                            message: 'Space DID must be a did:key',
-                        });
-                    }
-                    // Return mock RSA public key and metadata
-                    return Server.ok({
-                        publicKey: mockPublicKey,
-                        provider: mockProvider,
-                        algorithm: mockAlgorithm,
-                    });
-                }),
-                key: {
-                    decrypt: Server.provide(Space.EncryptionKeyDecrypt, async (input) => {
-                        // Call optional callback for testing
-                        if (onKeyDecrypt) {
-                            onKeyDecrypt(input);
-                        }
-                        // Validate the space DID
-                        if (!input.capability.with.startsWith('did:key:')) {
-                            return Server.error({
-                                name: 'InvalidSpace',
-                                message: 'Space DID must be a did:key',
-                            });
-                        }
-                        // Validate encrypted key is provided
-                        if (!input.capability.nb.key) {
-                            return Server.error({
-                                name: 'KeyNotFound',
-                                message: 'key is required',
-                            });
-                        }
-                        // For testing purposes, "decrypt" by converting bytes back to base64 string
-                        // In real implementation, this would call Google KMS
-                        const keyBytes = input.capability.nb.key;
-                        // No base64 decode here, just return the bytes as base64 string for mock
-                        const mockDecryptedKey = base64.encode(keyBytes);
-                        return Server.ok({
-                            decryptedSymmetricKey: mockDecryptedKey,
-                        });
-                    }),
-                },
-            },
+  const {
+    mockPublicKey,
+    mockProvider = 'google-kms',
+    mockAlgorithm = 'RSA-OAEP-2048-SHA256',
+    onEncryptionSetup,
+    onKeyDecrypt,
+  } = options
+  return {
+    space: {
+      encryption: {
+        setup: Server.provide(Space.EncryptionSetup, async (input) => {
+          // Call optional callback for testing
+          if (onEncryptionSetup) {
+            onEncryptionSetup(input)
+          }
+          // Validate the space DID format
+          if (!input.capability.with.startsWith('did:key:')) {
+            return Server.error({
+              name: 'InvalidSpace',
+              message: 'Space DID must be a did:key',
+            })
+          }
+          // Return mock RSA public key and metadata
+          return Server.ok({
+            publicKey: mockPublicKey,
+            provider: mockProvider,
+            algorithm: mockAlgorithm,
+          })
+        }),
+        key: {
+          decrypt: Server.provide(Space.EncryptionKeyDecrypt, async (input) => {
+            // Call optional callback for testing
+            if (onKeyDecrypt) {
+              onKeyDecrypt(input)
+            }
+            // Validate the space DID
+            if (!input.capability.with.startsWith('did:key:')) {
+              return Server.error({
+                name: 'InvalidSpace',
+                message: 'Space DID must be a did:key',
+              })
+            }
+            // Validate encrypted key is provided
+            if (!input.capability.nb.key) {
+              return Server.error({
+                name: 'KeyNotFound',
+                message: 'key is required',
+              })
+            }
+            // For testing purposes, "decrypt" by converting bytes back to base64 string
+            // In real implementation, this would call Google KMS
+            const keyBytes = input.capability.nb.key
+            // No base64 decode here, just return the bytes as base64 string for mock
+            const mockDecryptedKey = base64.encode(keyBytes)
+            return Server.ok({
+              decryptedSymmetricKey: mockDecryptedKey,
+            })
+          }),
         },
-    };
+      },
+    },
+  }
 }
 /**
  * Create a mock key manager service server
@@ -79,59 +85,69 @@ export function createMockKeyManagerService(options) {
  * @param {number} port - The port to listen on
  * @param {boolean} [useHttps] - Whether to use HTTPS URLs (testing HTTPS scenarios)
  */
-export function createMockKeyManagerServer(service, keyManagerServiceDID, port, useHttps = false) {
-    const ucantoServer = Server.create({
-        id: keyManagerServiceDID,
-        service,
-        codec: CAR.inbound,
-        validateAuthorization: () => ({ ok: {} }), // Skip auth validation for tests
-    });
-    const httpServer = createServer(async (req, res) => {
-        res.setHeader('Access-Control-Allow-Origin', '*');
-        res.setHeader('Access-Control-Allow-Methods', '*');
-        res.setHeader('Access-Control-Allow-Headers', '*');
-        if (req.method === 'OPTIONS')
-            return res.end();
-        if (req.method === 'POST') {
-            const bodyBuffer = Buffer.concat(await collect(req));
-            const reqHeaders = /** @type {Record<string, string>} */ (Object.fromEntries(Object.entries(req.headers)));
-            const { headers, body, status } = await ucantoServer.request({
-                body: new Uint8Array(bodyBuffer.buffer, bodyBuffer.byteOffset, bodyBuffer.byteLength),
-                headers: reqHeaders,
-            });
-            for (const [key, value] of Object.entries(headers)) {
-                res.setHeader(key, value);
-            }
-            res.writeHead(status ?? 200);
-            res.end(body);
-        }
-        else {
-            res.end();
-        }
-    });
-    return new Promise((resolve, reject) => {
-        httpServer.listen(port, (/** @type {Error | undefined} */ err) => {
-            if (err) {
-                reject(err);
-            }
-            else {
-                const protocol = useHttps ? 'https' : 'http';
-                resolve({
-                    server: httpServer,
-                    url: `${protocol}://localhost:${port}`,
-                    close: () => new Promise((resolve) => httpServer.close(resolve)),
-                });
-            }
-        });
-    });
+export function createMockKeyManagerServer(
+  service,
+  keyManagerServiceDID,
+  port,
+  useHttps = false
+) {
+  const ucantoServer = Server.create({
+    id: keyManagerServiceDID,
+    service,
+    codec: CAR.inbound,
+    validateAuthorization: () => ({ ok: {} }), // Skip auth validation for tests
+  })
+  const httpServer = createServer(async (req, res) => {
+    res.setHeader('Access-Control-Allow-Origin', '*')
+    res.setHeader('Access-Control-Allow-Methods', '*')
+    res.setHeader('Access-Control-Allow-Headers', '*')
+    if (req.method === 'OPTIONS') return res.end()
+    if (req.method === 'POST') {
+      const bodyBuffer = Buffer.concat(await collect(req))
+      const reqHeaders = /** @type {Record<string, string>} */ (
+        Object.fromEntries(Object.entries(req.headers))
+      )
+      const { headers, body, status } = await ucantoServer.request({
+        body: new Uint8Array(
+          bodyBuffer.buffer,
+          bodyBuffer.byteOffset,
+          bodyBuffer.byteLength
+        ),
+        headers: reqHeaders,
+      })
+      for (const [key, value] of Object.entries(headers)) {
+        res.setHeader(key, value)
+      }
+      res.writeHead(status ?? 200)
+      res.end(body)
+    } else {
+      res.end()
+    }
+  })
+  return new Promise((resolve, reject) => {
+    httpServer.listen(port, (/** @type {Error | undefined} */ err) => {
+      if (err) {
+        reject(err)
+      } else {
+        const protocol = useHttps ? 'https' : 'http'
+        resolve({
+          server: httpServer,
+          url: `${protocol}://localhost:${port}`,
+          close: () => new Promise((resolve) => httpServer.close(resolve)),
+        })
+      }
+    })
+  })
 }
 /** @param {import('node:stream').Readable} stream */
 const collect = (stream) => {
-    return /** @type {Promise<Buffer[]>} */ (new Promise((resolve, reject) => {
-        const chunks = /** @type {Buffer[]} */ ([]);
-        stream.on('data', (chunk) => chunks.push(Buffer.from(chunk)));
-        stream.on('error', (err) => reject(err));
-        stream.on('end', () => resolve(chunks));
-    }));
-};
-//# sourceMappingURL=key-manager.js.map
+  return /** @type {Promise<Buffer[]>} */ (
+    new Promise((resolve, reject) => {
+      const chunks = /** @type {Buffer[]} */ ([])
+      stream.on('data', (chunk) => chunks.push(Buffer.from(chunk)))
+      stream.on('error', (err) => reject(err))
+      stream.on('end', () => resolve(chunks))
+    })
+  )
+}
+//# sourceMappingURL=key-manager.js.map

package/dist/test/node-crypto-adapter.spec.d.ts

@@ -1,2 +1,2 @@
-export {};
-//# sourceMappingURL=node-crypto-adapter.spec.d.ts.map
+export {}
+//# sourceMappingURL=node-crypto-adapter.spec.d.ts.map