feat: implement JWK export for KeyObject (createPrivateKey/createPublicKey)

Wire up PublicKeyObject.export({ format: 'jwk' }) and
PrivateKeyObject.export({ format: 'jwk' }) to the existing native
exportJwk() method instead of throwing 'not implemented'.

The native C++ implementation was already complete — this change
bridges the TypeScript layer to call it.

Author: boorad

packages/react-native-quick-crypto/src/hkdf.ts

@@ -17,7 +17,8 @@ export interface HkdfAlgorithm {
 
 export interface CryptoKeyInternal {
   keyObject: {
-    export: () => Buffer;
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    export: (...args: any[]) => any;
   };
 }
 

packages/react-native-quick-crypto/src/keys/classes.ts

@@ -3,6 +3,7 @@ import { NitroModules } from 'react-native-nitro-modules';
 import type {
   AsymmetricKeyType,
   EncodingOptions,
+  JWK,
   KeyDetail,
   KeyObjectHandle,
   KeyUsage,
@@ -81,10 +82,10 @@ export class KeyObject {
 
   export(options: { format: 'pem' } & EncodingOptions): string | Buffer;
   export(options?: { format: 'der' } & EncodingOptions): Buffer;
-  export(options?: { format: 'jwk' } & EncodingOptions): never;
-  export(options?: EncodingOptions): string | Buffer;
+  export(options?: { format: 'jwk' } & EncodingOptions): JWK;
+  export(options?: EncodingOptions): string | Buffer | JWK;
   // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  export(_options?: EncodingOptions): string | Buffer {
+  export(_options?: EncodingOptions): string | Buffer | JWK {
     // This is a placeholder and should be overridden by subclasses.
     throw new Error('export() must be implemented by subclasses');
   }
@@ -284,10 +285,10 @@ export class PublicKeyObject extends AsymmetricKeyObject {
 
   export(options: { format: 'pem' } & EncodingOptions): string;
   export(options: { format: 'der' } & EncodingOptions): Buffer;
-  export(options: { format: 'jwk' } & EncodingOptions): never;
-  export(options: EncodingOptions): string | Buffer {
+  export(options: { format: 'jwk' } & EncodingOptions): JWK;
+  export(options: EncodingOptions): string | Buffer | JWK {
     if (options?.format === 'jwk') {
-      throw new Error('PublicKey export for jwk is not implemented');
+      return this.handle.exportJwk({}, false);
     }
     const { format, type } = parsePublicKeyEncoding(
       options,
@@ -309,13 +310,13 @@ export class PrivateKeyObject extends AsymmetricKeyObject {
 
   export(options: { format: 'pem' } & EncodingOptions): string;
   export(options: { format: 'der' } & EncodingOptions): Buffer;
-  export(options: { format: 'jwk' } & EncodingOptions): never;
-  export(options: EncodingOptions): string | Buffer {
+  export(options: { format: 'jwk' } & EncodingOptions): JWK;
+  export(options: EncodingOptions): string | Buffer | JWK {
     if (options?.format === 'jwk') {
       if (options.passphrase !== undefined) {
         throw new Error('jwk does not support encryption');
       }
-      throw new Error('PrivateKey export for jwk is not implemented');
+      return this.handle.exportJwk({}, false);
     }
     const { format, type, cipher, passphrase } = parsePrivateKeyEncoding(
       options,

packages/react-native-quick-crypto/src/keys/index.ts

@@ -27,17 +27,19 @@ import {
   parsePrivateKeyEncoding,
   parsePublicKeyEncoding,
 } from './utils';
-import type { BinaryLike } from '../utils';
+import { NitroModules } from 'react-native-nitro-modules';
+import type { BinaryLike, JWK, KeyObjectHandle } from '../utils';
 import {
   binaryLikeToArrayBuffer as toAB,
   isStringOrBuffer,
   KFormatType,
   KeyEncoding,
+  KeyType,
 } from '../utils';
 import { randomBytes } from '../random';
 
 interface KeyInputObject {
-  key: BinaryLike | KeyObject | CryptoKey;
+  key: BinaryLike | KeyObject | CryptoKey | JWK;
   format?: 'pem' | 'der' | 'jwk';
   type?: 'pkcs1' | 'pkcs8' | 'spki' | 'sec1';
   passphrase?: BinaryLike;
@@ -123,6 +125,29 @@ function prepareAsymmetricKey(
 }
 
 function createPublicKey(key: KeyInput): PublicKeyObject {
+  if (typeof key === 'object' && 'key' in key && key.format === 'jwk') {
+    const handle =
+      NitroModules.createHybridObject<KeyObjectHandle>('KeyObjectHandle');
+    const keyType = handle.initJwk(key.key as JWK);
+    if (keyType === undefined) {
+      throw new Error('Failed to import JWK');
+    }
+    if (keyType === KeyType.PRIVATE) {
+      // Extract public from private
+      const exported = handle.exportKey(KFormatType.DER, KeyEncoding.SPKI);
+      const pubHandle =
+        NitroModules.createHybridObject<KeyObjectHandle>('KeyObjectHandle');
+      pubHandle.init(
+        KeyType.PUBLIC,
+        exported,
+        KFormatType.DER,
+        KeyEncoding.SPKI,
+      );
+      return new PublicKeyObject(pubHandle);
+    }
+    return new PublicKeyObject(handle);
+  }
+
   const { data, format, type } = prepareAsymmetricKey(key, true);
 
   // Map format string to KFormatType enum
@@ -144,6 +169,16 @@ function createPublicKey(key: KeyInput): PublicKeyObject {
 }
 
 function createPrivateKey(key: KeyInput): PrivateKeyObject {
+  if (typeof key === 'object' && 'key' in key && key.format === 'jwk') {
+    const handle =
+      NitroModules.createHybridObject<KeyObjectHandle>('KeyObjectHandle');
+    const keyType = handle.initJwk(key.key as JWK);
+    if (keyType === undefined || keyType !== KeyType.PRIVATE) {
+      throw new Error('Failed to import private key from JWK');
+    }
+    return new PrivateKeyObject(handle);
+  }
+
   const { data, format, type } = prepareAsymmetricKey(key, false);
 
   // Map format string to KFormatType enum