Provide the adaptor for postgresql Drizzle ORM
I have dine the adaptor for postgresql Drizzle ORM. Kindly add this in the library.

import { and, eq, gt, lt } from "drizzle-orm";
import { PgColumn, PgTableWithColumns } from "drizzle-orm/pg-core";
import { PostgresJsDatabase } from "drizzle-orm/postgres-js";
import {
  IRateLimiterStoreNoAutoExpiryOptions,
  RateLimiterRes,
  RateLimiterStoreAbstract,
} from "rate-limiter-flexible";

export class RateLimiterDrizzle extends RateLimiterStoreAbstract {
  private modelName: string;
  private db: PostgresJsDatabase;
  private table: PostgreSQLRateLimitTable;
  private clearExpiredByTimeout: boolean;
  private _clearExpiredTimeoutId!: NodeJS.Timeout;

  /**
   * Constructor for the rate limiter
   * @param {Object} opts - Options for the rate limiter
   */
  constructor(opts: IRateLimiterDrizzleOptions) {
    super(opts);

    this.modelName = opts.tableName || "RateLimiterFlexible";
    this.db = opts.storeClient;
    this.table = opts.tableSchema;
    this.clearExpiredByTimeout = opts.clearExpiredByTimeout || true;

    if (!this.db) {
      throw new Error("Drizzle client is not provided");
    }

    if (this.clearExpiredByTimeout) {
      this._clearExpiredHourAgo();
    }
  }

  _getRateLimiterRes(
    rlKey: string,
    changedPoints: number,
    result: PostgreSQLRateLimitRes,
  ): RateLimiterRes {
    const isFirstInDuration = (result?.points || 0) === changedPoints;
    const consumedPoints = result?.points || 0;

    const remainingPoints = Math.max(this.points - consumedPoints, 0);
    const msBeforeNext =
      result?.expire ?
        Math.max(new Date(result.expire).getTime() - Date.now(), 0)
      : -1;

    return new RateLimiterRes(
      remainingPoints,
      msBeforeNext,
      consumedPoints,
      isFirstInDuration,
    );
  }

  _upsert(
    key: string,
    points: number,
    msDuration: number,
    forceExpire = false,
  ): Promise<PostgreSQLRateLimitRes> {
    if (!this.db) {
      return Promise.reject(new Error("Drizzle client is not established"));
    }

    const now = new Date();
    const expire = msDuration > 0 ? new Date(now.getTime() + msDuration) : now;

    return this.db.transaction(async (tx) => {
      const existingRecord = (
        await tx.select().from(this.table).where(eq(this.table.key, key))
      ).at(0);

      if (existingRecord) {
        // Determine if we should update the expire field
        const shouldUpdateExpire =
          forceExpire ||
          !existingRecord.expire ||
          existingRecord.expire <= now ||
          expire === null;

        const records = await this.db
          .update(this.table)
          .set({
            points:
              !shouldUpdateExpire ?
                (existingRecord?.points || 0) + points
              : points,
            expire: !shouldUpdateExpire ? existingRecord.expire : expire,
          })
          .where(eq(this.table.key, key))
          .returning();
        return records.at(0) as PostgreSQLRateLimitRes;
      } else {
        const records = await this.db
          .insert(this.table)
          .values({ key, points, expire })
          .returning();
        return records.at(0) as PostgreSQLRateLimitRes;
      }
    });
  }

  _get(key: string): Promise<PostgreSQLRateLimitRes> {
    if (!this.db) {
      return Promise.reject(new Error("Drizzle client is not established"));
    }

    return this.db.transaction(async (tx) => {
      const records = await tx
        .select()
        .from(this.table)
        .where(and(eq(this.table.key, key), gt(this.table.expire, new Date())));
      return records.at(0) as PostgreSQLRateLimitRes;
    });
  }

  _delete(key: string): Promise<string> {
    if (!this.db) {
      return Promise.reject(new Error("Drizzle client is not established"));
    }

    return this.db.transaction(async (tx) => {
      await tx.delete(this.table).where(eq(this.table.key, key));
      return key;
    });
  }

  _clearExpiredHourAgo() {
    if (this._clearExpiredTimeoutId) {
      clearTimeout(this._clearExpiredTimeoutId);
    }
    this._clearExpiredTimeoutId = setTimeout(async () => {
      await this.db
        .delete(this.table)
        .where(lt(this.table.expire, new Date(Date.now() - 3600000)));
      this._clearExpiredHourAgo();
    }, 300000); // Clear every 5 minutes
  }
}

export interface IRateLimiterDrizzleOptions
  extends IRateLimiterStoreNoAutoExpiryOptions {
  tableSchema: PostgreSQLRateLimitTable;
}

export type PostgreSQLRateLimitTable = PgTableWithColumns<{
  dialect: "pg";
  schema: string | undefined;
  name: string;
  columns: {
    key: PgColumn<
      {
        dataType: "string";
        notNull: true;
        enumValues: [string, ...string[]];
        tableName: string;
        columnType: "PgText";
        data: string;
        driverParam: string;
        hasDefault: false;
        name: "key";
        isAutoincrement: false;
        isPrimaryKey: false;
        hasRuntimeDefault: false;
        generated: undefined;
      },
      object
    >;
    points: PgColumn<
      {
        dataType: "number";
        notNull: true;
        enumValues: undefined;
        tableName: string;
        columnType: "PgInteger";
        data: number;
        driverParam: string | number;
        hasDefault: false;
        name: "points";
        isAutoincrement: false;
        isPrimaryKey: false;
        hasRuntimeDefault: false;
        generated: undefined;
      },
      object
    >;
    expire: PgColumn<
      {
        dataType: "date";
        notNull: true;
        enumValues: undefined;
        tableName: string;
        columnType: "PgTimestamp";
        data: Date;
        driverParam: string;
        hasDefault: false;
        name: "expire";
        isAutoincrement: false;
        isPrimaryKey: false;
        hasRuntimeDefault: false;
        generated: undefined;
      },
      object
    >;
  };
}>;

export type PostgreSQLRateLimitRes =
  | {
      key: string;
      points: number;
      expire: number;
    }
  | undefined;
