@forklaunch/core 1.3.9 → 1.3.11

package/lib/{openTelemetryCollector-DorlR4pn.d.mts → openTelemetryCollector-DXGXRvQP.d.mts}

@@ -1,6 +1,5 @@
 import { Counter, Gauge, Histogram, UpDownCounter, ObservableCounter, ObservableGauge, ObservableUpDownCounter } from '@opentelemetry/api';
-import pino, { LevelWithSilentOrString, LevelWithSilent } from 'pino';
-import { AnyValueMap } from '@opentelemetry/api-logs';
+import { LevelWithSilentOrString, LevelWithSilent } from 'pino';
 
 type MetricType<T extends string> = T extends 'counter' ? Counter : T extends 'gauge' ? Gauge : T extends 'histogram' ? Histogram : T extends 'upDownCounter' ? UpDownCounter : T extends 'observableCounter' ? ObservableCounter : T extends 'observableGauge' ? ObservableGauge : T extends 'observableUpDownCounter' ? ObservableUpDownCounter : undefined;
 type MetricsDefinition = Record<string, 'counter' | 'gauge' | 'histogram' | 'upDownCounter' | 'observableCounter' | 'observableGauge' | 'observableUpDownCounter'>;
@@ -21,26 +20,8 @@ interface TelemetryOptions {
     level: LevelWithSilentOrString;
 }
 
