Class Cache<TType>

Cache class can be derived from any ICacheAdapter.

IMPORT_PATH: "@daiso-tech/core/cache/implementations/derivables"

Type Parameters

TType = unknown

Implements

IGroupableCache<TType>

Constructors

constructor

new Cache<TType>(settings): Cache<TType>

Type Parameters

TType = unknown

Parameters

settings: CacheSettings

Returns Cache<TType>

Example

import type { IGroupableCache } from "@daiso-tech/core/cache/contracts";
import { Cache } from "@daiso-tech/core/cache/implementations/derivables";
import { MemoryCacheAdapter } from "@daiso-tech/core/cache/implementations/adapters";

const cache: IGroupableCache = new Cache({
  adapter: new MemoryCacheAdapter({
    rootGroup: "@global"
  }),
});

Methods

add

add(key, value, ttl?): LazyPromise<boolean>
The add method adds a key with given value when key doesn't exists. Returns true when key doesn't exists otherwise false will be returned. You can provide a ttl value. If null is passed, the item will not expire.
Parameters
- key: string
- value: TType
- ttl: null | TimeSpan = ...
  Default
  null
Returns LazyPromise<boolean>
Implementation of IGroupableCache.add
- Defined in src/cache/implementations/derivables/cache/cache.ts:523

addListener

addListener<TEventClass>(eventName, listener): LazyPromise<void>

You can listen to different events of Cache class instance.

Refer to CacheEvents, to se all events dispatched by Cache class instance. Refer to IEventListenable for details on how the method works.

Type Parameters

TEventClass extends EventClass<CacheEvents>

Parameters

eventName: TEventClass
listener: Invokable<EventInstance<TEventClass>>

Returns LazyPromise<void>

Example

import type { IGroupableCache } from "@daiso-tech/core/cache/contracts";
import type { IGroupableEventBus } from "@daiso-tech/core/event-bus/contracts";
import { Cache } from "@daiso-tech/core/cache/implementations/derivables";
import { MemoryCacheAdapter } from "@daiso-tech/core/cache/implementations/adapters";
import type { Invokable} from "@daiso-tech/core/event-bus/contracts";
import { KeyAddedCacheEvent, type CacheEvents } from "@daiso-tech/core/cache/contracts";

const cache: IGroupableCache = new Cache({
  adapter: new MemoryCacheAdapter({
    rootGroup: "@global"
  }),
});

const listener: Invokable<CacheEvents> = event => {
  console.log(event);
};
await cache.addListener(KeyAddedCacheEvent, listener);
await cache.add("a", 1);

addListenerMany

addListenerMany<TEventClass>(eventNames, listener): LazyPromise<void>

You can listen to different events of Cache class instance.

Refer to CacheEvents, to se all events dispatched by Cache class instance. Refer to IEventListenable for details on how the method works.

Type Parameters

TEventClass extends EventClass<CacheEvents>

Parameters

eventNames: TEventClass[]
listener: Invokable<EventInstance<TEventClass>>

Returns LazyPromise<void>

Example

import type { IGroupableCache } from "@daiso-tech/core/cache/contracts";
import type { IGroupableEventBus } from "@daiso-tech/core/event-bus/contracts";
import { Cache } from "@daiso-tech/core/cache/implementations/derivables";
import { MemoryCacheAdapter } from "@daiso-tech/core/cache/implementations/adapters";
import type { Invokable} from "@daiso-tech/core/event-bus/contracts";
import type { Invokable} from "@daiso-tech/core/event-bus/contracts";
import { KeyAddedCacheEvent, type CacheEvents } from "@daiso-tech/core/cache/contracts";

const cache: IGroupableCache = new Cache({
  adapter: new MemoryCacheAdapter({
    rootGroup: "@global"
  }),
});

const listener: Invokable<CacheEvents> = event => {
  console.log(event);
};
await cache.addListenerMany([KeyAddedCacheEvent], listener);
await cache.add("a", 1);

addMany

addMany<TKeys>(values): LazyPromise<Record<TKeys, boolean>>
The addMany method adds new keys. Returns true for the keys that where added otherwise false will be returned.
Type Parameters
- TKeys extends string
Parameters
- values: Record<TKeys, WithTtlValue<TType>>
Returns LazyPromise<Record<TKeys, boolean>>
Implementation of IGroupableCache.addMany
- Defined in src/cache/implementations/derivables/cache/cache.ts:1098

