@dereekb/calcom 13.4.0

package/nestjs/index.cjs.js

@@ -0,0 +1,1970 @@
+'use strict';
+
+var common = require('@nestjs/common');
+var calcom = require('@dereekb/calcom');
+var util = require('@dereekb/util');
+var crypto = require('crypto');
+var path = require('path');
+var fs = require('fs');
+var config = require('@nestjs/config');
+var nestjs = require('@dereekb/nestjs');
+
+function _type_of(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);
+    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;
+}
+function __param(paramIndex, decorator) {
+    return function(target, key) {
+        decorator(target, key, paramIndex);
+    };
+}
+typeof SuppressedError === "function" ? SuppressedError : function(error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+};
+
+function _class_call_check$8(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+    }
+}
+function _defineProperties$6(target, props) {
+    for(var i = 0; i < props.length; i++){
+        var descriptor = props[i];
+        descriptor.enumerable = descriptor.enumerable || false;
+        descriptor.configurable = true;
+        if ("value" in descriptor) descriptor.writable = true;
+        Object.defineProperty(target, descriptor.key, descriptor);
+    }
+}
+function _create_class$6(Constructor, protoProps, staticProps) {
+    if (staticProps) _defineProperties$6(Constructor, staticProps);
+    return Constructor;
+}
+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;
+}
+var CALCOM_SERVICE_NAME = 'calcom';
+var CALCOM_CLIENT_ID_CONFIG_KEY = 'CALCOM_CLIENT_ID';
+var CALCOM_CLIENT_SECRET_CONFIG_KEY = 'CALCOM_CLIENT_SECRET';
+var CALCOM_REFRESH_TOKEN_CONFIG_KEY = 'CALCOM_REFRESH_TOKEN';
+var CALCOM_API_KEY_CONFIG_KEY = 'CALCOM_API_KEY';
+/**
+ * Configuration for CalcomOAuthService
+ */ 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);
+    }
+    _create_class$6(CalcomOAuthServiceConfig, null, [
+        {
+            key: "assertValidConfig",
+            value: function assertValidConfig(config) {
+                var calcomOAuth = config.calcomOAuth;
+                if (!calcomOAuth) {
+                    throw new Error('CalcomOAuthServiceConfig.calcomOAuth is required');
+                }
+                var hasApiKey = !!calcomOAuth.apiKey;
+                var hasOAuth = !!calcomOAuth.clientId && !!calcomOAuth.clientSecret;
+                if (!hasApiKey && !hasOAuth) {
+                    throw new Error('CalcomOAuthServiceConfig requires either apiKey or clientId+clientSecret');
+                }
+            }
+        }
+    ]);
+    return CalcomOAuthServiceConfig;
+}();
+function calcomOAuthServiceConfigFactory(configService) {
+    var clientId = configService.get(CALCOM_CLIENT_ID_CONFIG_KEY);
+    var clientSecret = configService.get(CALCOM_CLIENT_SECRET_CONFIG_KEY);
+    var refreshToken = configService.get(CALCOM_REFRESH_TOKEN_CONFIG_KEY);
+    var apiKey = configService.get(CALCOM_API_KEY_CONFIG_KEY);
+    var config = {
+        calcomOAuth: {
+            clientId: clientId || undefined,
+            clientSecret: clientSecret || undefined,
+            refreshToken: refreshToken || undefined,
+            apiKey: apiKey || undefined
+        }
+    };
+    CalcomOAuthServiceConfig.assertValidConfig(config);
+    return config;
+}
+
+function _array_like_to_array$3(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
+    return arr2;
+}
+function _array_with_holes(arr) {
+    if (Array.isArray(arr)) return arr;
+}
+function _array_without_holes$3(arr) {
+    if (Array.isArray(arr)) return _array_like_to_array$3(arr);
+}
+function asyncGeneratorStep$2(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) {
+        resolve(value);
+    } else {
+        Promise.resolve(value).then(_next, _throw);
+    }
+}
+function _async_to_generator$2(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep$2(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep$2(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+function _class_call_check$7(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+    }
+}
+function _iterable_to_array$3(iter) {
+    if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
+}
+function _iterable_to_array_limit(arr, i) {
+    var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"];
+    if (_i == null) return;
+    var _arr = [];
+    var _n = true;
+    var _d = false;
+    var _s, _e;
+    try {
+        for(_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true){
+            _arr.push(_s.value);
+            if (i && _arr.length === i) break;
+        }
+    } catch (err) {
+        _d = true;
+        _e = err;
+    } finally{
+        try {
+            if (!_n && _i["return"] != null) _i["return"]();
+        } finally{
+            if (_d) throw _e;
+        }
+    }
+    return _arr;
+}
+function _non_iterable_rest() {
+    throw new TypeError("Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+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 _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 _unsupported_iterable_to_array$3(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _array_like_to_array$3(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    if (n === "Map" || n === "Set") return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array$3(o, minLen);
+}
+function _ts_generator$2(thisArg, body) {
+    var f, y, t, _ = {
+        label: 0,
+        sent: function() {
+            if (t[0] & 1) throw t[1];
+            return t[1];
+        },
+        trys: [],
+        ops: []
+    }, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype), d = Object.defineProperty;
+    return d(g, "next", {
+        value: verb(0)
+    }), d(g, "throw", {
+        value: verb(1)
+    }), d(g, "return", {
+        value: verb(2)
+    }), typeof Symbol === "function" && d(g, Symbol.iterator, {
+        value: function() {
+            return this;
+        }
+    }), g;
+    function verb(n) {
+        return function(v) {
+            return step([
+                n,
+                v
+            ]);
+        };
+    }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while(g && (g = 0, op[0] && (_ = 0)), _)try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [
+                op[0] & 2,
+                t.value
+            ];
+            switch(op[0]){
+                case 0:
+                case 1:
+                    t = op;
+                    break;
+                case 4:
+                    _.label++;
+                    return {
+                        value: op[1],
+                        done: false
+                    };
+                case 5:
+                    _.label++;
+                    y = op[1];
+                    op = [
+                        0
+                    ];
+                    continue;
+                case 7:
+                    op = _.ops.pop();
+                    _.trys.pop();
+                    continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+                        _ = 0;
+                        continue;
+                    }
+                    if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+                        _.label = op[1];
+                        break;
+                    }
+                    if (op[0] === 6 && _.label < t[1]) {
+                        _.label = t[1];
+                        t = op;
+                        break;
+                    }
+                    if (t && _.label < t[2]) {
+                        _.label = t[2];
+                        _.ops.push(op);
+                        break;
+                    }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop();
+                    continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) {
+            op = [
+                6,
+                e
+            ];
+            y = 0;
+        } finally{
+            f = t = 0;
+        }
+        if (op[0] & 5) throw op[1];
+        return {
+            value: op[0] ? op[1] : void 0,
+            done: true
+        };
+    }
+}
+/**
+ * Service used for retrieving CalcomAccessTokenCache for Cal.com services.
+ *
+ * Implementations store and retrieve OAuth access tokens (and the rotated refresh tokens
+ * embedded in them). The service supports both a server-level cache and per-user caches
+ * keyed by the user's initial refresh token.
+ */ exports.CalcomOAuthAccessTokenCacheService = function CalcomOAuthAccessTokenCacheService() {
+    _class_call_check$7(this, CalcomOAuthAccessTokenCacheService);
+};
+exports.CalcomOAuthAccessTokenCacheService = __decorate([
+    common.Injectable()
+], exports.CalcomOAuthAccessTokenCacheService);
+/**
+ * Derives a short, filesystem-safe cache key from a refresh token using md5.
+ */ function calcomRefreshTokenCacheKey(refreshToken) {
+    return crypto.createHash('md5').update(refreshToken).digest('hex').substring(0, 16);
+}
+function logMergeCalcomOAuthAccessTokenCacheServiceErrorFunction(failedUpdates) {
+    console.warn("mergeCalcomOAuthAccessTokenCacheServices(): failed updating ".concat(failedUpdates.length, " caches."));
+    failedUpdates.forEach(function(param, i) {
+        var _param = _sliced_to_array(param, 2); _param[0]; var e = _param[1];
+        console.warn("Cache update failure ".concat(i + 1, ": - ").concat(e));
+    });
+}
+/**
+ * Merges the input services in order to use some as a backup source.
+ *
+ * If one source fails retrieval, the next will be tried.
+ * When updating a cached token, it will update the token across all services.
+ *
+ * @param inputServicesToMerge Must include at least one service. Empty arrays will throw an error.
+ */ function mergeCalcomOAuthAccessTokenCacheServices(inputServicesToMerge, logError) {
+    var allServices = _to_consumable_array$3(inputServicesToMerge);
+    var logErrorFunction = typeof logError === 'function' ? logError : logError !== false ? logMergeCalcomOAuthAccessTokenCacheServiceErrorFunction : undefined;
+    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 = {
+            loadCachedToken: function loadCachedToken() {
+                return loadCachedTokenFromFirstService();
+            },
+            updateCachedToken: function updateCachedToken(accessToken) {
+                return _async_to_generator$2(function() {
+                    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
+                                if (logErrorFunction != null) {
+                                    var failedUpdates = util.filterMaybeArrayValues(x.map(function(y) {
+                                        return y.value;
+                                    }));
+                                    if (failedUpdates.length) {
+                                        logErrorFunction(failedUpdates);
+                                    }
+                                }
+                            })
+                        ];
+                    });
+                })();
+            }
+        };
+        return cacheForService;
+    };
+    var allServiceAccessTokenCaches = allServices.map(function(x) {
+        return x.loadCalcomAccessTokenCache();
+    });
+    var allServicesWithCacheForRefreshToken = allServices.filter(function(x) {
+        return x.cacheForRefreshToken != null;
+    });
+    var cacheForRefreshToken = allServicesWithCacheForRefreshToken.length > 0 ? function(refreshToken) {
+        var allCaches = allServicesWithCacheForRefreshToken.map(function(x) {
+            return x.cacheForRefreshToken(refreshToken);
+        });
+        return loadCalcomAccessTokenCache(allCaches);
+    } : undefined;
+    var service = {
+        loadCalcomAccessTokenCache: function loadCalcomAccessTokenCache1() {
+            return loadCalcomAccessTokenCache(allServiceAccessTokenCaches);
+        },
+        cacheForRefreshToken: cacheForRefreshToken
+    };
+    return service;
+}
+// MARK: Memory Access Token Cache
+/**
+ * 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.
+ */ function memoryCalcomOAuthAccessTokenCacheService(existingToken, logAccessToConsole) {
+    var serverToken = existingToken;
+    var userTokens = new Map();
+    function makeCache(getToken, setToken) {
+        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
+                        ];
+                    });
+                })();
+            },
+            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
+                        ];
+                    });
+                })();
+            }
+        };
+    }
+    return {
+        loadCalcomAccessTokenCache: function loadCalcomAccessTokenCache() {
+            return makeCache(function() {
+                return serverToken;
+            }, function(t) {
+                serverToken = t;
+            });
+        },
+        cacheForRefreshToken: function cacheForRefreshToken(refreshToken) {
+            var key = calcomRefreshTokenCacheKey(refreshToken);
+            return makeCache(function() {
+                return userTokens.get(key);
+            }, function(t) {
+                return userTokens.set(key, t);
+            });
+        }
+    };
+}
+// MARK: File System Access Token Cache
+var DEFAULT_FILE_CALCOM_ACCESS_TOKEN_CACHE_DIR = '.tmp/calcom-tokens';
+var CALCOM_SERVER_TOKEN_FILE_KEY = 'server';
+/**
+ * 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.
+ *
+ * File structure:
+ * ```
+ * <cacheDir>/
+ *   server.json              — server-level token
+ *   user-<md5hash>.json      — per-user tokens (hash of initial refresh token)
+ * ```
+ *
+ * @param cacheDir Directory to store token files. Defaults to `.tmp/calcom-tokens`.
+ */ 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 path.join(cacheDir, "".concat(key, ".json"));
+    }
+    function readTokenFile(filePath) {
+        return new Promise(function(resolve) {
+            fs.mkdirSync(path.dirname(filePath), {
+                recursive: true
+            });
+            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) {
+            fs.mkdirSync(path.dirname(filePath), {
+                recursive: true
+            });
+            fs.writeFile(filePath, JSON.stringify(content, null, 2), {}, function(err) {
+                if (!err) {
+                    resolve();
+                } else {
+                    reject(err);
+                }
+            });
+        });
+    }
+    function makeCacheForKey(fileKey) {
+        var filePath = filePathForKey(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
+                                ];
+                        }
+                    });
+                })();
+            },
+            updateCachedToken: function updateCachedToken(accessToken) {
+                return _async_to_generator$2(function() {
+                    var content, 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,
+                                    ,
+                                    4
+                                ]);
+                                return [
+                                    4,
+                                    writeTokenFile(filePath, content)
+                                ];
+                            case 2:
+                                _state.sent();
+                                return [
+                                    3,
+                                    4
+                                ];
+                            case 3:
+                                e = _state.sent();
+                                console.error("Failed updating token file ".concat(filePath, ": "), e);
+                                return [
+                                    3,
+                                    4
+                                ];
+                            case 4:
+                                return [
+                                    2
+                                ];
+                        }
+                    });
+                })();
+            }
+        };
+    }
+    return {
+        cacheDir: cacheDir,
+        loadCalcomAccessTokenCache: function loadCalcomAccessTokenCache() {
+            return makeCacheForKey(CALCOM_SERVER_TOKEN_FILE_KEY);
+        },
+        cacheForRefreshToken: function cacheForRefreshToken(refreshToken) {
+            return makeCacheForKey("user-".concat(calcomRefreshTokenCacheKey(refreshToken)));
+        }
+    };
+}
+
+function _class_call_check$6(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+    }
+}
+function _defineProperties$5(target, props) {
+    for(var i = 0; i < props.length; i++){
+        var descriptor = props[i];
+        descriptor.enumerable = descriptor.enumerable || false;
+        descriptor.configurable = true;
+        if ("value" in descriptor) descriptor.writable = true;
+        Object.defineProperty(target, descriptor.key, descriptor);
+    }
+}
+function _create_class$5(Constructor, protoProps, staticProps) {
+    if (protoProps) _defineProperties$5(Constructor.prototype, protoProps);
+    return Constructor;
+}
+function _define_property$6(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;
+}
+exports.CalcomOAuthApi = /*#__PURE__*/ function() {
+    function CalcomOAuthApi(config, cacheService) {
+        _class_call_check$6(this, CalcomOAuthApi);
+        var _config_factoryConfig;
+        _define_property$6(this, "config", void 0);
+        _define_property$6(this, "cacheService", void 0);
+        _define_property$6(this, "calcomOAuth", void 0);
+        this.config = config;
+        this.cacheService = cacheService;
+        var accessTokenCache = cacheService.loadCalcomAccessTokenCache();
+        var _config_calcomOAuth = config.calcomOAuth, clientId = _config_calcomOAuth.clientId, clientSecret = _config_calcomOAuth.clientSecret, refreshToken = _config_calcomOAuth.refreshToken, apiKey = _config_calcomOAuth.apiKey;
+        this.calcomOAuth = calcom.calcomOAuthFactory((_config_factoryConfig = config.factoryConfig) !== null && _config_factoryConfig !== void 0 ? _config_factoryConfig : {})({
+            accessTokenCache: accessTokenCache,
+            clientId: clientId !== null && clientId !== void 0 ? clientId : '',
+            clientSecret: clientSecret !== null && clientSecret !== void 0 ? clientSecret : '',
+            refreshToken: refreshToken,
+            apiKey: apiKey
+        });
+    }
+    _create_class$5(CalcomOAuthApi, [
+        {
+            key: "oauthContext",
+            get: function get() {
+                return this.calcomOAuth.oauthContext;
+            }
+        },
+        {
+            key: "exchangeAuthorizationCode",
+            get: // MARK: Accessors
+            /** Configured pass-through for {@link exchangeAuthorizationCode}. */ function get() {
+                return calcom.exchangeAuthorizationCode(this.oauthContext);
+            }
+        },
+        {
+            /**
+     * Retrieves an access token for a specific user using their refresh token.
+     */ key: "userAccessToken",
+            value: function userAccessToken(input) {
+                var factory = this.oauthContext.makeUserAccessTokenFactory(input);
+                return factory();
+            }
+        },
+        {
+            /**
+     * Returns a per-user CalcomAccessTokenCache derived from the refresh token (md5 hashed as the file key).
+     * Returns undefined if the cache service does not support per-user caching.
+     */ key: "cacheForRefreshToken",
+            value: function cacheForRefreshToken(refreshToken) {
+                var _this_cacheService_cacheForRefreshToken, _this_cacheService;
+                return (_this_cacheService_cacheForRefreshToken = (_this_cacheService = this.cacheService).cacheForRefreshToken) === null || _this_cacheService_cacheForRefreshToken === void 0 ? void 0 : _this_cacheService_cacheForRefreshToken.call(_this_cacheService, refreshToken);
+            }
+        }
+    ]);
+    return CalcomOAuthApi;
+}();
+exports.CalcomOAuthApi = __decorate([
+    common.Injectable(),
+    __param(0, common.Inject(CalcomOAuthServiceConfig)),
+    __param(1, common.Inject(exports.CalcomOAuthAccessTokenCacheService))
+], exports.CalcomOAuthApi);
+
+function _array_like_to_array$2(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
+    return arr2;
+}
+function _array_without_holes$2(arr) {
+    if (Array.isArray(arr)) return _array_like_to_array$2(arr);
+}
+function _iterable_to_array$2(iter) {
+    if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
+}
+function _non_iterable_spread$2() {
+    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 _to_consumable_array$2(arr) {
+    return _array_without_holes$2(arr) || _iterable_to_array$2(arr) || _unsupported_iterable_to_array$2(arr) || _non_iterable_spread$2();
+}
+function _unsupported_iterable_to_array$2(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _array_like_to_array$2(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    if (n === "Map" || n === "Set") return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array$2(o, minLen);
+}
+/**
+ * Convenience function used to generate ModuleMetadata for an app's CalcomOAuthModule.
+ */ function appCalcomOAuthModuleMetadata(config$1) {
+    var _config_calcomOAuthServiceConfigFactory;
+    var dependencyModule = config$1.dependencyModule, imports = config$1.imports, exports$1 = config$1.exports, providers = config$1.providers;
+    var dependencyModuleImport = dependencyModule ? [
+        dependencyModule
+    ] : [];
+    return {
+        imports: [
+            config.ConfigModule
+        ].concat(_to_consumable_array$2(dependencyModuleImport), _to_consumable_array$2(imports !== null && imports !== void 0 ? imports : [])),
+        exports: [
+            exports.CalcomOAuthApi
+        ].concat(_to_consumable_array$2(exports$1 !== null && exports$1 !== void 0 ? exports$1 : [])),
+        providers: [
+            {
+                provide: CalcomOAuthServiceConfig,
+                inject: [
+                    config.ConfigService
+                ],
+                useFactory: (_config_calcomOAuthServiceConfigFactory = config$1.calcomOAuthServiceConfigFactory) !== null && _config_calcomOAuthServiceConfigFactory !== void 0 ? _config_calcomOAuthServiceConfigFactory : calcomOAuthServiceConfigFactory
+            },
+            exports.CalcomOAuthApi
+        ].concat(_to_consumable_array$2(providers !== null && providers !== void 0 ? providers : []))
+    };
+}
+
+function _class_call_check$5(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+    }
+}
+function _defineProperties$4(target, props) {
+    for(var i = 0; i < props.length; i++){
+        var descriptor = props[i];
+        descriptor.enumerable = descriptor.enumerable || false;
+        descriptor.configurable = true;
+        if ("value" in descriptor) descriptor.writable = true;
+        Object.defineProperty(target, descriptor.key, descriptor);
+    }
+}
+function _create_class$4(Constructor, protoProps, staticProps) {
+    if (staticProps) _defineProperties$4(Constructor, staticProps);
+    return Constructor;
+}
+function _define_property$5(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;
+}
+/**
+ * Configuration for CalcomService
+ */ var CalcomServiceConfig = /*#__PURE__*/ function() {
+    function CalcomServiceConfig() {
+        _class_call_check$5(this, CalcomServiceConfig);
+        _define_property$5(this, "calcom", void 0);
+        _define_property$5(this, "factoryConfig", void 0);
+    }
+    _create_class$4(CalcomServiceConfig, null, [
+        {
+            key: "assertValidConfig",
+            value: function assertValidConfig(_config) {
+            // no required env-specific config currently
+            }
+        }
+    ]);
+    return CalcomServiceConfig;
+} 
+();
+
+function _class_call_check$4(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+    }
+}
+function _defineProperties$3(target, props) {
+    for(var i = 0; i < props.length; i++){
+        var descriptor = props[i];
+        descriptor.enumerable = descriptor.enumerable || false;
+        descriptor.configurable = true;
+        if ("value" in descriptor) descriptor.writable = true;
+        Object.defineProperty(target, descriptor.key, descriptor);
+    }
+}
+function _create_class$3(Constructor, protoProps, staticProps) {
+    if (protoProps) _defineProperties$3(Constructor.prototype, protoProps);
+    return Constructor;
+}
+function _define_property$4(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 _object_spread$1(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$4(target, key, source[key]);
+        });
+    }
+    return target;
+}
+function ownKeys$1(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$1(target, source) {
+    source = source != null ? source : {};
+    if (Object.getOwnPropertyDescriptors) {
+        Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
+    } else {
+        ownKeys$1(Object(source)).forEach(function(key) {
+            Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+        });
+    }
+    return target;
+}
+/**
+ * Injectable NestJS service that provides access to the Cal.com API.
+ *
+ * Use {@link serverContextInstance} to access API functions via the server context,
+ * or {@link makeUserContextInstance} to create per-mentor API instances.
+ *
+ * @example
+ * ```ts
+ * // Server context (API key or server OAuth)
+ * const instance = calcomApi.serverContextInstance;
+ * const me = await instance.getMe();
+ *
+ * // Per-mentor context
+ * const mentorInstance = calcomApi.makeUserContextInstance({ refreshToken: mentor.calcomRefreshToken });
+ * const eventTypes = await mentorInstance.getEventTypes();
+ *
+ * // Public slot query (no auth)
+ * const slots = await calcomApi.getAvailableSlots({ start: '...', end: '...', eventTypeId: 123 });
+ * ```
+ */ exports.CalcomApi = /*#__PURE__*/ function() {
+    function CalcomApi(config, calcomOAuthApi) {
+        var _this = this;
+        _class_call_check$4(this, CalcomApi);
+        _define_property$4(this, "config", void 0);
+        _define_property$4(this, "calcomOAuthApi", void 0);
+        _define_property$4(this, "calcom", void 0);
+        _define_property$4(this, "_serverInstance", util.cachedGetter(function() {
+            return new CalcomApiContextInstance(_this, _this.calcomServerContext);
+        }));
+        _define_property$4(this, "_publicContext", util.cachedGetter(function() {
+            return _this.calcom.calcomServerContext.makePublicContext();
+        }));
+        this.config = config;
+        this.calcomOAuthApi = calcomOAuthApi;
+        this.calcom = calcom.calcomFactory(_object_spread_props$1(_object_spread$1({}, config.factoryConfig), {
+            oauthContext: calcomOAuthApi.oauthContext
+        }))(config.calcom);
+    }
+    _create_class$3(CalcomApi, [
+        {
+            key: "calcomServerContext",
+            get: function get() {
+                return this.calcom.calcomServerContext;
+            }
+        },
+        {
+            key: "serverContextInstance",
+            get: /**
+     * Returns the cached {@link CalcomApiContextInstance} for the server context.
+     * All API functions are available through this instance.
+     */ function get() {
+                return this._serverInstance();
+            }
+        },
+        {
+            key: "getAvailableSlots",
+            get: // MARK: Public Context
+            /** Configured pass-through for {@link getAvailableSlots} using the public (unauthenticated) context. */ function get() {
+                return calcom.getAvailableSlots(this._publicContext());
+            }
+        },
+        {
+            // MARK: Context Creation
+            /**
+     * Creates a {@link CalcomApiContextInstance} for a specific user using their OAuth refresh token.
+     * The returned instance has all API functions scoped to that user's account.
+     *
+     * When no explicit `accessTokenCache` is provided, a per-user cache is automatically
+     * resolved from the cache service using an md5 hash of the refresh token as the key.
+     * This ensures tokens persist across requests and server restarts without collisions.
+     *
+     * @example
+     * ```ts
+     * // Automatic per-user caching (recommended):
+     * const userInstance = calcomApi.makeUserContextInstance({
+     *   refreshToken: user.calcomRefreshToken
+     * });
+     *
+     * // With explicit cache override:
+     * const userInstance = calcomApi.makeUserContextInstance({
+     *   refreshToken: user.calcomRefreshToken,
+     *   accessTokenCache: customCache
+     * });
+     * ```
+     */ key: "makeUserContextInstance",
+            value: function makeUserContextInstance(input) {
+                var contextInput = _object_spread$1({}, input);
+                // Auto-resolve per-user cache from the refresh token if no explicit cache was given
+                if (!contextInput.accessTokenCache && contextInput.refreshToken) {
+                    var userCache = this.calcomOAuthApi.cacheForRefreshToken(contextInput.refreshToken);
+                    if (userCache) {
+                        contextInput.accessTokenCache = userCache;
+                    }
+                }
+                var userContext = this.calcom.calcomServerContext.makeUserContext(contextInput);
+                return this.makeContextInstance(userContext);
+            }
+        },
+        {
+            /**
+     * Creates a {@link CalcomApiContextInstance} from any {@link CalcomContext}.
+     */ key: "makeContextInstance",
+            value: function makeContextInstance(context) {
+                return new CalcomApiContextInstance(this, context);
+            }
+        },
+        {
+            /**
+     * Creates a raw {@link CalcomUserContext} from a refresh token, without wrapping in a {@link CalcomApiContextInstance}.
+     * Prefer {@link makeUserContextInstance} unless you need direct context access.
+     */ key: "makeUserContext",
+            value: function makeUserContext(input) {
+                return this.calcom.calcomServerContext.makeUserContext(input);
+            }
+        }
+    ]);
+    return CalcomApi;
+}();
+exports.CalcomApi = __decorate([
+    common.Injectable(),
+    __param(0, common.Inject(CalcomServiceConfig)),
+    __param(1, common.Inject(exports.CalcomOAuthApi))
+], exports.CalcomApi);
+/**
+ * Wraps a {@link CalcomContext} (server or user) and exposes all authenticated Cal.com API
+ * functions bound to that context. Each getter delegates to the corresponding function
+ * from `@dereekb/calcom`.
+ *
+ * Access the parent {@link CalcomApi} via {@link calcomApi} for public endpoints
+ * (e.g., `calcomApi.getAvailableSlots`) or to create additional context instances.
+ *
+ * @example
+ * ```ts
+ * const instance = calcomApi.serverContextInstance;
+ *
+ * // Authenticated API calls
+ * const me = await instance.getMe();
+ * const schedules = await instance.getSchedules();
+ *
+ * // Access public endpoints via parent
+ * const slots = await instance.calcomApi.getAvailableSlots({ start: '...', end: '...', eventTypeId: 123 });
+ * ```
+ */ var CalcomApiContextInstance = /*#__PURE__*/ function() {
+    function CalcomApiContextInstance(calcomApi, context) {
+        _class_call_check$4(this, CalcomApiContextInstance);
+        _define_property$4(this, "calcomApi", void 0);
+        _define_property$4(this, "context", void 0);
+        this.calcomApi = calcomApi;
+        this.context = context;
+    }
+    _create_class$3(CalcomApiContextInstance, [
+        {
+            key: "getMe",
+            get: // MARK: User
+            /**
+     * Configured pass-through for {@link getMe}.
+     */ function get() {
+                return calcom.getMe(this.context);
+            }
+        },
+        {
+            key: "getSchedules",
+            get: // MARK: Schedules
+            /**
+     * Configured pass-through for {@link getSchedules}.
+     */ function get() {
+                return calcom.getSchedules(this.context);
+            }
+        },
+        {
+            key: "createBooking",
+            get: // MARK: Bookings
+            /**
+     * Configured pass-through for {@link createBooking}.
+     */ function get() {
+                return calcom.createBooking(this.context);
+            }
+        },
+        {
+            key: "getBooking",
+            get: /**
+     * Configured pass-through for {@link getBooking}.
+     */ function get() {
+                return calcom.getBooking(this.context);
+            }
+        },
+        {
+            key: "cancelBooking",
+            get: /**
+     * Configured pass-through for {@link cancelBooking}.
+     */ function get() {
+                return calcom.cancelBooking(this.context);
+            }
+        },
+        {
+            key: "getEventTypes",
+            get: // MARK: Event Types
+            /**
+     * Configured pass-through for {@link getEventTypes}.
+     */ function get() {
+                return calcom.getEventTypes(this.context);
+            }
+        },
+        {
+            key: "createEventType",
+            get: /**
+     * Configured pass-through for {@link createEventType}.
+     */ function get() {
+                return calcom.createEventType(this.context);
+            }
+        },
+        {
+            key: "updateEventType",
+            get: /**
+     * Configured pass-through for {@link updateEventType}.
+     */ function get() {
+                return calcom.updateEventType(this.context);
+            }
+        },
+        {
+            key: "deleteEventType",
+            get: /**
+     * Configured pass-through for {@link deleteEventType}.
+     */ function get() {
+                return calcom.deleteEventType(this.context);
+            }
+        },
+        {
+            key: "getCalendars",
+            get: // MARK: Calendars
+            /**
+     * Configured pass-through for {@link getCalendars}.
+     */ function get() {
+                return calcom.getCalendars(this.context);
+            }
+        },
+        {
+            key: "getBusyTimes",
+            get: /**
+     * Configured pass-through for {@link getBusyTimes}.
+     */ function get() {
+                return calcom.getBusyTimes(this.context);
+            }
+        },
+        {
+            key: "createWebhook",
+            get: // MARK: Webhooks
+            /**
+     * Configured pass-through for {@link createWebhook}.
+     */ function get() {
+                return calcom.createWebhook(this.context);
+            }
+        },
+        {
+            key: "getWebhooks",
+            get: /**
+     * Configured pass-through for {@link getWebhooks}.
+     */ function get() {
+                return calcom.getWebhooks(this.context);
+            }
+        },
+        {
+            key: "getWebhook",
+            get: /**
+     * Configured pass-through for {@link getWebhook}.
+     */ function get() {
+                return calcom.getWebhook(this.context);
+            }
+        },
+        {
+            key: "updateWebhook",
+            get: /**
+     * Configured pass-through for {@link updateWebhook}.
+     */ function get() {
+                return calcom.updateWebhook(this.context);
+            }
+        },
+        {
+            key: "deleteWebhook",
+            get: /**
+     * Configured pass-through for {@link deleteWebhook}.
+     */ function get() {
+                return calcom.deleteWebhook(this.context);
+            }
+        }
+    ]);
+    return CalcomApiContextInstance;
+} 
+();
+
+function _array_like_to_array$1(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
+    return arr2;
+}
+function _array_without_holes$1(arr) {
+    if (Array.isArray(arr)) return _array_like_to_array$1(arr);
+}
+function _iterable_to_array$1(iter) {
+    if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
+}
+function _non_iterable_spread$1() {
+    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 _to_consumable_array$1(arr) {
+    return _array_without_holes$1(arr) || _iterable_to_array$1(arr) || _unsupported_iterable_to_array$1(arr) || _non_iterable_spread$1();
+}
+function _unsupported_iterable_to_array$1(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _array_like_to_array$1(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    if (n === "Map" || n === "Set") return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array$1(o, minLen);
+}
+// MARK: Provider Factories
+function calcomServiceConfigFactory(_configService) {
+    var config = {
+        calcom: {}
+    };
+    CalcomServiceConfig.assertValidConfig(config);
+    return config;
+}
+/**
+ * Convenience function used to generate ModuleMetadata for an app's CalcomModule.
+ */ function appCalcomModuleMetadata(config$1) {
+    var dependencyModule = config$1.dependencyModule, imports = config$1.imports, exports$1 = config$1.exports, providers = config$1.providers;
+    var dependencyModuleImport = dependencyModule ? [
+        dependencyModule
+    ] : [];
+    return {
+        imports: [
+            config.ConfigModule
+        ].concat(_to_consumable_array$1(dependencyModuleImport), _to_consumable_array$1(imports !== null && imports !== void 0 ? imports : [])),
+        exports: [
+            exports.CalcomApi
+        ].concat(_to_consumable_array$1(exports$1 !== null && exports$1 !== void 0 ? exports$1 : [])),
+        providers: [
+            {
+                provide: CalcomServiceConfig,
+                inject: [
+                    config.ConfigService
+                ],
+                useFactory: calcomServiceConfigFactory
+            },
+            exports.CalcomApi
+        ].concat(_to_consumable_array$1(providers !== null && providers !== void 0 ? providers : []))
+    };
+}
+
+// MARK: Event Types
+var CALCOM_WEBHOOK_BOOKING_CREATED = 'BOOKING_CREATED';
+var CALCOM_WEBHOOK_BOOKING_CANCELLED = 'BOOKING_CANCELLED';
+var CALCOM_WEBHOOK_BOOKING_RESCHEDULED = 'BOOKING_RESCHEDULED';
+var CALCOM_WEBHOOK_BOOKING_CONFIRMED = 'BOOKING_CONFIRMED';
+
+function _define_property$3(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 _object_spread(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$3(target, key, source[key]);
+        });
+    }
+    return target;
+}
+function ownKeys(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(target, source) {
+    source = source != null ? source : {};
+    if (Object.getOwnPropertyDescriptors) {
+        Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
+    } else {
+        ownKeys(Object(source)).forEach(function(key) {
+            Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+        });
+    }
+    return target;
+}
+/**
+ * Creates a CalcomWebhookEvent and treats the data as the input type.
+ */ function calcomWebhookEvent(event) {
+    return {
+        triggerEvent: event.triggerEvent,
+        createdAt: event.createdAt,
+        payload: event.payload
+    };
+}
+var calcomEventHandlerFactory = util.handlerFactory(function(x) {
+    return x.triggerEvent;
+});
+var calcomEventHandlerConfigurerFactory = util.handlerConfigurerFactory({
+    configurerForAccessor: function configurerForAccessor(accessor) {
+        // eslint-disable-next-line
+        var fnWithKey = util.handlerMappedSetFunctionFactory(accessor, calcomWebhookEvent);
+        var configurer = _object_spread_props(_object_spread({}, accessor), {
+            handleBookingCreated: fnWithKey(CALCOM_WEBHOOK_BOOKING_CREATED),
+            handleBookingCancelled: fnWithKey(CALCOM_WEBHOOK_BOOKING_CANCELLED),
+            handleBookingRescheduled: fnWithKey(CALCOM_WEBHOOK_BOOKING_RESCHEDULED),
+            handleBookingConfirmed: fnWithKey(CALCOM_WEBHOOK_BOOKING_CONFIRMED)
+        });
+        return configurer;
+    }
+});
+
+function _class_call_check$3(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+    }
+}
+function _defineProperties$2(target, props) {
+    for(var i = 0; i < props.length; i++){
+        var descriptor = props[i];
+        descriptor.enumerable = descriptor.enumerable || false;
+        descriptor.configurable = true;
+        if ("value" in descriptor) descriptor.writable = true;
+        Object.defineProperty(target, descriptor.key, descriptor);
+    }
+}
+function _create_class$2(Constructor, protoProps, staticProps) {
+    if (staticProps) _defineProperties$2(Constructor, staticProps);
+    return Constructor;
+}
+function _define_property$2(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;
+}
+var CALCOM_WEBHOOK_SECRET_CONFIG_KEY = 'CALCOM_WEBHOOK_SECRET';
+/**
+ * Configuration for CalcomWebhookService
+ */ var CalcomWebhookServiceConfig = /*#__PURE__*/ function() {
+    function CalcomWebhookServiceConfig() {
+        _class_call_check$3(this, CalcomWebhookServiceConfig);
+        _define_property$2(this, "webhookConfig", void 0);
+    }
+    _create_class$2(CalcomWebhookServiceConfig, null, [
+        {
+            key: "assertValidConfig",
+            value: function assertValidConfig(config) {
+                if (!config.webhookConfig.webhookSecret) {
+                    throw new Error('No Cal.com webhook secret specified.');
+                }
+            }
+        }
+    ]);
+    return CalcomWebhookServiceConfig;
+} 
+();
+
+/**
+ * Verifies a Cal.com webhook event using HMAC-SHA256 signature.
+ *
+ * @param secret The webhook signing secret.
+ * @returns A function that verifies a Cal.com webhook event.
+ */ function calcomWebhookEventVerifier(secret) {
+    return function(rawBody, headers) {
+        var _headers_xcalsignature256;
+        var rawBodyString = rawBody.toString('utf8');
+        var signature = (_headers_xcalsignature256 = headers['x-cal-signature-256']) !== null && _headers_xcalsignature256 !== void 0 ? _headers_xcalsignature256 : '';
+        var expectedSignature = crypto.createHmac('sha256', secret).update(rawBodyString).digest('hex');
+        var valid = signature === expectedSignature;
+        var event;
+        try {
+            event = JSON.parse(rawBodyString);
+        } catch (e) {
+            event = {
+                triggerEvent: '',
+                createdAt: '',
+                payload: {}
+            };
+        }
+        var result = {
+            valid: valid,
+            event: event
+        };
+        return result;
+    };
+}
+
+function asyncGeneratorStep$1(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) {
+        resolve(value);
+    } else {
+        Promise.resolve(value).then(_next, _throw);
+    }
+}
+function _async_to_generator$1(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep$1(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep$1(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+function _class_call_check$2(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+    }
+}
+function _defineProperties$1(target, props) {
+    for(var i = 0; i < props.length; i++){
+        var descriptor = props[i];
+        descriptor.enumerable = descriptor.enumerable || false;
+        descriptor.configurable = true;
+        if ("value" in descriptor) descriptor.writable = true;
+        Object.defineProperty(target, descriptor.key, descriptor);
+    }
+}
+function _create_class$1(Constructor, protoProps, staticProps) {
+    if (protoProps) _defineProperties$1(Constructor.prototype, protoProps);
+    return Constructor;
+}
+function _define_property$1(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 _ts_generator$1(thisArg, body) {
+    var f, y, t, _ = {
+        label: 0,
+        sent: function() {
+            if (t[0] & 1) throw t[1];
+            return t[1];
+        },
+        trys: [],
+        ops: []
+    }, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype), d = Object.defineProperty;
+    return d(g, "next", {
+        value: verb(0)
+    }), d(g, "throw", {
+        value: verb(1)
+    }), d(g, "return", {
+        value: verb(2)
+    }), typeof Symbol === "function" && d(g, Symbol.iterator, {
+        value: function() {
+            return this;
+        }
+    }), g;
+    function verb(n) {
+        return function(v) {
+            return step([
+                n,
+                v
+            ]);
+        };
+    }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while(g && (g = 0, op[0] && (_ = 0)), _)try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [
+                op[0] & 2,
+                t.value
+            ];
+            switch(op[0]){
+                case 0:
+                case 1:
+                    t = op;
+                    break;
+                case 4:
+                    _.label++;
+                    return {
+                        value: op[1],
+                        done: false
+                    };
+                case 5:
+                    _.label++;
+                    y = op[1];
+                    op = [
+                        0
+                    ];
+                    continue;
+                case 7:
+                    op = _.ops.pop();
+                    _.trys.pop();
+                    continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+                        _ = 0;
+                        continue;
+                    }
+                    if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+                        _.label = op[1];
+                        break;
+                    }
+                    if (op[0] === 6 && _.label < t[1]) {
+                        _.label = t[1];
+                        t = op;
+                        break;
+                    }
+                    if (t && _.label < t[2]) {
+                        _.label = t[2];
+                        _.ops.push(op);
+                        break;
+                    }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop();
+                    continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) {
+            op = [
+                6,
+                e
+            ];
+            y = 0;
+        } finally{
+            f = t = 0;
+        }
+        if (op[0] & 5) throw op[1];
+        return {
+            value: op[0] ? op[1] : void 0,
+            done: true
+        };
+    }
+}
+/**
+ * Service that makes system changes based on Cal.com webhook events.
+ */ exports.CalcomWebhookService = /*#__PURE__*/ function() {
+    function CalcomWebhookService(config) {
+        _class_call_check$2(this, CalcomWebhookService);
+        _define_property$1(this, "logger", new common.Logger('CalcomWebhookService'));
+        _define_property$1(this, "_verifier", void 0);
+        _define_property$1(this, "handler", calcomEventHandlerFactory());
+        _define_property$1(this, "configure", calcomEventHandlerConfigurerFactory(this.handler));
+        this._verifier = calcomWebhookEventVerifier(config.webhookConfig.webhookSecret);
+    }
+    _create_class$1(CalcomWebhookService, [
+        {
+            key: "updateForWebhook",
+            value: function updateForWebhook(req, rawBody) {
+                return _async_to_generator$1(function() {
+                    var headers, _this__verifier, valid, event, handled, result;
+                    return _ts_generator$1(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                headers = req.headers;
+                                _this__verifier = this._verifier(rawBody, headers), valid = _this__verifier.valid, event = _this__verifier.event;
+                                handled = false;
+                                if (!!valid) return [
+                                    3,
+                                    1
+                                ];
+                                this.logger.warn('Received invalid calcom event: ', event);
+                                return [
+                                    3,
+                                    3
+                                ];
+                            case 1:
+                                return [
+                                    4,
+                                    this.updateForCalcomEvent(event)
+                                ];
+                            case 2:
+                                handled = _state.sent();
+                                _state.label = 3;
+                            case 3:
+                                result = {
+                                    valid: valid,
+                                    handled: handled,
+                                    event: event
+                                };
+                                return [
+                                    2,
+                                    result
+                                ];
+                        }
+                    });
+                }).call(this);
+            }
+        },
+        {
+            key: "updateForCalcomEvent",
+            value: function updateForCalcomEvent(event) {
+                return _async_to_generator$1(function() {
+                    var handled;
+                    return _ts_generator$1(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                return [
+                                    4,
+                                    this.handler(event)
+                                ];
+                            case 1:
+                                handled = _state.sent();
+                                if (!handled) {
+                                    this.logger.warn('Received unexpected/unhandled calcom event: ', event);
+                                }
+                                return [
+                                    2,
+                                    handled
+                                ];
+                        }
+                    });
+                }).call(this);
+            }
+        }
+    ]);
+    return CalcomWebhookService;
+}();
+exports.CalcomWebhookService = __decorate([
+    common.Injectable(),
+    __param(0, common.Inject(CalcomWebhookServiceConfig))
+], exports.CalcomWebhookService);
+
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) {
+        resolve(value);
+    } else {
+        Promise.resolve(value).then(_next, _throw);
+    }
+}
+function _async_to_generator(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+function _class_call_check$1(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+    }
+}
+function _defineProperties(target, props) {
+    for(var i = 0; i < props.length; i++){
+        var descriptor = props[i];
+        descriptor.enumerable = descriptor.enumerable || false;
+        descriptor.configurable = true;
+        if ("value" in descriptor) descriptor.writable = true;
+        Object.defineProperty(target, descriptor.key, descriptor);
+    }
+}
+function _create_class(Constructor, protoProps, staticProps) {
+    if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+    return Constructor;
+}
+function _define_property(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 _ts_generator(thisArg, body) {
+    var f, y, t, _ = {
+        label: 0,
+        sent: function() {
+            if (t[0] & 1) throw t[1];
+            return t[1];
+        },
+        trys: [],
+        ops: []
+    }, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype), d = Object.defineProperty;
+    return d(g, "next", {
+        value: verb(0)
+    }), d(g, "throw", {
+        value: verb(1)
+    }), d(g, "return", {
+        value: verb(2)
+    }), typeof Symbol === "function" && d(g, Symbol.iterator, {
+        value: function() {
+            return this;
+        }
+    }), g;
+    function verb(n) {
+        return function(v) {
+            return step([
+                n,
+                v
+            ]);
+        };
+    }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while(g && (g = 0, op[0] && (_ = 0)), _)try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [
+                op[0] & 2,
+                t.value
+            ];
+            switch(op[0]){
+                case 0:
+                case 1:
+                    t = op;
+                    break;
+                case 4:
+                    _.label++;
+                    return {
+                        value: op[1],
+                        done: false
+                    };
+                case 5:
+                    _.label++;
+                    y = op[1];
+                    op = [
+                        0
+                    ];
+                    continue;
+                case 7:
+                    op = _.ops.pop();
+                    _.trys.pop();
+                    continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+                        _ = 0;
+                        continue;
+                    }
+                    if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+                        _.label = op[1];
+                        break;
+                    }
+                    if (op[0] === 6 && _.label < t[1]) {
+                        _.label = t[1];
+                        t = op;
+                        break;
+                    }
+                    if (t && _.label < t[2]) {
+                        _.label = t[2];
+                        _.ops.push(op);
+                        break;
+                    }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop();
+                    continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) {
+            op = [
+                6,
+                e
+            ];
+            y = 0;
+        } finally{
+            f = t = 0;
+        }
+        if (op[0] & 5) throw op[1];
+        return {
+            value: op[0] ? op[1] : void 0,
+            done: true
+        };
+    }
+}
+exports.CalcomWebhookController = /*#__PURE__*/ function() {
+    function CalcomWebhookController(calcomWebhookService) {
+        _class_call_check$1(this, CalcomWebhookController);
+        _define_property(this, "calcomWebhookService", void 0);
+        this.calcomWebhookService = calcomWebhookService;
+    }
+    _create_class(CalcomWebhookController, [
+        {
+            key: "handleCalcomWebhook",
+            value: function handleCalcomWebhook(res, req, rawBody) {
+                return _async_to_generator(function() {
+                    var _ref, response;
+                    return _ts_generator(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                return [
+                                    4,
+                                    this.calcomWebhookService.updateForWebhook(req, rawBody)
+                                ];
+                            case 1:
+                                _ref = _state.sent(), _ref.valid;
+                                response = res.status(200); // always return a 200 status code
+                                response.json({});
+                                return [
+                                    2
+                                ];
+                        }
+                    });
+                }).call(this);
+            }
+        }
+    ]);
+    return CalcomWebhookController;
+}();
+__decorate([
+    common.Post(),
+    __param(0, common.Res()),
+    __param(1, common.Req()),
+    __param(2, nestjs.RawBody())
+], exports.CalcomWebhookController.prototype, "handleCalcomWebhook", null);
+exports.CalcomWebhookController = __decorate([
+    common.Controller('/webhook/calcom'),
+    __param(0, common.Inject(exports.CalcomWebhookService))
+], exports.CalcomWebhookController);
+
+function _array_like_to_array(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
+    return arr2;
+}
+function _array_without_holes(arr) {
+    if (Array.isArray(arr)) return _array_like_to_array(arr);
+}
+function _class_call_check(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+    }
+}
+function _iterable_to_array(iter) {
+    if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
+}
+function _non_iterable_spread() {
+    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 _to_consumable_array(arr) {
+    return _array_without_holes(arr) || _iterable_to_array(arr) || _unsupported_iterable_to_array(arr) || _non_iterable_spread();
+}
+function _unsupported_iterable_to_array(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _array_like_to_array(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    if (n === "Map" || n === "Set") return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array(o, minLen);
+}
+function calcomWebhookServiceConfigFactory(configService) {
+    var config = {
+        webhookConfig: {
+            webhookSecret: configService.get(CALCOM_WEBHOOK_SECRET_CONFIG_KEY)
+        }
+    };
+    CalcomWebhookServiceConfig.assertValidConfig(config);
+    return config;
+}
+/**
+ * Configures webhooks for the service.
+ */ exports.CalcomWebhookModule = function CalcomWebhookModule() {
+    _class_call_check(this, CalcomWebhookModule);
+};
+exports.CalcomWebhookModule = __decorate([
+    common.Module({
+        imports: [
+            config.ConfigModule
+        ],
+        controllers: [
+            exports.CalcomWebhookController
+        ],
+        exports: [
+            exports.CalcomWebhookService
+        ],
+        providers: [
+            {
+                provide: CalcomWebhookServiceConfig,
+                inject: [
+                    config.ConfigService
+                ],
+                useFactory: calcomWebhookServiceConfigFactory
+            },
+            exports.CalcomWebhookService
+        ]
+    })
+], exports.CalcomWebhookModule);
+/**
+ * Convenience function used to generate ModuleMetadata for an app's CalcomWebhookModule.
+ */ function appCalcomWebhookModuleMetadata(config$1) {
+    var dependencyModule = config$1.dependencyModule, imports = config$1.imports, exports$1 = config$1.exports, providers = config$1.providers;
+    var dependencyModuleImport = dependencyModule ? [
+        dependencyModule
+    ] : [];
+    return {
+        imports: [
+            config.ConfigModule
+        ].concat(_to_consumable_array(dependencyModuleImport), _to_consumable_array(imports !== null && imports !== void 0 ? imports : [])),
+        controllers: [
+            exports.CalcomWebhookController
+        ],
+        exports: [
+            exports.CalcomWebhookService
+        ].concat(_to_consumable_array(exports$1 !== null && exports$1 !== void 0 ? exports$1 : [])),
+        providers: [
+            {
+                provide: CalcomWebhookServiceConfig,
+                inject: [
+                    config.ConfigService
+                ],
+                useFactory: calcomWebhookServiceConfigFactory
+            },
+            exports.CalcomWebhookService
+        ].concat(_to_consumable_array(providers !== null && providers !== void 0 ? providers : []))
+    };
+}
+
+exports.CALCOM_API_KEY_CONFIG_KEY = CALCOM_API_KEY_CONFIG_KEY;
+exports.CALCOM_CLIENT_ID_CONFIG_KEY = CALCOM_CLIENT_ID_CONFIG_KEY;
+exports.CALCOM_CLIENT_SECRET_CONFIG_KEY = CALCOM_CLIENT_SECRET_CONFIG_KEY;
+exports.CALCOM_REFRESH_TOKEN_CONFIG_KEY = CALCOM_REFRESH_TOKEN_CONFIG_KEY;
+exports.CALCOM_SERVER_TOKEN_FILE_KEY = CALCOM_SERVER_TOKEN_FILE_KEY;
+exports.CALCOM_SERVICE_NAME = CALCOM_SERVICE_NAME;
+exports.CALCOM_WEBHOOK_BOOKING_CANCELLED = CALCOM_WEBHOOK_BOOKING_CANCELLED;
+exports.CALCOM_WEBHOOK_BOOKING_CONFIRMED = CALCOM_WEBHOOK_BOOKING_CONFIRMED;
+exports.CALCOM_WEBHOOK_BOOKING_CREATED = CALCOM_WEBHOOK_BOOKING_CREATED;
+exports.CALCOM_WEBHOOK_BOOKING_RESCHEDULED = CALCOM_WEBHOOK_BOOKING_RESCHEDULED;
+exports.CALCOM_WEBHOOK_SECRET_CONFIG_KEY = CALCOM_WEBHOOK_SECRET_CONFIG_KEY;
+exports.CalcomApiContextInstance = CalcomApiContextInstance;
+exports.CalcomOAuthServiceConfig = CalcomOAuthServiceConfig;
+exports.CalcomServiceConfig = CalcomServiceConfig;
+exports.CalcomWebhookServiceConfig = CalcomWebhookServiceConfig;
+exports.DEFAULT_FILE_CALCOM_ACCESS_TOKEN_CACHE_DIR = DEFAULT_FILE_CALCOM_ACCESS_TOKEN_CACHE_DIR;
+exports.appCalcomModuleMetadata = appCalcomModuleMetadata;
+exports.appCalcomOAuthModuleMetadata = appCalcomOAuthModuleMetadata;
+exports.appCalcomWebhookModuleMetadata = appCalcomWebhookModuleMetadata;
+exports.calcomEventHandlerConfigurerFactory = calcomEventHandlerConfigurerFactory;
+exports.calcomEventHandlerFactory = calcomEventHandlerFactory;
+exports.calcomOAuthServiceConfigFactory = calcomOAuthServiceConfigFactory;
+exports.calcomRefreshTokenCacheKey = calcomRefreshTokenCacheKey;
+exports.calcomServiceConfigFactory = calcomServiceConfigFactory;
+exports.calcomWebhookEvent = calcomWebhookEvent;
+exports.calcomWebhookEventVerifier = calcomWebhookEventVerifier;
+exports.calcomWebhookServiceConfigFactory = calcomWebhookServiceConfigFactory;
+exports.fileCalcomOAuthAccessTokenCacheService = fileCalcomOAuthAccessTokenCacheService;
+exports.logMergeCalcomOAuthAccessTokenCacheServiceErrorFunction = logMergeCalcomOAuthAccessTokenCacheServiceErrorFunction;
+exports.memoryCalcomOAuthAccessTokenCacheService = memoryCalcomOAuthAccessTokenCacheService;
+exports.mergeCalcomOAuthAccessTokenCacheServices = mergeCalcomOAuthAccessTokenCacheServices;