@kyro-cms/core 0.2.4 → 0.2.9

package/dist/index.cjs

@@ -1,6 +1,6 @@
 'use strict';
 
-var chunkKDVDIZ4Y_cjs = require('./chunk-KDVDIZ4Y.cjs');
+var chunkPNBZZ76A_cjs = require('./chunk-PNBZZ76A.cjs');
 var chunkBLMFBDBG_cjs = require('./chunk-BLMFBDBG.cjs');
 var chunk4M5PHMUE_cjs = require('./chunk-4M5PHMUE.cjs');
 var chunkEWP5AT6A_cjs = require('./chunk-EWP5AT6A.cjs');
@@ -21,7 +21,7 @@ var stream = require('stream');
 var https = require('https');
 var http2 = require('http2');
 var zod = require('zod');
-var bcrypt = require('bcrypt');
+var bcrypt = require('bcryptjs');
 var jwt = require('jsonwebtoken');
 var crypto = require('crypto');
 var path = require('path');
@@ -649,40 +649,111 @@ or increase socketAcquisitionWarningTimeout=(millis) in the NodeHttpHandler conf
   }
 });
 
+// node_modules/@smithy/node-http-handler/dist-es/http2/ClientHttp2SessionRef.js
+var ids, ClientHttp2SessionRef;
+var init_ClientHttp2SessionRef = chunkG7VZBCD6_cjs.__esm({
+  "node_modules/@smithy/node-http-handler/dist-es/http2/ClientHttp2SessionRef.js"() {
+    ids = new Uint16Array(1);
+    ClientHttp2SessionRef = class {
+      id = ids[0]++;
+      total = 0;
+      max = 0;
+      session;
+      refs = 0;
+      constructor(session) {
+        session.unref();
+        this.session = session;
+      }
+      retain() {
+        if (this.session.destroyed) {
+          throw new Error("@smithy/node-http-handler - cannot acquire reference to destroyed session.");
+        }
+        this.refs += 1;
+        this.total += 1;
+        this.max = Math.max(this.refs, this.max);
+        this.session.ref();
+      }
+      free() {
+        if (this.session.destroyed) {
+          return;
+        }
+        this.refs -= 1;
+        if (this.refs === 0) {
+          this.session.unref();
+        }
+        if (this.refs < 0) {
+          throw new Error("@smithy/node-http-handler - ClientHttp2Session refcount at zero, cannot decrement.");
+        }
+      }
+      deref() {
+        return this.session;
+      }
+      close() {
+        if (!this.session.closed) {
+          this.session.close();
+        }
+      }
+      destroy() {
+        this.refs = 0;
+        if (!this.session.destroyed) {
+          this.session.destroy();
+        }
+      }
+      useCount() {
+        return this.refs;
+      }
+    };
+  }
+});
+
 // node_modules/@smithy/node-http-handler/dist-es/node-http2-connection-pool.js
 var NodeHttp2ConnectionPool;
 var init_node_http2_connection_pool = chunkG7VZBCD6_cjs.__esm({
   "node_modules/@smithy/node-http-handler/dist-es/node-http2-connection-pool.js"() {
+    init_ClientHttp2SessionRef();
     NodeHttp2ConnectionPool = class {
       sessions = [];
+      maxConcurrency = 0;
       constructor(sessions) {
-        this.sessions = sessions ?? [];
+        this.sessions = (sessions ?? []).map((session) => new ClientHttp2SessionRef(session));
       }
       poll() {
-        if (this.sessions.length > 0) {
-          return this.sessions.shift();
+        let cleanup = false;
+        for (const session of this.sessions) {
+          if (session.deref().destroyed) {
+            cleanup = true;
+            continue;
+          }
+          if (!this.maxConcurrency || session.useCount() < this.maxConcurrency) {
+            return session;
+          }
+        }
+        if (cleanup) {
+          for (const session of this.sessions) {
+            if (session.deref().destroyed) {
+              this.remove(session);
+            }
+          }
         }
       }
-      offerLast(session) {
-        this.sessions.push(session);
-      }
-      contains(session) {
-        return this.sessions.includes(session);
+      offerLast(ref) {
+        this.sessions.push(ref);
       }
-      remove(session) {
-        this.sessions = this.sessions.filter((s) => s !== session);
+      remove(ref) {
+        const ix = this.sessions.indexOf(ref);
+        if (ix > -1) {
+          this.sessions.splice(ix, 1);
+        }
       }
       [Symbol.iterator]() {
         return this.sessions[Symbol.iterator]();
       }
-      destroy(connection) {
-        for (const session of this.sessions) {
-          if (session === connection) {
-            if (!session.destroyed) {
-              session.destroy();
-            }
-          }
-        }
+      setMaxConcurrency(maxConcurrency) {
+        this.maxConcurrency = maxConcurrency;
+      }
+      destroy(ref) {
+        this.remove(ref);
+        ref.destroy();
       }
     };
   }
@@ -690,26 +761,29 @@ var init_node_http2_connection_pool = chunkG7VZBCD6_cjs.__esm({
 var NodeHttp2ConnectionManager;
 var init_node_http2_connection_manager = chunkG7VZBCD6_cjs.__esm({
   "node_modules/@smithy/node-http-handler/dist-es/node-http2-connection-manager.js"() {
+    init_ClientHttp2SessionRef();
     init_node_http2_connection_pool();
     NodeHttp2ConnectionManager = class {
+      config;
+      connectionPools = /* @__PURE__ */ new Map();
       constructor(config) {
         this.config = config;
         if (this.config.maxConcurrency && this.config.maxConcurrency <= 0) {
           throw new RangeError("maxConcurrency must be greater than zero.");
         }
       }
-      config;
-      sessionCache = /* @__PURE__ */ new Map();
       lease(requestContext, connectionConfiguration) {
         const url = this.getUrlString(requestContext);
-        const existingPool = this.sessionCache.get(url);
-        if (existingPool) {
-          const existingSession = existingPool.poll();
-          if (existingSession && !this.config.disableConcurrency) {
-            return existingSession;
+        const pool = this.getPool(url);
+        if (!this.config.disableConcurrency && !connectionConfiguration.isEventStream) {
+          const available = pool.poll();
+          if (available) {
+            available.retain();
+            return available;
           }
         }
-        const session = http2__default.default.connect(url);
+        const ref = new ClientHttp2SessionRef(http2__default.default.connect(url));
+        const session = ref.deref();
         if (this.config.maxConcurrency) {
           session.settings({ maxConcurrentStreams: this.config.maxConcurrency }, (err) => {
             if (err) {
@@ -717,47 +791,49 @@ var init_node_http2_connection_manager = chunkG7VZBCD6_cjs.__esm({
             }
           });
         }
-        session.unref();
-        const destroySessionCb = () => {
-          session.destroy();
-          this.deleteSession(url, session);
+        const graceful = () => {
+          this.removeFromPoolAndClose(url, ref);
+        };
+        const ensureDestroyed = () => {
+          this.removeFromPoolAndCheckedDestroy(url, ref);
         };
-        session.on("goaway", destroySessionCb);
-        session.on("error", destroySessionCb);
-        session.on("frameError", destroySessionCb);
-        session.on("close", () => this.deleteSession(url, session));
+        session.on("goaway", graceful);
+        session.on("error", ensureDestroyed);
+        session.on("frameError", ensureDestroyed);
+        session.on("close", ensureDestroyed);
         if (connectionConfiguration.requestTimeout) {
-          session.setTimeout(connectionConfiguration.requestTimeout, destroySessionCb);
-        }
-        const connectionPool = this.sessionCache.get(url) || new NodeHttp2ConnectionPool();
-        connectionPool.offerLast(session);
-        this.sessionCache.set(url, connectionPool);
-        return session;
-      }
-      deleteSession(authority, session) {
-        const existingConnectionPool = this.sessionCache.get(authority);
-        if (!existingConnectionPool) {
-          return;
-        }
-        if (!existingConnectionPool.contains(session)) {
-          return;
+          session.setTimeout(connectionConfiguration.requestTimeout, ensureDestroyed);
         }
-        existingConnectionPool.remove(session);
-        this.sessionCache.set(authority, existingConnectionPool);
+        pool.offerLast(ref);
+        ref.retain();
+        return ref;
+      }
+      release(_requestContext, ref) {
+        ref.free();
       }
-      release(requestContext, session) {
-        const cacheKey = this.getUrlString(requestContext);
-        this.sessionCache.get(cacheKey)?.offerLast(session);
+      createIsolatedSession(requestContext, connectionConfiguration) {
+        const url = this.getUrlString(requestContext);
+        const ref = new ClientHttp2SessionRef(http2__default.default.connect(url));
+        const session = ref.deref();
+        session.settings({ maxConcurrentStreams: 1 });
+        const ensureDestroyed = () => {
+          ref.destroy();
+        };
+        session.on("error", ensureDestroyed);
+        session.on("frameError", ensureDestroyed);
+        session.on("close", ensureDestroyed);
+        if (connectionConfiguration.requestTimeout) {
+          session.setTimeout(connectionConfiguration.requestTimeout, ensureDestroyed);
+        }
+        ref.retain();
+        return ref;
       }
       destroy() {
-        for (const [key, connectionPool] of this.sessionCache) {
-          for (const session of connectionPool) {
-            if (!session.destroyed) {
-              session.destroy();
-            }
-            connectionPool.remove(session);
+        for (const [url, connectionPool] of this.connectionPools) {
+          for (const session of [...connectionPool]) {
+            session.destroy();
           }
-          this.sessionCache.delete(key);
+          this.connectionPools.delete(url);
         }
       }
       setMaxConcurrentStreams(maxConcurrentStreams) {
@@ -765,10 +841,47 @@ var init_node_http2_connection_manager = chunkG7VZBCD6_cjs.__esm({
           throw new RangeError("maxConcurrentStreams must be greater than zero.");
         }
         this.config.maxConcurrency = maxConcurrentStreams;
+        for (const pool of this.connectionPools.values()) {
+          pool.setMaxConcurrency(maxConcurrentStreams);
+        }
       }
       setDisableConcurrentStreams(disableConcurrentStreams) {
         this.config.disableConcurrency = disableConcurrentStreams;
       }
+      debug() {
+        const pools = {};
+        for (const [url, pool] of this.connectionPools) {
+          const sessions = [];
+          for (const ref of pool) {
+            sessions.push({
+              id: ref.id,
+              active: ref.useCount(),
+              maxConcurrent: ref.max,
+              totalRequests: ref.total
+            });
+          }
+          pools[url] = { sessions };
+        }
+        return pools;
+      }
+      removeFromPoolAndClose(authority, ref) {
+        this.connectionPools.get(authority)?.remove(ref);
+        ref.close();
+      }
+      removeFromPoolAndCheckedDestroy(authority, ref) {
+        this.connectionPools.get(authority)?.remove(ref);
+        ref.destroy();
+      }
+      getPool(url) {
+        if (!this.connectionPools.has(url)) {
+          const pool = new NodeHttp2ConnectionPool();
+          if (this.config.maxConcurrency) {
+            pool.setMaxConcurrency(this.config.maxConcurrency);
+          }
+          this.connectionPools.set(url, pool);
+        }
+        return this.connectionPools.get(url);
+      }
       getUrlString(request) {
         return request.destination.toString();
       }
@@ -809,15 +922,17 @@ var init_node_http2_handler = chunkG7VZBCD6_cjs.__esm({
       destroy() {
         this.connectionManager.destroy();
       }
-      async handle(request, { abortSignal, requestTimeout } = {}) {
+      async handle(request, { abortSignal, requestTimeout, isEventStream } = {}) {
         if (!this.config) {
           this.config = await this.configProvider;
-          this.connectionManager.setDisableConcurrentStreams(this.config.disableConcurrentStreams || false);
-          if (this.config.maxConcurrentStreams) {
-            this.connectionManager.setMaxConcurrentStreams(this.config.maxConcurrentStreams);
+          const { disableConcurrentStreams: disableConcurrentStreams2, maxConcurrentStreams } = this.config;
+          this.connectionManager.setDisableConcurrentStreams(disableConcurrentStreams2 ?? false);
+          if (maxConcurrentStreams) {
+            this.connectionManager.setMaxConcurrentStreams(maxConcurrentStreams);
           }
         }
         const { requestTimeout: configRequestTimeout, disableConcurrentStreams } = this.config;
+        const useIsolatedSession = disableConcurrentStreams || isEventStream;
         const effectiveRequestTimeout = requestTimeout ?? configRequestTimeout;
         return new Promise((_resolve, _reject) => {
           let fulfilled = false;
@@ -845,18 +960,20 @@ var init_node_http2_handler = chunkG7VZBCD6_cjs.__esm({
           }
           const authority = `${protocol}//${auth}${hostname}${port ? `:${port}` : ""}`;
           const requestContext = { destination: new URL(authority) };
-          const session = this.connectionManager.lease(requestContext, {
+          const connectConfig = {
             requestTimeout: this.config?.sessionTimeout,
-            disableConcurrentStreams: disableConcurrentStreams || false
-          });
+            isEventStream
+          };
+          const ref = useIsolatedSession ? this.connectionManager.createIsolatedSession(requestContext, connectConfig) : this.connectionManager.lease(requestContext, connectConfig);
+          const session = ref.deref();
           const rejectWithDestroy = (err) => {
-            if (disableConcurrentStreams) {
-              this.destroySession(session);
+            if (useIsolatedSession) {
+              ref.destroy();
             }
             fulfilled = true;
             reject(err);
           };
-          const queryString = buildQueryString(query || {});
+          const queryString = buildQueryString(query ?? {});
           let path2 = request.path;
           if (queryString) {
             path2 += `?${queryString}`;
@@ -864,28 +981,14 @@ var init_node_http2_handler = chunkG7VZBCD6_cjs.__esm({
           if (request.fragment) {
             path2 += `#${request.fragment}`;
           }
-          const req = session.request({
+          const clientHttp2Stream = session.request({
             ...request.headers,
             [http2.constants.HTTP2_HEADER_PATH]: path2,
             [http2.constants.HTTP2_HEADER_METHOD]: method
           });
-          session.ref();
-          req.on("response", (headers) => {
-            const httpResponse = new HttpResponse({
-              statusCode: headers[":status"] || -1,
-              headers: getTransformedHeaders(headers),
-              body: req
-            });
-            fulfilled = true;
-            resolve({ response: httpResponse });
-            if (disableConcurrentStreams) {
-              session.close();
-              this.connectionManager.deleteSession(authority, session);
-            }
-          });
           if (effectiveRequestTimeout) {
-            req.setTimeout(effectiveRequestTimeout, () => {
-              req.close();
+            clientHttp2Stream.setTimeout(effectiveRequestTimeout, () => {
+              clientHttp2Stream.close();
               const timeoutError = new Error(`Stream timed out because of no activity for ${effectiveRequestTimeout} ms`);
               timeoutError.name = "TimeoutError";
               rejectWithDestroy(timeoutError);
@@ -893,35 +996,48 @@ var init_node_http2_handler = chunkG7VZBCD6_cjs.__esm({
           }
           if (abortSignal) {
             const onAbort = () => {
-              req.close();
+              clientHttp2Stream.close();
               const abortError = buildAbortError(abortSignal);
               rejectWithDestroy(abortError);
             };
             if (typeof abortSignal.addEventListener === "function") {
               const signal = abortSignal;
               signal.addEventListener("abort", onAbort, { once: true });
-              req.once("close", () => signal.removeEventListener("abort", onAbort));
+              clientHttp2Stream.once("close", () => signal.removeEventListener("abort", onAbort));
             } else {
               abortSignal.onabort = onAbort;
             }
           }
-          req.on("frameError", (type, code, id) => {
+          clientHttp2Stream.on("frameError", (type, code, id) => {
             rejectWithDestroy(new Error(`Frame type id ${type} in stream id ${id} has failed with code ${code}.`));
           });
-          req.on("error", rejectWithDestroy);
-          req.on("aborted", () => {
-            rejectWithDestroy(new Error(`HTTP/2 stream is abnormally aborted in mid-communication with result code ${req.rstCode}.`));
+          clientHttp2Stream.on("error", rejectWithDestroy);
+          clientHttp2Stream.on("aborted", () => {
+            rejectWithDestroy(new Error(`HTTP/2 stream is abnormally aborted in mid-communication with result code ${clientHttp2Stream.rstCode}.`));
+          });
+          clientHttp2Stream.on("response", (headers) => {
+            const httpResponse = new HttpResponse({
+              statusCode: headers[":status"] ?? -1,
+              headers: getTransformedHeaders(headers),
+              body: clientHttp2Stream
+            });
+            fulfilled = true;
+            resolve({ response: httpResponse });
+            if (useIsolatedSession) {
+              session.close();
+            }
           });
-          req.on("close", () => {
-            session.unref();
-            if (disableConcurrentStreams) {
-              session.destroy();
+          clientHttp2Stream.on("close", () => {
+            if (useIsolatedSession) {
+              ref.destroy();
+            } else {
+              this.connectionManager.release(requestContext, ref);
             }
             if (!fulfilled) {
               rejectWithDestroy(new Error("Unexpected error: http2 request did not get a response"));
             }
           });
-          writeRequestBodyPromise = writeRequestBody(req, request, effectiveRequestTimeout);
+          writeRequestBodyPromise = writeRequestBody(clientHttp2Stream, request, effectiveRequestTimeout);
         });
       }
       updateHttpClientConfig(key, value) {
@@ -936,11 +1052,6 @@ var init_node_http2_handler = chunkG7VZBCD6_cjs.__esm({
       httpHandlerConfigs() {
         return this.config ?? {};
       }
-      destroySession(session) {
-        if (!session.destroyed) {
-          session.destroy();
-        }
-      }
     };
   }
 });
@@ -3604,9 +3715,9 @@ var AuditLogger = class {
   }
   async getUserActivity(userId, limit = 50) {
     const key = `${this.prefix}user:${userId}`;
-    const ids = await this.redis.zrange(key, 0, limit - 1);
+    const ids2 = await this.redis.zrange(key, 0, limit - 1);
     const logs = [];
-    for (const id of ids) {
+    for (const id of ids2) {
       const log = await this.get(id);
       if (log) logs.push(log);
     }
@@ -3623,8 +3734,8 @@ var AuditLogger = class {
     let successCount = 0;
     const uniqueUsers = /* @__PURE__ */ new Set();
     for (const key of keys) {
-      const ids = await this.redis.zrange(key, 0, -1);
-      for (const id of ids) {
+      const ids2 = await this.redis.zrange(key, 0, -1);
+      for (const id of ids2) {
         const log = await this.get(id);
         if (log) {
           totalEvents++;
@@ -6591,10 +6702,10 @@ var MediaService = class _MediaService {
     const [updated] = await this.db.update(mediaSchema).set({ ...data, updatedAt: /* @__PURE__ */ new Date() }).where(mediaSchema.id.equals(id)).returning();
     return updated ? this.rowToMedia(updated) : null;
   }
-  async updateMany(ids, data) {
+  async updateMany(ids2, data) {
     const now = this.now();
     if (this.dialect === "sqlite") {
-      for (const id of ids) {
+      for (const id of ids2) {
         const sets = ["updated_at = ?"];
         const p = [now];
         if (data.folder !== void 0) {
@@ -6609,7 +6720,7 @@ var MediaService = class _MediaService {
       }
     } else {
       const { media: mediaSchema } = await (this.dialect === "mysql" ? import('./mysql-media-AI6YK767.cjs') : import('./media-WKP5AOX2.cjs'));
-      for (const id of ids) {
+      for (const id of ids2) {
         await this.db.update(mediaSchema).set({ ...data, updatedAt: /* @__PURE__ */ new Date() }).where(mediaSchema.id.equals(id));
       }
     }
@@ -6722,47 +6833,47 @@ function defineConfig(config) {
 
 Object.defineProperty(exports, "allSettingsGlobals", {
   enumerable: true,
-  get: function () { return chunkKDVDIZ4Y_cjs.allSettingsGlobals; }
+  get: function () { return chunkPNBZZ76A_cjs.allSettingsGlobals; }
 });
 Object.defineProperty(exports, "blogCollections", {
   enumerable: true,
-  get: function () { return chunkKDVDIZ4Y_cjs.blogCollections; }
+  get: function () { return chunkPNBZZ76A_cjs.blogCollections; }
 });
 Object.defineProperty(exports, "blogGlobals", {
   enumerable: true,
-  get: function () { return chunkKDVDIZ4Y_cjs.blogGlobals; }
+  get: function () { return chunkPNBZZ76A_cjs.blogGlobals; }
 });
 Object.defineProperty(exports, "coreSettingsGlobals", {
   enumerable: true,
-  get: function () { return chunkKDVDIZ4Y_cjs.coreSettingsGlobals; }
+  get: function () { return chunkPNBZZ76A_cjs.coreSettingsGlobals; }
 });
 Object.defineProperty(exports, "createTemplateConfig", {
   enumerable: true,
-  get: function () { return chunkKDVDIZ4Y_cjs.createTemplateConfig; }
+  get: function () { return chunkPNBZZ76A_cjs.createTemplateConfig; }
 });
 Object.defineProperty(exports, "ecommerceCollections", {
   enumerable: true,
-  get: function () { return chunkKDVDIZ4Y_cjs.ecommerceCollections; }
+  get: function () { return chunkPNBZZ76A_cjs.ecommerceCollections; }
 });
 Object.defineProperty(exports, "ecommerceGlobals", {
   enumerable: true,
-  get: function () { return chunkKDVDIZ4Y_cjs.ecommerceGlobals; }
+  get: function () { return chunkPNBZZ76A_cjs.ecommerceGlobals; }
 });
 Object.defineProperty(exports, "ecommerceSettingsGlobals", {
   enumerable: true,
-  get: function () { return chunkKDVDIZ4Y_cjs.ecommerceSettingsGlobals; }
+  get: function () { return chunkPNBZZ76A_cjs.ecommerceSettingsGlobals; }
 });
 Object.defineProperty(exports, "kitchenSinkCollections", {
   enumerable: true,
-  get: function () { return chunkKDVDIZ4Y_cjs.kitchenSinkCollections; }
+  get: function () { return chunkPNBZZ76A_cjs.kitchenSinkCollections; }
 });
 Object.defineProperty(exports, "mediaCollections", {
   enumerable: true,
-  get: function () { return chunkKDVDIZ4Y_cjs.mediaCollections; }
+  get: function () { return chunkPNBZZ76A_cjs.mediaCollections; }
 });
 Object.defineProperty(exports, "minimalCollections", {
   enumerable: true,
-  get: function () { return chunkKDVDIZ4Y_cjs.minimalCollections; }
+  get: function () { return chunkPNBZZ76A_cjs.minimalCollections; }
 });
 Object.defineProperty(exports, "RedisAuthAdapter", {
   enumerable: true,