@welshare/react 0.0.1-alpha.2 → 0.1.0

package/dist/node_modules/@welshare/react/src/lib/encryption.ts

@@ -0,0 +1,110 @@
+export const ALGORITHM = "AES-GCM";
+export type Algorithm = "AES-GCM";
+
+export const generateRandomAESKey = async (): Promise<CryptoKey> => {
+  // Generate a 256-bit AES-GCM key for file encryption
+  return window.crypto.subtle.generateKey(
+    {
+      name: ALGORITHM,
+      length: 256, // 256-bit key
+    },
+    true, // Key is extractable (needed for storage/transmission)
+    ["encrypt", "decrypt"] // Key usage
+  );
+};
+
+/// also Generates random IV (12 bytes for AES-GCM)
+/// @return {arraybuffer ciphertext, uint8array iv}
+export const encryptFile = async (
+  file: File,
+  key: CryptoKey
+): Promise<{ encryptedData: ArrayBuffer; iv: Uint8Array }> => {
+  // Read file as ArrayBuffer
+  const fileData = await file.arrayBuffer();
+  const iv = window.crypto.getRandomValues(new Uint8Array(12));
+
+  // Encrypt the file data
+  const encryptedData = await window.crypto.subtle.encrypt(
+    {
+      name: ALGORITHM,
+      iv: iv,
+    },
+    key,
+    fileData
+  );
+
+  return { encryptedData, iv };
+};
+
+export type EncryptionKey = {
+  algorithm: Algorithm;
+  key: string;
+  iv: string;
+};
+
+export const encodeEncryptionKey = async (
+  key: CryptoKey,
+  iv: Uint8Array
+): Promise<EncryptionKey> => {
+  // Export the key as raw bytes
+  const exportedKey = await window.crypto.subtle.exportKey("raw", key);
+  const keyHex = Array.from(new Uint8Array(exportedKey))
+    .map((b) => b.toString(16).padStart(2, "0"))
+    .join("");
+
+  const ivHex = Array.from(iv)
+    .map((b) => b.toString(16).padStart(2, "0"))
+    .join("");
+
+  return {
+    algorithm: ALGORITHM,
+    key: keyHex,
+    iv: ivHex,
+  };
+};
+
+export const decodeEncryptionKey = (
+  encryptionKey: EncryptionKey
+): { key: Uint8Array<ArrayBuffer>; iv: Uint8Array<ArrayBuffer> } => {
+  const keyBytes = new Uint8Array(
+    encryptionKey.key
+      .match(/.{1,2}/g)!
+      .map((byte: string) => parseInt(byte, 16))
+  );
+  const ivBytes = new Uint8Array(
+    encryptionKey.iv.match(/.{1,2}/g)!.map((byte: string) => parseInt(byte, 16))
+  );
+  return { key: keyBytes, iv: ivBytes };
+};
+
+// Helper function to decrypt a file using encoded encryption key
+export const decrypt = async (
+  encryptedData: ArrayBuffer,
+  encryptionKey: EncryptionKey
+): Promise<ArrayBuffer | null> => {
+  try {
+    const { key: keyBytes, iv } = decodeEncryptionKey(encryptionKey);
+
+    const key = await window.crypto.subtle.importKey(
+      "raw",
+      keyBytes,
+      { name: ALGORITHM },
+      false,
+      ["decrypt"]
+    );
+
+    const decryptedData = await window.crypto.subtle.decrypt(
+      {
+        name: ALGORITHM,
+        iv,
+      },
+      key,
+      encryptedData
+    );
+
+    return decryptedData;
+  } catch (error) {
+    console.error("Failed to decrypt file:", error);
+    return null;
+  }
+};

package/dist/node_modules/@welshare/react/src/lib/uploads.ts

@@ -0,0 +1,29 @@
+import {
+  encodeEncryptionKey,
+  encryptFile,
+  EncryptionKey,
+  generateRandomAESKey,
+} from "./encryption.js";
+
+export const encryptAndUploadFile = async (
+  file: File,
+  presignedUrl: string
+): Promise<EncryptionKey> => {
+  const encryptionKey = await generateRandomAESKey();
+  const { encryptedData, iv } = await encryptFile(file, encryptionKey);
+
+  // Upload encrypted file to S3
+  const uploadResponse = await fetch(presignedUrl, {
+    method: "PUT",
+    body: encryptedData,
+    headers: {
+      "Content-Type": file.type,
+    },
+  });
+
+  if (!uploadResponse.ok) {
+    throw new Error(`Failed to upload file ${uploadResponse.status}`);
+  }
+
+  return encodeEncryptionKey(encryptionKey, iv);
+};

package/dist/node_modules/@welshare/react/src/types.ts

@@ -1,3 +1,5 @@
+import { EncryptionKey } from "./lib/encryption.js";
+
 export interface DialogMessage {
   type: string;
   payload?: any;
@@ -18,8 +20,41 @@ export interface SubmissionPayload<T> {
   submission: T;
 }
 
+export type UploadCredentials = {
+  presignedUrl: string;
+  uploadKey: string;
+}
+
+export interface RequestUploadCredentialsPayload {
+  timestamp?: Date;
+  applicationId: string;
+  reference: string;
+  fileName: string;
+  fileType: string;
+}
+
+export interface BinaryFileSubmissionPayload extends RequestUploadCredentialsPayload {
+  encryptionKey: EncryptionKey;
+  /// in bytes
+  fileSize: number;
+  url: string;
+}
+
+export interface RunningFileUpload extends RequestUploadCredentialsPayload {
+  credentials?: UploadCredentials;
+  file: File;
+  reference: string;
+  uploadPromise: {
+    resolve: (result: { url: string; binaryFileUid: string }) => void;
+    reject: (error: Error) => void;
+  };
+}
+
 export interface DataSubmissionDialogMessage extends DialogMessage {
-  payload: SubmissionPayload<unknown>;
+  payload: 
+    | SubmissionPayload<unknown> 
+    | BinaryFileSubmissionPayload
+    | RequestUploadCredentialsPayload;
 }
 
 export interface WelshareConnectionOptions {
@@ -28,6 +63,7 @@ export interface WelshareConnectionOptions {
   apiBaseUrl?: string;
   environment?: WelshareEnvironment;
   callbacks: {
+    onFileUploaded?: (insertedUid: string, url: string) => void;
     onUploaded?: (payload: SubmissionPayload<unknown>) => void;
     onError?: (error: string) => void;
     onSessionReady?: (sessionPubKey: string) => void;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@welshare/react",
-  "version": "0.0.1-alpha.2",
+  "version": "0.1.0",
   "description": "React library for integrating with Welshare's sovereign data sharing platform",
   "keywords": [
     "react",