@forklaunch/core 0.8.2 → 0.8.4

package/lib/src/cache/index.mjs

@@ -2,471 +2,7 @@
 var createCacheKey = (cacheKeyPrefix) => (id) => {
   return `${cacheKeyPrefix}:${id}`;
 };
-
-// src/cache/redisTtlCache.ts
-import { safeParse, safeStringify as safeStringify3 } from "@forklaunch/common";
-import { createClient } from "redis";
-
-// src/http/middleware/request/cors.middleware.ts
-import corsMiddleware from "cors";
-
-// src/http/middleware/request/createContext.middleware.ts
-import { trace } from "@opentelemetry/api";
-import { v4 } from "uuid";
-
-// src/http/telemetry/constants.ts
-import {
-  ATTR_HTTP_REQUEST_METHOD,
-  ATTR_HTTP_RESPONSE_STATUS_CODE,
-  ATTR_HTTP_ROUTE,
-  ATTR_SERVICE_NAME
-} from "@opentelemetry/semantic-conventions";
-
-// src/http/guards/isExpressLikeSchemaHandler.ts
-import { extractArgumentNames } from "@forklaunch/common";
-
-// src/http/middleware/request/auth.middleware.ts
-import { jwtVerify } from "jose";
-
-// src/services/getEnvVar.ts
-function getEnvVar(name) {
-  const value = process.env[name];
-  return value;
-}
-
-// src/http/telemetry/openTelemetryCollector.ts
-import { HyperExpressInstrumentation } from "@forklaunch/opentelemetry-instrumentation-hyper-express";
-import {
-  metrics
-} from "@opentelemetry/api";
-import { OTLPLogExporter } from "@opentelemetry/exporter-logs-otlp-http";
-import { OTLPMetricExporter } from "@opentelemetry/exporter-metrics-otlp-http";
-import { OTLPTraceExporter } from "@opentelemetry/exporter-trace-otlp-http";
-import { ExpressInstrumentation } from "@opentelemetry/instrumentation-express";
-import { HttpInstrumentation } from "@opentelemetry/instrumentation-http";
-import { resourceFromAttributes } from "@opentelemetry/resources";
-import { BatchLogRecordProcessor } from "@opentelemetry/sdk-logs";
-import { PeriodicExportingMetricReader } from "@opentelemetry/sdk-metrics";
-import { NodeSDK } from "@opentelemetry/sdk-node";
-import {
-  ATTR_SERVICE_NAME as ATTR_SERVICE_NAME2
-} from "@opentelemetry/semantic-conventions";
-import dotenv from "dotenv";
-import { v4 as v42 } from "uuid";
-
-// src/http/guards/isForklaunchRequest.ts
-function isForklaunchRequest(request) {
-  return request != null && typeof request === "object" && "contractDetails" in request;
-}
-
-// src/http/telemetry/pinoLogger.ts
-import { isNever, safeStringify } from "@forklaunch/common";
-import { trace as trace2 } from "@opentelemetry/api";
-import { logs } from "@opentelemetry/api-logs";
-import pino from "pino";
-import PinoPretty from "pino-pretty";
-
-// src/http/telemetry/openTelemetryCollector.ts
-dotenv.config({ path: getEnvVar("ENV_FILE_PATH") });
-new NodeSDK({
-  resource: resourceFromAttributes({
-    [ATTR_SERVICE_NAME2]: getEnvVar("OTEL_SERVICE_NAME")
-  }),
-  traceExporter: new OTLPTraceExporter({
-    url: `${getEnvVar("OTEL_EXPORTER_OTLP_ENDPOINT") ?? "http://localhost:4318"}/v1/traces`
-  }),
-  metricReader: new PeriodicExportingMetricReader({
-    exporter: new OTLPMetricExporter({
-      url: `${getEnvVar("OTEL_EXPORTER_OTLP_ENDPOINT") ?? "http://localhost:4318"}/v1/metrics`
-    }),
-    exportIntervalMillis: 5e3
-  }),
-  logRecordProcessors: [
-    new BatchLogRecordProcessor(
-      new OTLPLogExporter({
-        url: `${getEnvVar("OTEL_EXPORTER_OTLP_ENDPOINT") ?? "http://localhost:4318"}/v1/logs`
-      })
-    )
-  ],
-  instrumentations: [
-    new HttpInstrumentation({
-      applyCustomAttributesOnSpan: (span, request) => {
-        span.setAttribute(
-          "service.name",
-          getEnvVar("OTEL_SERVICE_NAME") ?? "unknown"
-        );
-        if (isForklaunchRequest(request)) {
-          span.setAttribute("api.name", request.contractDetails?.name);
-        }
-      }
-    }),
-    new ExpressInstrumentation(),
-    new HyperExpressInstrumentation()
-  ]
-}).start();
-var httpRequestsTotalCounter = metrics.getMeter(getEnvVar("OTEL_SERVICE_NAME") || "unknown").createCounter("http_requests_total", {
-  description: "Number of HTTP requests"
-});
-var httpServerDurationHistogram = metrics.getMeter(getEnvVar("OTEL_SERVICE_NAME") || "unknown").createHistogram("http_server_duration", {
-  description: "Duration of HTTP server requests",
-  unit: "s"
-});
-
-// src/http/middleware/request/parse.middleware.ts
-import {
-  prettyPrintParseErrors
-} from "@forklaunch/validator";
-
-// src/http/middleware/response/parse.middleware.ts
-import {
-  prettyPrintParseErrors as prettyPrintParseErrors2
-} from "@forklaunch/validator";
-
-// src/http/middleware/response/enrichExpressLikeSend.middleware.ts
-import {
-  isAsyncGenerator,
-  isNever as isNever3,
-  isNodeJsWriteableStream,
-  isRecord,
-  readableStreamToAsyncIterable,
-  safeStringify as safeStringify2
-} from "@forklaunch/common";
-
-// src/http/telemetry/recordMetric.ts
-import {
-  ATTR_HTTP_REQUEST_METHOD as ATTR_HTTP_REQUEST_METHOD3,
-  ATTR_HTTP_RESPONSE_STATUS_CODE as ATTR_HTTP_RESPONSE_STATUS_CODE3,
-  ATTR_HTTP_ROUTE as ATTR_HTTP_ROUTE3,
-  ATTR_SERVICE_NAME as ATTR_SERVICE_NAME3
-} from "@opentelemetry/semantic-conventions";
-
-// src/services/configInjector.ts
-import { extractArgumentNames as extractArgumentNames2, isNever as isNever2 } from "@forklaunch/common";
-import {
-  prettyPrintParseErrors as prettyPrintParseErrors3
-} from "@forklaunch/validator";
-
-// src/http/telemetry/evaluateTelemetryOptions.ts
-function evaluateTelemetryOptions(telemetryOptions) {
-  return {
-    enabled: typeof telemetryOptions.enabled === "boolean" ? {
-      metrics: telemetryOptions.enabled,
-      tracing: telemetryOptions.enabled,
-      logging: telemetryOptions.enabled
-    } : {
-      metrics: telemetryOptions.enabled.metrics,
-      tracing: telemetryOptions.enabled.tracing,
-      logging: telemetryOptions.enabled.logging
-    },
-    level: telemetryOptions.level
-  };
-}
-
-// src/cache/redisTtlCache.ts
-var RedisTtlCache = class {
-  /**
-   * Creates an instance of RedisTtlCache.
-   *
-   * @param {number} ttlMilliseconds - The default Time-To-Live in milliseconds for cache entries
-   * @param {OpenTelemetryCollector<MetricsDefinition>} openTelemetryCollector - Collector for OpenTelemetry metrics
-   * @param {RedisClientOptions} hostingOptions - Configuration options for the Redis client
-   * @param {TelemetryOptions} telemetryOptions - Configuration options for telemetry
-   */
-  constructor(ttlMilliseconds, openTelemetryCollector, hostingOptions, telemetryOptions) {
-    this.ttlMilliseconds = ttlMilliseconds;
-    this.openTelemetryCollector = openTelemetryCollector;
-    this.telemetryOptions = evaluateTelemetryOptions(telemetryOptions);
-    this.client = createClient(hostingOptions);
-    if (this.telemetryOptions.enabled.logging) {
-      this.client.on("error", (err) => this.openTelemetryCollector.error(err));
-      this.client.connect().catch(this.openTelemetryCollector.error);
-    }
-  }
-  client;
-  telemetryOptions;
-  /**
-   * Parses a raw Redis reply into the expected type.
-   * Handles null values, arrays, buffers, and JSON strings.
-   *
-   * @template T - The expected type of the parsed value
-   * @param {RedisCommandRawReply} value - The raw value from Redis to parse
-   * @returns {T} The parsed value cast to type T
-   */
-  parseValue(value) {
-    if (value == null) {
-      return null;
-    }
-    if (Array.isArray(value)) {
-      return value.map((v) => this.parseValue(v));
-    }
-    if (Buffer.isBuffer(value)) {
-      return value.toJSON();
-    }
-    switch (typeof value) {
-      case "object":
-      case "string":
-        return safeParse(value);
-      case "number":
-        return value;
-    }
-  }
-  /**
-   * Puts a record into the Redis cache.
-   *
-   * @template T - The type of value being cached
-   * @param {TtlCacheRecord<T>} param0 - The cache record containing key, value and optional TTL
-   * @param {string} param0.key - The key to store the value under
-   * @param {T} param0.value - The value to cache
-   * @param {number} [param0.ttlMilliseconds] - Optional TTL in milliseconds, defaults to constructor value
-   * @returns {Promise<void>} A promise that resolves when the value is cached
-   */
-  async putRecord({
-    key,
-    value,
-    ttlMilliseconds = this.ttlMilliseconds
-  }) {
-    if (this.telemetryOptions.enabled.logging) {
-      this.openTelemetryCollector.info(`Putting record into cache: ${key}`);
-    }
-    await this.client.set(key, safeStringify3(value), {
-      PX: ttlMilliseconds
-    });
-  }
-  /**
-   * Puts multiple records into the Redis cache in a single transaction.
-   *
-   * @template T - The type of values being cached
-   * @param {TtlCacheRecord<T>[]} cacheRecords - Array of cache records to store
-   * @returns {Promise<void>} A promise that resolves when all values are cached
-   */
-  async putBatchRecords(cacheRecords) {
-    const multiCommand = this.client.multi();
-    for (const { key, value, ttlMilliseconds } of cacheRecords) {
-      multiCommand.set(key, safeStringify3(value), {
-        PX: ttlMilliseconds || this.ttlMilliseconds
-      });
-    }
-    await multiCommand.exec();
-  }
-  /**
-   * Adds a value to the left end of a Redis list.
-   *
-   * @template T - The type of value being enqueued
-   * @param {string} queueName - The name of the Redis list
-   * @param {T} value - The value to add to the list
-   * @returns {Promise<void>} A promise that resolves when the value is enqueued
-   */
-  async enqueueRecord(queueName, value) {
-    await this.client.lPush(queueName, safeStringify3(value));
-  }
-  /**
-   * Adds multiple values to the left end of a Redis list in a single transaction.
-   *
-   * @template T - The type of values being enqueued
-   * @param {string} queueName - The name of the Redis list
-   * @param {T[]} values - Array of values to add to the list
-   * @returns {Promise<void>} A promise that resolves when all values are enqueued
-   */
-  async enqueueBatchRecords(queueName, values) {
-    const multiCommand = this.client.multi();
-    for (const value of values) {
-      multiCommand.lPush(queueName, safeStringify3(value));
-    }
-    await multiCommand.exec();
-  }
-  /**
-   * Deletes a record from the Redis cache.
-   *
-   * @param {string} cacheRecordKey - The key of the record to delete
-   * @returns {Promise<void>} A promise that resolves when the record is deleted
-   */
-  async deleteRecord(cacheRecordKey) {
-    await this.client.del(cacheRecordKey);
-  }
-  /**
-   * Deletes multiple records from the Redis cache in a single transaction.
-   *
-   * @param {string[]} cacheRecordKeys - Array of keys to delete
-   * @returns {Promise<void>} A promise that resolves when all records are deleted
-   */
-  async deleteBatchRecords(cacheRecordKeys) {
-    const multiCommand = this.client.multi();
-    for (const key of cacheRecordKeys) {
-      multiCommand.del(key);
-    }
-    await multiCommand.exec();
-  }
-  /**
-   * Removes and returns the rightmost element from a Redis list.
-   *
-   * @template T - The type of value being dequeued
-   * @param {string} queueName - The name of the Redis list
-   * @returns {Promise<T>} A promise that resolves with the dequeued value
-   * @throws {Error} If the queue is empty
-   */
-  async dequeueRecord(queueName) {
-    const value = await this.client.rPop(queueName);
-    if (value === null) {
-      throw new Error(`Queue is empty: ${queueName}`);
-    }
-    return safeParse(value);
-  }
-  /**
-   * Removes and returns multiple elements from the right end of a Redis list.
-   *
-   * @template T - The type of values being dequeued
-   * @param {string} queueName - The name of the Redis list
-   * @param {number} pageSize - Maximum number of elements to dequeue
-   * @returns {Promise<T[]>} A promise that resolves with an array of dequeued values
-   */
-  async dequeueBatchRecords(queueName, pageSize) {
-    const multiCommand = this.client.multi();
-    for (let i = 0; i < pageSize; i++) {
-      multiCommand.rPop(queueName);
-    }
-    const values = await multiCommand.exec();
-    return values.map(
-      (value) => this.parseValue(value)
-    ).filter(Boolean);
-  }
-  /**
-   * Reads a record from the Redis cache.
-   *
-   * @template T - The type of value being read
-   * @param {string} cacheRecordKey - The key of the record to read
-   * @returns {Promise<TtlCacheRecord<T>>} A promise that resolves with the cache record
-   * @throws {Error} If the record is not found
-   */
-  async readRecord(cacheRecordKey) {
-    const [value, ttl] = await this.client.multi().get(cacheRecordKey).ttl(cacheRecordKey).exec();
-    if (value === null) {
-      throw new Error(`Record not found for key: ${cacheRecordKey}`);
-    }
-    return {
-      key: cacheRecordKey,
-      value: this.parseValue(value),
-      ttlMilliseconds: this.parseValue(ttl) * 1e3
-    };
-  }
-  /**
-   * Reads multiple records from the Redis cache.
-   *
-   * @template T - The type of values being read
-   * @param {string[] | string} cacheRecordKeysOrPrefix - Array of keys to read, or a prefix pattern
-   * @returns {Promise<TtlCacheRecord<T>[]>} A promise that resolves with an array of cache records
-   */
-  async readBatchRecords(cacheRecordKeysOrPrefix) {
-    const keys = Array.isArray(cacheRecordKeysOrPrefix) ? cacheRecordKeysOrPrefix : await this.client.keys(cacheRecordKeysOrPrefix + "*");
-    const multiCommand = this.client.multi();
-    for (const key of keys) {
-      multiCommand.get(key);
-      multiCommand.ttl(key);
-    }
-    const values = await multiCommand.exec();
-    return values.reduce((acc, value, index) => {
-      if (index % 2 === 0) {
-        const maybeValue = this.parseValue(
-          value
-        );
-        const ttl = this.parseValue(
-          values[index + 1]
-        );
-        if (maybeValue && ttl) {
-          acc.push({
-            key: keys[index / 2],
-            value: maybeValue,
-            ttlMilliseconds: ttl * 1e3
-          });
-        }
-      }
-      return acc;
-    }, []);
-  }
-  /**
-   * Lists all keys in the Redis cache that match a pattern prefix.
-   *
-   * @param {string} pattern_prefix - The prefix pattern to match keys against
-   * @returns {Promise<string[]>} A promise that resolves with an array of matching keys
-   */
-  async listKeys(pattern_prefix) {
-    const keys = await this.client.keys(pattern_prefix + "*");
-    return keys;
-  }
-  /**
-   * Checks if a record exists in the Redis cache.
-   *
-   * @param {string} cacheRecordKey - The key to check
-   * @returns {Promise<boolean>} A promise that resolves with true if the record exists, false otherwise
-   */
-  async peekRecord(cacheRecordKey) {
-    const result = await this.client.exists(cacheRecordKey);
-    return result === 1;
-  }
-  /**
-   * Checks if multiple records exist in the Redis cache.
-   *
-   * @param {string[] | string} cacheRecordKeysOrPrefix - Array of keys to check, or a prefix pattern
-   * @returns {Promise<boolean[]>} A promise that resolves with an array of existence booleans
-   */
-  async peekBatchRecords(cacheRecordKeysOrPrefix) {
-    const keys = Array.isArray(cacheRecordKeysOrPrefix) ? cacheRecordKeysOrPrefix : await this.client.keys(cacheRecordKeysOrPrefix + "*");
-    const multiCommand = this.client.multi();
-    for (const key of keys) {
-      multiCommand.exists(key);
-    }
-    const results = await multiCommand.exec();
-    return results.map((result) => result === 1);
-  }
-  /**
-   * Peeks at a record in the Redis cache.
-   *
-   * @template T - The type of value being peeked at
-   * @param {string} queueName - The name of the Redis queue
-   * @returns {Promise<T>} A promise that resolves with the peeked value
-   */
-  async peekQueueRecord(queueName) {
-    const value = await this.client.lRange(queueName, 0, 0);
-    return this.parseValue(value[0]);
-  }
-  /**
-   * Peeks at multiple records in the Redis cache.
-   *
-   * @template T - The type of values being peeked at
-   * @param {string} queueName - The name of the Redis queue
-   * @param {number} pageSize - The number of records to peek at
-   * @returns {Promise<T[]>} A promise that resolves with an array of peeked values
-   */
-  async peekQueueRecords(queueName, pageSize) {
-    const values = await this.client.lRange(queueName, 0, pageSize - 1);
-    return values.map((value) => this.parseValue(value)).filter(Boolean);
-  }
-  /**
-   * Gracefully disconnects from the Redis server.
-   *
-   * @returns {Promise<void>} A promise that resolves when the connection is closed
-   */
-  async disconnect() {
-    await this.client.quit();
-  }
-  /**
-   * Gets the default Time-To-Live value in milliseconds.
-   *
-   * @returns {number} The default TTL in milliseconds
-   */
-  getTtlMilliseconds() {
-    return this.ttlMilliseconds;
-  }
-  /**
-   * Gets the underlying Redis client instance.
-   *
-   * @returns {typeof this.client} The Redis client instance
-   */
-  getClient() {
-    return this.client;
-  }
-};
 export {
-  RedisTtlCache,
   createCacheKey
 };
 //# sourceMappingURL=index.mjs.map