@honeybadger-io/js 6.11.3 → 6.12.0

package/dist/server/honeybadger.js

@@ -891,7 +891,7 @@ function default_1$3(_window) {
 }
 events.default = default_1$3;
 
-var client = {};
+var client$1 = {};
 
 var store = {};
 
@@ -1194,8 +1194,8 @@ var __generator$2 = (commonjsGlobal && commonjsGlobal.__generator) || function (
         if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
     }
 };
-Object.defineProperty(client, "__esModule", { value: true });
-client.Client = void 0;
+Object.defineProperty(client$1, "__esModule", { value: true });
+client$1.Client = void 0;
 var util_1$5 = util$1;
 var store_1 = store;
 var throttled_events_logger_1 = throttled_events_logger;
@@ -1214,7 +1214,7 @@ var Client = /** @class */ (function () {
         this.__notifier = {
             name: '@honeybadger-io/core',
             url: 'https://github.com/honeybadger-io/honeybadger-js/tree/master/packages/core',
-            version: '6.11.3'
+            version: '6.12.0'
         };
         this.config = __assign$1(__assign$1({}, defaults_1.CONFIG), opts);
         this.__initStore();
@@ -1592,7 +1592,7 @@ var Client = /** @class */ (function () {
     };
     return Client;
 }());
-client.Client = Client;
+client$1.Client = Client;
 
 var types = {};
 
@@ -1631,7 +1631,7 @@ Object.defineProperty(types, "__esModule", { value: true });
 	Object.defineProperty(exports, "__esModule", { value: true });
 	exports.Plugins = exports.Defaults = exports.Util = exports.Types = exports.Client = void 0;
 	var events_1 = __importDefault(events);
-	var client_1 = client;
+	var client_1 = client$1;
 	Object.defineProperty(exports, "Client", { enumerable: true, get: function () { return client_1.Client; } });
 	__exportStar(store, exports);
 	exports.Types = __importStar(types);
@@ -2488,6 +2488,562 @@ var StackedStore = /** @class */ (function () {
 }());
 stacked_store.StackedStore = StackedStore;
 
+var checkInsManager = {};
+
+var client = {};
+
+var checkIn = {};
+
+var hasRequiredCheckIn;
+
+function requireCheckIn () {
+	if (hasRequiredCheckIn) return checkIn;
+	hasRequiredCheckIn = 1;
+	Object.defineProperty(checkIn, "__esModule", { value: true });
+	checkIn.CheckIn = void 0;
+	var CheckIn = /** @class */ (function () {
+	    function CheckIn(props) {
+	        this.id = props.id;
+	        this.name = props.name;
+	        this.slug = props.slug;
+	        this.scheduleType = props.scheduleType;
+	        this.reportPeriod = props.reportPeriod;
+	        this.gracePeriod = props.gracePeriod;
+	        this.cronSchedule = props.cronSchedule;
+	        this.cronTimezone = props.cronTimezone;
+	        this.deleted = false;
+	    }
+	    CheckIn.prototype.isDeleted = function () {
+	        return this.deleted;
+	    };
+	    CheckIn.prototype.markAsDeleted = function () {
+	        this.deleted = true;
+	    };
+	    CheckIn.prototype.validate = function () {
+	        if (!this.slug) {
+	            throw new Error('slug is required for each check-in');
+	        }
+	        if (!this.scheduleType) {
+	            throw new Error('scheduleType is required for each check-in');
+	        }
+	        if (!['simple', 'cron'].includes(this.scheduleType)) {
+	            throw new Error("".concat(this.slug, " [scheduleType] must be \"simple\" or \"cron\""));
+	        }
+	        if (this.scheduleType === 'simple' && !this.reportPeriod) {
+	            throw new Error("".concat(this.slug, " [reportPeriod] is required for simple check-ins"));
+	        }
+	        if (this.scheduleType === 'cron' && !this.cronSchedule) {
+	            throw new Error("".concat(this.slug, " [cronSchedule] is required for cron check-ins"));
+	        }
+	    };
+	    CheckIn.prototype.asRequestPayload = function () {
+	        var _a, _b;
+	        var payload = {
+	            name: this.name,
+	            schedule_type: this.scheduleType,
+	            slug: this.slug,
+	            grace_period: (_a = this.gracePeriod) !== null && _a !== void 0 ? _a : '' // default is empty string
+	        };
+	        if (this.scheduleType === 'simple') {
+	            payload.report_period = this.reportPeriod;
+	        }
+	        else {
+	            payload.cron_schedule = this.cronSchedule;
+	            payload.cron_timezone = (_b = this.cronTimezone) !== null && _b !== void 0 ? _b : ''; // default is empty string
+	        }
+	        return payload;
+	    };
+	    /**
+	     * Compares two check-ins, usually the one from the API and the one from the config file.
+	     * If the one in the config file does not match the check-in from the API,
+	     * then we issue an update request.
+	     *
+	     * `name`, `gracePeriod` and `cronTimezone` are optional fields that are automatically
+	     * set to a value from the server if one is not provided,
+	     * so we ignore their values if they are not set locally.
+	     */
+	    CheckIn.prototype.isInSync = function (other) {
+	        var ignoreNameCheck = this.name === undefined;
+	        var ignoreGracePeriodCheck = this.gracePeriod === undefined;
+	        var ignoreCronTimezoneCheck = this.cronTimezone === undefined;
+	        return this.slug === other.slug
+	            && this.scheduleType === other.scheduleType
+	            && this.reportPeriod === other.reportPeriod
+	            && this.cronSchedule === other.cronSchedule
+	            && (ignoreNameCheck || this.name === other.name)
+	            && (ignoreGracePeriodCheck || this.gracePeriod === other.gracePeriod)
+	            && (ignoreCronTimezoneCheck || this.cronTimezone === other.cronTimezone);
+	    };
+	    CheckIn.fromResponsePayload = function (payload) {
+	        return new CheckIn({
+	            id: payload.id,
+	            name: payload.name,
+	            slug: payload.slug,
+	            scheduleType: payload.schedule_type,
+	            reportPeriod: payload.report_period,
+	            gracePeriod: payload.grace_period,
+	            cronSchedule: payload.cron_schedule,
+	            cronTimezone: payload.cron_timezone,
+	        });
+	    };
+	    return CheckIn;
+	}());
+	checkIn.CheckIn = CheckIn;
+	
+	return checkIn;
+}
+
+var hasRequiredClient;
+
+function requireClient () {
+	if (hasRequiredClient) return client;
+	hasRequiredClient = 1;
+	var __awaiter = (commonjsGlobal && commonjsGlobal.__awaiter) || function (thisArg, _arguments, P, generator) {
+	    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+	    return new (P || (P = Promise))(function (resolve, reject) {
+	        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+	        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+	        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+	        step((generator = generator.apply(thisArg, _arguments || [])).next());
+	    });
+	};
+	var __generator = (commonjsGlobal && commonjsGlobal.__generator) || function (thisArg, body) {
+	    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+	    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = 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 (_) 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 };
+	    }
+	};
+	Object.defineProperty(client, "__esModule", { value: true });
+	client.CheckInsClient = void 0;
+	var core_1 = src;
+	var check_in_1 = requireCheckIn();
+	var CheckInsClient = /** @class */ (function () {
+	    function CheckInsClient(config, transport) {
+	        this.transport = transport;
+	        this.config = config;
+	        this.logger = config.logger;
+	    }
+	    CheckInsClient.prototype.getProjectId = function (projectApiKey) {
+	        var _a;
+	        return __awaiter(this, void 0, void 0, function () {
+	            var response, data;
+	            return __generator(this, function (_b) {
+	                switch (_b.label) {
+	                    case 0:
+	                        if (!this.config.personalAuthToken || this.config.personalAuthToken === '') {
+	                            throw new Error('personalAuthToken is required');
+	                        }
+	                        return [4 /*yield*/, this.transport.send({
+	                                method: 'GET',
+	                                headers: this.getHeaders(),
+	                                endpoint: core_1.Util.endpoint(this.config.appEndpoint, "v2/project_keys/".concat(projectApiKey)),
+	                                logger: this.logger,
+	                            })];
+	                    case 1:
+	                        response = _b.sent();
+	                        if (response.statusCode !== 200) {
+	                            throw new Error("Failed to fetch project[".concat(projectApiKey, "]: ").concat(this.getErrorMessage(response.body)));
+	                        }
+	                        data = JSON.parse(response.body);
+	                        return [2 /*return*/, (_a = data === null || data === void 0 ? void 0 : data.project) === null || _a === void 0 ? void 0 : _a.id];
+	                }
+	            });
+	        });
+	    };
+	    CheckInsClient.prototype.listForProject = function (projectId) {
+	        return __awaiter(this, void 0, void 0, function () {
+	            var response, data;
+	            return __generator(this, function (_a) {
+	                switch (_a.label) {
+	                    case 0:
+	                        if (!this.config.personalAuthToken || this.config.personalAuthToken === '') {
+	                            throw new Error('personalAuthToken is required');
+	                        }
+	                        return [4 /*yield*/, this.transport.send({
+	                                method: 'GET',
+	                                headers: this.getHeaders(),
+	                                endpoint: core_1.Util.endpoint(this.config.appEndpoint, "v2/projects/".concat(projectId, "/check_ins")),
+	                                logger: this.logger,
+	                            })];
+	                    case 1:
+	                        response = _a.sent();
+	                        if (response.statusCode !== 200) {
+	                            throw new Error("Failed to fetch checkins for project[".concat(projectId, "]: ").concat(this.getErrorMessage(response.body)));
+	                        }
+	                        data = JSON.parse(response.body);
+	                        return [2 /*return*/, data.results.map(function (checkin) { return check_in_1.CheckIn.fromResponsePayload(checkin); })];
+	                }
+	            });
+	        });
+	    };
+	    CheckInsClient.prototype.get = function (projectId, checkInId) {
+	        return __awaiter(this, void 0, void 0, function () {
+	            var response, data;
+	            return __generator(this, function (_a) {
+	                switch (_a.label) {
+	                    case 0:
+	                        if (!this.config.personalAuthToken || this.config.personalAuthToken === '') {
+	                            throw new Error('personalAuthToken is required');
+	                        }
+	                        return [4 /*yield*/, this.transport.send({
+	                                method: 'GET',
+	                                headers: this.getHeaders(),
+	                                endpoint: core_1.Util.endpoint(this.config.appEndpoint, "v2/projects/".concat(projectId, "/check_ins/").concat(checkInId)),
+	                                logger: this.logger,
+	                            })];
+	                    case 1:
+	                        response = _a.sent();
+	                        if (response.statusCode !== 200) {
+	                            throw new Error("Failed to fetch check-in[".concat(checkInId, "] for project[").concat(projectId, "]: ").concat(this.getErrorMessage(response.body)));
+	                        }
+	                        data = JSON.parse(response.body);
+	                        return [2 /*return*/, check_in_1.CheckIn.fromResponsePayload(data)];
+	                }
+	            });
+	        });
+	    };
+	    CheckInsClient.prototype.create = function (projectId, checkIn) {
+	        return __awaiter(this, void 0, void 0, function () {
+	            var response, data;
+	            return __generator(this, function (_a) {
+	                switch (_a.label) {
+	                    case 0:
+	                        if (!this.config.personalAuthToken || this.config.personalAuthToken === '') {
+	                            throw new Error('personalAuthToken is required');
+	                        }
+	                        return [4 /*yield*/, this.transport.send({
+	                                method: 'POST',
+	                                headers: this.getHeaders(),
+	                                endpoint: core_1.Util.endpoint(this.config.appEndpoint, "v2/projects/".concat(projectId, "/check_ins")),
+	                                logger: this.logger,
+	                            }, { check_in: checkIn.asRequestPayload() })];
+	                    case 1:
+	                        response = _a.sent();
+	                        if (response.statusCode !== 201) {
+	                            throw new Error("Failed to create check-in[".concat(checkIn.slug, "] for project[").concat(projectId, "]: ").concat(this.getErrorMessage(response.body)));
+	                        }
+	                        data = JSON.parse(response.body);
+	                        return [2 /*return*/, check_in_1.CheckIn.fromResponsePayload(data)];
+	                }
+	            });
+	        });
+	    };
+	    CheckInsClient.prototype.update = function (projectId, checkIn) {
+	        return __awaiter(this, void 0, void 0, function () {
+	            var response;
+	            return __generator(this, function (_a) {
+	                switch (_a.label) {
+	                    case 0:
+	                        if (!this.config.personalAuthToken || this.config.personalAuthToken === '') {
+	                            throw new Error('personalAuthToken is required');
+	                        }
+	                        return [4 /*yield*/, this.transport.send({
+	                                method: 'PUT',
+	                                headers: this.getHeaders(),
+	                                endpoint: core_1.Util.endpoint(this.config.appEndpoint, "v2/projects/".concat(projectId, "/check_ins/").concat(checkIn.id)),
+	                                logger: this.logger,
+	                            }, { check_in: checkIn.asRequestPayload() })];
+	                    case 1:
+	                        response = _a.sent();
+	                        if (response.statusCode !== 204) {
+	                            throw new Error("Failed to update checkin[".concat(checkIn.slug, "] for project[").concat(projectId, "]: ").concat(this.getErrorMessage(response.body)));
+	                        }
+	                        return [2 /*return*/, checkIn];
+	                }
+	            });
+	        });
+	    };
+	    CheckInsClient.prototype.remove = function (projectId, checkIn) {
+	        return __awaiter(this, void 0, void 0, function () {
+	            var response;
+	            return __generator(this, function (_a) {
+	                switch (_a.label) {
+	                    case 0:
+	                        if (!this.config.personalAuthToken || this.config.personalAuthToken === '') {
+	                            throw new Error('personalAuthToken is required');
+	                        }
+	                        return [4 /*yield*/, this.transport.send({
+	                                method: 'DELETE',
+	                                headers: this.getHeaders(),
+	                                endpoint: core_1.Util.endpoint(this.config.appEndpoint, "v2/projects/".concat(projectId, "/check_ins/").concat(checkIn.id)),
+	                                logger: this.logger,
+	                            })];
+	                    case 1:
+	                        response = _a.sent();
+	                        if (response.statusCode !== 204) {
+	                            throw new Error("Failed to remove checkin[".concat(checkIn.slug, "] for project[").concat(projectId, "]: ").concat(this.getErrorMessage(response.body)));
+	                        }
+	                        return [2 /*return*/];
+	                }
+	            });
+	        });
+	    };
+	    CheckInsClient.prototype.getHeaders = function () {
+	        return {
+	            'Authorization': "Basic ".concat(Buffer.from("".concat(this.config.personalAuthToken, ":")).toString('base64')),
+	            'Content-Type': 'application/json'
+	        };
+	    };
+	    CheckInsClient.prototype.getErrorMessage = function (responseBody) {
+	        var _a;
+	        if (!responseBody) {
+	            return '';
+	        }
+	        try {
+	            var jsonBody = JSON.parse(responseBody);
+	            return (_a = jsonBody.errors) !== null && _a !== void 0 ? _a : '';
+	        }
+	        catch (e) {
+	            return responseBody;
+	        }
+	    };
+	    return CheckInsClient;
+	}());
+	client.CheckInsClient = CheckInsClient;
+	
+	return client;
+}
+
+var hasRequiredCheckInsManager;
+
+function requireCheckInsManager () {
+	if (hasRequiredCheckInsManager) return checkInsManager;
+	hasRequiredCheckInsManager = 1;
+	(function (exports) {
+		var __awaiter = (commonjsGlobal && commonjsGlobal.__awaiter) || function (thisArg, _arguments, P, generator) {
+		    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+		    return new (P || (P = Promise))(function (resolve, reject) {
+		        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+		        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+		        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+		        step((generator = generator.apply(thisArg, _arguments || [])).next());
+		    });
+		};
+		var __generator = (commonjsGlobal && commonjsGlobal.__generator) || function (thisArg, body) {
+		    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+		    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = 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 (_) 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 __spreadArray = (commonjsGlobal && commonjsGlobal.__spreadArray) || function (to, from, pack) {
+		    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+		        if (ar || !(i in from)) {
+		            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+		            ar[i] = from[i];
+		        }
+		    }
+		    return to.concat(ar || Array.prototype.slice.call(from));
+		};
+		Object.defineProperty(exports, "__esModule", { value: true });
+		exports.CheckInsManager = exports.CheckIn = exports.CheckInsClient = void 0;
+		var core_1 = src;
+		var client_1 = requireClient();
+		var transport_1 = transport;
+		var check_in_1 = requireCheckIn();
+		var client_2 = requireClient();
+		Object.defineProperty(exports, "CheckInsClient", { enumerable: true, get: function () { return client_2.CheckInsClient; } });
+		var check_in_2 = requireCheckIn();
+		Object.defineProperty(exports, "CheckIn", { enumerable: true, get: function () { return check_in_2.CheckIn; } });
+		var CheckInsManager = /** @class */ (function () {
+		    function CheckInsManager(config, client) {
+		        var _a, _b, _c, _d, _e, _f;
+		        this.config = {
+		            appEndpoint: (_a = config.appEndpoint) !== null && _a !== void 0 ? _a : core_1.Defaults.CONFIG.appEndpoint,
+		            debug: (_b = config.debug) !== null && _b !== void 0 ? _b : false,
+		            apiKey: (_c = config.apiKey) !== null && _c !== void 0 ? _c : undefined,
+		            personalAuthToken: (_d = config.personalAuthToken) !== null && _d !== void 0 ? _d : undefined,
+		            checkins: (_e = config.checkins) !== null && _e !== void 0 ? _e : [],
+		            logger: (_f = config.logger) !== null && _f !== void 0 ? _f : console,
+		        };
+		        var transport = new transport_1.ServerTransport();
+		        this.logger = core_1.Util.logger(this);
+		        this.client = client !== null && client !== void 0 ? client : new client_1.CheckInsClient({
+		            appEndpoint: config.appEndpoint,
+		            apiKey: config.apiKey,
+		            personalAuthToken: config.personalAuthToken,
+		            logger: this.logger
+		        }, transport);
+		    }
+		    CheckInsManager.prototype.sync = function () {
+		        return __awaiter(this, void 0, void 0, function () {
+		            var localCheckIns, projectId, remoteCheckIns, createdOrUpdated, removed;
+		            return __generator(this, function (_a) {
+		                switch (_a.label) {
+		                    case 0:
+		                        // check if app endpoint is set
+		                        if (!this.config.appEndpoint || this.config.appEndpoint === '') {
+		                            throw new Error('appEndpoint is required');
+		                        }
+		                        // check if api key is set
+		                        if (!this.config.apiKey || this.config.apiKey === '') {
+		                            throw new Error('apiKey is required');
+		                        }
+		                        // check if personal auth token is set
+		                        if (!this.config.personalAuthToken || this.config.personalAuthToken === '') {
+		                            throw new Error('personalAuthToken is required');
+		                        }
+		                        localCheckIns = this.getLocalCheckIns();
+		                        return [4 /*yield*/, this.client.getProjectId(this.config.apiKey)];
+		                    case 1:
+		                        projectId = _a.sent();
+		                        return [4 /*yield*/, this.client.listForProject(projectId)];
+		                    case 2:
+		                        remoteCheckIns = _a.sent();
+		                        return [4 /*yield*/, this.createOrUpdate(projectId, localCheckIns, remoteCheckIns)];
+		                    case 3:
+		                        createdOrUpdated = _a.sent();
+		                        return [4 /*yield*/, this.remove(projectId, localCheckIns, remoteCheckIns)];
+		                    case 4:
+		                        removed = _a.sent();
+		                        return [2 /*return*/, __spreadArray(__spreadArray([], createdOrUpdated, true), removed, true)];
+		                }
+		            });
+		        });
+		    };
+		    CheckInsManager.prototype.getLocalCheckIns = function () {
+		        // create check-ins from configuration and validate them
+		        var localCheckIns = this.config.checkins.map(function (dto) {
+		            var checkIn = new check_in_1.CheckIn(dto);
+		            checkIn.validate();
+		            return checkIn;
+		        });
+		        // validate that we have unique check-in slugs
+		        var checkInSlugs = localCheckIns.map(function (checkIn) { return checkIn.slug; });
+		        var uniqueCheckInSlugs = new Set(checkInSlugs);
+		        if (checkInSlugs.length !== uniqueCheckInSlugs.size) {
+		            throw new Error('check-in slugs must be unique');
+		        }
+		        return localCheckIns;
+		    };
+		    CheckInsManager.prototype.createOrUpdate = function (projectId, localCheckIns, remoteCheckIns) {
+		        return __awaiter(this, void 0, void 0, function () {
+		            var results, _loop_1, this_1, _i, localCheckIns_1, localCheckIn;
+		            return __generator(this, function (_a) {
+		                switch (_a.label) {
+		                    case 0:
+		                        results = [];
+		                        _loop_1 = function (localCheckIn) {
+		                            var remoteCheckIn, _b, _c, _d, _e;
+		                            return __generator(this, function (_f) {
+		                                switch (_f.label) {
+		                                    case 0:
+		                                        remoteCheckIn = remoteCheckIns.find(function (checkIn) {
+		                                            return checkIn.slug === localCheckIn.slug;
+		                                        });
+		                                        if (!!remoteCheckIn) return [3 /*break*/, 2];
+		                                        _c = (_b = results).push;
+		                                        return [4 /*yield*/, this_1.client.create(projectId, localCheckIn)];
+		                                    case 1:
+		                                        _c.apply(_b, [_f.sent()]);
+		                                        return [3 /*break*/, 5];
+		                                    case 2:
+		                                        if (!!localCheckIn.isInSync(remoteCheckIn)) return [3 /*break*/, 4];
+		                                        localCheckIn.id = remoteCheckIn.id;
+		                                        _e = (_d = results).push;
+		                                        return [4 /*yield*/, this_1.client.update(projectId, localCheckIn)];
+		                                    case 3:
+		                                        _e.apply(_d, [_f.sent()]);
+		                                        return [3 /*break*/, 5];
+		                                    case 4:
+		                                        // no change - still need to add to results
+		                                        results.push(remoteCheckIn);
+		                                        _f.label = 5;
+		                                    case 5: return [2 /*return*/];
+		                                }
+		                            });
+		                        };
+		                        this_1 = this;
+		                        _i = 0, localCheckIns_1 = localCheckIns;
+		                        _a.label = 1;
+		                    case 1:
+		                        if (!(_i < localCheckIns_1.length)) return [3 /*break*/, 4];
+		                        localCheckIn = localCheckIns_1[_i];
+		                        return [5 /*yield**/, _loop_1(localCheckIn)];
+		                    case 2:
+		                        _a.sent();
+		                        _a.label = 3;
+		                    case 3:
+		                        _i++;
+		                        return [3 /*break*/, 1];
+		                    case 4: return [2 /*return*/, results];
+		                }
+		            });
+		        });
+		    };
+		    CheckInsManager.prototype.remove = function (projectId, localCheckIns, remoteCheckIns) {
+		        return __awaiter(this, void 0, void 0, function () {
+		            var checkInsToRemove;
+		            var _this = this;
+		            return __generator(this, function (_a) {
+		                checkInsToRemove = remoteCheckIns.filter(function (remoteCheckIn) {
+		                    return !localCheckIns.find(function (localCheckIn) {
+		                        return localCheckIn.slug === remoteCheckIn.slug;
+		                    });
+		                });
+		                return [2 /*return*/, Promise.all(checkInsToRemove.map(function (checkIn) { return __awaiter(_this, void 0, void 0, function () {
+		                        return __generator(this, function (_a) {
+		                            switch (_a.label) {
+		                                case 0: return [4 /*yield*/, this.client.remove(projectId, checkIn)];
+		                                case 1:
+		                                    _a.sent();
+		                                    checkIn.markAsDeleted();
+		                                    return [2 /*return*/, checkIn];
+		                            }
+		                        });
+		                    }); }))];
+		            });
+		        });
+		    };
+		    return CheckInsManager;
+		}());
+		exports.CheckInsManager = CheckInsManager;
+		
+} (checkInsManager));
+	return checkInsManager;
+}
+
 (function (exports) {
 	var __extends = (commonjsGlobal && commonjsGlobal.__extends) || (function () {
 	    var extendStatics = function (d, b) {
@@ -2556,7 +3112,7 @@ stacked_store.StackedStore = StackedStore;
 	};
 	var _a;
 	Object.defineProperty(exports, "__esModule", { value: true });
-	exports.Types = void 0;
+	exports.ServerTransport = exports.CheckIn = exports.CheckInsClient = exports.Types = void 0;
 	var os_1 = __importDefault(require$$0__default["default"]);
 	var domain_1 = __importDefault(require$$1__default$1["default"]);
 	var core_1 = src;
@@ -2724,7 +3280,7 @@ stacked_store.StackedStore = StackedStore;
 	var NOTIFIER = {
 	    name: '@honeybadger-io/js',
 	    url: 'https://github.com/honeybadger-io/honeybadger-js/tree/master/packages/js',
-	    version: '6.11.3'
+	    version: '6.12.0'
 	};
 	var userAgent = function () {
 	    return "Honeybadger JS Server Client ".concat(NOTIFIER.version, ", ").concat(os_1.default.version(), "; ").concat(os_1.default.platform());
@@ -2733,6 +3289,11 @@ stacked_store.StackedStore = StackedStore;
 	singleton.setNotifier(NOTIFIER);
 	var core_2 = src;
 	Object.defineProperty(exports, "Types", { enumerable: true, get: function () { return core_2.Types; } });
+	var check_ins_manager_1 = requireCheckInsManager();
+	Object.defineProperty(exports, "CheckInsClient", { enumerable: true, get: function () { return check_ins_manager_1.CheckInsClient; } });
+	Object.defineProperty(exports, "CheckIn", { enumerable: true, get: function () { return check_ins_manager_1.CheckIn; } });
+	var transport_2 = transport;
+	Object.defineProperty(exports, "ServerTransport", { enumerable: true, get: function () { return transport_2.ServerTransport; } });
 	exports.default = singleton;
 	
 } (server$1));