@cedarjs/api 0.0.4

package/dist/auth/verifiers/jwtVerifier.js

@@ -0,0 +1,55 @@
+import jwt from "jsonwebtoken";
+import {
+  WebhookSignError,
+  WebhookVerificationError,
+  DEFAULT_WEBHOOK_SECRET
+} from "./common.js";
+const createSignature = ({
+  payload,
+  secret = DEFAULT_WEBHOOK_SECRET,
+  options
+}) => {
+  try {
+    const signOptions = options?.issuer ? { issuer: options?.issuer } : void 0;
+    return jwt.sign(payload, secret, { ...signOptions });
+  } catch (error) {
+    throw new WebhookSignError(error.message);
+  }
+};
+const verifySignature = ({
+  payload,
+  secret = DEFAULT_WEBHOOK_SECRET,
+  signature,
+  options
+}) => {
+  try {
+    if (payload === void 0 || payload?.length === 0) {
+      console.warn("Missing payload");
+    }
+    if (options?.issuer) {
+      jwt.verify(signature, secret, { issuer: options?.issuer });
+    } else {
+      jwt.verify(signature, secret);
+    }
+    return true;
+  } catch {
+    throw new WebhookVerificationError();
+  }
+};
+const jwtVerifier = (options) => {
+  return {
+    sign: ({ payload, secret }) => {
+      return createSignature({ payload, secret, options });
+    },
+    verify: ({ payload, secret, signature }) => {
+      return verifySignature({ payload, secret, signature, options });
+    },
+    type: "jwtVerifier"
+  };
+};
+var jwtVerifier_default = jwtVerifier;
+export {
+  jwtVerifier_default as default,
+  jwtVerifier,
+  verifySignature
+};

package/dist/auth/verifiers/secretKeyVerifier.d.ts

@@ -0,0 +1,14 @@
+import type { WebhookVerifier, VerifyOptions } from './common.js';
+export interface SecretKeyVerifier extends WebhookVerifier {
+    type: 'secretKeyVerifier';
+}
+/**
+ *
+ * Secret Key Verifier
+ *
+ * Use when the payload is not signed, but rather authorized via a known secret key
+ *
+ */
+declare const secretKeyVerifier: (_options?: VerifyOptions) => SecretKeyVerifier;
+export default secretKeyVerifier;
+//# sourceMappingURL=secretKeyVerifier.d.ts.map

package/dist/auth/verifiers/secretKeyVerifier.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"secretKeyVerifier.d.ts","sourceRoot":"","sources":["../../../src/auth/verifiers/secretKeyVerifier.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,eAAe,EAAE,aAAa,EAAE,MAAM,aAAa,CAAA;AAEjE,MAAM,WAAW,iBAAkB,SAAQ,eAAe;IACxD,IAAI,EAAE,mBAAmB,CAAA;CAC1B;AAED;;;;;;GAMG;AACH,QAAA,MAAM,iBAAiB,cAAe,aAAa,KAAG,iBAgBrD,CAAA;AAED,eAAe,iBAAiB,CAAA"}

package/dist/auth/verifiers/secretKeyVerifier.js

@@ -0,0 +1,20 @@
+import { WebhookVerificationError, DEFAULT_WEBHOOK_SECRET } from "./common.js";
+const secretKeyVerifier = (_options) => {
+  return {
+    sign: ({ secret }) => {
+      return secret;
+    },
+    verify: ({ signature, secret = DEFAULT_WEBHOOK_SECRET }) => {
+      const verified = signature === secret;
+      if (!verified) {
+        throw new WebhookVerificationError();
+      }
+      return verified;
+    },
+    type: "secretKeyVerifier"
+  };
+};
+var secretKeyVerifier_default = secretKeyVerifier;
+export {
+  secretKeyVerifier_default as default
+};

package/dist/auth/verifiers/sha1Verifier.d.ts

@@ -0,0 +1,25 @@
+import type { WebhookVerifier, VerifyOptions } from './common.js';
+export interface Sha1Verifier extends WebhookVerifier {
+    type: 'sha1Verifier';
+}
+/**
+ *
+ * verifySignature
+ *
+ */
+export declare const verifySignature: ({ payload, secret, signature, }: {
+    payload: string | Record<string, unknown>;
+    secret: string;
+    signature: string;
+}) => boolean;
+/**
+ *
+ * SHA1 HMAC Payload Verifier
+ *
+ * Based on Vercel's webhook payload verification
+ * @see https://vercel.com/docs/api#integrations/webhooks/securing-webhooks
+ *
+ */
+declare const sha1Verifier: (_options?: VerifyOptions) => Sha1Verifier;
+export default sha1Verifier;
+//# sourceMappingURL=sha1Verifier.d.ts.map

