@holo-js/cache 0.1.3

package/dist/index.d.ts

@@ -0,0 +1,199 @@
+import { CacheFacade, CacheRepository, CacheFlexibleTtlInput, CacheFallback, CacheValueResolver, CacheDriverContract, CacheOptionalPackageError, CacheDependencyIndex, CacheQueryBridge, CacheKeyInput, CacheDependencyDescriptor, CacheRuntimeBindings, CacheKey, CacheTtlInput, CacheLockContract, defineCacheKey, normalizeCacheTtl, serializeCacheValue, deserializeCacheValue } from './contracts.js';
+export { CacheConfigError, CacheDriverGetResult, CacheDriverPutInput, CacheDriverResolutionError, CacheError, CacheErrorCode, CacheFallbackResolver, CacheInvalidNumericMutationError, CacheInvalidTtlError, CacheLockAcquisitionError, CacheQueryIntegrationError, CacheRuntimeNotConfiguredError, CacheSerializationError, NormalizedCacheTtl, cacheContractsInternals, isCacheKey, resolveCacheKey } from './contracts.js';
+import { HoloDatabaseConfig, NormalizedHoloDatabaseConfig, HoloDatabaseConnectionConfig, HoloRedisConfig, NormalizedHoloRedisConfig, NormalizedHoloRedisConnectionConfig, NormalizedHoloCacheConfig, HoloCacheConfig } from '@holo-js/config';
+export { CacheDatabaseDriverConfig, CacheDriver, CacheDriverConfig, CacheFileDriverConfig, CacheMemoryDriverConfig, CacheRedisDriverConfig, HoloCacheConfig, NormalizedCacheDatabaseDriverConfig, NormalizedCacheDriverConfig, NormalizedCacheFileDriverConfig, NormalizedCacheMemoryDriverConfig, NormalizedCacheRedisDriverConfig, NormalizedHoloCacheConfig, defineCacheConfig } from '@holo-js/config';
+
+type FlexibleEnvelope<TValue> = {
+    readonly __holo_cache_flexible: true;
+    readonly value: TValue;
+    readonly freshUntil: number;
+    readonly staleUntil: number;
+};
+type NormalizedFlexibleTtl = {
+    readonly freshSeconds: number;
+    readonly staleSeconds: number;
+};
+declare function resolveFallback<TValue>(fallback: CacheFallback<TValue>): Promise<TValue> | TValue;
+declare function resolveValue<TValue>(callback: CacheValueResolver<TValue>): Promise<Awaited<TValue>>;
+declare function resolveDriverKey(driverName?: string): string;
+declare function normalizeFlexibleTtl(ttl: CacheFlexibleTtlInput): NormalizedFlexibleTtl;
+declare function isFlexibleEnvelope<TValue>(value: unknown): value is FlexibleEnvelope<TValue>;
+declare function getOrCreateRepository(driverName?: string): CacheRepository;
+declare const cacheFacade: CacheFacade;
+declare const cacheFacadeInternals: {
+    createRefreshLockName(key: string): string;
+    getOrCreateRepository: typeof getOrCreateRepository;
+    isFlexibleEnvelope: typeof isFlexibleEnvelope;
+    normalizeFlexibleTtl: typeof normalizeFlexibleTtl;
+    resolveDriverKey: typeof resolveDriverKey;
+    resolveFallback: typeof resolveFallback;
+    resolveValue: typeof resolveValue;
+};
+
+type DatabaseCacheDriverOptions = {
+    readonly name: string;
+    readonly connectionName: string;
+    readonly table: string;
+    readonly lockTable: string;
+    readonly prefix?: string;
+    readonly connection: HoloDatabaseConnectionConfig | string;
+};
+type DatabaseCacheDriverModule = {
+    createDatabaseCacheDriver(options: DatabaseCacheDriverOptions): CacheDriverContract;
+};
+type DatabaseDriverModuleLoader = () => Promise<DatabaseCacheDriverModule>;
+declare function isNormalizedDatabaseConfig(config: HoloDatabaseConfig | NormalizedHoloDatabaseConfig): config is NormalizedHoloDatabaseConfig;
+declare function normalizeRuntimeDatabaseConfig(config: HoloDatabaseConfig | NormalizedHoloDatabaseConfig | undefined): NormalizedHoloDatabaseConfig | undefined;
+declare function resolveSharedDatabaseConnection(databaseConfig: NormalizedHoloDatabaseConfig | undefined, connectionName: string): HoloDatabaseConnectionConfig | string;
+declare function isModuleNotFoundError$1(error: unknown, expectedSpecifier?: string): boolean;
+declare function normalizeDatabaseModuleLoadError(error: unknown, expectedSpecifier?: string): CacheOptionalPackageError | unknown;
+declare function loadDatabaseDriverModule(): Promise<DatabaseCacheDriverModule>;
+declare function setDatabaseDriverModuleLoader(loader: DatabaseDriverModuleLoader): void;
+declare function resetDatabaseDriverModuleLoader(): void;
+declare const cacheDbInternals: {
+    isModuleNotFoundError: typeof isModuleNotFoundError$1;
+    isNormalizedDatabaseConfig: typeof isNormalizedDatabaseConfig;
+    loadDatabaseDriverModule: typeof loadDatabaseDriverModule;
+    normalizeDatabaseModuleLoadError: typeof normalizeDatabaseModuleLoadError;
+    normalizeRuntimeDatabaseConfig: typeof normalizeRuntimeDatabaseConfig;
+    resolveSharedDatabaseConnection: typeof resolveSharedDatabaseConnection;
+    resetDatabaseDriverModuleLoader: typeof resetDatabaseDriverModuleLoader;
+    setDatabaseDriverModuleLoader: typeof setDatabaseDriverModuleLoader;
+};
+
+type FileCacheEntryEnvelope = {
+    key: string;
+    payload: string;
+    expiresAt?: number;
+};
+type FileCacheLockEnvelope = {
+    name: string;
+    owner: string;
+    expiresAt: number;
+};
+declare function hashCacheKey(key: string): string;
+declare function resolveDriverRoot(path: string): string;
+declare function resolveEntryFilePath(rootPath: string, key: string): string;
+declare function resolveLockFilePath(rootPath: string, name: string): string;
+declare function isFileCacheEntryEnvelope(value: unknown): value is FileCacheEntryEnvelope;
+declare function isFileCacheLockEnvelope(value: unknown): value is FileCacheLockEnvelope;
+declare const fileDriverInternals: {
+    hashCacheKey: typeof hashCacheKey;
+    isFileCacheEntryEnvelope: typeof isFileCacheEntryEnvelope;
+    isFileCacheLockEnvelope: typeof isFileCacheLockEnvelope;
+    resolveDriverRoot: typeof resolveDriverRoot;
+    resolveEntryFilePath: typeof resolveEntryFilePath;
+    resolveLockFilePath: typeof resolveLockFilePath;
+};
+
+type DependencyIndexState = {
+    readonly keyToDependencies: Map<string, Set<CacheDependencyDescriptor>>;
+    readonly dependencyToKeys: Map<CacheDependencyDescriptor, Set<string>>;
+};
+declare function createMemoryDependencyIndex(state?: DependencyIndexState): CacheDependencyIndex;
+declare function getOrCreateDependencyIndex(): CacheDependencyIndex;
+declare function resetDefaultDependencyIndex(): void;
+declare function createIndexedKey(key: CacheKeyInput<unknown>, driverName?: string): string;
+declare function parseIndexedKey(indexedKey: string): {
+    readonly driverName: string;
+    readonly normalizedKey: string;
+};
+declare function setGlobalDatabaseQueryCacheBridge(bridge?: CacheQueryBridge): void;
+declare function createCacheQueryBridge(dependencyIndex?: CacheDependencyIndex): CacheQueryBridge;
+declare const cacheQueryBridgeInternals: {
+    createCacheQueryBridge: typeof createCacheQueryBridge;
+    createIndexedKey: typeof createIndexedKey;
+    createMemoryDependencyIndex: typeof createMemoryDependencyIndex;
+    getOrCreateDependencyIndex: typeof getOrCreateDependencyIndex;
+    parseIndexedKey: typeof parseIndexedKey;
+    resetDefaultDependencyIndex: typeof resetDefaultDependencyIndex;
+    setGlobalDatabaseQueryCacheBridge: typeof setGlobalDatabaseQueryCacheBridge;
+};
+
+type RedisCacheDriverOptions = {
+    readonly name: string;
+    readonly connectionName: string;
+    readonly prefix: string;
+    readonly redis: NormalizedHoloRedisConnectionConfig;
+};
+type RedisCacheDriverModule = {
+    createRedisCacheDriver(options: RedisCacheDriverOptions): CacheDriverContract;
+};
+type RedisDriverModuleLoader = () => Promise<RedisCacheDriverModule>;
+declare function isNormalizedRedisConfig(config: HoloRedisConfig | NormalizedHoloRedisConfig): config is NormalizedHoloRedisConfig;
+declare function normalizeRuntimeRedisConfig(config: HoloRedisConfig | NormalizedHoloRedisConfig | undefined): NormalizedHoloRedisConfig | undefined;
+declare function resolveSharedRedisConnection(redisConfig: NormalizedHoloRedisConfig | undefined, connectionName: string): NormalizedHoloRedisConnectionConfig;
+declare function isModuleNotFoundError(error: unknown): boolean;
+declare function normalizeRedisModuleLoadError(error: unknown): CacheOptionalPackageError | unknown;
+declare function loadRedisDriverModule(): Promise<RedisCacheDriverModule>;
+declare function setRedisDriverModuleLoader(loader: RedisDriverModuleLoader): void;
+declare function resetRedisDriverModuleLoader(): void;
+declare const cacheRedisInternals: {
+    isModuleNotFoundError: typeof isModuleNotFoundError;
+    isNormalizedRedisConfig: typeof isNormalizedRedisConfig;
+    loadRedisDriverModule: typeof loadRedisDriverModule;
+    normalizeRedisModuleLoadError: typeof normalizeRedisModuleLoadError;
+    normalizeRuntimeRedisConfig: typeof normalizeRuntimeRedisConfig;
+    resolveSharedRedisConnection: typeof resolveSharedRedisConnection;
+    resetRedisDriverModuleLoader: typeof resetRedisDriverModuleLoader;
+    setRedisDriverModuleLoader: typeof setRedisDriverModuleLoader;
+};
+
+type CacheRuntimeFacade = {
+    readonly config: NormalizedHoloCacheConfig;
+    readonly databaseConfig?: NormalizedHoloDatabaseConfig;
+    readonly redisConfig?: NormalizedHoloRedisConfig;
+    readonly drivers: Map<string, CacheDriverContract>;
+    readonly dependencyIndex?: CacheRuntimeBindings['dependencyIndex'];
+    readonly queryBridge?: CacheRuntimeBindings['queryBridge'];
+};
+type RuntimeCacheState = {
+    bindings?: CacheRuntimeFacade;
+};
+declare function isNormalizedCacheConfig(config: HoloCacheConfig | NormalizedHoloCacheConfig): config is NormalizedHoloCacheConfig;
+declare function normalizeRuntimeConfig(config: HoloCacheConfig | NormalizedHoloCacheConfig | undefined): NormalizedHoloCacheConfig;
+declare function getCacheRuntimeState(): RuntimeCacheState;
+declare function getCacheRuntimeBindings(): CacheRuntimeFacade | undefined;
+declare function getCacheRuntime(): CacheRuntimeFacade;
+declare function resolveConfiguredDriver(facade: CacheRuntimeFacade, requestedName?: string): CacheDriverContract;
+
+declare function configureCacheRuntime$1(bindings?: CacheRuntimeBindings): void;
+declare const cacheRuntimeInternals: {
+    getCacheRuntimeState: typeof getCacheRuntimeState;
+    isNormalizedCacheConfig: typeof isNormalizedCacheConfig;
+    normalizeRuntimeConfig: typeof normalizeRuntimeConfig;
+    resolveConfiguredDriver: typeof resolveConfiguredDriver;
+};
+
+declare function configureCacheRuntime(...parameters: Parameters<typeof configureCacheRuntime$1>): void;
+declare function resetCacheRuntime(): void;
+declare const cache: Readonly<{
+    driver(name?: string): CacheRepository;
+    get<TValue>(key: CacheKey<TValue>): Promise<TValue | null>;
+    get<TValue>(key: CacheKeyInput<TValue>, fallback: CacheFallback<TValue>): Promise<TValue>;
+    get<TValue>(key: string, fallback: CacheFallback<TValue>): Promise<TValue>;
+    get(key: string): Promise<unknown | null>;
+    put<TValue>(key: CacheKeyInput<TValue>, value: TValue, ttl: CacheTtlInput): Promise<boolean>;
+    add<TValue>(key: CacheKeyInput<TValue>, value: TValue, ttl: CacheTtlInput): Promise<boolean>;
+    forever<TValue>(key: CacheKeyInput<TValue>, value: TValue): Promise<boolean>;
+    has(key: CacheKeyInput<unknown>): Promise<boolean>;
+    missing(key: CacheKeyInput<unknown>): Promise<boolean>;
+    forget(key: CacheKeyInput<unknown>): Promise<boolean>;
+    flush(): Promise<void>;
+    increment(key: CacheKeyInput<number>, amount?: number): Promise<number>;
+    decrement(key: CacheKeyInput<number>, amount?: number): Promise<number>;
+    remember<TValue>(key: CacheKeyInput<Awaited<TValue>>, ttl: CacheTtlInput, callback: CacheValueResolver<TValue>): Promise<Awaited<TValue>>;
+    rememberForever<TValue>(key: CacheKeyInput<Awaited<TValue>>, callback: CacheValueResolver<TValue>): Promise<Awaited<TValue>>;
+    flexible<TValue>(key: CacheKeyInput<Awaited<TValue>>, ttl: CacheFlexibleTtlInput, callback: CacheValueResolver<TValue>): Promise<Awaited<TValue>>;
+    lock(name: string, seconds: number): CacheLockContract;
+    defineCacheKey: typeof defineCacheKey;
+    normalizeCacheTtl: typeof normalizeCacheTtl;
+    serializeCacheValue: typeof serializeCacheValue;
+    deserializeCacheValue: typeof deserializeCacheValue;
+    configureCacheRuntime: typeof configureCacheRuntime;
+    getCacheRuntime: typeof getCacheRuntime;
+    getCacheRuntimeBindings: typeof getCacheRuntimeBindings;
+    resetCacheRuntime: typeof resetCacheRuntime;
+}>;
+
+export { CacheDependencyDescriptor, CacheDependencyIndex, CacheDriverContract, CacheFacade, CacheFallback, CacheFlexibleTtlInput, CacheKey, CacheKeyInput, CacheLockContract, CacheOptionalPackageError, CacheQueryBridge, CacheRepository, CacheRuntimeBindings, CacheTtlInput, CacheValueResolver, cacheDbInternals, cacheFacade, cacheFacadeInternals, cacheQueryBridgeInternals, cacheRedisInternals, cacheRuntimeInternals, configureCacheRuntime, cache as default, defineCacheKey, deserializeCacheValue, fileDriverInternals, getCacheRuntime, getCacheRuntimeBindings, normalizeCacheTtl, resetCacheRuntime, serializeCacheValue };