99 lines
2.6 KiB
TypeScript
99 lines
2.6 KiB
TypeScript
import { uuid1 } from "./deps.ts";
|
|
|
|
/**
|
|
* Standard interface for the simplest key-value store
|
|
*/
|
|
export interface KeyValueStorage {
|
|
get(key: string): Promise<string | null>;
|
|
set(key: string, value: string | null): Promise<void>;
|
|
}
|
|
|
|
/**
|
|
* Basic memory implementation
|
|
*/
|
|
export class MemoryStorage implements KeyValueStorage {
|
|
private store: { [key: string]: string } = {};
|
|
|
|
async get(key: string): Promise<string | null> {
|
|
const result = this.store[key];
|
|
return (typeof result == "undefined") ? null : result;
|
|
}
|
|
|
|
async set(key: string, value: string | null): Promise<void> {
|
|
if (value === null) {
|
|
delete this.store[key];
|
|
} else {
|
|
this.store[key] = value;
|
|
}
|
|
}
|
|
}
|
|
|
|
type StorageDelegate = KeyValueStorage | (() => KeyValueStorage);
|
|
|
|
function fromDelegate(delegate: StorageDelegate): KeyValueStorage {
|
|
return (typeof delegate === "function") ? delegate() : delegate;
|
|
}
|
|
|
|
/**
|
|
* Wrap a storage, scoping the keys using a suffix
|
|
*/
|
|
export class ScopedStorage implements KeyValueStorage {
|
|
private readonly target: KeyValueStorage;
|
|
|
|
constructor(target: StorageDelegate, private readonly suffix: string) {
|
|
this.target = fromDelegate(target);
|
|
}
|
|
|
|
async get(key: string): Promise<string | null> {
|
|
return await this.target.get(`${key}#${this.suffix}`);
|
|
}
|
|
|
|
async set(key: string, value: string | null): Promise<void> {
|
|
return await this.target.set(`${key}#${this.suffix}`, value);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Use a target unscoped storage, scoping the keys in a virtual random namespace
|
|
*
|
|
* The namespace is persisted in a reference storage (used unscoped)
|
|
*/
|
|
export class RefScopedStorage implements KeyValueStorage {
|
|
private readonly reference: KeyValueStorage;
|
|
private readonly target: KeyValueStorage;
|
|
private inner?: KeyValueStorage;
|
|
|
|
constructor(reference: StorageDelegate, target: StorageDelegate) {
|
|
this.reference = fromDelegate(reference);
|
|
this.target = fromDelegate(target);
|
|
}
|
|
|
|
private async init(): Promise<KeyValueStorage> {
|
|
const refkey = "tk-storage-scope-ref";
|
|
const suffix = await this.reference.get(refkey);
|
|
if (suffix) {
|
|
return new ScopedStorage(this.target, suffix);
|
|
} else {
|
|
const suffix = uuid1.generate().toString();
|
|
await this.reference.set(refkey, suffix);
|
|
return new ScopedStorage(this.target, suffix);
|
|
}
|
|
}
|
|
|
|
async get(key: string): Promise<string | null> {
|
|
if (!this.inner) {
|
|
this.inner = await this.init();
|
|
}
|
|
|
|
return await this.inner.get(key);
|
|
}
|
|
|
|
async set(key: string, value: string | null): Promise<void> {
|
|
if (!this.inner) {
|
|
this.inner = await this.init();
|
|
}
|
|
|
|
return await this.inner.set(key, value);
|
|
}
|
|
}
|