package/dist/auth/verifiers/sha1Verifier.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sha1Verifier.d.ts","sourceRoot":"","sources":["../../../src/auth/verifiers/sha1Verifier.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,eAAe,EAAE,aAAa,EAAE,MAAM,aAAa,CAAA;AAEjE,MAAM,WAAW,YAAa,SAAQ,eAAe;IACnD,IAAI,EAAE,cAAc,CAAA;CACrB;AAkCD;;;;GAIG;AACH,eAAO,MAAM,eAAe,oCAIzB;IACD,OAAO,EAAE,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;IACzC,MAAM,EAAE,MAAM,CAAA;IACd,SAAS,EAAE,MAAM,CAAA;CAClB,KAAG,OA+BH,CAAA;AAED;;;;;;;GAOG;AACH,QAAA,MAAM,YAAY,cAAe,aAAa,KAAG,YAUhD,CAAA;AAED,eAAe,YAAY,CAAA"}

package/dist/auth/verifiers/sha1Verifier.js

@@ -0,0 +1,65 @@
+import { createHmac, timingSafeEqual } from "crypto";
+import {
+  WebhookVerificationError,
+  VERIFICATION_ERROR_MESSAGE,
+  DEFAULT_WEBHOOK_SECRET
+} from "./common.js";
+function toNormalizedJsonString(payload) {
+  return JSON.stringify(payload).replace(/[^\\]\\u[\da-f]{4}/g, (s) => {
+    return s.substr(0, 3) + s.substr(3).toUpperCase();
+  });
+}
+const createSignature = ({
+  payload,
+  secret = DEFAULT_WEBHOOK_SECRET
+}) => {
+  const algorithm = "sha1";
+  const hmac = createHmac(algorithm, secret);
+  payload = typeof payload === "string" ? payload : toNormalizedJsonString(payload);
+  const digest = Buffer.from(
+    algorithm + "=" + hmac.update(payload).digest("hex"),
+    "utf8"
+  );
+  return digest.toString();
+};
+const verifySignature = ({
+  payload,
+  secret = DEFAULT_WEBHOOK_SECRET,
+  signature
+}) => {
+  try {
+    const algorithm = signature.split("=")[0];
+    const webhookSignature = Buffer.from(signature || "", "utf8");
+    const hmac = createHmac(algorithm, secret);
+    payload = typeof payload === "string" ? payload : toNormalizedJsonString(payload);
+    const digest = Buffer.from(
+      algorithm + "=" + hmac.update(payload).digest("hex"),
+      "utf8"
+    );
+    const verified = webhookSignature.length === digest.length && timingSafeEqual(digest, webhookSignature);
+    if (verified) {
+      return verified;
+    }
+    throw new WebhookVerificationError();
+  } catch (error) {
+    throw new WebhookVerificationError(
+      `${VERIFICATION_ERROR_MESSAGE}: ${error.message}`
+    );
+  }
+};
+const sha1Verifier = (_options) => {
+  return {
+    sign: ({ payload, secret }) => {
+      return createSignature({ payload, secret });
+    },
+    verify: ({ payload, secret, signature }) => {
+      return verifySignature({ payload, secret, signature });
+    },
+    type: "sha1Verifier"
+  };
+};
+var sha1Verifier_default = sha1Verifier;
+export {
+  sha1Verifier_default as default,
+  verifySignature
+};

package/dist/auth/verifiers/sha256Verifier.d.ts

