@dereekb/trello 13.11.14

package/nestjs/index.esm.js

@@ -0,0 +1,1105 @@
+import { Injectable, Inject, Logger, Head, Post, Req, Controller, Module } from '@nestjs/common';
+import { trelloFactory, getBoard, createBoard, updateBoard, deleteBoard, listBoardLists, listBoardCards, listBoardMembers, listBoardLabels, getList, createList, updateList, listCardsInList, getCard, createCard, updateCard, deleteCard, addCommentToCard, addMemberToCard, addLabelToCard, listCardActions, getMember, getMe, createWebhook, getWebhook, updateWebhook, deleteWebhook, listWebhooksForToken } from '@dereekb/trello';
+import { ConfigService, ConfigModule } from '@nestjs/config';
+import { handlerFactory, handlerConfigurerFactory, handlerMappedSetFunctionFactory } from '@dereekb/util';
+import { RawBody } from '@dereekb/nestjs';
+import { timingSafeEqual, createHmac } from 'node:crypto';
+
+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$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;
+}
+var TRELLO_API_KEY_ENV_VAR = 'TRELLO_API_KEY';
+var TRELLO_API_TOKEN_ENV_VAR = 'TRELLO_API_TOKEN';
+/**
+ * Configuration for TrelloApi.
+ */ var TrelloServiceConfig = /*#__PURE__*/ function() {
+    function TrelloServiceConfig() {
+        _class_call_check$5(this, TrelloServiceConfig);
+        _define_property$5(this, "trello", void 0);
+        _define_property$5(this, "factoryConfig", void 0);
+    }
+    _create_class$4(TrelloServiceConfig, null, [
+        {
+            key: "assertValidConfig",
+            value: function assertValidConfig(config) {
+                if (!config.trello.apiKey) {
+                    throw new Error('No Trello API key specified.');
+                }
+                if (!config.trello.apiToken) {
+                    throw new Error('No Trello API token specified.');
+                }
+            }
+        }
+    ]);
+    return TrelloServiceConfig;
+} 
+();
+
+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;
+}
+var TrelloApi = /*#__PURE__*/ function() {
+    function TrelloApi(config) {
+        _class_call_check$4(this, TrelloApi);
+        _define_property$4(this, "config", void 0);
+        _define_property$4(this, "trello", void 0);
+        this.config = config;
+        this.trello = trelloFactory(config.factoryConfig)(config.trello);
+    }
+    _create_class$3(TrelloApi, [
+        {
+            key: "trelloContext",
+            get: function get() {
+                return this.trello.trelloContext;
+            }
+        },
+        {
+            key: "trelloRateLimiter",
+            get: function get() {
+                return this.trello.trelloContext.trelloRateLimiter;
+            }
+        },
+        {
+            key: "getBoard",
+            get: // MARK: Boards
+            function get() {
+                return getBoard(this.trelloContext);
+            }
+        },
+        {
+            key: "createBoard",
+            get: function get() {
+                return createBoard(this.trelloContext);
+            }
+        },
+        {
+            key: "updateBoard",
+            get: function get() {
+                return updateBoard(this.trelloContext);
+            }
+        },
+        {
+            key: "deleteBoard",
+            get: function get() {
+                return deleteBoard(this.trelloContext);
+            }
+        },
+        {
+            key: "listBoardLists",
+            get: function get() {
+                return listBoardLists(this.trelloContext);
+            }
+        },
+        {
+            key: "listBoardCards",
+            get: function get() {
+                return listBoardCards(this.trelloContext);
+            }
+        },
+        {
+            key: "listBoardMembers",
+            get: function get() {
+                return listBoardMembers(this.trelloContext);
+            }
+        },
+        {
+            key: "listBoardLabels",
+            get: function get() {
+                return listBoardLabels(this.trelloContext);
+            }
+        },
+        {
+            key: "getList",
+            get: // MARK: Lists
+            function get() {
+                return getList(this.trelloContext);
+            }
+        },
+        {
+            key: "createList",
+            get: function get() {
+                return createList(this.trelloContext);
+            }
+        },
+        {
+            key: "updateList",
+            get: function get() {
+                return updateList(this.trelloContext);
+            }
+        },
+        {
+            key: "listCardsInList",
+            get: function get() {
+                return listCardsInList(this.trelloContext);
+            }
+        },
+        {
+            key: "getCard",
+            get: // MARK: Cards
+            function get() {
+                return getCard(this.trelloContext);
+            }
+        },
+        {
+            key: "createCard",
+            get: function get() {
+                return createCard(this.trelloContext);
+            }
+        },
+        {
+            key: "updateCard",
+            get: function get() {
+                return updateCard(this.trelloContext);
+            }
+        },
+        {
+            key: "deleteCard",
+            get: function get() {
+                return deleteCard(this.trelloContext);
+            }
+        },
+        {
+            key: "addCommentToCard",
+            get: function get() {
+                return addCommentToCard(this.trelloContext);
+            }
+        },
+        {
+            key: "addMemberToCard",
+            get: function get() {
+                return addMemberToCard(this.trelloContext);
+            }
+        },
+        {
+            key: "addLabelToCard",
+            get: function get() {
+                return addLabelToCard(this.trelloContext);
+            }
+        },
+        {
+            key: "listCardActions",
+            get: function get() {
+                return listCardActions(this.trelloContext);
+            }
+        },
+        {
+            key: "getMember",
+            get: // MARK: Members
+            function get() {
+                return getMember(this.trelloContext);
+            }
+        },
+        {
+            key: "getMe",
+            get: function get() {
+                return getMe(this.trelloContext);
+            }
+        },
+        {
+            key: "createWebhook",
+            get: // MARK: Webhooks
+            function get() {
+                return createWebhook(this.trelloContext);
+            }
+        },
+        {
+            key: "getWebhook",
+            get: function get() {
+                return getWebhook(this.trelloContext);
+            }
+        },
+        {
+            key: "updateWebhook",
+            get: function get() {
+                return updateWebhook(this.trelloContext);
+            }
+        },
+        {
+            key: "deleteWebhook",
+            get: function get() {
+                return deleteWebhook(this.trelloContext);
+            }
+        },
+        {
+            key: "listWebhooksForToken",
+            get: function get() {
+                return listWebhooksForToken(this.trelloContext);
+            }
+        }
+    ]);
+    return TrelloApi;
+}();
+TrelloApi = __decorate([
+    Injectable(),
+    __param(0, Inject(TrelloServiceConfig))
+], TrelloApi);
+
+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 _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);
+}
+/**
+ * Default factory function for creating TrelloServiceConfig from ConfigService.
+ *
+ * Reads `TRELLO_API_KEY` and `TRELLO_API_TOKEN` from the environment.
+ *
+ * @param configService The NestJS ConfigService.
+ * @returns A validated TrelloServiceConfig.
+ */ function trelloServiceConfigFactory(configService) {
+    var config = {
+        trello: {
+            apiKey: configService.get(TRELLO_API_KEY_ENV_VAR),
+            apiToken: configService.get(TRELLO_API_TOKEN_ENV_VAR)
+        }
+    };
+    TrelloServiceConfig.assertValidConfig(config);
+    return config;
+}
+/**
+ * Convenience function used to generate ModuleMetadata for an app's TrelloModule.
+ *
+ * @param config Optional additional module metadata overrides.
+ * @returns Module metadata for the Trello module.
+ */ function appTrelloModuleMetadata(config) {
+    var _ref = config !== null && config !== void 0 ? config : {}, imports = _ref.imports, exports = _ref.exports, providers = _ref.providers;
+    return {
+        imports: [
+            ConfigModule
+        ].concat(_to_consumable_array(imports !== null && imports !== void 0 ? imports : [])),
+        exports: [
+            TrelloApi
+        ].concat(_to_consumable_array(exports !== null && exports !== void 0 ? exports : [])),
+        providers: [
+            {
+                provide: TrelloServiceConfig,
+                inject: [
+                    ConfigService
+                ],
+                useFactory: trelloServiceConfigFactory
+            },
+            TrelloApi
+        ].concat(_to_consumable_array(providers !== null && providers !== void 0 ? providers : []))
+    };
+}
+
+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;
+}
+/**
+ * Action type emitted when a new card is created.
+ */ var TRELLO_WEBHOOK_CREATE_CARD_ACTION_TYPE = 'createCard';
+/**
+ * Action type emitted when a card is updated.
+ */ var TRELLO_WEBHOOK_UPDATE_CARD_ACTION_TYPE = 'updateCard';
+/**
+ * Action type emitted when a card is deleted.
+ */ var TRELLO_WEBHOOK_DELETE_CARD_ACTION_TYPE = 'deleteCard';
+/**
+ * Action type emitted when a comment is added to a card.
+ */ var TRELLO_WEBHOOK_COMMENT_CARD_ACTION_TYPE = 'commentCard';
+/**
+ * Action type emitted when a member is added to a card.
+ */ var TRELLO_WEBHOOK_ADD_MEMBER_TO_CARD_ACTION_TYPE = 'addMemberToCard';
+/**
+ * Action type emitted when a member is removed from a card.
+ */ var TRELLO_WEBHOOK_REMOVE_MEMBER_FROM_CARD_ACTION_TYPE = 'removeMemberFromCard';
+/**
+ * Action type emitted when a board is updated.
+ */ var TRELLO_WEBHOOK_UPDATE_BOARD_ACTION_TYPE = 'updateBoard';
+/**
+ * Re-narrows an UntypedTrelloWebhookEvent's payload to the given action data type.
+ *
+ * @param event The untyped event.
+ * @returns A typed view over the same event.
+ */ function trelloWebhookEvent(event) {
+    return {
+        action: event.action,
+        model: event.model,
+        webhook: event.webhook
+    };
+}
+var trelloEventHandlerFactory = handlerFactory(function(x) {
+    return x.action.type;
+});
+var trelloEventHandlerConfigurerFactory = handlerConfigurerFactory({
+    configurerForAccessor: function configurerForAccessor(accessor) {
+        var fnWithKey = handlerMappedSetFunctionFactory(accessor, trelloWebhookEvent);
+        var configurer = _object_spread_props(_object_spread({}, accessor), {
+            handleCreateCard: fnWithKey(TRELLO_WEBHOOK_CREATE_CARD_ACTION_TYPE),
+            handleUpdateCard: fnWithKey(TRELLO_WEBHOOK_UPDATE_CARD_ACTION_TYPE),
+            handleDeleteCard: fnWithKey(TRELLO_WEBHOOK_DELETE_CARD_ACTION_TYPE),
+            handleCommentCard: fnWithKey(TRELLO_WEBHOOK_COMMENT_CARD_ACTION_TYPE),
+            handleAddMemberToCard: fnWithKey(TRELLO_WEBHOOK_ADD_MEMBER_TO_CARD_ACTION_TYPE),
+            handleRemoveMemberFromCard: fnWithKey(TRELLO_WEBHOOK_REMOVE_MEMBER_FROM_CARD_ACTION_TYPE),
+            handleUpdateBoard: fnWithKey(TRELLO_WEBHOOK_UPDATE_BOARD_ACTION_TYPE)
+        });
+        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 TRELLO_APP_SECRET_ENV_VAR = 'TRELLO_APP_SECRET';
+var TRELLO_WEBHOOK_CALLBACK_URL_ENV_VAR = 'TRELLO_WEBHOOK_CALLBACK_URL';
+/**
+ * Configuration for {@link TrelloWebhookService}.
+ */ var TrelloWebhookServiceConfig = /*#__PURE__*/ function() {
+    function TrelloWebhookServiceConfig() {
+        _class_call_check$3(this, TrelloWebhookServiceConfig);
+        _define_property$2(this, "webhookConfig", void 0);
+    }
+    _create_class$2(TrelloWebhookServiceConfig, null, [
+        {
+            key: "assertValidConfig",
+            value: function assertValidConfig(config) {
+                if (!config.webhookConfig.appSecret) {
+                    throw new Error('No Trello app secret specified.');
+                }
+                if (!config.webhookConfig.callbackUrl) {
+                    throw new Error('No Trello webhook callback URL specified.');
+                }
+            }
+        }
+    ]);
+    return TrelloWebhookServiceConfig;
+} 
+();
+
+/**
+ * Computes the expected `X-Trello-Webhook` value for the given body + callback URL.
+ *
+ * Exported for testability.
+ *
+ * @param appSecret The Trello app secret.
+ * @param rawBody The raw request body bytes.
+ * @param callbackUrl The exact callback URL configured for this webhook.
+ * @returns The expected base64 signature value.
+ */ function trelloWebhookExpectedSignature(appSecret, rawBody, callbackUrl) {
+    var hmac = createHmac('sha1', appSecret);
+    hmac.update(rawBody);
+    hmac.update(callbackUrl);
+    return hmac.digest('base64');
+}
+/**
+ * Verifies a Trello webhook event header.
+ *
+ * @see https://developer.atlassian.com/cloud/trello/guides/rest-api/webhooks/#webhook-signatures
+ *
+ * @param config The verifier configuration.
+ * @returns A function that verifies a Trello webhook event.
+ */ function trelloWebhookEventVerifier(config) {
+    var appSecret = config.appSecret, callbackUrl = config.callbackUrl;
+    return function(request, rawBody) {
+        var headerValue = request.headers['x-trello-webhook'];
+        var signature = typeof headerValue === 'string' ? headerValue : Array.isArray(headerValue) ? headerValue[0] : undefined;
+        var valid = false;
+        if (signature) {
+            var expected = trelloWebhookExpectedSignature(appSecret, rawBody, callbackUrl);
+            var expectedBuffer = Buffer.from(expected);
+            var signatureBuffer = Buffer.from(signature);
+            valid = expectedBuffer.length === signatureBuffer.length && timingSafeEqual(expectedBuffer, signatureBuffer);
+        }
+        var event;
+        if (valid) {
+            try {
+                event = JSON.parse(rawBody.toString('utf8'));
+            } catch (unused) {
+                return {
+                    valid: false
+                };
+            }
+        }
+        return {
+            valid: valid,
+            event: event
+        };
+    };
+}
+
+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 processes Trello webhook events.
+ *
+ * Verifies the signature, then dispatches verified events through a {@link Handler}
+ * configured via {@link TrelloEventHandlerConfigurer}.
+ */ var TrelloWebhookService = /*#__PURE__*/ function() {
+    function TrelloWebhookService(config) {
+        _class_call_check$2(this, TrelloWebhookService);
+        _define_property$1(this, "logger", new Logger('TrelloWebhookService'));
+        _define_property$1(this, "_verifier", void 0);
+        _define_property$1(this, "handler", trelloEventHandlerFactory());
+        _define_property$1(this, "configure", trelloEventHandlerConfigurerFactory(this.handler));
+        this._verifier = trelloWebhookEventVerifier({
+            appSecret: config.webhookConfig.appSecret,
+            callbackUrl: config.webhookConfig.callbackUrl
+        });
+    }
+    _create_class$1(TrelloWebhookService, [
+        {
+            key: "updateForWebhook",
+            value: function updateForWebhook(req, rawBody) {
+                return _async_to_generator$1(function() {
+                    var _this__verifier, valid, event, handled;
+                    return _ts_generator$1(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                _this__verifier = this._verifier(req, rawBody), valid = _this__verifier.valid, event = _this__verifier.event;
+                                handled = false;
+                                if (!!valid) return [
+                                    3,
+                                    1
+                                ];
+                                this.logger.warn('Received invalid Trello webhook event');
+                                return [
+                                    3,
+                                    3
+                                ];
+                            case 1:
+                                if (!event) return [
+                                    3,
+                                    3
+                                ];
+                                return [
+                                    4,
+                                    this.updateForTrelloEvent(event)
+                                ];
+                            case 2:
+                                handled = _state.sent();
+                                _state.label = 3;
+                            case 3:
+                                return [
+                                    2,
+                                    {
+                                        valid: valid,
+                                        handled: handled,
+                                        event: event
+                                    }
+                                ];
+                        }
+                    });
+                }).call(this);
+            }
+        },
+        {
+            key: "updateForTrelloEvent",
+            value: function updateForTrelloEvent(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("Unhandled Trello webhook action type: ".concat(event.action.type));
+                                }
+                                return [
+                                    2,
+                                    handled
+                                ];
+                        }
+                    });
+                }).call(this);
+            }
+        }
+    ]);
+    return TrelloWebhookService;
+}();
+TrelloWebhookService = __decorate([
+    Injectable(),
+    __param(0, Inject(TrelloWebhookServiceConfig))
+], TrelloWebhookService);
+
+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
+        };
+    }
+}
+var TrelloWebhookController = /*#__PURE__*/ function() {
+    function TrelloWebhookController(trelloWebhookService) {
+        _class_call_check$1(this, TrelloWebhookController);
+        _define_property(this, "trelloWebhookService", void 0);
+        this.trelloWebhookService = trelloWebhookService;
+    }
+    _create_class(TrelloWebhookController, [
+        {
+            /**
+     * Endpoint Trello pings with HEAD during webhook registration. Must return 200.
+     */ key: "handleTrelloWebhookHead",
+            value: function handleTrelloWebhookHead() {
+            // Empty body, 200 status.
+            }
+        },
+        {
+            key: "handleTrelloWebhook",
+            value: function handleTrelloWebhook(req, rawBody) {
+                return _async_to_generator(function() {
+                    return _ts_generator(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                return [
+                                    4,
+                                    this.trelloWebhookService.updateForWebhook(req, rawBody)
+                                ];
+                            case 1:
+                                _state.sent();
+                                return [
+                                    2
+                                ];
+                        }
+                    });
+                }).call(this);
+            }
+        }
+    ]);
+    return TrelloWebhookController;
+}();
+__decorate([
+    Head()
+], TrelloWebhookController.prototype, "handleTrelloWebhookHead", null);
+__decorate([
+    Post(),
+    __param(0, Req()),
+    __param(1, RawBody())
+], TrelloWebhookController.prototype, "handleTrelloWebhook", null);
+TrelloWebhookController = __decorate([
+    Controller('/webhook/trello'),
+    __param(0, Inject(TrelloWebhookService))
+], TrelloWebhookController);
+
+function _class_call_check(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+    }
+}
+/**
+ * Factory function that creates TrelloWebhookServiceConfig from NestJS ConfigService.
+ *
+ * Reads `TRELLO_APP_SECRET` and `TRELLO_WEBHOOK_CALLBACK_URL` from the environment.
+ *
+ * @param configService The NestJS ConfigService.
+ * @returns A validated TrelloWebhookServiceConfig.
+ */ function trelloWebhookServiceConfigFactory(configService) {
+    var config = {
+        webhookConfig: {
+            appSecret: configService.get(TRELLO_APP_SECRET_ENV_VAR),
+            callbackUrl: configService.get(TRELLO_WEBHOOK_CALLBACK_URL_ENV_VAR)
+        }
+    };
+    TrelloWebhookServiceConfig.assertValidConfig(config);
+    return config;
+}
+var TrelloWebhookModule = function TrelloWebhookModule() {
+    _class_call_check(this, TrelloWebhookModule);
+};
+TrelloWebhookModule = __decorate([
+    Module({
+        imports: [
+            ConfigModule
+        ],
+        controllers: [
+            TrelloWebhookController
+        ],
+        exports: [
+            TrelloWebhookService
+        ],
+        providers: [
+            {
+                provide: TrelloWebhookServiceConfig,
+                inject: [
+                    ConfigService
+                ],
+                useFactory: trelloWebhookServiceConfigFactory
+            },
+            TrelloWebhookService
+        ]
+    })
+], TrelloWebhookModule);
+
+export { TRELLO_API_KEY_ENV_VAR, TRELLO_API_TOKEN_ENV_VAR, TRELLO_APP_SECRET_ENV_VAR, TRELLO_WEBHOOK_ADD_MEMBER_TO_CARD_ACTION_TYPE, TRELLO_WEBHOOK_CALLBACK_URL_ENV_VAR, TRELLO_WEBHOOK_COMMENT_CARD_ACTION_TYPE, TRELLO_WEBHOOK_CREATE_CARD_ACTION_TYPE, TRELLO_WEBHOOK_DELETE_CARD_ACTION_TYPE, TRELLO_WEBHOOK_REMOVE_MEMBER_FROM_CARD_ACTION_TYPE, TRELLO_WEBHOOK_UPDATE_BOARD_ACTION_TYPE, TRELLO_WEBHOOK_UPDATE_CARD_ACTION_TYPE, TrelloApi, TrelloServiceConfig, TrelloWebhookController, TrelloWebhookModule, TrelloWebhookService, TrelloWebhookServiceConfig, appTrelloModuleMetadata, trelloEventHandlerConfigurerFactory, trelloEventHandlerFactory, trelloServiceConfigFactory, trelloWebhookEvent, trelloWebhookEventVerifier, trelloWebhookExpectedSignature, trelloWebhookServiceConfigFactory };