@protontech/drive-sdk 0.1.0 → 0.1.1

package/src/cache/interface.ts

@@ -1,33 +1,33 @@
 export interface ProtonDriveCacheConstructor<T> {
     /**
      * Initialize the cache.
-     * 
+     *
      * The local database should follow document-based structure. The SDK does
      * serialisation and data is not intended to be read by 3rd party. The SDK,
      * however, provides also clear fields in form of tags that is used for
      * search. Local database should have index or other structure for easier
      * look-up.
-     * 
+     *
      * See {@link setEntity} for more details how tags are used.
      */
-     new (): ProtonDriveCache<T>,
+    new (): ProtonDriveCache<T>;
 }
 
 export interface ProtonDriveCache<T> {
     /**
      * Re-creates the whole persistent cache.
-     * 
+     *
      * The SDK can call this when there is some inconsistency and it is better
      * to start from scratch rather than fix it.
      */
-    clear(): Promise<void>,
+    clear(): Promise<void>;
 
     /**
      * Adds or updates entity in the local database.
-     * 
+     *
      * The `tags` is a list of strings that should be stored properly for fast
      * look-up.
-     * 
+     *
      * @example Usage by the SDK
      * ```ts
      * await cache.setEntity("node-abc42", "{ node abc42 serialised data }", ["parentUid:abc123", "sharedWithMe"] });
@@ -35,7 +35,7 @@ export interface ProtonDriveCache<T> {
      * await cache.getEntity("node-abc42"); // returns "{ node abc42 serialised data }"
      * await Array.fromAsync(cache.iterateEntities(["node-abc42"])); // returns ["{ node abc42 serialised data }"]
      * ```
-     * 
+     *
      * @example Stored data
      * ```json
      * {
@@ -54,51 +54,51 @@ export interface ProtonDriveCache<T> {
      *     }
      * }
      * ```
-     * 
+     *
      * @param key - Key is internal ID controlled by the SDK. It combines type and ID of the entity.
      * @param value - Serialised JSON object controlled by the SDK. It is not intended for use outside of the SDK.
      * @param tags - Clear metadata about the entity used for filtering. It is intended to store efficiently for fast look-up.
      * @throws Exception if `key` from `tags` is not one of the tag keys provided from `usedTagKeysBySDK` in constructor.
      */
-    setEntity(key: string, value: T, tags?: string[] ): Promise<void>,
-    
+    setEntity(key: string, value: T, tags?: string[]): Promise<void>;
+
     /**
      * Returns the data of the entity stored locally.
-     * 
+     *
      * @throws Exception if entity is not present.
      */
-    getEntity(key: string): Promise<T>,
+    getEntity(key: string): Promise<T>;
 
     /**
      * Generator providing the data of the entities stored locally for given
      * list of keys.
-     * 
+     *
      * No exception is thrown when data is missing.
      */
-    iterateEntities(keys: string[]): AsyncGenerator<EntityResult<T>>,
+    iterateEntities(keys: string[]): AsyncGenerator<EntityResult<T>>;
 
     /**
      * Generator providing the data of the entities stored locally for given
      * filter option.
-     * 
+     *
      * No exception is thrown when data is missing.
-     * 
+     *
      * @example Usage by the SDK
      * ```ts
      * await cache.setEntity("node-abc42", "{ node abc42 serialised data }", { "parentUid": "abc123", "shared": "withMe" });
      * await Array.fromAsync(cache.iterateEntitiesByTag("parentUid", "abc123")); // returns ["node-abc42"]
      * ```
-     * 
+     *
      * @param tag - The tag, for example `parentUid:abc123`
      */
-    iterateEntitiesByTag(tag: string): AsyncGenerator<EntityResult<T>>,
+    iterateEntitiesByTag(tag: string): AsyncGenerator<EntityResult<T>>;
 
     /**
      * Removes completely the entity stored locally from the database.
-     * 
+     *
      * It is no-op if entity is not present.
      */
-    removeEntities(keys: string[]): Promise<void>,
+    removeEntities(keys: string[]): Promise<void>;
 }
 
-export type EntityResult<T> = {key: string, ok: true, value: T} | {key: string, ok: false, error: string};
+export type EntityResult<T> = { key: string; ok: true; value: T } | { key: string; ok: false; error: string };

package/src/cache/memoryCache.test.ts