@@ -0,0 +1,25 @@
+import type { WebhookVerifier, VerifyOptions } from './common.js';
+export interface Sha256Verifier extends WebhookVerifier {
+    type: 'sha256Verifier';
+}
+/**
+ *
+ * verifySignature
+ *
+ */
+export declare const verifySignature: ({ payload, secret, signature, }: {
+    payload: string | Record<string, unknown>;
+    secret: string;
+    signature: string;
+}) => boolean;
+/**
+ *
+ * SHA256 HMAC Payload Verifier
+ *
+ * Based on GitHub's webhook payload verification
+ * @see https://docs.github.com/en/developers/webhooks-and-events/securing-your-webhooks
+ *
+ */
+declare const sha256Verifier: (_options?: VerifyOptions) => Sha256Verifier;
+export default sha256Verifier;
+//# sourceMappingURL=sha256Verifier.d.ts.map

package/dist/auth/verifiers/sha256Verifier.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sha256Verifier.d.ts","sourceRoot":"","sources":["../../../src/auth/verifiers/sha256Verifier.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,eAAe,EAAE,aAAa,EAAE,MAAM,aAAa,CAAA;AAEjE,MAAM,WAAW,cAAe,SAAQ,eAAe;IACrD,IAAI,EAAE,gBAAgB,CAAA;CACvB;AAkCD;;;;GAIG;AACH,eAAO,MAAM,eAAe,oCAIzB;IACD,OAAO,EAAE,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;IACzC,MAAM,EAAE,MAAM,CAAA;IACd,SAAS,EAAE,MAAM,CAAA;CAClB,KAAG,OA+BH,CAAA;AAED;;;;;;;GAOG;AACH,QAAA,MAAM,cAAc,cAAe,aAAa,KAAG,cAUlD,CAAA;AAED,eAAe,cAAc,CAAA"}

package/dist/auth/verifiers/sha256Verifier.js

@@ -0,0 +1,65 @@
+import { createHmac, timingSafeEqual } from "crypto";
+import {
+  WebhookVerificationError,
+  VERIFICATION_ERROR_MESSAGE,
+  DEFAULT_WEBHOOK_SECRET
+} from "./common.js";
+function toNormalizedJsonString(payload) {
+  return JSON.stringify(payload).replace(/[^\\]\\u[\da-f]{4}/g, (s) => {
+    return s.substr(0, 3) + s.substr(3).toUpperCase();
+  });
+}
+const createSignature = ({
+  payload,
+  secret = DEFAULT_WEBHOOK_SECRET
+}) => {
+  const algorithm = "sha256";
+  const hmac = createHmac(algorithm, secret);
+  payload = typeof payload === "string" ? payload : toNormalizedJsonString(payload);
+  const digest = Buffer.from(
+    algorithm + "=" + hmac.update(payload).digest("hex"),
+    "utf8"
+  );
+  return digest.toString();
+};
+const verifySignature = ({
+  payload,
+  secret = DEFAULT_WEBHOOK_SECRET,
+  signature
+}) => {
+  try {
+    const algorithm = signature.split("=")[0];
+    const webhookSignature = Buffer.from(signature || "", "utf8");
+    const hmac = createHmac(algorithm, secret);
+    payload = typeof payload === "string" ? payload : toNormalizedJsonString(payload);
+    const digest = Buffer.from(
+      algorithm + "=" + hmac.update(payload).digest("hex"),
+      "utf8"
+    );
+    const verified = webhookSignature.length === digest.length && timingSafeEqual(digest, webhookSignature);
+    if (verified) {
+      return verified;
+    }
+    throw new WebhookVerificationError();
+  } catch (error) {
+    throw new WebhookVerificationError(
+      `${VERIFICATION_ERROR_MESSAGE}: ${error.message}`
+    );
+  }
+};
+const sha256Verifier = (_options) => {
+  return {
+    sign: ({ payload, secret }) => {
+      return createSignature({ payload, secret });
+    },
+    verify: ({ payload, secret, signature }) => {
+      return verifySignature({ payload, secret, signature });
+    },
+    type: "sha256Verifier"
+  };
+};
+var sha256Verifier_default = sha256Verifier;
+export {
+  sha256Verifier_default as default,
+  verifySignature
+};

package/dist/auth/verifiers/skipVerifier.d.ts

@@ -0,0 +1,13 @@
+import type { VerifyOptions, WebhookVerifier } from './common.js';
+export interface SkipVerifier extends WebhookVerifier {
+    type: 'skipVerifier';
+}
+/**
+ * skipVerifier skips webhook signature verification.
+ * Use when there is no signature provided or the webhook is
+ * entirely public.
+ *
+ */
+declare const skipVerifier: (_options?: VerifyOptions) => SkipVerifier;
+export default skipVerifier;
+//# sourceMappingURL=skipVerifier.d.ts.map

