@2112-lab/central-plant 0.2.12 → 0.3.1

package/dist/esm/src/managers/cache/S3MetadataCacheService.js

@@ -0,0 +1,497 @@
+import { createClass as _createClass, classCallCheck as _classCallCheck, asyncToGenerator as _asyncToGenerator, regenerator as _regenerator, toConsumableArray as _toConsumableArray, objectSpread2 as _objectSpread2 } from '../../../_virtual/_rollupPluginBabelHelpers.js';
+import { getCachedJsonData, cacheJsonData, removeCachedJsonData } from './S3CacheService.js';
+
+var CACHE_KEY = 's3-component-metadata';
+var CACHE_VERSION = 1;
+
+/**
+ * Simple mutex implementation for preventing concurrent read-modify-write operations
+ */
+var SimpleMutex = /*#__PURE__*/function () {
+  function SimpleMutex() {
+    _classCallCheck(this, SimpleMutex);
+    this._locked = false;
+    this._queue = [];
+  }
+  return _createClass(SimpleMutex, [{
+    key: "acquire",
+    value: function () {
+      var _acquire = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee() {
+        var _this = this;
+        return _regenerator().w(function (_context) {
+          while (1) switch (_context.n) {
+            case 0:
+              return _context.a(2, new Promise(function (resolve) {
+                if (!_this._locked) {
+                  _this._locked = true;
+                  resolve();
+                } else {
+                  _this._queue.push(resolve);
+                }
+              }));
+          }
+        }, _callee);
+      }));
+      function acquire() {
+        return _acquire.apply(this, arguments);
+      }
+      return acquire;
+    }()
+  }, {
+    key: "release",
+    value: function release() {
+      if (this._queue.length > 0) {
+        var next = this._queue.shift();
+        next();
+      } else {
+        this._locked = false;
+      }
+    }
+  }]);
+}();
+var S3MetadataCacheService = /*#__PURE__*/function () {
+  function S3MetadataCacheService() {
+    _classCallCheck(this, S3MetadataCacheService);
+    this._mutex = new SimpleMutex();
+    this._memoryCache = null;
+    this._memoryCacheTime = 0;
+    this._memoryCacheTTL = 5000; // 5 seconds in-memory cache
+  }
+
+  /**
+   * Create empty metadata structure
+   */
+  return _createClass(S3MetadataCacheService, [{
+    key: "_createEmptyMetadata",
+    value: function _createEmptyMetadata() {
+      return {
+        version: CACHE_VERSION,
+        components: [],
+        timestamp: Date.now()
+      };
+    }
+
+    /**
+     * Validate and migrate metadata if needed
+     */
+  }, {
+    key: "_validateMetadata",
+    value: function _validateMetadata(metadata) {
+      if (!metadata) {
+        return this._createEmptyMetadata();
+      }
+
+      // Ensure components array exists
+      if (!Array.isArray(metadata.components)) {
+        metadata.components = [];
+      }
+
+      // Add version if missing (for legacy cache)
+      if (metadata.version === undefined) {
+        metadata.version = CACHE_VERSION;
+      }
+      return metadata;
+    }
+
+    /**
+     * Check if memory cache is still valid
+     */
+  }, {
+    key: "_isMemoryCacheValid",
+    value: function _isMemoryCacheValid() {
+      return this._memoryCache !== null && Date.now() - this._memoryCacheTime < this._memoryCacheTTL;
+    }
+
+    /**
+     * Invalidate the memory cache
+     */
+  }, {
+    key: "_invalidateMemoryCache",
+    value: function _invalidateMemoryCache() {
+      this._memoryCache = null;
+      this._memoryCacheTime = 0;
+    }
+
+    /**
+     * Get all cached components
+     * @returns {Promise<Array>} Array of cached component metadata
+     */
+  }, {
+    key: "getAll",
+    value: (function () {
+      var _getAll = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee2() {
+        var metadata, validated, _t;
+        return _regenerator().w(function (_context2) {
+          while (1) switch (_context2.n) {
+            case 0:
+              if (!this._isMemoryCacheValid()) {
+                _context2.n = 1;
+                break;
+              }
+              return _context2.a(2, _toConsumableArray(this._memoryCache.components));
+            case 1:
+              _context2.p = 1;
+              _context2.n = 2;
+              return getCachedJsonData(CACHE_KEY);
+            case 2:
+              metadata = _context2.v;
+              validated = this._validateMetadata(metadata); // Update memory cache
+              this._memoryCache = validated;
+              this._memoryCacheTime = Date.now();
+              return _context2.a(2, _toConsumableArray(validated.components));
+            case 3:
+              _context2.p = 3;
+              _t = _context2.v;
+              console.warn('⚠️ S3MetadataCacheService: Failed to get components:', _t);
+              return _context2.a(2, []);
+          }
+        }, _callee2, this, [[1, 3]]);
+      }));
+      function getAll() {
+        return _getAll.apply(this, arguments);
+      }
+      return getAll;
+    }()
+    /**
+     * Get the full metadata object (for advanced use cases)
+     * @returns {Promise<Object>} Full metadata object with version, components, timestamp
+     */
+    )
+  }, {
+    key: "getMetadata",
+    value: (function () {
+      var _getMetadata = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee3() {
+        var metadata, validated, _t2;
+        return _regenerator().w(function (_context3) {
+          while (1) switch (_context3.n) {
+            case 0:
+              if (!this._isMemoryCacheValid()) {
+                _context3.n = 1;
+                break;
+              }
+              return _context3.a(2, _objectSpread2({}, this._memoryCache));
+            case 1:
+              _context3.p = 1;
+              _context3.n = 2;
+              return getCachedJsonData(CACHE_KEY);
+            case 2:
+              metadata = _context3.v;
+              validated = this._validateMetadata(metadata);
+              this._memoryCache = validated;
+              this._memoryCacheTime = Date.now();
+              return _context3.a(2, _objectSpread2({}, validated));
+            case 3:
+              _context3.p = 3;
+              _t2 = _context3.v;
+              console.warn('⚠️ S3MetadataCacheService: Failed to get metadata:', _t2);
+              return _context3.a(2, this._createEmptyMetadata());
+          }
+        }, _callee3, this, [[1, 3]]);
+      }));
+      function getMetadata() {
+        return _getMetadata.apply(this, arguments);
+      }
+      return getMetadata;
+    }()
+    /**
+     * Add or update a component in the cache
+     * Uses mutex to prevent race conditions
+     * @param {Object} component - Component metadata to add/update
+     * @returns {Promise<boolean>} Success status
+     */
+    )
+  }, {
+    key: "addComponent",
+    value: (function () {
+      var _addComponent = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee4(component) {
+        var metadata, validated, existingIndex, _t3;
+        return _regenerator().w(function (_context4) {
+          while (1) switch (_context4.n) {
+            case 0:
+              if (!(!component || !component.id && !component.uuid)) {
+                _context4.n = 1;
+                break;
+              }
+              console.warn('⚠️ S3MetadataCacheService: Cannot add component without id or uuid');
+              return _context4.a(2, false);
+            case 1:
+              _context4.n = 2;
+              return this._mutex.acquire();
+            case 2:
+              _context4.p = 2;
+              _context4.n = 3;
+              return getCachedJsonData(CACHE_KEY);
+            case 3:
+              metadata = _context4.v;
+              validated = this._validateMetadata(metadata); // Remove existing entry if it exists (by id or uuid)
+              existingIndex = validated.components.findIndex(function (c) {
+                return c.id === component.id || c.uuid === component.uuid || component.id && c.uuid === component.id || component.uuid && c.id === component.uuid;
+              });
+              if (existingIndex !== -1) {
+                validated.components.splice(existingIndex, 1);
+              }
+
+              // Add new component
+              validated.components.push(component);
+              validated.timestamp = Date.now();
+
+              // Write back to cache
+              _context4.n = 4;
+              return cacheJsonData(CACHE_KEY, validated);
+            case 4:
+              // Update memory cache
+              this._memoryCache = validated;
+              this._memoryCacheTime = Date.now();
+              console.log("\uD83D\uDCBE S3MetadataCacheService: Added/updated component ".concat(component.name || component.id));
+              return _context4.a(2, true);
+            case 5:
+              _context4.p = 5;
+              _t3 = _context4.v;
+              console.error('❌ S3MetadataCacheService: Failed to add component:', _t3);
+              return _context4.a(2, false);
+            case 6:
+              _context4.p = 6;
+              this._mutex.release();
+              return _context4.f(6);
+            case 7:
+              return _context4.a(2);
+          }
+        }, _callee4, this, [[2, 5, 6, 7]]);
+      }));
+      function addComponent(_x) {
+        return _addComponent.apply(this, arguments);
+      }
+      return addComponent;
+    }()
+    /**
+     * Remove a component from the cache
+     * Uses mutex to prevent race conditions
+     * @param {string} identifier - Component id or uuid to remove
+     * @returns {Promise<boolean>} Success status
+     */
+    )
+  }, {
+    key: "removeComponent",
+    value: (function () {
+      var _removeComponent = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee5(identifier) {
+        var metadata, validated, originalLength, removed, _t4;
+        return _regenerator().w(function (_context5) {
+          while (1) switch (_context5.n) {
+            case 0:
+              if (identifier) {
+                _context5.n = 1;
+                break;
+              }
+              console.warn('⚠️ S3MetadataCacheService: Cannot remove component without identifier');
+              return _context5.a(2, false);
+            case 1:
+              _context5.n = 2;
+              return this._mutex.acquire();
+            case 2:
+              _context5.p = 2;
+              _context5.n = 3;
+              return getCachedJsonData(CACHE_KEY);
+            case 3:
+              metadata = _context5.v;
+              if (!(!metadata || !metadata.components)) {
+                _context5.n = 4;
+                break;
+              }
+              console.log('ℹ️ S3MetadataCacheService: No metadata to remove from');
+              return _context5.a(2, true);
+            case 4:
+              validated = this._validateMetadata(metadata);
+              originalLength = validated.components.length; // Filter out the component by both id and uuid
+              validated.components = validated.components.filter(function (c) {
+                return c.id !== identifier && c.uuid !== identifier;
+              });
+              removed = originalLength !== validated.components.length;
+              if (!removed) {
+                _context5.n = 6;
+                break;
+              }
+              validated.timestamp = Date.now();
+              _context5.n = 5;
+              return cacheJsonData(CACHE_KEY, validated);
+            case 5:
+              // Update memory cache
+              this._memoryCache = validated;
+              this._memoryCacheTime = Date.now();
+              console.log("\uD83D\uDDD1\uFE0F S3MetadataCacheService: Removed component ".concat(identifier));
+            case 6:
+              return _context5.a(2, true);
+            case 7:
+              _context5.p = 7;
+              _t4 = _context5.v;
+              console.error('❌ S3MetadataCacheService: Failed to remove component:', _t4);
+              return _context5.a(2, false);
+            case 8:
+              _context5.p = 8;
+              this._mutex.release();
+              return _context5.f(8);
+            case 9:
+              return _context5.a(2);
+          }
+        }, _callee5, this, [[2, 7, 8, 9]]);
+      }));
+      function removeComponent(_x2) {
+        return _removeComponent.apply(this, arguments);
+      }
+      return removeComponent;
+    }()
+    /**
+     * Clear all cached metadata
+     * @returns {Promise<boolean>} Success status
+     */
+    )
+  }, {
+    key: "clear",
+    value: (function () {
+      var _clear = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee6() {
+        var _t5;
+        return _regenerator().w(function (_context6) {
+          while (1) switch (_context6.n) {
+            case 0:
+              _context6.n = 1;
+              return this._mutex.acquire();
+            case 1:
+              _context6.p = 1;
+              _context6.n = 2;
+              return removeCachedJsonData(CACHE_KEY);
+            case 2:
+              this._invalidateMemoryCache();
+              console.log('🗑️ S3MetadataCacheService: Cleared all metadata');
+              return _context6.a(2, true);
+            case 3:
+              _context6.p = 3;
+              _t5 = _context6.v;
+              console.error('❌ S3MetadataCacheService: Failed to clear metadata:', _t5);
+              return _context6.a(2, false);
+            case 4:
+              _context6.p = 4;
+              this._mutex.release();
+              return _context6.f(4);
+            case 5:
+              return _context6.a(2);
+          }
+        }, _callee6, this, [[1, 3, 4, 5]]);
+      }));
+      function clear() {
+        return _clear.apply(this, arguments);
+      }
+      return clear;
+    }()
+    /**
+     * Check if a component exists in the cache
+     * @param {string} identifier - Component id or uuid
+     * @returns {Promise<boolean>} True if exists
+     */
+    )
+  }, {
+    key: "hasComponent",
+    value: (function () {
+      var _hasComponent = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee7(identifier) {
+        var components;
+        return _regenerator().w(function (_context7) {
+          while (1) switch (_context7.n) {
+            case 0:
+              _context7.n = 1;
+              return this.getAll();
+            case 1:
+              components = _context7.v;
+              return _context7.a(2, components.some(function (c) {
+                return c.id === identifier || c.uuid === identifier;
+              }));
+          }
+        }, _callee7, this);
+      }));
+      function hasComponent(_x3) {
+        return _hasComponent.apply(this, arguments);
+      }
+      return hasComponent;
+    }()
+    /**
+     * Force refresh from persistent cache (bypass memory cache)
+     * @returns {Promise<Array>} Array of cached components
+     */
+    )
+  }, {
+    key: "refresh",
+    value: (function () {
+      var _refresh = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee8() {
+        return _regenerator().w(function (_context8) {
+          while (1) switch (_context8.n) {
+            case 0:
+              this._invalidateMemoryCache();
+              return _context8.a(2, this.getAll());
+          }
+        }, _callee8, this);
+      }));
+      function refresh() {
+        return _refresh.apply(this, arguments);
+      }
+      return refresh;
+    }()
+    /**
+     * Replace all cached components with a new array
+     * Used for bulk operations like initial fetch
+     * @param {Array} components - Array of components to cache
+     * @returns {Promise<boolean>} Success status
+     */
+    )
+  }, {
+    key: "setAll",
+    value: (function () {
+      var _setAll = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee9(components) {
+        var metadata, _t6;
+        return _regenerator().w(function (_context9) {
+          while (1) switch (_context9.n) {
+            case 0:
+              if (Array.isArray(components)) {
+                _context9.n = 1;
+                break;
+              }
+              console.warn('⚠️ S3MetadataCacheService: setAll requires an array');
+              return _context9.a(2, false);
+            case 1:
+              _context9.n = 2;
+              return this._mutex.acquire();
+            case 2:
+              _context9.p = 2;
+              metadata = {
+                version: CACHE_VERSION,
+                components: components,
+                timestamp: Date.now()
+              };
+              _context9.n = 3;
+              return cacheJsonData(CACHE_KEY, metadata);
+            case 3:
+              // Update memory cache
+              this._memoryCache = metadata;
+              this._memoryCacheTime = Date.now();
+              console.log("\uD83D\uDCBE S3MetadataCacheService: Set ".concat(components.length, " components"));
+              return _context9.a(2, true);
+            case 4:
+              _context9.p = 4;
+              _t6 = _context9.v;
+              console.error('❌ S3MetadataCacheService: Failed to set components:', _t6);
+              return _context9.a(2, false);
+            case 5:
+              _context9.p = 5;
+              this._mutex.release();
+              return _context9.f(5);
+            case 6:
+              return _context9.a(2);
+          }
+        }, _callee9, this, [[2, 4, 5, 6]]);
+      }));
+      function setAll(_x4) {
+        return _setAll.apply(this, arguments);
+      }
+      return setAll;
+    }())
+  }]);
+}(); // Export singleton instance
+var s3MetadataCache = new S3MetadataCacheService();
+
+export { S3MetadataCacheService, s3MetadataCache };

