@nsshunt/stsfhirpg 1.1.7 → 1.2.1

package/dist/stsfhirpg.mjs

@@ -1,9 +1,9 @@
 import fs from "node:fs";
-import { defaultLogger, Sleep } from "@nsshunt/stsutils";
+import { defaultLogger } from "@nsshunt/stsutils";
 import { isAbsoluteUrl } from "@nsshunt/stsfhirclient";
 import { goptions } from "@nsshunt/stsconfig";
 import cluster from "cluster";
-import require$$0, { randomUUID as randomUUID$1 } from "crypto";
+import require$$0 from "crypto";
 import require$$0$3 from "events";
 import require$$1$1 from "util";
 import require$$0$2 from "dns";
@@ -13,7 +13,6 @@ import require$$1$2 from "tls";
 import require$$0$7 from "path";
 import require$$0$6 from "stream";
 import require$$0$5 from "buffer";
-import { createClient } from "redis";
 class LuxonError extends Error {
 }
 class InvalidDateTimeError extends LuxonError {
@@ -18943,230 +18942,11 @@ class PGFhirAccessLayer extends tinyEmitterExports.TinyEmitter {
     }
   };
 }
-const RELEASE_SCRIPT = `
-if redis.call("get", KEYS[1]) == ARGV[1] then
-  return redis.call("del", KEYS[1])
-else
-  return 0
-end
-`;
-const RENEW_SCRIPT = `
-if redis.call("get", KEYS[1]) == ARGV[1] then
-  return redis.call("pexpire", KEYS[1], ARGV[2])
-else
-  return 0
-end
-`;
-class RedisDistributedLock {
-  client;
-  ttlMs;
-  heartbeatMs;
-  keyPrefix;
-  constructor(client2, options) {
-    this.client = client2;
-    this.ttlMs = options?.ttlMs ?? 3e4;
-    this.heartbeatMs = options?.heartbeatMs ?? Math.floor(this.ttlMs / 3);
-    this.keyPrefix = options?.keyPrefix ?? "lock:";
-    if (this.ttlMs <= 0) {
-      throw new Error("ttlMs must be > 0");
-    }
-    if (this.heartbeatMs <= 0) {
-      throw new Error("heartbeatMs must be > 0");
-    }
-    if (this.heartbeatMs >= this.ttlMs) {
-      throw new Error("heartbeatMs should be less than ttlMs");
-    }
-  }
-  buildKey(name) {
-    return `${this.keyPrefix}${name}`;
-  }
-  async acquire(name, ttlMs) {
-    const key = this.buildKey(name);
-    const token = randomUUID$1();
-    const effectiveTtlMs = ttlMs ?? this.ttlMs;
-    const result2 = await this.client.set(key, token, {
-      NX: true,
-      PX: effectiveTtlMs
-    });
-    if (result2 !== "OK") {
-      return null;
-    }
-    return {
-      key,
-      token,
-      ttlMs: effectiveTtlMs
-    };
-  }
-  async release(lock) {
-    const result2 = await this.client.eval(RELEASE_SCRIPT, {
-      keys: [lock.key],
-      arguments: [lock.token]
-    });
-    return Number(result2) === 1;
-  }
-  async renew(lock, ttlMs) {
-    const effectiveTtlMs = ttlMs ?? lock.ttlMs;
-    const result2 = await this.client.eval(RENEW_SCRIPT, {
-      keys: [lock.key],
-      arguments: [lock.token, String(effectiveTtlMs)]
-    });
-    return Number(result2) === 1;
-  }
-  async isOwner(lock) {
-    const currentValue = await this.client.get(lock.key);
-    return currentValue === lock.token;
-  }
-  async runExclusive(name, task, options) {
-    const lock = await this.acquire(name, options?.ttlMs);
-    if (!lock) {
-      if (options?.onLockNotAcquired) {
-        await options.onLockNotAcquired();
-      }
-      return { acquired: false };
-    }
-    let timer = null;
-    let stopped = false;
-    let renewalError = null;
-    const autoRenew = options?.autoRenew ?? false;
-    const heartbeatMs = options?.heartbeatMs ?? this.heartbeatMs;
-    const stopHeartbeat = () => {
-      stopped = true;
-      if (timer) {
-        clearInterval(timer);
-        timer = null;
-      }
-    };
-    if (autoRenew) {
-      timer = setInterval(async () => {
-        if (stopped) {
-          return;
-        }
-        try {
-          const ok = await this.renew(lock, lock.ttlMs);
-          if (!ok) {
-            renewalError = new Error(
-              `Lost lock ownership while renewing "${lock.key}"`
-            );
-            stopHeartbeat();
-          }
-        } catch (err) {
-          renewalError = err instanceof Error ? err : new Error(String(err));
-          stopHeartbeat();
-        }
-      }, heartbeatMs).unref();
-    }
-    try {
-      const result2 = await task();
-      if (renewalError) {
-        throw renewalError;
-      }
-      return { acquired: true, result: result2 };
-    } finally {
-      stopHeartbeat();
-      try {
-        await this.release(lock);
-      } catch {
-      }
-    }
-  }
-}
-class SearchParameterManager {
-  redis;
-  EnsureSearchParameterDataLoaded = async (name, loadFn, options) => {
-    if (!this.redis) {
-      const redisUrl = goptions.imRedisMessageProcessorUrl;
-      console.log(`SearchParameterManager(): redis trying to connect ...`);
-      this.redis = createClient({
-        url: redisUrl
-      });
-      await this.redis.connect();
-      console.log(`SearchParameterManager(): redis connected`);
-    }
-    try {
-      const pollIntervalMs = options?.pollIntervalMs ?? 250;
-      const lockTtlMs = options?.lockTtlMs ?? 3e4;
-      const autoRenew = options?.autoRenew ?? true;
-      const heartbeatMs = options?.heartbeatMs ?? 1e4;
-      const completeTtlSeconds = options?.completeTtlSeconds;
-      const timeoutMs = options?.timeoutMs;
-      const completeKey = `fhir:searchparam:${name}:complete`;
-      const startedAt = Date.now();
-      const lockManager = new RedisDistributedLock(this.redis, {
-        ttlMs: 3e4,
-        heartbeatMs: 1e4,
-        keyPrefix: "lock:"
-      });
-      while (true) {
-        if (typeof timeoutMs === "number" && timeoutMs > 0) {
-          const elapsedMs = Date.now() - startedAt;
-          if (elapsedMs >= timeoutMs) {
-            throw new Error(
-              `Timed out waiting for search param "${name}" to be loaded`
-            );
-          }
-        }
-        try {
-          const alreadyComplete = await this.redis.get(completeKey);
-          if (alreadyComplete) {
-            console.log(`ensureSearchParamLoaded():alreadyComplete: PID: [${process.pid}] data loaded: [${alreadyComplete}]`);
-            return;
-          }
-        } catch (error) {
-          console.error(error);
-          throw error;
-        }
-        const runResult = await lockManager.runExclusive(
-          `fhir:searchparam:${name}`,
-          async () => {
-            console.log(`ensureSearchParamLoaded(): PID: [${process.pid}] lock acquired`);
-            const completeAfterLock = await this.redis.get(completeKey);
-            if (completeAfterLock) {
-              console.log(`ensureSearchParamLoaded():completeAfterLock: PID: [${process.pid}] data loaded: [${completeAfterLock}]`);
-              return;
-            }
-            await loadFn();
-            const completeValue = JSON.stringify({
-              loaded: true,
-              loadedAt: (/* @__PURE__ */ new Date()).toLocaleString(),
-              name,
-              workerPid: process.pid
-            });
-            console.log(`ensureSearchParamLoaded(): PID: [${process.pid}] data loaded: [${completeValue}]`);
-            if (typeof completeTtlSeconds === "number" && completeTtlSeconds > 0) {
-              await this.redis.set(completeKey, completeValue, {
-                EX: completeTtlSeconds
-              });
-            } else {
-              await this.redis.set(completeKey, completeValue);
-            }
-          },
-          {
-            ttlMs: lockTtlMs,
-            autoRenew,
-            heartbeatMs
-          }
-        );
-        if (runResult.acquired) {
-          return;
-        }
-        console.log(`ensureSearchParamLoaded(): PID: [${process.pid}] Did not get lock`);
-        await Sleep(pollIntervalMs);
-      }
-    } finally {
-      if (this.redis) {
-        this.redis.close();
-        console.log(`SearchParameterManager(): redis closed`);
-      }
-    }
-  };
-}
 export {
   DBSearchIndex,
   FHIRDateUtils,
   PGFhirAccessLayer,
-  RedisDistributedLock,
   ResourceHelper,
-  SearchParameterManager,
   hashReferenceParam,
   hashStringParam,
   hashTokenParam,