@dereekb/calcom 13.10.9 → 13.11.1

package/nestjs/index.cjs.js

@@ -3,19 +3,18 @@
 var common = require('@nestjs/common');
 var calcom = require('@dereekb/calcom');
 var util = require('@dereekb/util');
+var nestjs = require('@dereekb/nestjs');
 var node_crypto = require('node:crypto');
 var node_path = require('node:path');
-var node_fs = require('node:fs');
 var config = require('@nestjs/config');
-var nestjs = require('@dereekb/nestjs');
 
-function _type_of(obj) {
+function _type_of$1(obj) {
     "@swc/helpers - typeof";
     return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
 }
 function __decorate(decorators, target, key, desc) {
     var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if ((typeof Reflect === "undefined" ? "undefined" : _type_of(Reflect)) === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    if ((typeof Reflect === "undefined" ? "undefined" : _type_of$1(Reflect)) === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
     else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 }
@@ -47,7 +46,7 @@ function _create_class$6(Constructor, protoProps, staticProps) {
     if (staticProps) _defineProperties$6(Constructor, staticProps);
     return Constructor;
 }
-function _define_property$7(obj, key, value) {
+function _define_property$8(obj, key, value) {
     if (key in obj) {
         Object.defineProperty(obj, key, {
             value: value,
@@ -70,8 +69,8 @@ var CALCOM_API_KEY_CONFIG_KEY = 'CALCOM_API_KEY';
  */ var CalcomOAuthServiceConfig = /*#__PURE__*/ function() {
     function CalcomOAuthServiceConfig() {
         _class_call_check$8(this, CalcomOAuthServiceConfig);
-        _define_property$7(this, "calcomOAuth", void 0);
-        _define_property$7(this, "factoryConfig", void 0);
+        _define_property$8(this, "calcomOAuth", void 0);
+        _define_property$8(this, "factoryConfig", void 0);
     }
     _create_class$6(CalcomOAuthServiceConfig, null, [
         {
@@ -158,6 +157,27 @@ function _class_call_check$7(instance, Constructor) {
         throw new TypeError("Cannot call a class as a function");
     }
 }
+function _define_property$7(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _instanceof(left, right) {
+    "@swc/helpers - instanceof";
+    if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
+        return !!right[Symbol.hasInstance](left);
+    } else {
+        return left instanceof right;
+    }
+}
 function _iterable_to_array$3(iter) {
     if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
 }
@@ -191,12 +211,50 @@ function _non_iterable_rest() {
 function _non_iterable_spread$3() {
     throw new TypeError("Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
 }
+function _object_spread$2(target) {
+    for(var i = 1; i < arguments.length; i++){
+        var source = arguments[i] != null ? arguments[i] : {};
+        var ownKeys = Object.keys(source);
+        if (typeof Object.getOwnPropertySymbols === "function") {
+            ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(source, sym).enumerable;
+            }));
+        }
+        ownKeys.forEach(function(key) {
+            _define_property$7(target, key, source[key]);
+        });
+    }
+    return target;
+}
+function ownKeys$2(object, enumerableOnly) {
+    var keys = Object.keys(object);
+    if (Object.getOwnPropertySymbols) {
+        var symbols = Object.getOwnPropertySymbols(object);
+        keys.push.apply(keys, symbols);
+    }
+    return keys;
+}
+function _object_spread_props$2(target, source) {
+    source = source != null ? source : {};
+    if (Object.getOwnPropertyDescriptors) {
+        Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
+    } else {
+        ownKeys$2(Object(source)).forEach(function(key) {
+            Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+        });
+    }
+    return target;
+}
 function _sliced_to_array(arr, i) {
     return _array_with_holes(arr) || _iterable_to_array_limit(arr, i) || _unsupported_iterable_to_array$3(arr, i) || _non_iterable_rest();
 }
 function _to_consumable_array$3(arr) {
     return _array_without_holes$3(arr) || _iterable_to_array$3(arr) || _unsupported_iterable_to_array$3(arr) || _non_iterable_spread$3();
 }
+function _type_of(obj) {
+    "@swc/helpers - typeof";
+    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+}
 function _unsupported_iterable_to_array$3(o, minLen) {
     if (!o) return;
     if (typeof o === "string") return _array_like_to_array$3(o, minLen);
@@ -326,6 +384,56 @@ exports.CalcomOAuthAccessTokenCacheService = __decorate([
  */ function calcomRefreshTokenCacheKey(refreshToken) {
     return node_crypto.createHash('sha256').update(refreshToken).digest('hex').substring(0, 16);
 }
+// MARK: Merge
+function buildCalcomReadAdapter(cache) {
+    return {
+        load: function load() {
+            return _async_to_generator$2(function() {
+                var value;
+                return _ts_generator$2(this, function(_state) {
+                    switch(_state.label){
+                        case 0:
+                            return [
+                                4,
+                                cache.loadCachedToken().catch(function() {
+                                    return undefined;
+                                })
+                            ];
+                        case 1:
+                            value = _state.sent();
+                            return [
+                                2,
+                                value != null && !util.isExpired(value) ? value : undefined
+                            ];
+                    }
+                });
+            })();
+        },
+        update: function update(token) {
+            return cache.updateCachedToken(token);
+        },
+        clear: function clear() {
+            return _async_to_generator$2(function() {
+                return _ts_generator$2(this, function(_state) {
+                    return [
+                        2
+                    ];
+                });
+            // CalcomAccessTokenCache does not expose a clear method.
+            })();
+        }
+    };
+}
+function updateCalcomCacheCapturingError(cache, accessToken) {
+    return cache.updateCachedToken(accessToken).then(function() {
+        return null;
+    }).catch(function(e) {
+        return [
+            cache,
+            e
+        ];
+    });
+}
 /**
  * Default error logging function for {@link mergeCalcomOAuthAccessTokenCacheServices}.
  * Logs a warning for each cache that failed to update.
@@ -344,6 +452,11 @@ exports.CalcomOAuthAccessTokenCacheService = __decorate([
  * If one source fails retrieval, the next will be tried.
  * When updating a cached token, it will update the token across all services.
  *
+ * Read fall-through is delegated to {@link mergeAsyncValueCaches} after wrapping each
+ * underlying cache with an {@link isExpired}-aware filter, so an expired cached token
+ * never short-circuits the lookup. Updates run across all services in parallel via
+ * `Promise.allSettled`, mirroring the previous behavior, with optional error logging.
+ *
  * @param inputServicesToMerge Must include at least one service. Empty arrays will throw an error.
  * @param logError - optional error logging configuration; pass a function, true for default logging, or false to disable
  * @returns a merged CalcomOAuthAccessTokenCacheService that delegates across all input services
@@ -353,60 +466,44 @@ exports.CalcomOAuthAccessTokenCacheService = __decorate([
     if (allServices.length === 0) {
         throw new Error('mergeCalcomOAuthAccessTokenCacheServices() input cannot be empty.');
     }
-    var loadCalcomAccessTokenCache = function loadCalcomAccessTokenCache(accessCachesForServices) {
-        var loadCachedTokenFromFirstService = util.tryWithPromiseFactoriesFunction({
-            promiseFactories: accessCachesForServices.map(function(x) {
-                return function() {
-                    return x.loadCachedToken().catch(function() {
-                        return null;
-                    }).then(function(x) {
-                        var result = undefined;
-                        if (x && !util.isPast(x.expiresAt)) {
-                            result = x; // only return from cache if it is not expired
-                        }
-                        return result;
-                    });
-                };
-            }),
-            successOnMaybe: false,
-            throwErrors: false
-        });
-        var cacheForService = {
+    function mergeCachesForService(accessCachesForServices) {
+        var readAdapters = accessCachesForServices.map(buildCalcomReadAdapter);
+        var merged = util.mergeAsyncValueCaches(readAdapters);
+        return {
             loadCachedToken: function loadCachedToken() {
-                return loadCachedTokenFromFirstService();
+                return merged.load();
             },
             updateCachedToken: function updateCachedToken(accessToken) {
                 return _async_to_generator$2(function() {
+                    var settled, failedUpdates;
                     return _ts_generator$2(this, function(_state) {
-                        return [
-                            2,
-                            Promise.allSettled(accessCachesForServices.map(function(x) {
-                                return x.updateCachedToken(accessToken).then(function() {
-                                    return null;
-                                }).catch(function(e) {
-                                    return [
-                                        x,
-                                        e
-                                    ];
-                                });
-                            })).then(function(x) {
-                                // only find the failures if we're logging
+                        switch(_state.label){
+                            case 0:
+                                return [
+                                    4,
+                                    Promise.allSettled(accessCachesForServices.map(function(cache) {
+                                        return updateCalcomCacheCapturingError(cache, accessToken);
+                                    }))
+                                ];
+                            case 1:
+                                settled = _state.sent();
                                 if (logErrorFunction != null) {
-                                    var failedUpdates = util.filterMaybeArrayValues(x.map(function(y) {
+                                    failedUpdates = util.filterMaybeArrayValues(settled.map(function(y) {
                                         return y.value;
                                     }));
                                     if (failedUpdates.length) {
                                         logErrorFunction(failedUpdates);
                                     }
                                 }
-                            })
-                        ];
+                                return [
+                                    2
+                                ];
+                        }
                     });
                 })();
             }
         };
-        return cacheForService;
-    };
+    }
     var allServiceAccessTokenCaches = allServices.map(function(x) {
         return x.loadCalcomAccessTokenCache();
     });
@@ -417,206 +514,204 @@ exports.CalcomOAuthAccessTokenCacheService = __decorate([
         var allCaches = allServicesWithCacheForRefreshToken.map(function(x) {
             return x.cacheForRefreshToken(refreshToken);
         });
-        return loadCalcomAccessTokenCache(allCaches);
+        return mergeCachesForService(allCaches);
     } : undefined;
     var service = {
-        loadCalcomAccessTokenCache: function loadCalcomAccessTokenCache1() {
-            return loadCalcomAccessTokenCache(allServiceAccessTokenCaches);
+        loadCalcomAccessTokenCache: function loadCalcomAccessTokenCache() {
+            return mergeCachesForService(allServiceAccessTokenCaches);
         },
         cacheForRefreshToken: cacheForRefreshToken
     };
     return service;
 }
 // MARK: Memory Access Token Cache
+/**
+ * Adapts an {@link AsyncValueCache} to a {@link CalcomAccessTokenCache}, optionally logging cache reads/writes to the console.
+ *
+ * @param cache - underlying single-value cache for the access token
+ * @param logAccessToConsole - when true, logs reads and writes to the console
+ * @returns the CalcomAccessTokenCache backed by the given async cache
+ */ function calcomAccessTokenCacheFromAsyncValueCache(cache, logAccessToConsole) {
+    return {
+        loadCachedToken: function loadCachedToken() {
+            return _async_to_generator$2(function() {
+                var token;
+                return _ts_generator$2(this, function(_state) {
+                    switch(_state.label){
+                        case 0:
+                            return [
+                                4,
+                                cache.load()
+                            ];
+                        case 1:
+                            token = _state.sent();
+                            if (logAccessToConsole) {
+                                console.log('retrieving access token from memory: ', {
+                                    hit: token != null,
+                                    expiresAt: token === null || token === void 0 ? void 0 : token.expiresAt
+                                });
+                            }
+                            return [
+                                2,
+                                token
+                            ];
+                    }
+                });
+            })();
+        },
+        updateCachedToken: function updateCachedToken(accessToken) {
+            return _async_to_generator$2(function() {
+                return _ts_generator$2(this, function(_state) {
+                    switch(_state.label){
+                        case 0:
+                            return [
+                                4,
+                                cache.update(accessToken)
+                            ];
+                        case 1:
+                            _state.sent();
+                            if (logAccessToConsole) {
+                                console.log('updating access token in memory: ', {
+                                    expiresAt: accessToken === null || accessToken === void 0 ? void 0 : accessToken.expiresAt
+                                });
+                            }
+                            return [
+                                2
+                            ];
+                    }
+                });
+            })();
+        }
+    };
+}
 /**
  * Creates a CalcomOAuthAccessTokenCacheService that uses in-memory storage.
- * Per-user caches are stored in a Map keyed by the md5 hash of the refresh token.
+ *
+ * The server-level token is held in a single-slot {@link inMemoryAsyncValueCache};
+ * per-user tokens are held in an {@link inMemoryAsyncKeyedValueCache} keyed by the
+ * sha256-truncated refresh token hash.
  *
  * @param existingToken - optional pre-existing server-level access token to seed the cache
  * @param logAccessToConsole - when true, logs all cache reads and writes to console
- * @returns a CalcomOAuthAccessTokenCacheService backed by in-memory Maps
+ * @returns a CalcomOAuthAccessTokenCacheService backed by in-memory caches
  */ function memoryCalcomOAuthAccessTokenCacheService(existingToken, logAccessToConsole) {
-    var serverToken = existingToken;
-    var userTokens = new Map();
-    function makeCache(getToken, setToken) {
+    var serverCache = util.inMemoryAsyncValueCache(existingToken);
+    var userCache = util.inMemoryAsyncKeyedValueCache();
+    function userCacheView(key) {
         return {
-            loadCachedToken: function loadCachedToken() {
-                return _async_to_generator$2(function() {
-                    var token;
-                    return _ts_generator$2(this, function(_state) {
-                        token = getToken();
-                        if (logAccessToConsole) {
-                            console.log('retrieving access token from memory: ', {
-                                token: token
-                            });
-                        }
-                        return [
-                            2,
-                            token
-                        ];
-                    });
-                })();
+            load: function load() {
+                return userCache.get(key);
             },
-            updateCachedToken: function updateCachedToken(accessToken) {
-                return _async_to_generator$2(function() {
-                    return _ts_generator$2(this, function(_state) {
-                        setToken(accessToken);
-                        if (logAccessToConsole) {
-                            console.log('updating access token in memory: ', {
-                                accessToken: accessToken
-                            });
-                        }
-                        return [
-                            2
-                        ];
-                    });
-                })();
+            update: function update(token) {
+                return userCache.set(key, token);
+            },
+            clear: function clear() {
+                return userCache.remove(key);
             }
         };
     }
     return {
         loadCalcomAccessTokenCache: function loadCalcomAccessTokenCache() {
-            return makeCache(function() {
-                return serverToken;
-            }, function(t) {
-                serverToken = t;
-            });
+            return calcomAccessTokenCacheFromAsyncValueCache(serverCache, logAccessToConsole);
         },
         cacheForRefreshToken: function cacheForRefreshToken(refreshToken) {
             var key = calcomRefreshTokenCacheKey(refreshToken);
-            return makeCache(function() {
-                return userTokens.get(key);
-            }, function(t) {
-                return userTokens.set(key, t);
-            });
+            return calcomAccessTokenCacheFromAsyncValueCache(userCacheView(key), logAccessToConsole);
         }
     };
 }
 // MARK: File System Access Token Cache
 var DEFAULT_FILE_CALCOM_ACCESS_TOKEN_CACHE_DIR = '.tmp/calcom-tokens';
 var CALCOM_SERVER_TOKEN_FILE_KEY = 'server';
+/**
+ * Reviver applied to the cached file payload on load so `expiresAt` is always a `Date`
+ * regardless of how it was serialized.
+ *
+ * @param raw - the raw JSON-parsed file payload
+ * @returns the revived CalcomAccessToken, or undefined when the payload is empty/invalid
+ */ function reviveCalcomAccessTokenFile(raw) {
+    if (raw == null || (typeof raw === "undefined" ? "undefined" : _type_of(raw)) !== 'object') {
+        return undefined;
+    }
+    var wrapper = raw;
+    var token = wrapper.token;
+    if (token == null) {
+        return undefined;
+    }
+    var rawExpiresAt = token.expiresAt;
+    var expiresAt = rawExpiresAt != null && !_instanceof(rawExpiresAt, Date) ? new Date(rawExpiresAt) : rawExpiresAt;
+    return _object_spread_props$2(_object_spread$2({}, token), {
+        expiresAt: expiresAt
+    });
+}
 /**
  * Creates a CalcomOAuthAccessTokenCacheService that reads and writes access tokens
- * to the file system. Each user gets their own file, keyed by an md5 hash of their refresh token.
+ * to the file system. Each user gets their own file, keyed by an sha256 hash of their refresh token.
+ *
+ * Backed by {@link createMemoizedJsonFileAsyncValueCache} for each key, so reads after
+ * the first hit memory.
  *
  * File structure:
  * ```
  * <cacheDir>/
  *   server.json              — server-level token
- *   user-<md5hash>.json      — per-user tokens (hash of initial refresh token)
+ *   user-<sha256hash>.json   — per-user tokens (hash of initial refresh token)
  * ```
  *
  * @param cacheDir Directory to store token files. Defaults to `.tmp/calcom-tokens`.
  * @returns a CalcomOAuthAccessTokenCacheService backed by the file system
  */ function fileCalcomOAuthAccessTokenCacheService() {
     var cacheDir = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : DEFAULT_FILE_CALCOM_ACCESS_TOKEN_CACHE_DIR;
-    var memoryTokens = new Map();
-    function filePathForKey(key) {
-        return node_path.join(cacheDir, "".concat(key, ".json"));
-    }
-    function readTokenFile(filePath) {
-        return new Promise(function(resolve) {
-            node_fs.mkdirSync(node_path.dirname(filePath), {
-                recursive: true
-            });
-            node_fs.readFile(filePath, {}, function(err, data) {
-                var result = undefined;
-                if (!err) {
-                    try {
-                        result = JSON.parse(data.toString());
-                        if (result === null || result === void 0 ? void 0 : result.token) {
-                            result.token.expiresAt = new Date(result.token.expiresAt);
-                        }
-                    } catch (e) {
-                        console.error("Failed reading token file ".concat(filePath, ": "), e);
-                    }
-                }
-                resolve(result);
-            });
-        });
-    }
-    function writeTokenFile(filePath, content) {
-        return new Promise(function(resolve, reject) {
-            node_fs.mkdirSync(node_path.dirname(filePath), {
-                recursive: true
-            });
-            node_fs.writeFile(filePath, JSON.stringify(content, null, 2), {}, function(err) {
-                if (!err) {
-                    resolve();
-                } else {
-                    reject(err);
+    var cachesByKey = new Map();
+    function cacheForKey(fileKey) {
+        var cache = cachesByKey.get(fileKey);
+        if (cache == null) {
+            cache = nestjs.createMemoizedJsonFileAsyncValueCache({
+                filePath: node_path.join(cacheDir, "".concat(fileKey, ".json")),
+                reviver: reviveCalcomAccessTokenFile,
+                replacer: function replacer(token) {
+                    return {
+                        token: token
+                    };
                 }
             });
-        });
+            cachesByKey.set(fileKey, cache);
+        }
+        return cache;
     }
     function makeCacheForKey(fileKey) {
-        var filePath = filePathForKey(fileKey);
+        var cache = cacheForKey(fileKey);
         return {
             loadCachedToken: function loadCachedToken() {
-                return _async_to_generator$2(function() {
-                    var memoryEntry, fileContent;
-                    return _ts_generator$2(this, function(_state) {
-                        switch(_state.label){
-                            case 0:
-                                // Check memory first
-                                memoryEntry = memoryTokens.get(fileKey);
-                                if (memoryEntry !== undefined) {
-                                    return [
-                                        2,
-                                        memoryEntry === null || memoryEntry === void 0 ? void 0 : memoryEntry.token
-                                    ];
-                                }
-                                return [
-                                    4,
-                                    readTokenFile(filePath)
-                                ];
-                            case 1:
-                                fileContent = _state.sent();
-                                memoryTokens.set(fileKey, fileContent !== null && fileContent !== void 0 ? fileContent : null);
-                                return [
-                                    2,
-                                    fileContent === null || fileContent === void 0 ? void 0 : fileContent.token
-                                ];
-                        }
-                    });
-                })();
+                return cache.load();
             },
             updateCachedToken: function updateCachedToken(accessToken) {
                 return _async_to_generator$2(function() {
-                    var content, e;
+                    var e;
                     return _ts_generator$2(this, function(_state) {
                         switch(_state.label){
                             case 0:
-                                content = {
-                                    token: accessToken
-                                };
-                                memoryTokens.set(fileKey, content);
-                                _state.label = 1;
-                            case 1:
                                 _state.trys.push([
-                                    1,
-                                    3,
+                                    0,
+                                    2,
                                     ,
-                                    4
+                                    3
                                 ]);
                                 return [
                                     4,
-                                    writeTokenFile(filePath, content)
+                                    cache.update(accessToken)
                                 ];
-                            case 2:
+                            case 1:
                                 _state.sent();
                                 return [
                                     3,
-                                    4
+                                    3
                                 ];
-                            case 3:
+                            case 2:
                                 e = _state.sent();
-                                console.error("Failed updating token file ".concat(filePath, ": "), e);
-                                return [
-                                    3,
-                                    4
-                                ];
-                            case 4:
+                                console.error("Failed updating token file for ".concat(fileKey, ": "), e);
+                                throw e;
+                            case 3:
                                 return [
                                     2
                                 ];

package/nestjs/index.esm.js

@@ -1,19 +1,18 @@
 import { Injectable, Inject, Logger, Post, Res, Req, Controller, Module } from '@nestjs/common';
 import { calcomOAuthFactory, exchangeAuthorizationCode, calcomFactory, getMe, getSchedules, createBooking, getBooking, cancelBooking, getEventTypes, createEventType, updateEventType, deleteEventType, getCalendars, getBusyTimes, createWebhook, getWebhooks, getWebhook, updateWebhook, deleteWebhook, getAvailableSlots } from '@dereekb/calcom';
-import { tryWithPromiseFactoriesFunction, isPast, filterMaybeArrayValues, cachedGetter, handlerFactory, handlerConfigurerFactory, handlerMappedSetFunctionFactory } from '@dereekb/util';
+import { inMemoryAsyncValueCache, inMemoryAsyncKeyedValueCache, mergeAsyncValueCaches, isExpired, filterMaybeArrayValues, cachedGetter, handlerFactory, handlerConfigurerFactory, handlerMappedSetFunctionFactory } from '@dereekb/util';
+import { createMemoizedJsonFileAsyncValueCache, RawBody } from '@dereekb/nestjs';
 import { createHash, createHmac } from 'node:crypto';
-import { join, dirname } from 'node:path';
-import { mkdirSync, writeFile, readFile } from 'node:fs';
+import { join } from 'node:path';
 import { ConfigService, ConfigModule } from '@nestjs/config';
-import { RawBody } from '@dereekb/nestjs';
 
-function _type_of(obj) {
+function _type_of$1(obj) {
     "@swc/helpers - typeof";
     return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
 }
 function __decorate(decorators, target, key, desc) {
     var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if ((typeof Reflect === "undefined" ? "undefined" : _type_of(Reflect)) === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    if ((typeof Reflect === "undefined" ? "undefined" : _type_of$1(Reflect)) === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
     else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 }
@@ -45,7 +44,7 @@ function _create_class$6(Constructor, protoProps, staticProps) {
     if (staticProps) _defineProperties$6(Constructor, staticProps);
     return Constructor;
 }
-function _define_property$7(obj, key, value) {
+function _define_property$8(obj, key, value) {
     if (key in obj) {
         Object.defineProperty(obj, key, {
             value: value,
@@ -68,8 +67,8 @@ var CALCOM_API_KEY_CONFIG_KEY = 'CALCOM_API_KEY';
  */ var CalcomOAuthServiceConfig = /*#__PURE__*/ function() {
     function CalcomOAuthServiceConfig() {
         _class_call_check$8(this, CalcomOAuthServiceConfig);
-        _define_property$7(this, "calcomOAuth", void 0);
-        _define_property$7(this, "factoryConfig", void 0);
+        _define_property$8(this, "calcomOAuth", void 0);
+        _define_property$8(this, "factoryConfig", void 0);
     }
     _create_class$6(CalcomOAuthServiceConfig, null, [
         {
@@ -156,6 +155,27 @@ function _class_call_check$7(instance, Constructor) {
         throw new TypeError("Cannot call a class as a function");
     }
 }
+function _define_property$7(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _instanceof(left, right) {
+    "@swc/helpers - instanceof";
+    if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
+        return !!right[Symbol.hasInstance](left);
+    } else {
+        return left instanceof right;
+    }
+}
 function _iterable_to_array$3(iter) {
     if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
 }
@@ -189,12 +209,50 @@ function _non_iterable_rest() {
 function _non_iterable_spread$3() {
     throw new TypeError("Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
 }
+function _object_spread$2(target) {
+    for(var i = 1; i < arguments.length; i++){
+        var source = arguments[i] != null ? arguments[i] : {};
+        var ownKeys = Object.keys(source);
+        if (typeof Object.getOwnPropertySymbols === "function") {
+            ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(source, sym).enumerable;
+            }));
+        }
+        ownKeys.forEach(function(key) {
+            _define_property$7(target, key, source[key]);
+        });
+    }
+    return target;
+}
+function ownKeys$2(object, enumerableOnly) {
+    var keys = Object.keys(object);
+    if (Object.getOwnPropertySymbols) {
+        var symbols = Object.getOwnPropertySymbols(object);
+        keys.push.apply(keys, symbols);
+    }
+    return keys;
+}
+function _object_spread_props$2(target, source) {
+    source = source != null ? source : {};
+    if (Object.getOwnPropertyDescriptors) {
+        Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
+    } else {
+        ownKeys$2(Object(source)).forEach(function(key) {
+            Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+        });
+    }
+    return target;
+}
 function _sliced_to_array(arr, i) {
     return _array_with_holes(arr) || _iterable_to_array_limit(arr, i) || _unsupported_iterable_to_array$3(arr, i) || _non_iterable_rest();
 }
 function _to_consumable_array$3(arr) {
     return _array_without_holes$3(arr) || _iterable_to_array$3(arr) || _unsupported_iterable_to_array$3(arr) || _non_iterable_spread$3();
 }
+function _type_of(obj) {
+    "@swc/helpers - typeof";
+    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+}
 function _unsupported_iterable_to_array$3(o, minLen) {
     if (!o) return;
     if (typeof o === "string") return _array_like_to_array$3(o, minLen);
@@ -324,6 +382,56 @@ CalcomOAuthAccessTokenCacheService = __decorate([
  */ function calcomRefreshTokenCacheKey(refreshToken) {
     return createHash('sha256').update(refreshToken).digest('hex').substring(0, 16);
 }
+// MARK: Merge
+function buildCalcomReadAdapter(cache) {
+    return {
+        load: function load() {
+            return _async_to_generator$2(function() {
+                var value;
+                return _ts_generator$2(this, function(_state) {
+                    switch(_state.label){
+                        case 0:
+                            return [
+                                4,
+                                cache.loadCachedToken().catch(function() {
+                                    return undefined;
+                                })
+                            ];
+                        case 1:
+                            value = _state.sent();
+                            return [
+                                2,
+                                value != null && !isExpired(value) ? value : undefined
+                            ];
+                    }
+                });
+            })();
+        },
+        update: function update(token) {
+            return cache.updateCachedToken(token);
+        },
+        clear: function clear() {
+            return _async_to_generator$2(function() {
+                return _ts_generator$2(this, function(_state) {
+                    return [
+                        2
+                    ];
+                });
+            // CalcomAccessTokenCache does not expose a clear method.
+            })();
+        }
+    };
+}
+function updateCalcomCacheCapturingError(cache, accessToken) {
+    return cache.updateCachedToken(accessToken).then(function() {
+        return null;
+    }).catch(function(e) {
+        return [
+            cache,
+            e
+        ];
+    });
+}
 /**
  * Default error logging function for {@link mergeCalcomOAuthAccessTokenCacheServices}.
  * Logs a warning for each cache that failed to update.
@@ -342,6 +450,11 @@ CalcomOAuthAccessTokenCacheService = __decorate([
  * If one source fails retrieval, the next will be tried.
  * When updating a cached token, it will update the token across all services.
  *
+ * Read fall-through is delegated to {@link mergeAsyncValueCaches} after wrapping each
+ * underlying cache with an {@link isExpired}-aware filter, so an expired cached token
+ * never short-circuits the lookup. Updates run across all services in parallel via
+ * `Promise.allSettled`, mirroring the previous behavior, with optional error logging.
+ *
  * @param inputServicesToMerge Must include at least one service. Empty arrays will throw an error.
  * @param logError - optional error logging configuration; pass a function, true for default logging, or false to disable
  * @returns a merged CalcomOAuthAccessTokenCacheService that delegates across all input services
@@ -351,60 +464,44 @@ CalcomOAuthAccessTokenCacheService = __decorate([
     if (allServices.length === 0) {
         throw new Error('mergeCalcomOAuthAccessTokenCacheServices() input cannot be empty.');
     }
-    var loadCalcomAccessTokenCache = function loadCalcomAccessTokenCache(accessCachesForServices) {
-        var loadCachedTokenFromFirstService = tryWithPromiseFactoriesFunction({
-            promiseFactories: accessCachesForServices.map(function(x) {
-                return function() {
-                    return x.loadCachedToken().catch(function() {
-                        return null;
-                    }).then(function(x) {
-                        var result = undefined;
-                        if (x && !isPast(x.expiresAt)) {
-                            result = x; // only return from cache if it is not expired
-                        }
-                        return result;
-                    });
-                };
-            }),
-            successOnMaybe: false,
-            throwErrors: false
-        });
-        var cacheForService = {
+    function mergeCachesForService(accessCachesForServices) {
+        var readAdapters = accessCachesForServices.map(buildCalcomReadAdapter);
+        var merged = mergeAsyncValueCaches(readAdapters);
+        return {
             loadCachedToken: function loadCachedToken() {
-                return loadCachedTokenFromFirstService();
+                return merged.load();
             },
             updateCachedToken: function updateCachedToken(accessToken) {
                 return _async_to_generator$2(function() {
+                    var settled, failedUpdates;
                     return _ts_generator$2(this, function(_state) {
-                        return [
-                            2,
-                            Promise.allSettled(accessCachesForServices.map(function(x) {
-                                return x.updateCachedToken(accessToken).then(function() {
-                                    return null;
-                                }).catch(function(e) {
-                                    return [
-                                        x,
-                                        e
-                                    ];
-                                });
-                            })).then(function(x) {
-                                // only find the failures if we're logging
+                        switch(_state.label){
+                            case 0:
+                                return [
+                                    4,
+                                    Promise.allSettled(accessCachesForServices.map(function(cache) {
+                                        return updateCalcomCacheCapturingError(cache, accessToken);
+                                    }))
+                                ];
+                            case 1:
+                                settled = _state.sent();
                                 if (logErrorFunction != null) {
-                                    var failedUpdates = filterMaybeArrayValues(x.map(function(y) {
+                                    failedUpdates = filterMaybeArrayValues(settled.map(function(y) {
                                         return y.value;
                                     }));
                                     if (failedUpdates.length) {
                                         logErrorFunction(failedUpdates);
                                     }
                                 }
-                            })
-                        ];
+                                return [
+                                    2
+                                ];
+                        }
                     });
                 })();
             }
         };
-        return cacheForService;
-    };
+    }
     var allServiceAccessTokenCaches = allServices.map(function(x) {
         return x.loadCalcomAccessTokenCache();
     });
@@ -415,206 +512,204 @@ CalcomOAuthAccessTokenCacheService = __decorate([
         var allCaches = allServicesWithCacheForRefreshToken.map(function(x) {
             return x.cacheForRefreshToken(refreshToken);
         });
-        return loadCalcomAccessTokenCache(allCaches);
+        return mergeCachesForService(allCaches);
     } : undefined;
     var service = {
-        loadCalcomAccessTokenCache: function loadCalcomAccessTokenCache1() {
-            return loadCalcomAccessTokenCache(allServiceAccessTokenCaches);
+        loadCalcomAccessTokenCache: function loadCalcomAccessTokenCache() {
+            return mergeCachesForService(allServiceAccessTokenCaches);
         },
         cacheForRefreshToken: cacheForRefreshToken
     };
     return service;
 }
 // MARK: Memory Access Token Cache
+/**
+ * Adapts an {@link AsyncValueCache} to a {@link CalcomAccessTokenCache}, optionally logging cache reads/writes to the console.
+ *
+ * @param cache - underlying single-value cache for the access token
+ * @param logAccessToConsole - when true, logs reads and writes to the console
+ * @returns the CalcomAccessTokenCache backed by the given async cache
+ */ function calcomAccessTokenCacheFromAsyncValueCache(cache, logAccessToConsole) {
+    return {
+        loadCachedToken: function loadCachedToken() {
+            return _async_to_generator$2(function() {
+                var token;
+                return _ts_generator$2(this, function(_state) {
+                    switch(_state.label){
+                        case 0:
+                            return [
+                                4,
+                                cache.load()
+                            ];
+                        case 1:
+                            token = _state.sent();
+                            if (logAccessToConsole) {
+                                console.log('retrieving access token from memory: ', {
+                                    hit: token != null,
+                                    expiresAt: token === null || token === void 0 ? void 0 : token.expiresAt
+                                });
+                            }
+                            return [
+                                2,
+                                token
+                            ];
+                    }
+                });
+            })();
+        },
+        updateCachedToken: function updateCachedToken(accessToken) {
+            return _async_to_generator$2(function() {
+                return _ts_generator$2(this, function(_state) {
+                    switch(_state.label){
+                        case 0:
+                            return [
+                                4,
+                                cache.update(accessToken)
+                            ];
+                        case 1:
+                            _state.sent();
+                            if (logAccessToConsole) {
+                                console.log('updating access token in memory: ', {
+                                    expiresAt: accessToken === null || accessToken === void 0 ? void 0 : accessToken.expiresAt
+                                });
+                            }
+                            return [
+                                2
+                            ];
+                    }
+                });
+            })();
+        }
+    };
+}
 /**
  * Creates a CalcomOAuthAccessTokenCacheService that uses in-memory storage.
- * Per-user caches are stored in a Map keyed by the md5 hash of the refresh token.
+ *
+ * The server-level token is held in a single-slot {@link inMemoryAsyncValueCache};
+ * per-user tokens are held in an {@link inMemoryAsyncKeyedValueCache} keyed by the
+ * sha256-truncated refresh token hash.
  *
  * @param existingToken - optional pre-existing server-level access token to seed the cache
  * @param logAccessToConsole - when true, logs all cache reads and writes to console
- * @returns a CalcomOAuthAccessTokenCacheService backed by in-memory Maps
+ * @returns a CalcomOAuthAccessTokenCacheService backed by in-memory caches
  */ function memoryCalcomOAuthAccessTokenCacheService(existingToken, logAccessToConsole) {
-    var serverToken = existingToken;
-    var userTokens = new Map();
-    function makeCache(getToken, setToken) {
+    var serverCache = inMemoryAsyncValueCache(existingToken);
+    var userCache = inMemoryAsyncKeyedValueCache();
+    function userCacheView(key) {
         return {
-            loadCachedToken: function loadCachedToken() {
-                return _async_to_generator$2(function() {
-                    var token;
-                    return _ts_generator$2(this, function(_state) {
-                        token = getToken();
-                        if (logAccessToConsole) {
-                            console.log('retrieving access token from memory: ', {
-                                token: token
-                            });
-                        }
-                        return [
-                            2,
-                            token
-                        ];
-                    });
-                })();
+            load: function load() {
+                return userCache.get(key);
             },
-            updateCachedToken: function updateCachedToken(accessToken) {
-                return _async_to_generator$2(function() {
-                    return _ts_generator$2(this, function(_state) {
-                        setToken(accessToken);
-                        if (logAccessToConsole) {
-                            console.log('updating access token in memory: ', {
-                                accessToken: accessToken
-                            });
-                        }
-                        return [
-                            2
-                        ];
-                    });
-                })();
+            update: function update(token) {
+                return userCache.set(key, token);
+            },
+            clear: function clear() {
+                return userCache.remove(key);
             }
         };
     }
     return {
         loadCalcomAccessTokenCache: function loadCalcomAccessTokenCache() {
-            return makeCache(function() {
-                return serverToken;
-            }, function(t) {
-                serverToken = t;
-            });
+            return calcomAccessTokenCacheFromAsyncValueCache(serverCache, logAccessToConsole);
         },
         cacheForRefreshToken: function cacheForRefreshToken(refreshToken) {
             var key = calcomRefreshTokenCacheKey(refreshToken);
-            return makeCache(function() {
-                return userTokens.get(key);
-            }, function(t) {
-                return userTokens.set(key, t);
-            });
+            return calcomAccessTokenCacheFromAsyncValueCache(userCacheView(key), logAccessToConsole);
         }
     };
 }
 // MARK: File System Access Token Cache
 var DEFAULT_FILE_CALCOM_ACCESS_TOKEN_CACHE_DIR = '.tmp/calcom-tokens';
 var CALCOM_SERVER_TOKEN_FILE_KEY = 'server';
+/**
+ * Reviver applied to the cached file payload on load so `expiresAt` is always a `Date`
+ * regardless of how it was serialized.
+ *
+ * @param raw - the raw JSON-parsed file payload
+ * @returns the revived CalcomAccessToken, or undefined when the payload is empty/invalid
+ */ function reviveCalcomAccessTokenFile(raw) {
+    if (raw == null || (typeof raw === "undefined" ? "undefined" : _type_of(raw)) !== 'object') {
+        return undefined;
+    }
+    var wrapper = raw;
+    var token = wrapper.token;
+    if (token == null) {
+        return undefined;
+    }
+    var rawExpiresAt = token.expiresAt;
+    var expiresAt = rawExpiresAt != null && !_instanceof(rawExpiresAt, Date) ? new Date(rawExpiresAt) : rawExpiresAt;
+    return _object_spread_props$2(_object_spread$2({}, token), {
+        expiresAt: expiresAt
+    });
+}
 /**
  * Creates a CalcomOAuthAccessTokenCacheService that reads and writes access tokens
- * to the file system. Each user gets their own file, keyed by an md5 hash of their refresh token.
+ * to the file system. Each user gets their own file, keyed by an sha256 hash of their refresh token.
+ *
+ * Backed by {@link createMemoizedJsonFileAsyncValueCache} for each key, so reads after
+ * the first hit memory.
  *
  * File structure:
  * ```
  * <cacheDir>/
  *   server.json              — server-level token
- *   user-<md5hash>.json      — per-user tokens (hash of initial refresh token)
+ *   user-<sha256hash>.json   — per-user tokens (hash of initial refresh token)
  * ```
  *
  * @param cacheDir Directory to store token files. Defaults to `.tmp/calcom-tokens`.
  * @returns a CalcomOAuthAccessTokenCacheService backed by the file system
  */ function fileCalcomOAuthAccessTokenCacheService() {
     var cacheDir = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : DEFAULT_FILE_CALCOM_ACCESS_TOKEN_CACHE_DIR;
-    var memoryTokens = new Map();
-    function filePathForKey(key) {
-        return join(cacheDir, "".concat(key, ".json"));
-    }
-    function readTokenFile(filePath) {
-        return new Promise(function(resolve) {
-            mkdirSync(dirname(filePath), {
-                recursive: true
-            });
-            readFile(filePath, {}, function(err, data) {
-                var result = undefined;
-                if (!err) {
-                    try {
-                        result = JSON.parse(data.toString());
-                        if (result === null || result === void 0 ? void 0 : result.token) {
-                            result.token.expiresAt = new Date(result.token.expiresAt);
-                        }
-                    } catch (e) {
-                        console.error("Failed reading token file ".concat(filePath, ": "), e);
-                    }
-                }
-                resolve(result);
-            });
-        });
-    }
-    function writeTokenFile(filePath, content) {
-        return new Promise(function(resolve, reject) {
-            mkdirSync(dirname(filePath), {
-                recursive: true
-            });
-            writeFile(filePath, JSON.stringify(content, null, 2), {}, function(err) {
-                if (!err) {
-                    resolve();
-                } else {
-                    reject(err);
+    var cachesByKey = new Map();
+    function cacheForKey(fileKey) {
+        var cache = cachesByKey.get(fileKey);
+        if (cache == null) {
+            cache = createMemoizedJsonFileAsyncValueCache({
+                filePath: join(cacheDir, "".concat(fileKey, ".json")),
+                reviver: reviveCalcomAccessTokenFile,
+                replacer: function replacer(token) {
+                    return {
+                        token: token
+                    };
                 }
             });
-        });
+            cachesByKey.set(fileKey, cache);
+        }
+        return cache;
     }
     function makeCacheForKey(fileKey) {
-        var filePath = filePathForKey(fileKey);
+        var cache = cacheForKey(fileKey);
         return {
             loadCachedToken: function loadCachedToken() {
-                return _async_to_generator$2(function() {
-                    var memoryEntry, fileContent;
-                    return _ts_generator$2(this, function(_state) {
-                        switch(_state.label){
-                            case 0:
-                                // Check memory first
-                                memoryEntry = memoryTokens.get(fileKey);
-                                if (memoryEntry !== undefined) {
-                                    return [
-                                        2,
-                                        memoryEntry === null || memoryEntry === void 0 ? void 0 : memoryEntry.token
-                                    ];
-                                }
-                                return [
-                                    4,
-                                    readTokenFile(filePath)
-                                ];
-                            case 1:
-                                fileContent = _state.sent();
-                                memoryTokens.set(fileKey, fileContent !== null && fileContent !== void 0 ? fileContent : null);
-                                return [
-                                    2,
-                                    fileContent === null || fileContent === void 0 ? void 0 : fileContent.token
-                                ];
-                        }
-                    });
-                })();
+                return cache.load();
             },
             updateCachedToken: function updateCachedToken(accessToken) {
                 return _async_to_generator$2(function() {
-                    var content, e;
+                    var e;
                     return _ts_generator$2(this, function(_state) {
                         switch(_state.label){
                             case 0:
-                                content = {
-                                    token: accessToken
-                                };
-                                memoryTokens.set(fileKey, content);
-                                _state.label = 1;
-                            case 1:
                                 _state.trys.push([
-                                    1,
-                                    3,
+                                    0,
+                                    2,
                                     ,
-                                    4
+                                    3
                                 ]);
                                 return [
                                     4,
-                                    writeTokenFile(filePath, content)
+                                    cache.update(accessToken)
                                 ];
-                            case 2:
+                            case 1:
                                 _state.sent();
                                 return [
                                     3,
-                                    4
+                                    3
                                 ];
-                            case 3:
+                            case 2:
                                 e = _state.sent();
-                                console.error("Failed updating token file ".concat(filePath, ": "), e);
-                                return [
-                                    3,
-                                    4
-                                ];
-                            case 4:
+                                console.error("Failed updating token file for ".concat(fileKey, ": "), e);
+                                throw e;
+                            case 3:
                                 return [
                                     2
                                 ];

package/nestjs/package.json

@@ -1,11 +1,11 @@
 {
   "name": "@dereekb/calcom/nestjs",
-  "version": "13.10.9",
+  "version": "13.11.1",
   "peerDependencies": {
-    "@dereekb/nestjs": "13.10.9",
-    "@dereekb/rxjs": "13.10.9",
-    "@dereekb/util": "13.10.9",
-    "@dereekb/calcom": "13.10.9",
+    "@dereekb/nestjs": "13.11.1",
+    "@dereekb/rxjs": "13.11.1",
+    "@dereekb/util": "13.11.1",
+    "@dereekb/calcom": "13.11.1",
     "@nestjs/common": "^11.1.19",
     "@nestjs/config": "^4.0.4",
     "express": "^5.2.1"

package/nestjs/src/lib/oauth/oauth.service.d.ts

@@ -45,6 +45,11 @@ export declare function logMergeCalcomOAuthAccessTokenCacheServiceErrorFunction(
  * If one source fails retrieval, the next will be tried.
  * When updating a cached token, it will update the token across all services.
  *
+ * Read fall-through is delegated to {@link mergeAsyncValueCaches} after wrapping each
+ * underlying cache with an {@link isExpired}-aware filter, so an expired cached token
+ * never short-circuits the lookup. Updates run across all services in parallel via
+ * `Promise.allSettled`, mirroring the previous behavior, with optional error logging.
+ *
  * @param inputServicesToMerge Must include at least one service. Empty arrays will throw an error.
  * @param logError - optional error logging configuration; pass a function, true for default logging, or false to disable
  * @returns a merged CalcomOAuthAccessTokenCacheService that delegates across all input services
@@ -52,11 +57,14 @@ export declare function logMergeCalcomOAuthAccessTokenCacheServiceErrorFunction(
 export declare function mergeCalcomOAuthAccessTokenCacheServices(inputServicesToMerge: CalcomOAuthAccessTokenCacheService[], logError?: Maybe<boolean | LogMergeCalcomOAuthAccessTokenCacheServiceErrorFunction>): CalcomOAuthAccessTokenCacheService;
 /**
  * Creates a CalcomOAuthAccessTokenCacheService that uses in-memory storage.
- * Per-user caches are stored in a Map keyed by the md5 hash of the refresh token.
+ *
+ * The server-level token is held in a single-slot {@link inMemoryAsyncValueCache};
+ * per-user tokens are held in an {@link inMemoryAsyncKeyedValueCache} keyed by the
+ * sha256-truncated refresh token hash.
  *
  * @param existingToken - optional pre-existing server-level access token to seed the cache
  * @param logAccessToConsole - when true, logs all cache reads and writes to console
- * @returns a CalcomOAuthAccessTokenCacheService backed by in-memory Maps
+ * @returns a CalcomOAuthAccessTokenCacheService backed by in-memory caches
  */
 export declare function memoryCalcomOAuthAccessTokenCacheService(existingToken?: Maybe<CalcomAccessToken>, logAccessToConsole?: boolean): CalcomOAuthAccessTokenCacheService;
 export declare const DEFAULT_FILE_CALCOM_ACCESS_TOKEN_CACHE_DIR = ".tmp/calcom-tokens";
@@ -69,13 +77,16 @@ export interface FileSystemCalcomOAuthAccessTokenCacheService extends CalcomOAut
 }
 /**
  * Creates a CalcomOAuthAccessTokenCacheService that reads and writes access tokens
- * to the file system. Each user gets their own file, keyed by an md5 hash of their refresh token.
+ * to the file system. Each user gets their own file, keyed by an sha256 hash of their refresh token.
+ *
+ * Backed by {@link createMemoizedJsonFileAsyncValueCache} for each key, so reads after
+ * the first hit memory.
  *
  * File structure:
  * ```
  * <cacheDir>/
  *   server.json              — server-level token
- *   user-<md5hash>.json      — per-user tokens (hash of initial refresh token)
+ *   user-<sha256hash>.json   — per-user tokens (hash of initial refresh token)
  * ```
  *
  * @param cacheDir Directory to store token files. Defaults to `.tmp/calcom-tokens`.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dereekb/calcom",
-  "version": "13.10.9",
+  "version": "13.11.1",
   "exports": {
     "./nestjs": {
       "module": "./nestjs/index.esm.js",
@@ -17,9 +17,9 @@
     }
   },
   "peerDependencies": {
-    "@dereekb/nestjs": "13.10.9",
-    "@dereekb/rxjs": "13.10.9",
-    "@dereekb/util": "13.10.9",
+    "@dereekb/nestjs": "13.11.1",
+    "@dereekb/rxjs": "13.11.1",
+    "@dereekb/util": "13.11.1",
     "@nestjs/common": "^11.1.19",
     "@nestjs/config": "^4.0.4",
     "express": "^5.2.1",