@@ -1,5 +1,5 @@
-import { EntityResult } from "./interface";
-import { MemoryCache } from "./memoryCache";
+import { EntityResult } from './interface';
+import { MemoryCache } from './memoryCache';
 
 describe('MemoryCache', () => {
     let cache: MemoryCache<string>;
@@ -81,9 +81,7 @@ describe('MemoryCache', () => {
             results.push(result);
         }
 
-        expect(results).toEqual([
-            { key: 'key1', ok: true, value: 'value1' },
-        ]);
+        expect(results).toEqual([{ key: 'key1', ok: true, value: 'value1' }]);
     });
 
     it('should iterate over entities by empty tag', async () => {
@@ -97,9 +95,11 @@ describe('MemoryCache', () => {
 
     it('should iterate over entities with concurrent changes to the same set', async () => {
         const iterator = cache.iterateEntities(['key1', 'key2', 'key3']);
-        
+
         const results: string[] = [];
-        const { value: { key: key1 } } = await iterator.next();
+        const {
+            value: { key: key1 },
+        } = await iterator.next();
         results.push(key1);
         await cache.removeEntities([key1]);
 

package/src/cache/memoryCache.ts

@@ -1,11 +1,11 @@
 import type { ProtonDriveCache, EntityResult } from './interface';
 
-type KeyValueCache<T> = { [ key: string ]: T };
-type TagsCache = { [ tag: string ]: string[] };
+type KeyValueCache<T> = { [key: string]: T };
+type TagsCache = { [tag: string]: string[] };
 
 /**
  * In-memory cache implementation for Proton Drive SDK.
- * 
+ *
  * This cache is not persistent and is intended for mostly for testing or
  * development only. It is not recommended to use this cache in production
  * environments.
@@ -82,4 +82,4 @@ export class MemoryCache<T> implements ProtonDriveCache<T> {
             });
         }
     }
-};
+}

package/src/cache/nullCache.ts

@@ -35,4 +35,4 @@ export class NullCache<T> implements ProtonDriveCache<T> {
     async removeEntities(keys: string[]) {
         // No-op.
     }
-};
+}

package/src/config.ts

@@ -6,14 +6,14 @@ import { ProtonDriveConfig } from './interface';
  * The object should be almost identical to the original config, but making
  * some fields required (setting reasonable defaults for the missing fields),
  * or changed for easier usage inside of the SDK.
- * 
+ *
  * For more property details, see the original config declaration.
  */
 type ParsedProtonDriveConfig = {
-    baseUrl: string,
-    language: string,
-    clientUid?: string,
-}
+    baseUrl: string;
+    language: string;
+    clientUid?: string;
+};
 
 export function getConfig(config?: ProtonDriveConfig): ParsedProtonDriveConfig {
     return {

package/src/crypto/driveCrypto.test.ts

@@ -1,44 +1,44 @@
-import { uint8ArrayToUtf8, arrayToHexString } from "./driveCrypto";
+import { uint8ArrayToUtf8, arrayToHexString } from './driveCrypto';
 
-describe("uint8ArrayToUtf8", () => {
-    it("should convert a Uint8Array to a UTF-8 string", () => {
+describe('uint8ArrayToUtf8', () => {
+    it('should convert a Uint8Array to a UTF-8 string', () => {
         const input = new Uint8Array([72, 101, 108, 108, 111]);
-        const expectedOutput = "Hello";
+        const expectedOutput = 'Hello';
         const result = uint8ArrayToUtf8(input);
         expect(result).toBe(expectedOutput);
     });
 
-    it("should handle an empty Uint8Array", () => {
+    it('should handle an empty Uint8Array', () => {
         const input = new Uint8Array([]);
-        const expectedOutput = "";
+        const expectedOutput = '';
         const result = uint8ArrayToUtf8(input);
         expect(result).toBe(expectedOutput);
     });
 
-    it("should throw if input is invalid", () => {
+    it('should throw if input is invalid', () => {
         const input = new Uint8Array([887987979887897989]);
-        expect(() => uint8ArrayToUtf8(input)).toThrow("The encoded data was not valid for encoding utf-8");
+        expect(() => uint8ArrayToUtf8(input)).toThrow('The encoded data was not valid for encoding utf-8');
     });
 });
 
-describe("arrayToHexString", () => {
-    it("should convert a Uint8Array to a hex string", () => {
+describe('arrayToHexString', () => {
+    it('should convert a Uint8Array to a hex string', () => {
         const input = new Uint8Array([0, 255, 16, 32]);
-        const expectedOutput = "00ff1020";
+        const expectedOutput = '00ff1020';
         const result = arrayToHexString(input);
         expect(result).toBe(expectedOutput);
     });
 
-    it("should handle an empty Uint8Array", () => {
+    it('should handle an empty Uint8Array', () => {
         const input = new Uint8Array([]);
-        const expectedOutput = "";
+        const expectedOutput = '';
         const result = arrayToHexString(input);
         expect(result).toBe(expectedOutput);
     });
 
-    it("should handle a Uint8Array with one element", () => {
+    it('should handle a Uint8Array with one element', () => {
         const input = new Uint8Array([1]);
-        const expectedOutput = "01";
+        const expectedOutput = '01';
         const result = arrayToHexString(input);
         expect(result).toBe(expectedOutput);
     });