package/dist/auth/verifiers/skipVerifier.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"skipVerifier.d.ts","sourceRoot":"","sources":["../../../src/auth/verifiers/skipVerifier.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,aAAa,CAAA;AAEjE,MAAM,WAAW,YAAa,SAAQ,eAAe;IACnD,IAAI,EAAE,cAAc,CAAA;CACrB;AACD;;;;;GAKG;AACH,QAAA,MAAM,YAAY,cAAe,aAAa,KAAG,YAYhD,CAAA;AAED,eAAe,YAAY,CAAA"}

package/dist/auth/verifiers/skipVerifier.js

@@ -0,0 +1,17 @@
+const skipVerifier = (_options) => {
+  return {
+    sign: () => {
+      console.warn(`No signature is created for the skipVerifier verifier`);
+      return "";
+    },
+    verify: () => {
+      console.warn(`The skipVerifier verifier considers all signatures valid`);
+      return true;
+    },
+    type: "skipVerifier"
+  };
+};
+var skipVerifier_default = skipVerifier;
+export {
+  skipVerifier_default as default
+};

package/dist/auth/verifiers/timestampSchemeVerifier.d.ts

@@ -0,0 +1,16 @@
+import type { WebhookVerifier, VerifyOptions } from './common.js';
+export interface TimestampSchemeVerifier extends WebhookVerifier {
+    type: 'timestampSchemeVerifier';
+}
+/**
+ *
+ * Timestamp & Scheme Verifier
+ *
+ * Based on Stripe's secure webhook implementation
+ *
+ * @see https://stripe.com/docs/webhooks/signatures
+ *
+ */
+declare const timestampSchemeVerifier: (options?: VerifyOptions) => TimestampSchemeVerifier;
+export default timestampSchemeVerifier;
+//# sourceMappingURL=timestampSchemeVerifier.d.ts.map

package/dist/auth/verifiers/timestampSchemeVerifier.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"timestampSchemeVerifier.d.ts","sourceRoot":"","sources":["../../../src/auth/verifiers/timestampSchemeVerifier.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,eAAe,EAAE,aAAa,EAAE,MAAM,aAAa,CAAA;AAEjE,MAAM,WAAW,uBAAwB,SAAQ,eAAe;IAC9D,IAAI,EAAE,yBAAyB,CAAA;CAChC;AAwHD;;;;;;;;GAQG;AACH,QAAA,MAAM,uBAAuB,aACjB,aAAa,KACtB,uBAcF,CAAA;AAED,eAAe,uBAAuB,CAAA"}

package/dist/auth/verifiers/timestampSchemeVerifier.js

@@ -0,0 +1,65 @@
+import { createHmac } from "crypto";
+import {
+  WebhookVerificationError,
+  DEFAULT_WEBHOOK_SECRET,
+  DEFAULT_TOLERANCE
+} from "./common.js";
+const getHmac = ({ secret }) => {
+  if (typeof secret === "undefined" || secret === "") {
+    throw new WebhookVerificationError();
+  }
+  return createHmac("sha256", secret);
+};
+const createSignature = ({
+  payload,
+  secret = DEFAULT_WEBHOOK_SECRET,
+  timestamp = Date.now()
+}) => {
+  const hmac = getHmac({ secret });
+  hmac.update(timestamp + "." + payload);
+  return `t=${timestamp},v1=${hmac.digest("hex")}`;
+};
+const verifySignature = ({
+  payload,
+  secret = DEFAULT_WEBHOOK_SECRET,
+  signature,
+  options
+}) => {
+  const match = /t=(\d+),v1=([\da-f]+)/.exec(signature);
+  if (!match) {
+    throw new WebhookVerificationError();
+  }
+  const signedStamp = Number(match[1]);
+  const signedPayload = match[2];
+  const timestamp = options?.currentTimestampOverride ?? Date.now();
+  const tolerance = options?.tolerance ?? DEFAULT_TOLERANCE;
+  const difference = Math.abs(timestamp - signedStamp);
+  if (difference > tolerance) {
+    throw new WebhookVerificationError();
+  }
+  const hmac = getHmac({ secret });
+  hmac.update(signedStamp + "." + payload);
+  if (hmac.digest("hex") === signedPayload) {
+    return true;
+  }
+  throw new WebhookVerificationError();
+};
+const timestampSchemeVerifier = (options) => {
+  return {
+    sign: ({ payload, secret }) => {
+      return createSignature({
+        payload,
+        secret,
+        timestamp: options?.currentTimestampOverride
+      });
+    },
+    verify: ({ payload, secret, signature }) => {
+      return verifySignature({ payload, secret, signature, options });
+    },
+    type: "timestampSchemeVerifier"
+  };
+};
+var timestampSchemeVerifier_default = timestampSchemeVerifier;
+export {
+  timestampSchemeVerifier_default as default
+};