asPromise

asPromise<TEventClass>(event): LazyPromise<EventInstance<TEventClass>>
The asPromise method returns LazyPromise objecet that resolves once the BaseEvent is dispatched.
Type Parameters
- TEventClass extends EventClass<CacheEvents>
Parameters
- event: TEventClass
Returns LazyPromise<EventInstance<TEventClass>>
Throws
UnableToAddListenerEventBusError
Implementation of IGroupableCache.asPromise
- Defined in src/cache/implementations/derivables/cache/cache.ts:349

clear

clear(): LazyPromise<void>
The clear method removes all the keys in the cache.

Returns LazyPromise<void>
Implementation of IGroupableCache.clear
- Defined in src/cache/implementations/derivables/cache/cache.ts:754

decrement

decrement(key, value?): LazyPromise<boolean>
The decrement method will decrement the given key if found otherwise nonthing will occur. Returns true if key exists otherwise false will be returned. An error will thrown if the key is not a number.
Parameters
- key: string
- value: Extract<TType, number> = ...
Returns LazyPromise<boolean>
Throws
TypeCacheError
Implementation of IGroupableCache.decrement
- Defined in src/cache/implementations/derivables/cache/cache.ts:1342

exists

exists(key): LazyPromise<boolean>
The exists method returns true when key is found otherwise false will be returned.
Parameters
- key: string
Returns LazyPromise<boolean>
Implementation of IGroupableCache.exists
- Defined in src/cache/implementations/derivables/cache/cache.ts:780

existsMany

existsMany<TKeys>(keys): LazyPromise<Record<TKeys, boolean>>
The existsMany method returns true for the keys that are found otherwise false will be returned.
Type Parameters
- TKeys extends string
Parameters
- keys: TKeys[]
Returns LazyPromise<Record<TKeys, boolean>>
Implementation of IGroupableCache.existsMany
- Defined in src/cache/implementations/derivables/cache/cache.ts:787

get

get(key): LazyPromise<null | TType>
The get method returns the value when key is found otherwise null will be returned.
Parameters
- key: string
Returns LazyPromise<null | TType>
Implementation of IGroupableCache.get
- Defined in src/cache/implementations/derivables/cache/cache.ts:482

getAndRemove

getAndRemove(key): LazyPromise<null | TType>

Parameters

key: string

Returns LazyPromise<null | TType>

Example

import type { IGroupableCache } from "@daiso-tech/core/cache/contracts";
import type { IGroupableEventBus } from "@daiso-tech/core/event-bus/contracts";
import { Cache } from "@daiso-tech/core/cache/implementations/derivables";
import { MemoryCacheAdapter } from "@daiso-tech/core/cache/implementations/adapters";

const cache: IGroupableCache = new Cache({
  adapter: new MemoryCacheAdapter({
    rootGroup: "@global"
  }),
});

const result1 = await cache.getAndRemove("a");
// Will print null
console.log(result1);

await cache.add("a", 2)

const result2 = await cache.getAndRemove("a");
// Will print 2
console.log(result2);

const result3 = await cache.get("a");
// Will print null
console.log(result3);

getGroup

getGroup(): string

Returns string

Example

import type { IGroupableCache } from "@daiso-tech/core/cache/contracts";
import type { IGroupableEventBus } from "@daiso-tech/core/event-bus/contracts";
import { Cache } from "@daiso-tech/core/cache/implementations/derivables";
import { MemoryCacheAdapter } from "@daiso-tech/core/cache/implementations/adapters";

const cache: IGroupableCache = new Cache({
  adapter: new MemoryCacheAdapter({
    rootGroup: "@global"
  }),
});

// Will print "@global"
console.log(cache.getGroup());

getMany

getMany<TKeys>(keys): LazyPromise<Record<TKeys, null | TType>>
The getMany returns the value for the keys that are found otherwise null will be returned.
Type Parameters
- TKeys extends string
Parameters
- keys: TKeys[]
Returns LazyPromise<Record<TKeys, null | TType>>
Implementation of IGroupableCache.getMany
- Defined in src/cache/implementations/derivables/cache/cache.ts:846

getOr

