alepha/redis.d.ts

Alepha is a convention-driven TypeScript framework for building robust, end-to-end type-safe applications, from serverless APIs to full-stack React apps.

import * as _alepha_core1 from "alepha";
import * as _alepha_core3 from "alepha";
import * as _alepha_core0 from "alepha";
import { Alepha, Logger, Static, TNumber, TObject, TOptional, TString } from "alepha";
import { RedisClientType, SetOptions, createClient } from "@redis/client";

//#region src/providers/RedisProvider.d.ts
declare const envSchema: TObject<{
  REDIS_PORT: TNumber;
  REDIS_HOST: TString;
  REDIS_PASSWORD: TOptional<TString>;
}>;
declare module "alepha" {
  interface Env extends Partial<Static<typeof envSchema>> {}
}
type RedisClient = RedisClientType<{}, {}, {}, 3, {
  36: BufferConstructor;
}>;
type RedisClientOptions = Parameters<typeof createClient>[0];
type RedisSetOptions = SetOptions;
/**
 * Redis client provider.
 */
declare class RedisProvider {
  protected readonly log: Logger;
  protected readonly alepha: Alepha;
  protected readonly env: Static<typeof envSchema>;
  protected readonly client: RedisClient;
  get publisher(): RedisClient;
  protected readonly start: _alepha_core1.HookDescriptor<"start">;
  protected readonly stop: _alepha_core1.HookDescriptor<"stop">;
  /**
   * Connect to the Redis server.
   */
  connect(): Promise<void>;
  /**
   * Close the connection to the Redis server.
   */
  close(): Promise<void>;
  duplicate(options?: Partial<RedisClientOptions>): RedisClient;
  get(key: string): Promise<Buffer | undefined>;
  set(key: string, value: Buffer | string, options?: RedisSetOptions): Promise<Buffer>;
  has(key: string): Promise<boolean>;
  keys(pattern: string): Promise<string[]>;
  del(keys: string[]): Promise<void>;
  /**
   * Redis subscriber client factory method.
   */
  protected createClient(): RedisClient;
}
//#endregion
//#region src/providers/RedisSubscriberProvider.d.ts
declare class RedisSubscriberProvider {
  protected readonly log: Logger;
  protected readonly alepha: Alepha;
  protected readonly redisProvider: RedisProvider;
  protected readonly client: RedisClient;
  get subscriber(): RedisClient;
  protected readonly start: _alepha_core3.HookDescriptor<"start">;
  protected readonly stop: _alepha_core3.HookDescriptor<"stop">;
  connect(): Promise<void>;
  close(): Promise<void>;
  /**
   * Redis subscriber client factory method.
   */
  protected createClient(): RedisClient;
}
//# sourceMappingURL=RedisSubscriberProvider.d.ts.map
//#endregion
//#region src/index.d.ts
/**
 * Redis client provider for Alepha applications.
 *
 * @see {@link RedisProvider}
 * @module alepha.redis
 */
declare const AlephaRedis: _alepha_core0.Service<_alepha_core0.Module>;
//# sourceMappingURL=index.d.ts.map

//#endregion
export { AlephaRedis, RedisClient, RedisClientOptions, RedisProvider, RedisSetOptions, RedisSubscriberProvider };
//# sourceMappingURL=index.d.ts.map