package/dist/bins/redwood.d.ts

@@ -0,0 +1,9 @@
+#!/usr/bin/env node
+/**
+ * This file lets users run the Cedar CLI commands inside the /api directory
+ * in their projects.
+ * This works because of the "bin" field in the @cedarjs/api package.json file
+ * that points to this file.
+ */
+export {};
+//# sourceMappingURL=redwood.d.ts.map

package/dist/bins/redwood.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"redwood.d.ts","sourceRoot":"","sources":["../../src/bins/redwood.ts"],"names":[],"mappings":";AAEA;;;;;GAKG"}

package/dist/bins/rwfw.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=rwfw.d.ts.map

package/dist/bins/rwfw.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rwfw.d.ts","sourceRoot":"","sources":["../../src/bins/rwfw.ts"],"names":[],"mappings":""}

package/dist/bins/tsc.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=tsc.d.ts.map

package/dist/bins/tsc.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tsc.d.ts","sourceRoot":"","sources":["../../src/bins/tsc.ts"],"names":[],"mappings":""}

package/dist/cache/clients/BaseClient.d.ts

@@ -0,0 +1,11 @@
+export default abstract class BaseClient {
+    constructor();
+    disconnect?(): void | Promise<void>;
+    abstract connect(): void | Promise<void>;
+    abstract get(key: string): any;
+    abstract set(key: string, value: unknown, options: {
+        expires?: number;
+    }): Promise<any> | any;
+    abstract del(key: string): Promise<boolean> | any;
+}
+//# sourceMappingURL=BaseClient.d.ts.map

package/dist/cache/clients/BaseClient.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BaseClient.d.ts","sourceRoot":"","sources":["../../../src/cache/clients/BaseClient.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,OAAO,CAAC,QAAQ,OAAO,UAAU;;IAKtC,UAAU,CAAC,IAAI,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC;IAEnC,QAAQ,CAAC,OAAO,IAAI,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC;IAGxC,QAAQ,CAAC,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG;IAG9B,QAAQ,CAAC,GAAG,CACV,GAAG,EAAE,MAAM,EACX,KAAK,EAAE,OAAO,EACd,OAAO,EAAE;QAAE,OAAO,CAAC,EAAE,MAAM,CAAA;KAAE,GAC5B,OAAO,CAAC,GAAG,CAAC,GAAG,GAAG;IAGrB,QAAQ,CAAC,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,GAAG,GAAG;CAClD"}

package/dist/cache/clients/BaseClient.js

@@ -0,0 +1,7 @@
+class BaseClient {
+  constructor() {
+  }
+}
+export {
+  BaseClient as default
+};

package/dist/cache/clients/InMemoryClient.d.ts

@@ -0,0 +1,31 @@
+import BaseClient from './BaseClient.js';
+type CacheOptions = {
+    expires?: number;
+};
+export default class InMemoryClient extends BaseClient {
+    storage: Record<string, {
+        expires: number;
+        value: string;
+    }>;
+    constructor(data?: {});
+    /**
+     * Special function for testing, only available in InMemoryClient
+     *
+     * Returns deserialized content of cache as an array of values (without cache keys)
+     *
+     */
+    get contents(): any[];
+    disconnect(): Promise<void>;
+    connect(): Promise<void>;
+    get(key: string): Promise<any>;
+    set(key: string, value: unknown, options?: CacheOptions): Promise<boolean>;
+    del(key: string): Promise<boolean>;
+    /**
+     * Special functions for testing, only available in InMemoryClient
+     */
+    clear(): Promise<void>;
+    cacheKeyForValue(value: any): string | null;
+    isCached(value: any): boolean;
+}
+export {};
+//# sourceMappingURL=InMemoryClient.d.ts.map