getOr(key, defaultValue): LazyPromise<TType>

Parameters

key: string
defaultValue: AsyncLazyable<TType>

Returns LazyPromise<TType>

Example

import type { IGroupableCache } from "@daiso-tech/core/cache/contracts";
import type { IGroupableEventBus } from "@daiso-tech/core/event-bus/contracts";
import { Cache } from "@daiso-tech/core/cache/implementations/derivables";
import { MemoryCacheAdapter } from "@daiso-tech/core/cache/implementations/adapters";

const cache: IGroupableCache = new Cache({
  adapter: new MemoryCacheAdapter({
    rootGroup: "@global"
  }),
});

const result = await cache.getOr("a", -1);
// -1
console.log(result);

You can pass function as default value.

Example

import type { IGroupableCache } from "@daiso-tech/core/cache/contracts";
import type { IGroupableEventBus } from "@daiso-tech/core/event-bus/contracts";
import { Cache } from "@daiso-tech/core/cache/implementations/derivables";
import { MemoryCacheAdapter } from "@daiso-tech/core/cache/implementations/adapters";

const cache: IGroupableCache = new Cache({
  adapter: new MemoryCacheAdapter({
    rootGroup: "@global"
  }),
});

const result = await cache.getOr("a", () => -1);
// -1
console.log(result);

You can pass async function as default value.

Example

import type { IGroupableCache } from "@daiso-tech/core/cache/contracts";
import type { IGroupableEventBus } from "@daiso-tech/core/event-bus/contracts";
import { Cache } from "@daiso-tech/core/cache/implementations/derivables";
import { MemoryCacheAdapter } from "@daiso-tech/core/cache/implementations/adapters";

const cache: IGroupableCache = new Cache({
  adapter: new MemoryCacheAdapter({
    rootGroup: "@global"
  }),
});

const result = await cache.getOr("a", async () => -1);
// -1
console.log(result);

You can pass LazyPromise as default value.

Example

import type { IGroupableCache } from "@daiso-tech/core/cache/contracts";
import type { IGroupableEventBus } from "@daiso-tech/core/event-bus/contracts";
import { Cache } from "@daiso-tech/core/cache/implementations/derivables";
import { MemoryCacheAdapter } from "@daiso-tech/core/cache/implementations/adapters";

const cache: IGroupableCache = new Cache({
  adapter: new MemoryCacheAdapter({
    rootGroup: "@global"
  }),
});

const result = await cache.getOr("a", new LazyPromise(async () => -1));
// -1
console.log(result);

getOrAdd

getOrAdd(key, valueToAdd, ttl?): LazyPromise<TType>

Parameters

key: string
valueToAdd: AsyncLazyable<GetOrAddValue<TType>>
Optionalttl: TimeSpan
Default
```
{null}
```

Returns LazyPromise<TType>

Example

import type { IGroupableCache } from "@daiso-tech/core/cache/contracts";
import type { IGroupableEventBus } from "@daiso-tech/core/event-bus/contracts";
import { Cache } from "@daiso-tech/core/cache/implementations/derivables";
import { MemoryCacheAdapter } from "@daiso-tech/core/cache/implementations/adapters";

const cache: IGroupableCache = new Cache({
  adapter: new MemoryCacheAdapter({
    rootGroup: "@global"
  }),
});

const result = await cache.getOrAdd("a", -1);
// -1
console.log(result);

You can pass function as default value.

Example

import type { IGroupableCache } from "@daiso-tech/core/cache/contracts";
import type { IGroupableEventBus } from "@daiso-tech/core/event-bus/contracts";
import { Cache } from "@daiso-tech/core/cache/implementations/derivables";
import { MemoryCacheAdapter } from "@daiso-tech/core/cache/implementations/adapters";

const cache: IGroupableCache = new Cache({
  adapter: new MemoryCacheAdapter({
    rootGroup: "@global"
  }),
});

const result = await cache.getOrAdd("a", () => -1);
// -1
console.log(result);

You can pass async function as default value.

Example

import type { IGroupableCache } from "@daiso-tech/core/cache/contracts";
import type { IGroupableEventBus } from "@daiso-tech/core/event-bus/contracts";
import { Cache } from "@daiso-tech/core/cache/implementations/derivables";
import { MemoryCacheAdapter } from "@daiso-tech/core/cache/implementations/adapters";

