@forklaunch/core 0.6.5 → 0.7.0

package/lib/src/cache/index.mjs

@@ -1,104 +1,447 @@
+// src/cache/cacheKey.ts
+var createCacheKey = (cacheKeyPrefix) => (id) => {
+  return `${cacheKeyPrefix}:${id}`;
+};
+
 // src/cache/redisTtlCache.ts
 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";
+
+// src/http/guards/isForklaunchRequest.ts
+function isForklaunchRequest(request) {
+  return request != null && typeof request === "object" && "contractDetails" in request;
+}
+
+// src/http/telemetry/pinoLogger.ts
+import { isNever } 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/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 TTL in milliseconds.
-   * @param {RedisClientOptions} [hostingOptions] - The Redis client options.
+   * @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) {
+  constructor(ttlMilliseconds, openTelemetryCollector, hostingOptions, telemetryOptions) {
     this.ttlMilliseconds = ttlMilliseconds;
     this.openTelemetryCollector = openTelemetryCollector;
+    this.telemetryOptions = evaluateTelemetryOptions(telemetryOptions);
     this.client = createClient(hostingOptions);
-    this.client.on("error", (err) => openTelemetryCollector.error(err));
-    this.client.connect().catch(openTelemetryCollector.error);
+    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 JSON.parse(value);
+      case "number":
+        return value;
+    }
+  }
   /**
    * Puts a record into the Redis cache.
    *
-   * @param {TtlCacheRecord} param0 - The cache record to put into the cache.
-   * @returns {Promise<void>} - A promise that resolves when the record is put into the 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, JSON.stringify(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) {
+    let multiCommand = this.client.multi();
+    for (const { key, value, ttlMilliseconds } of cacheRecords) {
+      multiCommand = multiCommand.set(key, JSON.stringify(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, JSON.stringify(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) {
+    let multiCommand = this.client.multi();
+    for (const value of values) {
+      multiCommand = multiCommand.lPush(queueName, JSON.stringify(value));
+    }
+    await multiCommand.exec();
+  }
   /**
    * Deletes a record from the Redis cache.
    *
-   * @param {string} cacheRecordKey - The key of the cache record to delete.
-   * @returns {Promise<void>} - A promise that resolves when the record is deleted from the 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) {
+    let multiCommand = this.client.multi();
+    for (const key of cacheRecordKeys) {
+      multiCommand = 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 JSON.parse(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) {
+    let multiCommand = this.client.multi();
+    for (let i = 0; i < pageSize; i++) {
+      multiCommand = multiCommand.rPop(queueName);
+    }
+    const values = await multiCommand.exec();
+    return values.map((value) => this.parseValue(value));
+  }
   /**
    * Reads a record from the Redis cache.
    *
-   * @param {string} cacheRecordKey - The key of the cache record to read.
-   * @returns {Promise<TtlCacheRecord>} - A promise that resolves with the cache record.
-   * @throws {Error} - Throws an error if the record is not found.
+   * @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 = await this.client.get(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}`);
     }
-    const ttl = await this.client.ttl(cacheRecordKey);
     return {
       key: cacheRecordKey,
-      value: JSON.parse(value),
-      ttlMilliseconds: ttl * 1e3
+      value: this.parseValue(value),
+      ttlMilliseconds: this.parseValue(ttl) * 1e3
     };
   }
   /**
-   * Lists the keys in the Redis cache that match a pattern prefix.
+   * 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 + "*");
+    let multiCommand = this.client.multi();
+    for (const key of keys) {
+      multiCommand = multiCommand.get(key);
+      multiCommand = multiCommand.ttl(key);
+    }
+    const values = await multiCommand.exec();
+    return values.reduce((acc, value, index) => {
+      if (index % 2 === 0) {
+        acc.push({
+          key: keys[index / 2],
+          value: this.parseValue(value),
+          ttlMilliseconds: this.parseValue(values[index + 1]) * 1e3
+        });
+      }
+      return acc;
+    }, []);
+  }
+  /**
+   * Lists all keys in the Redis cache that match a pattern prefix.
    *
-   * @param {string} pattern_prefix - The pattern prefix to match.
-   * @returns {Promise<string[]>} - A promise that resolves with an array of keys matching the 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;
   }
   /**
-   * Peeks at a record in the Redis cache to check if it exists.
+   * Checks if a record exists in the Redis cache.
    *
-   * @param {string} cacheRecordKey - The key of the cache record to peek at.
-   * @returns {Promise<boolean>} - A promise that resolves with a boolean indicating if the record exists.
+   * @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;
   }
   /**
-   * Disconnects the Redis client.
+   * Checks if multiple records exist in the Redis cache.
    *
-   * @returns {Promise<void>} - A promise that resolves when the client is disconnected.
+   * @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 + "*");
+    let multiCommand = this.client.multi();
+    for (const key of keys) {
+      multiCommand = 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));
+  }
+  /**
+   * 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 TTL (Time-To-Live) in milliseconds.
+   * Gets the default Time-To-Live value in milliseconds.
    *
-   * @returns {number} - The TTL in milliseconds.
+   * @returns {number} The default TTL in milliseconds
    */
   getTtlMilliseconds() {
     return this.ttlMilliseconds;
   }
-};
-
-// src/cache/utils/cacheKey.ts
-var createCacheKey = (cacheKeyPrefix) => (id) => {
-  return `${cacheKeyPrefix}:${id}`;
+  /**
+   * Gets the underlying Redis client instance.
+   *
+   * @returns {typeof this.client} The Redis client instance
+   */
+  getClient() {
+    return this.client;
+  }
 };
 export {
   RedisTtlCache,