package/dist/cache/clients/InMemoryClient.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"InMemoryClient.d.ts","sourceRoot":"","sources":["../../../src/cache/clients/InMemoryClient.ts"],"names":[],"mappings":"AAEA,OAAO,UAAU,MAAM,iBAAiB,CAAA;AAExC,KAAK,YAAY,GAAG;IAClB,OAAO,CAAC,EAAE,MAAM,CAAA;CACjB,CAAA;AAED,MAAM,CAAC,OAAO,OAAO,cAAe,SAAQ,UAAU;IACpD,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE;QAAE,OAAO,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE,CAAC,CAAA;gBAG/C,IAAI,KAAK;IAKrB;;;;;OAKG;IACH,IAAI,QAAQ,UAIX;IAGK,UAAU;IACV,OAAO;IAEP,GAAG,CAAC,GAAG,EAAE,MAAM;IAWf,GAAG,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,EAAE,OAAO,GAAE,YAAiB;IAU3D,GAAG,CAAC,GAAG,EAAE,MAAM;IASrB;;OAEG;IACG,KAAK;IAIX,gBAAgB,CAAC,KAAK,EAAE,GAAG;IAU3B,QAAQ,CAAC,KAAK,EAAE,GAAG;CAGpB"}

package/dist/cache/clients/InMemoryClient.js

@@ -0,0 +1,70 @@
+import BaseClient from "./BaseClient.js";
+class InMemoryClient extends BaseClient {
+  storage;
+  // initialize with pre-cached data if needed
+  constructor(data = {}) {
+    super();
+    this.storage = data;
+  }
+  /**
+   * Special function for testing, only available in InMemoryClient
+   *
+   * Returns deserialized content of cache as an array of values (without cache keys)
+   *
+   */
+  get contents() {
+    return Object.values(this.storage).map(
+      (cacheObj) => JSON.parse(cacheObj.value)
+    );
+  }
+  // Not needed for InMemoryClient
+  async disconnect() {
+  }
+  async connect() {
+  }
+  async get(key) {
+    const now = /* @__PURE__ */ new Date();
+    if (this.storage[key] && this.storage[key].expires > now.getTime()) {
+      return JSON.parse(this.storage[key].value);
+    } else {
+      delete this.storage[key];
+      return null;
+    }
+  }
+  // stores expiration dates as epoch
+  async set(key, value, options = {}) {
+    const now = /* @__PURE__ */ new Date();
+    now.setSeconds(now.getSeconds() + (options?.expires || 31536e4));
+    const data = { expires: now.getTime(), value: JSON.stringify(value) };
+    this.storage[key] = data;
+    return true;
+  }
+  async del(key) {
+    if (this.storage[key]) {
+      delete this.storage[key];
+      return true;
+    } else {
+      return false;
+    }
+  }
+  /**
+   * Special functions for testing, only available in InMemoryClient
+   */
+  async clear() {
+    this.storage = {};
+  }
+  cacheKeyForValue(value) {
+    for (const [cacheKey, cacheObj] of Object.entries(this.storage)) {
+      if (cacheObj.value === JSON.stringify(value)) {
+        return cacheKey;
+      }
+    }
+    return null;
+  }
+  isCached(value) {
+    return !!this.cacheKeyForValue(value);
+  }
+}
+export {
+  InMemoryClient as default
+};

package/dist/cache/clients/MemcachedClient.d.ts

@@ -0,0 +1,16 @@
+import type { Client as ClientType, ClientOptions, ServerOptions } from 'memjs';
+import BaseClient from './BaseClient.js';
+export default class MemcachedClient extends BaseClient {
+    client?: ClientType | null;
+    servers: string;
+    options: (ClientOptions<string | Buffer, Buffer | null> & ServerOptions) | undefined;
+    constructor(servers: string, options?: ClientOptions & ServerOptions);
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    get(key: string): Promise<any>;
+    set(key: string, value: unknown, options: {
+        expires?: number;
+    }): Promise<boolean | undefined>;
+    del(key: string): Promise<boolean | undefined>;
+}
+//# sourceMappingURL=MemcachedClient.d.ts.map