const cache: IGroupableCache = new Cache({
  adapter: new MemoryCacheAdapter({
    rootGroup: "@global"
  }),
});

const result = await cache.getOrAdd("a", async () => -1);
// -1
console.log(result);

You can pass LazyPromise as default value.

Example

import type { IGroupableCache } from "@daiso-tech/core/cache/contracts";
import type { IGroupableEventBus } from "@daiso-tech/core/event-bus/contracts";
import { Cache } from "@daiso-tech/core/cache/implementations/derivables";
import { MemoryCacheAdapter } from "@daiso-tech/core/cache/implementations/adapters";

const cache: IGroupableCache = new Cache({
  adapter: new MemoryCacheAdapter({
    rootGroup: "@global"
  }),
});

const result = await cache.getOrAdd("a", new LazyPromise(async () => -1));
// -1
console.log(result);

getOrFail

getOrFail(key): LazyPromise<TType>

Parameters

key: string

Returns LazyPromise<TType>

Example

import type { IGroupableCache } from "@daiso-tech/core/cache/contracts";
import type { IGroupableEventBus } from "@daiso-tech/core/event-bus/contracts";
import { Cache } from "@daiso-tech/core/cache/implementations/derivables";
import { MemoryCacheAdapter } from "@daiso-tech/core/cache/implementations/adapters";

const cache: IGroupableCache = new Cache({
  adapter: new MemoryCacheAdapter({
    rootGroup: "@global"
  }),
});

await cache.add("a", 1);

const result1 = await cache.getOrFail("a");
// Will print 1
console.log(result1);

await cache.remove("a");

// Will throw an error
await cache.getOrFail("a");

getOrMany

getOrMany<TKeys>(keysWithDefaults): LazyPromise<Record<TKeys, TType>>

Type Parameters

TKeys extends string

Parameters

keysWithDefaults: Record<TKeys, AsyncLazyable<TType>>

Returns LazyPromise<Record<TKeys, TType>>

Example

import type { IGroupableCache } from "@daiso-tech/core/cache/contracts";
import type { IGroupableEventBus } from "@daiso-tech/core/event-bus/contracts";
import { Cache } from "@daiso-tech/core/cache/implementations/derivables";
import { MemoryCacheAdapter } from "@daiso-tech/core/cache/implementations/adapters";

const cache: IGroupableCache = new Cache({
  adapter: new MemoryCacheAdapter({
    rootGroup: "@global"
  }),
});

const result = await cache.getOrMany({ a: -1 });
// { a: -1 }
console.log(result);

You can pass function as default value.

Example

import type { IGroupableCache } from "@daiso-tech/core/cache/contracts";
import type { IGroupableEventBus } from "@daiso-tech/core/event-bus/contracts";
import { Cache } from "@daiso-tech/core/cache/implementations/derivables";
import { MemoryCacheAdapter } from "@daiso-tech/core/cache/implementations/adapters";

const cache: IGroupableCache = new Cache({
  adapter: new MemoryCacheAdapter({
    rootGroup: "@global"
  }),
});

const result = await cache.getOrMany({ a: () => -1 });
// { a: -1 }
console.log(result);

You can pass async function as default value.

Example

import type { IGroupableCache } from "@daiso-tech/core/cache/contracts";
import type { IGroupableEventBus } from "@daiso-tech/core/event-bus/contracts";
import { Cache } from "@daiso-tech/core/cache/implementations/derivables";
import { MemoryCacheAdapter } from "@daiso-tech/core/cache/implementations/adapters";

const cache: IGroupableCache = new Cache({
  adapter: new MemoryCacheAdapter({
    rootGroup: "@global"
  }),
});

const result = await cache.getOrMany({ a: async () => -1 });
// { a: -1 }
console.log(result);

You can pass LazyPromise as default value.

Example

import type { IGroupableCache } from "@daiso-tech/core/cache/contracts";
import type { IGroupableEventBus } from "@daiso-tech/core/event-bus/contracts";
import { Cache } from "@daiso-tech/core/cache/implementations/derivables";
import { MemoryCacheAdapter } from "@daiso-tech/core/cache/implementations/adapters";

const cache: IGroupableCache = new Cache({
  adapter: new MemoryCacheAdapter({
    rootGroup: "@global"
  }),
});