-declare function meta(meta: Record<string, unknown>): LoggerMeta;
-declare class PinoLogger {
-    private pinoLogger;
-    private meta;
-    constructor(level: LevelWithSilentOrString, meta?: AnyValueMap);
-    log(level: LevelWithSilent, ...args: (string | unknown | LoggerMeta)[]): void;
-    error: LogFn;
-    info: LogFn;
-    debug: LogFn;
-    warn: LogFn;
-    trace: LogFn;
-    child(meta?: AnyValueMap): PinoLogger;
-    getBaseLogger(): pino.Logger;
-}
-declare function logger(level: LevelWithSilentOrString, meta?: AnyValueMap): PinoLogger;
-
 declare class OpenTelemetryCollector<AppliedMetricsDefinition extends MetricsDefinition> {
-    _logger: PinoLogger;
-    _serviceName: string;
-    _metrics: Record<keyof AppliedMetricsDefinition, Counter | Gauge | Histogram | UpDownCounter | ObservableCounter | ObservableGauge | ObservableUpDownCounter>;
+    #private;
     constructor(serviceName: string, level?: LevelWithSilentOrString, metricDefinitions?: AppliedMetricsDefinition);
     log(level: LevelWithSilent, ...args: (string | unknown | LoggerMeta)[]): void;
     info: LogFn;
@@ -67,4 +48,4 @@ declare const httpServerDurationHistogram: Histogram<{
     "http.response.status_code": number;
 }>;
 
-export { type LogFn as L, type MetricsDefinition as M, OpenTelemetryCollector as O, PinoLogger as P, type TelemetryOptions as T, type LoggerMeta as a, type MetricType as b, httpServerDurationHistogram as c, httpRequestsTotalCounter as h, logger as l, meta as m };
+export { type LoggerMeta as L, type MetricsDefinition as M, OpenTelemetryCollector as O, type TelemetryOptions as T, type LogFn as a, type MetricType as b, httpServerDurationHistogram as c, httpRequestsTotalCounter as h };

package/lib/{openTelemetryCollector-DorlR4pn.d.ts → openTelemetryCollector-DXGXRvQP.d.ts}

@@ -1,6 +1,5 @@
 import { Counter, Gauge, Histogram, UpDownCounter, ObservableCounter, ObservableGauge, ObservableUpDownCounter } from '@opentelemetry/api';
-import pino, { LevelWithSilentOrString, LevelWithSilent } from 'pino';
-import { AnyValueMap } from '@opentelemetry/api-logs';
+import { LevelWithSilentOrString, LevelWithSilent } from 'pino';
 
 type MetricType<T extends string> = T extends 'counter' ? Counter : T extends 'gauge' ? Gauge : T extends 'histogram' ? Histogram : T extends 'upDownCounter' ? UpDownCounter : T extends 'observableCounter' ? ObservableCounter : T extends 'observableGauge' ? ObservableGauge : T extends 'observableUpDownCounter' ? ObservableUpDownCounter : undefined;
 type MetricsDefinition = Record<string, 'counter' | 'gauge' | 'histogram' | 'upDownCounter' | 'observableCounter' | 'observableGauge' | 'observableUpDownCounter'>;
@@ -21,26 +20,8 @@ interface TelemetryOptions {
     level: LevelWithSilentOrString;
 }
 
-declare function meta(meta: Record<string, unknown>): LoggerMeta;
-declare class PinoLogger {
-    private pinoLogger;
-    private meta;
-    constructor(level: LevelWithSilentOrString, meta?: AnyValueMap);
-    log(level: LevelWithSilent, ...args: (string | unknown | LoggerMeta)[]): void;
-    error: LogFn;
-    info: LogFn;
-    debug: LogFn;
-    warn: LogFn;
-    trace: LogFn;
-    child(meta?: AnyValueMap): PinoLogger;
-    getBaseLogger(): pino.Logger;
-}
-declare function logger(level: LevelWithSilentOrString, meta?: AnyValueMap): PinoLogger;
-
 declare class OpenTelemetryCollector<AppliedMetricsDefinition extends MetricsDefinition> {
-    _logger: PinoLogger;
-    _serviceName: string;
-    _metrics: Record<keyof AppliedMetricsDefinition, Counter | Gauge | Histogram | UpDownCounter | ObservableCounter | ObservableGauge | ObservableUpDownCounter>;
+    #private;
     constructor(serviceName: string, level?: LevelWithSilentOrString, metricDefinitions?: AppliedMetricsDefinition);
     log(level: LevelWithSilent, ...args: (string | unknown | LoggerMeta)[]): void;
     info: LogFn;
@@ -67,4 +48,4 @@ declare const httpServerDurationHistogram: Histogram<{
     "http.response.status_code": number;
 }>;
 
-export { type LogFn as L, type MetricsDefinition as M, OpenTelemetryCollector as O, PinoLogger as P, type TelemetryOptions as T, type LoggerMeta as a, type MetricType as b, httpServerDurationHistogram as c, httpRequestsTotalCounter as h, logger as l, meta as m };
+export { type LoggerMeta as L, type MetricsDefinition as M, OpenTelemetryCollector as O, type TelemetryOptions as T, type LogFn as a, type MetricType as b, httpServerDurationHistogram as c, httpRequestsTotalCounter as h };

package/lib/persistence/index.d.mts

@@ -186,31 +186,32 @@ declare function getCurrentTenantId(): string;
 /**
  * MikroORM custom Type that transparently encrypts/decrypts values.
  *
- * Works with any JS type (string, number, boolean, object/JSON).
- * Non-string values are JSON-serialized before encryption and
- * JSON-parsed after decryption.
+ * Works with any JS type. Non-string values are serialized before
+ * encryption and hydrated after decryption using the original Type's
+ * runtimeType for correct JS type reconstruction.
  *
  * DB column is always `text` — the encrypted ciphertext is a string
  * regardless of the original JS type.
  *
- * Operates at the data conversion layer — before the identity map,
- * during hydration, and during persistence. Entities always hold
- * their original JS values (plaintext).
+ * For array container types, the element type is tracked separately
+ * so each element is hydrated individually after decryption.
  */
 declare class EncryptedType extends Type<unknown, string | null> {
-    private readonly originalType;
+    #private;
     /**
-     * @param originalType - The original JS type hint ('string' | 'json' | 'number' | 'boolean').
-     *                       Used to determine serialization strategy.
+     * @param elementRuntimeType - The runtimeType of the (element) type,
+     *   e.g. 'string', 'number', 'Date', 'bigint', 'Buffer', 'any'.
+     * @param isArray - Whether this is an array container type.
      */
-    constructor(originalType?: string);
+    constructor(elementRuntimeType?: string, isArray?: boolean);
     convertToDatabaseValue(value: unknown, _platform: Platform, _context?: TransformContext): string | null;
     convertToJSValue(value: string | null, _platform: Platform): unknown;
     getColumnType(): string;
     get runtimeType(): string;
     ensureComparable(): boolean;
-    private serializeValue;
-    private deserializeValue;
+    private serialize;
+    private deserialize;
+    private tryJsonParse;
 }
 
 /**

package/lib/persistence/index.d.ts

@@ -186,31 +186,32 @@ declare function getCurrentTenantId(): string;
 /**
  * MikroORM custom Type that transparently encrypts/decrypts values.
  *
- * Works with any JS type (string, number, boolean, object/JSON).
- * Non-string values are JSON-serialized before encryption and
- * JSON-parsed after decryption.
+ * Works with any JS type. Non-string values are serialized before
+ * encryption and hydrated after decryption using the original Type's
+ * runtimeType for correct JS type reconstruction.
  *
  * DB column is always `text` — the encrypted ciphertext is a string
  * regardless of the original JS type.
  *
- * Operates at the data conversion layer — before the identity map,
- * during hydration, and during persistence. Entities always hold
- * their original JS values (plaintext).
+ * For array container types, the element type is tracked separately
+ * so each element is hydrated individually after decryption.
  */
 declare class EncryptedType extends Type<unknown, string | null> {
-    private readonly originalType;
+    #private;
     /**
-     * @param originalType - The original JS type hint ('string' | 'json' | 'number' | 'boolean').
-     *                       Used to determine serialization strategy.
+     * @param elementRuntimeType - The runtimeType of the (element) type,
+     *   e.g. 'string', 'number', 'Date', 'bigint', 'Buffer', 'any'.
+     * @param isArray - Whether this is an array container type.
      */
-    constructor(originalType?: string);
+    constructor(elementRuntimeType?: string, isArray?: boolean);
     convertToDatabaseValue(value: unknown, _platform: Platform, _context?: TransformContext): string | null;
     convertToJSValue(value: string | null, _platform: Platform): unknown;
     getColumnType(): string;
     get runtimeType(): string;
     ensureComparable(): boolean;
-    private serializeValue;
-    private deserializeValue;
+    private serialize;
+    private deserialize;
+    private tryJsonParse;
 }
 
 /**

package/lib/persistence/index.js

@@ -170,39 +170,75 @@ function setEncryptionTenantId(tenantId) {
 function getCurrentTenantId() {
   return _tenantContext.getStore()?.tenantId ?? "";
 }
+function resolveTypeInstance(type) {
+  if (type instanceof import_core.Type) return type;
+  if (typeof type === "function") {
+    try {
+      const inst = new type();
+      return inst instanceof import_core.Type ? inst : void 0;
+    } catch {
+      return void 0;
+    }
+  }
+  return void 0;
+}
+function hydrateValue(value, runtimeType) {
+  if (value === null || value === void 0) return value;
+  switch (runtimeType) {
+    case "string":
+      return typeof value === "string" ? value : String(value);
+    case "number":
+      return typeof value === "number" ? value : Number(value);
+    case "boolean":
+      return typeof value === "boolean" ? value : typeof value === "string" ? value === "true" : Boolean(value);
+    case "Date":
+      return value instanceof Date ? value : new Date(value);
+    case "bigint":
+      return typeof value === "bigint" ? value : BigInt(value);
+    case "Buffer":
+      return Buffer.isBuffer(value) ? value : typeof value === "string" ? Buffer.from(value, "base64") : Buffer.from(value);
+    case "any":
+    // json — return as-is after JSON.parse
+    default:
+      return value;
+  }
+}
 var EncryptedType = class extends import_core.Type {
-  originalType;
+  #elementRuntimeType;
+  #isArray;
   /**
-   * @param originalType - The original JS type hint ('string' | 'json' | 'number' | 'boolean').
-   *                       Used to determine serialization strategy.
+   * @param elementRuntimeType - The runtimeType of the (element) type,
+   *   e.g. 'string', 'number', 'Date', 'bigint', 'Buffer', 'any'.
+   * @param isArray - Whether this is an array container type.
    */
-  constructor(originalType = "string") {
+  constructor(elementRuntimeType = "string", isArray = false) {
     super();
-    this.originalType = originalType;
+    this.#elementRuntimeType = elementRuntimeType;
+    this.#isArray = isArray;
   }
   convertToDatabaseValue(value, _platform, _context) {
     if (value === null || value === void 0) return null;
     if (typeof value === "string" && value.length === 0) return "";
     if (!_encryptor) {
-      return this.serializeValue(value);
+      return this.serialize(value);
     }
     if (typeof value === "string" && isEncrypted(value)) {
       return value;
     }
-    const serialized = this.serializeValue(value);
+    const serialized = this.serialize(value);
     return _encryptor.encrypt(serialized, getCurrentTenantId()) ?? serialized;
   }
   convertToJSValue(value, _platform) {
     if (value === null || value === void 0) return null;
     if (typeof value !== "string") return value;
     if (!isEncrypted(value)) {
-      return this.deserializeValue(value);
+      return this.deserialize(value);
     }
     if (!_encryptor) return value;
     try {
       const decrypted = _encryptor.decrypt(value, getCurrentTenantId());
       if (decrypted === null) return null;
-      return this.deserializeValue(decrypted);
+      return this.deserialize(decrypted);
     } catch {
       return value;
     }
@@ -211,7 +247,8 @@ var EncryptedType = class extends import_core.Type {
     return "text";
   }
   get runtimeType() {
-    return this.originalType === "json" ? "object" : this.originalType;
+    if (this.#isArray) return "object";
+    return this.#elementRuntimeType;
   }
   ensureComparable() {
     return false;
@@ -219,25 +256,50 @@ var EncryptedType = class extends import_core.Type {
   // ---------------------------------------------------------------------------
   // Serialization helpers
   // ---------------------------------------------------------------------------
-  serializeValue(value) {
+  serialize(value) {
     if (typeof value === "string") return value;
+    if (value instanceof Date) return value.toISOString();
+    if (typeof value === "bigint") return value.toString();
+    if (Buffer.isBuffer(value) || value instanceof Uint8Array)
+      return Buffer.from(value).toString("base64");
     return JSON.stringify(value);
   }
-  deserializeValue(value) {
-    switch (this.originalType) {
+  deserialize(value) {
+    if (this.#isArray) {
+      try {
+        const arr = JSON.parse(value);
+        if (!Array.isArray(arr)) return arr;
+        return arr.map(
+          (el) => hydrateValue(el, this.#elementRuntimeType)
+        );
+      } catch {
+        return value;
+      }
+    }
+    switch (this.#elementRuntimeType) {
       case "string":
         return value;
-      case "number":
-        return Number(value);
-      case "boolean":
-        return value === "true";
-      case "json":
-      default:
+      case "any":
         try {
           return JSON.parse(value);
         } catch {
           return value;
         }
+      // Types serialized via toString/toISOString/base64 — hydrate from string directly
+      case "bigint":
+      case "Date":
+      case "Buffer":
+        return hydrateValue(value, this.#elementRuntimeType);
+      // Types where JSON.parse recovers the native JS value (number, boolean)
+      default:
+        return hydrateValue(this.tryJsonParse(value), this.#elementRuntimeType);
+    }
+  }
+  tryJsonParse(value) {
+    try {
+      return JSON.parse(value);
+    } catch {
+      return value;
     }
   }
 };
@@ -273,32 +335,27 @@ var ENCRYPTED_LEVELS = /* @__PURE__ */ new Set([
   "phi",
   "pci"
 ]);
-function detectOriginalType(options) {
+function resolveEncryptedTypeArgs(options) {
   const type = options.type;
-  if (!type) return "string";
-  let t;
-  if (typeof type === "string") {
-    t = type.toLowerCase();
-  } else if (typeof type === "object" && type !== null) {
-    const rt = type.runtimeType;
-    t = rt ?? type.constructor?.name?.toLowerCase() ?? "string";
-  } else {
-    return "string";
-  }
-  if (t.includes("json") || t === "object") return "json";
-  if (t.includes("int") || t === "number" || t === "double" || t === "float" || t === "decimal" || t === "smallint" || t === "tinyint")
-    return "number";
-  if (t === "boolean" || t === "bool") return "boolean";
-  return "string";
+  const isArray = options.array === true;
+  const resolved = resolveTypeInstance(type);
+  if (resolved) {
+    const rt = resolved.runtimeType;
+    if (rt.endsWith("[]")) {
+      return { elementRuntimeType: rt.slice(0, -2) || "string", isArray: true };
+    }
+    return { elementRuntimeType: rt, isArray };
+  }
+  return { elementRuntimeType: "string", isArray };
 }
 function wrapClassified(builder, level) {
   if (ENCRYPTED_LEVELS.has(level)) {
     const options = builder["~options"];
     if (options) {
-      const originalType = detectOriginalType(options);
-      options.type = new EncryptedType(originalType);
+      const { elementRuntimeType, isArray } = resolveEncryptedTypeArgs(options);
+      options.type = new EncryptedType(elementRuntimeType, isArray);
       options.columnType = "text";
-      options.runtimeType = originalType === "json" ? "object" : originalType;
+      options.runtimeType = isArray ? "object" : elementRuntimeType;
     }
   }
   return new Proxy(builder, {