package/dist/cache/clients/MemcachedClient.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MemcachedClient.d.ts","sourceRoot":"","sources":["../../../src/cache/clients/MemcachedClient.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,IAAI,UAAU,EAAE,aAAa,EAAE,aAAa,EAAE,MAAM,OAAO,CAAA;AAE/E,OAAO,UAAU,MAAM,iBAAiB,CAAA;AAExC,MAAM,CAAC,OAAO,OAAO,eAAgB,SAAQ,UAAU;IACrD,MAAM,CAAC,EAAE,UAAU,GAAG,IAAI,CAAA;IAC1B,OAAO,SAAA;IACP,OAAO,8EAAA;gBAEK,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,aAAa,GAAG,aAAa;IAM9D,OAAO;IAKP,UAAU;IAKV,GAAG,CAAC,GAAG,EAAE,MAAM;IAcf,GAAG,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,EAAE,OAAO,EAAE;QAAE,OAAO,CAAC,EAAE,MAAM,CAAA;KAAE;IAQ9D,GAAG,CAAC,GAAG,EAAE,MAAM;CAQtB"}

package/dist/cache/clients/MemcachedClient.js

@@ -0,0 +1,45 @@
+import BaseClient from "./BaseClient.js";
+class MemcachedClient extends BaseClient {
+  client;
+  servers;
+  options;
+  constructor(servers, options) {
+    super();
+    this.servers = servers;
+    this.options = options;
+  }
+  async connect() {
+    const { Client: MemCachedClient } = await import("memjs");
+    this.client = MemCachedClient.create(this.servers, this.options);
+  }
+  async disconnect() {
+    this.client?.close();
+    this.client = null;
+  }
+  async get(key) {
+    if (!this.client) {
+      await this.connect();
+    }
+    const result = await this.client?.get(key);
+    if (result?.value) {
+      return JSON.parse(result.value.toString());
+    } else {
+      return result?.value;
+    }
+  }
+  async set(key, value, options) {
+    if (!this.client) {
+      await this.connect();
+    }
+    return this.client?.set(key, JSON.stringify(value), options);
+  }
+  async del(key) {
+    if (!this.client) {
+      await this.connect();
+    }
+    return this.client?.delete(key);
+  }
+}
+export {
+  MemcachedClient as default
+};

package/dist/cache/clients/RedisClient.d.ts

@@ -0,0 +1,20 @@
+import type { RedisClientType, RedisClientOptions } from 'redis';
+import type { Logger } from '../../logger/index.js';
+import BaseClient from './BaseClient.js';
+type LoggerOptions = {
+    logger?: Logger;
+};
+export default class RedisClient extends BaseClient {
+    client?: RedisClientType | null;
+    logger?: Logger;
+    redisOptions?: RedisClientOptions;
+    constructor(options: RedisClientOptions & LoggerOptions);
+    connect(): Promise<void>;
+    get(key: string): Promise<any>;
+    set(key: string, value: unknown, options: {
+        expires?: number;
+    }): Promise<string | null | undefined>;
+    del(key: string): Promise<boolean>;
+}
+export {};
+//# sourceMappingURL=RedisClient.d.ts.map

package/dist/cache/clients/RedisClient.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RedisClient.d.ts","sourceRoot":"","sources":["../../../src/cache/clients/RedisClient.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,kBAAkB,EAAE,MAAM,OAAO,CAAA;AAEhE,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,uBAAuB,CAAA;AAEnD,OAAO,UAAU,MAAM,iBAAiB,CAAA;AAMxC,KAAK,aAAa,GAAG;IACnB,MAAM,CAAC,EAAE,MAAM,CAAA;CAChB,CAAA;AAED,MAAM,CAAC,OAAO,OAAO,WAAY,SAAQ,UAAU;IACjD,MAAM,CAAC,EAAE,eAAe,GAAG,IAAI,CAAA;IAC/B,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,YAAY,CAAC,EAAE,kBAAkB,CAAA;gBAErB,OAAO,EAAE,kBAAkB,GAAG,aAAa;IAQjD,OAAO;IAiBP,GAAG,CAAC,GAAG,EAAE,MAAM;IAUf,GAAG,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,EAAE,OAAO,EAAE;QAAE,OAAO,CAAC,EAAE,MAAM,CAAA;KAAE;IAc9D,GAAG,CAAC,GAAG,EAAE,MAAM;CAQtB"}