const result = await cache.getOrMany({ a: new LazyPromise(async () => - 1) });
// { a: -1 }
console.log(result);

increment

increment(key, value?): LazyPromise<boolean>
The increment method will increment the given key if found otherwise nonthing will occur. Returns true if key is incremented otherwise false will be returned. An error will thrown if the key is not a number.
Parameters
- key: string
- value: Extract<TType, number> = ...
Returns LazyPromise<boolean>
Throws
TypeCacheError
Implementation of IGroupableCache.increment
- Defined in src/cache/implementations/derivables/cache/cache.ts:697

listenOnce

listenOnce<TEventClass>(eventName, listener): LazyPromise<void>

You can listen to different events of Cache class instance.

Refer to CacheEvents, to se all events dispatched by Cache class instance. Refer to IEventListenable for details on how the method works.

Type Parameters

TEventClass extends EventClass<CacheEvents>

Parameters

eventName: TEventClass
listener: Invokable<EventInstance<TEventClass>>

Returns LazyPromise<void>

Example

import type { IGroupableCache } from "@daiso-tech/core/cache/contracts";
import type { IGroupableEventBus } from "@daiso-tech/core/event-bus/contracts";
import { Cache } from "@daiso-tech/core/cache/implementations/derivables";
import { MemoryCacheAdapter } from "@daiso-tech/core/cache/implementations/adapters";
import type { Invokable} from "@daiso-tech/core/event-bus/contracts";
import { KeyAddedCacheEvent, type CacheEvents } from "@daiso-tech/core/cache/contracts";

const cache: IGroupableCache = new Cache({
  adapter: new MemoryCacheAdapter({
    rootGroup: "@global"
  }),
});

const listener: Invokable<CacheEvents> = event => {
  console.log(event);
};
await cache.listenOnce(KeyAddedCacheEvent, listener);
await cache.add("a", 1);

missing

missing(key): LazyPromise<boolean>
The missing method returns true when key is not found otherwise false will be returned.
Parameters
- key: string
Returns LazyPromise<boolean>
Implementation of IGroupableCache.missing
- Defined in src/cache/implementations/derivables/cache/cache.ts:813

missingMany

missingMany<TKeys>(keys): LazyPromise<Record<TKeys, boolean>>
The missingMany method returns true for the keys that are not found otherwise false will be returned.
Type Parameters
- TKeys extends string
Parameters
- keys: TKeys[]
Returns LazyPromise<Record<TKeys, boolean>>
Implementation of IGroupableCache.missingMany
- Defined in src/cache/implementations/derivables/cache/cache.ts:820

put

put(key, value, ttl?): LazyPromise<boolean>
The put method replaces a key if the key exists including the ttl value or adds key that do not exists with a given ttl. Returns true if the key where replaced otherwise false is returned. You can provide a ttl value for the replaced key. If null is passed, the item will not expires and null is the default value.
Parameters
- key: string
- value: TType
- ttl: null | TimeSpan = ...
  Default
  null
Returns LazyPromise<boolean>
Implementation of IGroupableCache.put
- Defined in src/cache/implementations/derivables/cache/cache.ts:606

putMany

putMany<TKeys>(values): LazyPromise<Record<TKeys, boolean>>
The putMany method replaces the keys that exists including their ttl values or adds keys that do not exists. Returns true for all the keys that where replaced otherwise false is returned.
Type Parameters
- TKeys extends string
Parameters
- values: Record<TKeys, WithTtlValue<TType>>
Returns LazyPromise<Record<TKeys, boolean>>
Implementation of IGroupableCache.putMany
- Defined in src/cache/implementations/derivables/cache/cache.ts:1152

remove

remove(key): LazyPromise<boolean>
The remove method removes the given key when found. Returns true if the key is found otherwise false is returned.
Parameters
- key: string
Returns LazyPromise<boolean>
Implementation of IGroupableCache.remove
- Defined in src/cache/implementations/derivables/cache/cache.ts:657

removeListener

removeListener<TEventClass>(eventName, listener): LazyPromise<void>

You can listen to different events of Cache class instance.

Refer to CacheEvents, to se all events dispatched by Cache class instance. Refer to IEventListenable for details on how the method works.

Type Parameters

TEventClass extends EventClass<CacheEvents>