package/dist/esm/src/managers/cache/s3Timing.js

@@ -0,0 +1,120 @@
+import { asyncToGenerator as _asyncToGenerator, regenerator as _regenerator } from '../../../_virtual/_rollupPluginBabelHelpers.js';
+import { cacheManager } from './CacheManager.js';
+
+/**
+ * Retrieve the injected Auth instance from cacheManager config.
+ * Falls back gracefully if not configured (skip credential refresh).
+ */
+function getAuth() {
+  return cacheManager.config.auth || null;
+}
+
+/**
+ * Measure S3 operation time and log results
+ * @param {string} operation - Operation name (e.g., "Upload GLB", "Download JSON")
+ * @param {Function} asyncFn - Async function to measure
+ * @param {number} fileSize - Optional file size in bytes for speed calculation
+ * @returns {Promise} - Result from asyncFn
+ */
+function measureS3Transfer(_x, _x2) {
+  return _measureS3Transfer.apply(this, arguments);
+}
+function _measureS3Transfer() {
+  _measureS3Transfer = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee2(operation, asyncFn) {
+    var fileSize,
+      startTime,
+      executeTransfer,
+      Auth,
+      endTime,
+      duration,
+      _args2 = arguments,
+      _t,
+      _t2;
+    return _regenerator().w(function (_context2) {
+      while (1) switch (_context2.n) {
+        case 0:
+          fileSize = _args2.length > 2 && _args2[2] !== undefined ? _args2[2] : null;
+          startTime = performance.now();
+          executeTransfer = /*#__PURE__*/function () {
+            var _ref = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee() {
+              var result, endTime, duration, logMessage, sizeMB, speedMBps;
+              return _regenerator().w(function (_context) {
+                while (1) switch (_context.n) {
+                  case 0:
+                    _context.n = 1;
+                    return asyncFn();
+                  case 1:
+                    result = _context.v;
+                    endTime = performance.now();
+                    duration = ((endTime - startTime) / 1000).toFixed(3); // Convert to seconds
+                    logMessage = "\u23F1\uFE0F S3 ".concat(operation, ": ").concat(duration, "s");
+                    if (fileSize) {
+                      sizeMB = (fileSize / (1024 * 1024)).toFixed(2);
+                      speedMBps = (sizeMB / duration).toFixed(2);
+                      logMessage += " (".concat(sizeMB, " MB @ ").concat(speedMBps, " MB/s)");
+                    }
+                    console.log(logMessage);
+                    return _context.a(2, result);
+                }
+              }, _callee);
+            }));
+            return function executeTransfer() {
+              return _ref.apply(this, arguments);
+            };
+          }();
+          _context2.p = 1;
+          _context2.n = 2;
+          return executeTransfer();
+        case 2:
+          return _context2.a(2, _context2.v);
+        case 3:
+          _context2.p = 3;
+          _t = _context2.v;
+          if (!(_t.code === 'ExpiredToken' || _t.message && _t.message.includes('ExpiredToken'))) {
+            _context2.n = 8;
+            break;
+          }
+          console.warn("\u26A0\uFE0F Token expired during ".concat(operation, ". Attempting session refresh and retry..."));
+          Auth = getAuth();
+          if (Auth) {
+            _context2.n = 4;
+            break;
+          }
+          console.error("\u274C Cannot refresh credentials: Auth not injected via cacheManager.configure({ auth })");
+          throw _t;
+        case 4:
+          _context2.p = 4;
+          _context2.n = 5;
+          return Auth.currentCredentials({
+            bypassCache: true
+          });
+        case 5:
+          console.log("\u2705 Session refreshed. Retrying ".concat(operation, "..."));
+
+          // Reset timer for the retry
+          startTime = performance.now();
+          _context2.n = 6;
+          return executeTransfer();
+        case 6:
+          return _context2.a(2, _context2.v);
+        case 7:
+          _context2.p = 7;
+          _t2 = _context2.v;
+          console.error("\u274C Retry failed for ".concat(operation, ":"), _t2);
+          // If retry fails, throw the Retry Error (likely unrelated or persistent auth issue)
+          throw _t2;
+        case 8:
+          // Standard error handling for non-expired tokens (or if logic above didn't catch it)
+          endTime = performance.now();
+          duration = ((endTime - startTime) / 1000).toFixed(3);
+          console.error("\u274C S3 ".concat(operation, " failed after ").concat(duration, "s:"), _t);
+          throw _t;
+        case 9:
+          return _context2.a(2);
+      }
+    }, _callee2, null, [[4, 7], [1, 3]]);
+  }));
+  return _measureS3Transfer.apply(this, arguments);
+}
+
+export { measureS3Transfer };