Class DriveCryptoCacheAdapter

cli/src/cache/driveCryptoCacheAdapter.ts:37–86

 * of the whole value.
 */
export class DriveCryptoCacheAdapter implements ProtonDriveCache<CachedCryptoMaterial> {
    constructor(private readonly cache: ProtonDriveCache<string>) {}

    async setEntity(key: string, value: CachedCryptoMaterial, tags?: string[]): Promise<void> {
        await this.cache.setEntity(key, await serializeCachedCryptoMaterial(value), tags);
    }

    async getEntity(key: string): Promise<CachedCryptoMaterial> {
        return deserializeCachedCryptoMaterial(await this.cache.getEntity(key));
    }

    async *iterateEntities(keys: string[]): AsyncGenerator<EntityResult<CachedCryptoMaterial>> {
        for await (const result of this.cache.iterateEntities(keys)) {
            yield await this.convertResult(result);
        }
    }

    async *iterateEntitiesByTag(tag: string): AsyncGenerator<EntityResult<CachedCryptoMaterial>> {
        for await (const result of this.cache.iterateEntitiesByTag(tag)) {
            yield await this.convertResult(result);
        }
    }

    private async convertResult(result: EntityResult<string>): Promise<EntityResult<CachedCryptoMaterial>> {
        if (!result.ok) {
            return result;
        }
        try {
            return {
                key: result.key,
                ok: true,
                value: await deserializeCachedCryptoMaterial(result.value),
            };
        } catch (error: unknown) {
            return {
                key: result.key,
                ok: false,
                error: error instanceof Error ? error.message : `${error}`,
            };
        }
    }

    async clear(): Promise<void> {
        return this.cache.clear();
    }

    async removeEntities(keys: string[]): Promise<void> {
        return this.cache.removeEntities(keys);
    }
}

async function serializeCachedCryptoMaterial(value: CachedCryptoMaterial): Promise<string> {
    const output: SerializedCachedCryptoMaterial = { v: VERSION };