Parameters

eventName: TEventClass
listener: Invokable<EventInstance<TEventClass>>

Returns LazyPromise<void>

Example

import type { IGroupableCache } from "@daiso-tech/core/cache/contracts";
import type { IGroupableEventBus } from "@daiso-tech/core/event-bus/contracts";
import { Cache } from "@daiso-tech/core/cache/implementations/derivables";
import { MemoryCacheAdapter } from "@daiso-tech/core/cache/implementations/adapters";
import type { Invokable} from "@daiso-tech/core/event-bus/contracts";
import { KeyAddedCacheEvent, type CacheEvents } from "@daiso-tech/core/cache/contracts";

const cache: IGroupableCache = new Cache({
  adapter: new MemoryCacheAdapter({
    rootGroup: "@global"
  }),
});

const listener: Invokable<CacheEvents> = event => {
  console.log(event);
};
await cache.addListener(KeyAddedCacheEvent, listener);
await cache.removeListener(KeyAddedCacheEvent, listener);
await cache.add("a", 1);

removeListenerMany

removeListenerMany<TEventClass>(eventNames, listener): LazyPromise<void>

You can listen to different events of Cache class instance.

Refer to CacheEvents, to se all events dispatched by Cache class instance. Refer to IEventListenable for details on how the method works.

Type Parameters

TEventClass extends EventClass<CacheEvents>

Parameters

eventNames: TEventClass[]
listener: Invokable<EventInstance<TEventClass>>

Returns LazyPromise<void>

Example

import type { IGroupableCache } from "@daiso-tech/core/cache/contracts";
import type { IGroupableEventBus } from "@daiso-tech/core/event-bus/contracts";
import { Cache } from "@daiso-tech/core/cache/implementations/derivables";
import { MemoryCacheAdapter } from "@daiso-tech/core/cache/implementations/adapters";
import type { Invokable} from "@daiso-tech/core/event-bus/contracts";
import { KeyAddedCacheEvent, type CacheEvents } from "@daiso-tech/core/cache/contracts";

const cache: IGroupableCache = new Cache({
  adapter: new MemoryCacheAdapter({
    rootGroup: "@global"
  }),
});

const listener: Invokable<CacheEvents> = event => {
  console.log(event);
};
await cache.addListenerMany([KeyAddedCacheEvent], listener);
await cache.removeListenerMany(KeyAddedCacheEvent, listener);
await cache.add("a", 1);

removeMany

removeMany<TKeys>(keys): LazyPromise<Record<TKeys, boolean>>
The removeMany method removes keys. Returns true for the keys that are removed otherwise false is returned.
Type Parameters
- TKeys extends string
Parameters
- keys: TKeys[]
Returns LazyPromise<Record<TKeys, boolean>>
Implementation of IGroupableCache.removeMany
- Defined in src/cache/implementations/derivables/cache/cache.ts:1179

subscribe<TEventClass>(eventName, listener): LazyPromise<Unsubscribe>

You can listen to different events of Cache class instance.

Refer to CacheEvents, to se all events dispatched by Cache class instance. Refer to IEventListenable for details on how the method works.

Type Parameters

TEventClass extends EventClass<CacheEvents>

Parameters

eventName: TEventClass
listener: Invokable<EventInstance<TEventClass>>

Returns LazyPromise<Unsubscribe>

Example

import type { IGroupableCache } from "@daiso-tech/core/cache/contracts";
import type { IGroupableEventBus } from "@daiso-tech/core/event-bus/contracts";
import { Cache } from "@daiso-tech/core/cache/implementations/derivables";
import { MemoryCacheAdapter } from "@daiso-tech/core/cache/implementations/adapters";
import type { Invokable} from "@daiso-tech/core/event-bus/contracts";
import { KeyAddedCacheEvent, type CacheEvents } from "@daiso-tech/core/cache/contracts";

const cache: IGroupableCache = new Cache({
  adapter: new MemoryCacheAdapter({
    rootGroup: "@global"
  }),
});

const listener: Invokable<CacheEvents> = event => {
  console.log(event);
};
const unsubscribe = await cache.subscribe(KeyAddedCacheEvent, listener);
await cache.add("a", 1);
await unsubscribe();

subscribeMany

subscribeMany<TEventClass>(eventNames, listener): LazyPromise<Unsubscribe>

You can listen to different events of Cache class instance.

Refer to CacheEvents, to se all events dispatched by Cache class instance. Refer to IEventListenable for details on how the method works.

Type Parameters

TEventClass extends EventClass<CacheEvents>

Parameters

eventNames: TEventClass[]
listener: Invokable<EventInstance<TEventClass>>

Returns LazyPromise<Unsubscribe>

Example

import type { IGroupableCache } from "@daiso-tech/core/cache/contracts";
import type { IGroupableEventBus } from "@daiso-tech/core/event-bus/contracts";
import { Cache } from "@daiso-tech/core/cache/implementations/derivables";
import { MemoryCacheAdapter } from "@daiso-tech/core/cache/implementations/adapters";
import type { Invokable} from "@daiso-tech/core/event-bus/contracts";
import { KeyAddedCacheEvent, type CacheEvents } from "@daiso-tech/core/cache/contracts";

const cache: IGroupableCache = new Cache({
  adapter: new MemoryCacheAdapter({
    rootGroup: "@global"
  }),
});

const listener: Invokable<CacheEvents> = event => {
  console.log(event);
};
const unsubscribe = await cache.subscribeMany([KeyAddedCacheEvent], listener);
await cache.add("a", 1);
await unsubscribe();

update

update(key, value): LazyPromise<boolean>
The update method updates the given key with given value. Returns true when key otherwise false will be returned.
Parameters
- key: string
- value: TType
Returns LazyPromise<boolean>
Implementation of IGroupableCache.update
- Defined in src/cache/implementations/derivables/cache/cache.ts:564

updateMany

updateMany<TKeys>(values): LazyPromise<Record<TKeys, boolean>>
The updateMany method updates the given keys. Returns true for the keys that where updated otherwise false will be returned.
Type Parameters
- TKeys extends string
Parameters
- values: Record<TKeys, TType>
Returns LazyPromise<Record<TKeys, boolean>>
Implementation of IGroupableCache.updateMany
- Defined in src/cache/implementations/derivables/cache/cache.ts:1125

withGroup

withGroup(group): ICache<TType>

Parameters

group: OneOrMore<string>

Returns ICache<TType>

Example

import type { IGroupableCache, ICache } from "@daiso-tech/core/cache/contracts";
import type { IGroupableEventBus } from "@daiso-tech/core/event-bus/contracts";
import { Cache } from "@daiso-tech/core/cache/implementations/derivables";
import { MemoryCacheAdapter } from "@daiso-tech/core/cache/implementations/adapters";

const cache: IGroupableCache = new Cache({
  adapter: new MemoryCacheAdapter({
    rootGroup: "@global"
  }),
});

// Will print "@global"
console.log(cache.getGroup());

const groupedCache: ICache = cache.withGroup("company-1");

// Will print "@global/company-1"
console.log(groupedCache.getGroup());

Class Cache<TType>

Type Parameters

Implements

Index

Constructors

Methods

Constructors

constructor

Type Parameters

Parameters

Returns Cache<TType>

Example

Methods

add

Parameters

Default

Returns LazyPromise<boolean>

addListener

Type Parameters

Parameters

Returns LazyPromise<void>

Example

addListenerMany

Type Parameters

Parameters

Returns LazyPromise<void>

Example

addMany

Type Parameters

Parameters

Returns LazyPromise<Record<TKeys, boolean>>

asPromise

Type Parameters

Parameters

Returns LazyPromise<EventInstance<TEventClass>>

Throws

clear

Returns LazyPromise<void>

decrement

Parameters

Returns LazyPromise<boolean>

Throws

exists

Parameters

Returns LazyPromise<boolean>

existsMany

Type Parameters

Parameters

Returns LazyPromise<Record<TKeys, boolean>>

get

Parameters

Returns LazyPromise<null | TType>

getAndRemove

Parameters

Returns LazyPromise<null | TType>

Example

getGroup

Returns string

Example

getMany

Type Parameters

Parameters

Returns LazyPromise<Record<TKeys, null | TType>>

getOr

Parameters

Returns LazyPromise<TType>

Example

Example

Example

Example

getOrAdd

Parameters

Default

Returns LazyPromise<TType>

Example

Example

Example

Example

getOrFail

Parameters