airbyte-faros-destination 0.1.53

package/lib/converters/statuspage/common.js

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StatusPageConverter = exports.IncidentSeverityCategory = exports.IncidentPriorityCategory = exports.IncidentStatusCategory = exports.StatuspageIncidentStatus = exports.StatuspageIncidentImpact = exports.IncidentEventTypeCategory = exports.ComponentStatus = void 0;
+const converter_1 = require("../converter");
+var ComponentStatus;
+(function (ComponentStatus) {
+    ComponentStatus["degraded_performance"] = "degraded_performance";
+    ComponentStatus["major_outage"] = "major_outage";
+    ComponentStatus["operational"] = "operational";
+    ComponentStatus["partial_outage"] = "partial_outage";
+    ComponentStatus["under_maintenance"] = "under_maintenance";
+})(ComponentStatus = exports.ComponentStatus || (exports.ComponentStatus = {}));
+var IncidentEventTypeCategory;
+(function (IncidentEventTypeCategory) {
+    IncidentEventTypeCategory["Created"] = "Created";
+    IncidentEventTypeCategory["Acknowledged"] = "Acknowledged";
+    IncidentEventTypeCategory["Resolved"] = "Resolved";
+    IncidentEventTypeCategory["Custom"] = "Custom";
+})(IncidentEventTypeCategory = exports.IncidentEventTypeCategory || (exports.IncidentEventTypeCategory = {}));
+var StatuspageIncidentImpact;
+(function (StatuspageIncidentImpact) {
+    StatuspageIncidentImpact["Critical"] = "critical";
+    StatuspageIncidentImpact["Major"] = "major";
+    StatuspageIncidentImpact["Minor"] = "minor";
+    StatuspageIncidentImpact["None"] = "none";
+})(StatuspageIncidentImpact = exports.StatuspageIncidentImpact || (exports.StatuspageIncidentImpact = {}));
+var StatuspageIncidentStatus;
+(function (StatuspageIncidentStatus) {
+    StatuspageIncidentStatus["Identified"] = "identified";
+    StatuspageIncidentStatus["Investigating"] = "investigating";
+    StatuspageIncidentStatus["Monitoring"] = "monitoring";
+    StatuspageIncidentStatus["Postmortem"] = "postmortem";
+    StatuspageIncidentStatus["Resolved"] = "resolved";
+})(StatuspageIncidentStatus = exports.StatuspageIncidentStatus || (exports.StatuspageIncidentStatus = {}));
+var IncidentStatusCategory;
+(function (IncidentStatusCategory) {
+    IncidentStatusCategory["Identified"] = "Identified";
+    IncidentStatusCategory["Investigating"] = "Investigating";
+    IncidentStatusCategory["Monitoring"] = "Monitoring";
+    IncidentStatusCategory["Resolved"] = "Resolved";
+    IncidentStatusCategory["Custom"] = "Custom";
+})(IncidentStatusCategory = exports.IncidentStatusCategory || (exports.IncidentStatusCategory = {}));
+var IncidentPriorityCategory;
+(function (IncidentPriorityCategory) {
+    IncidentPriorityCategory["Critical"] = "Critical";
+    IncidentPriorityCategory["High"] = "High";
+    IncidentPriorityCategory["Medium"] = "Medium";
+    IncidentPriorityCategory["Low"] = "Low";
+    IncidentPriorityCategory["Custom"] = "Custom";
+})(IncidentPriorityCategory = exports.IncidentPriorityCategory || (exports.IncidentPriorityCategory = {}));
+var IncidentSeverityCategory;
+(function (IncidentSeverityCategory) {
+    IncidentSeverityCategory["Sev1"] = "Sev1";
+    IncidentSeverityCategory["Sev2"] = "Sev2";
+    IncidentSeverityCategory["Sev3"] = "Sev3";
+    IncidentSeverityCategory["Sev4"] = "Sev4";
+    IncidentSeverityCategory["Sev5"] = "Sev5";
+    IncidentSeverityCategory["Custom"] = "Custom";
+})(IncidentSeverityCategory = exports.IncidentSeverityCategory || (exports.IncidentSeverityCategory = {}));
+/** StatusPage converter base */
+class StatusPageConverter extends converter_1.Converter {
+    constructor() {
+        super(...arguments);
+        this.source = 'StatusPage';
+    }
+    /** Every StatusPage record have id property */
+    id(record) {
+        var _a, _b;
+        return (_b = (_a = record === null || record === void 0 ? void 0 : record.record) === null || _a === void 0 ? void 0 : _a.data) === null || _b === void 0 ? void 0 : _b.id;
+    }
+    statuspageConfig(ctx) {
+        var _a, _b;
+        return (_b = (_a = ctx.config.source_specific_configs) === null || _a === void 0 ? void 0 : _a.statuspage) !== null && _b !== void 0 ? _b : {};
+    }
+    applicationMapping(ctx) {
+        var _a, _b;
+        return ((_b = (0, converter_1.parseObjectConfig)((_a = this.statuspageConfig(ctx)) === null || _a === void 0 ? void 0 : _a.application_mapping, 'Application Mapping')) !== null && _b !== void 0 ? _b : {});
+    }
+}
+exports.StatusPageConverter = StatusPageConverter;

package/lib/converters/statuspage/incident_updates.d.ts

@@ -0,0 +1,8 @@
+import { AirbyteRecord } from 'faros-airbyte-cdk';
+import { DestinationModel, DestinationRecord, StreamContext } from '../converter';
+import { StatusPageConverter } from './common';
+export declare class IncidentUpdates extends StatusPageConverter {
+    readonly destinationModels: ReadonlyArray<DestinationModel>;
+    convert(record: AirbyteRecord, ctx: StreamContext): Promise<ReadonlyArray<DestinationRecord>>;
+    private eventType;
+}

package/lib/converters/statuspage/incident_updates.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IncidentUpdates = void 0;
+const faros_feeds_sdk_1 = require("faros-feeds-sdk");
+const common_1 = require("./common");
+class IncidentUpdates extends common_1.StatusPageConverter {
+    constructor() {
+        super(...arguments);
+        this.destinationModels = [
+            'ims_IncidentEvent',
+        ];
+    }
+    async convert(record, ctx) {
+        const source = this.streamName.source;
+        const update = record.record.data;
+        return [
+            {
+                model: 'ims_IncidentEvent',
+                record: {
+                    uid: update.id,
+                    type: this.eventType(update.status),
+                    createdAt: faros_feeds_sdk_1.Utils.toDate(update.created_at),
+                    detail: update.body,
+                    incident: { uid: update.incident_id, source },
+                },
+            },
+        ];
+    }
+    eventType(updateStatus) {
+        const detail = updateStatus;
+        switch (updateStatus) {
+            case common_1.StatuspageIncidentStatus.Investigating:
+                return { category: common_1.IncidentEventTypeCategory.Created, detail };
+            case common_1.StatuspageIncidentStatus.Identified:
+                return { category: common_1.IncidentEventTypeCategory.Acknowledged, detail };
+            case common_1.StatuspageIncidentStatus.Resolved:
+                return { category: common_1.IncidentEventTypeCategory.Resolved, detail };
+            case common_1.StatuspageIncidentStatus.Monitoring:
+            case common_1.StatuspageIncidentStatus.Postmortem:
+            default:
+                return { category: common_1.IncidentEventTypeCategory.Custom, detail };
+        }
+    }
+}
+exports.IncidentUpdates = IncidentUpdates;

package/lib/converters/statuspage/incidents.d.ts

@@ -0,0 +1,10 @@
+import { AirbyteRecord } from 'faros-airbyte-cdk';
+import { DestinationModel, DestinationRecord, StreamContext } from '../converter';
+import { StatusPageConverter } from './common';
+export declare class Incidents extends StatusPageConverter {
+    readonly destinationModels: ReadonlyArray<DestinationModel>;
+    convert(record: AirbyteRecord, ctx: StreamContext): Promise<ReadonlyArray<DestinationRecord>>;
+    private getPriority;
+    private getSeverity;
+    private getIncidentStatus;
+}

package/lib/converters/statuspage/incidents.js

@@ -0,0 +1,128 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Incidents = void 0;
+const faros_feeds_sdk_1 = require("faros-feeds-sdk");
+const common_1 = require("./common");
+class Incidents extends common_1.StatusPageConverter {
+    constructor() {
+        super(...arguments);
+        this.destinationModels = [
+            'compute_Application',
+            'ims_Incident',
+            'ims_IncidentApplicationImpact',
+        ];
+    }
+    async convert(record, ctx) {
+        var _a;
+        const source = this.streamName.source;
+        const incident = record.record.data;
+        const res = [];
+        const applicationMapping = this.applicationMapping(ctx);
+        const incidentRef = { uid: incident.id, source };
+        const createdAt = faros_feeds_sdk_1.Utils.toDate(incident.created_at);
+        let acknowledgedAt = faros_feeds_sdk_1.Utils.toDate(incident.created_at); // StatusPage doesn't have "triggered" semantic status
+        const resolvedAt = incident.resolved_at
+            ? faros_feeds_sdk_1.Utils.toDate(incident.resolved_at)
+            : undefined, updatedAt = faros_feeds_sdk_1.Utils.toDate(incident.updated_at);
+        for (const update of incident.incident_updates) {
+            const eventTime = faros_feeds_sdk_1.Utils.toDate(update.created_at);
+            if (update.status === common_1.StatuspageIncidentStatus.Investigating) {
+                acknowledgedAt = eventTime;
+            }
+        }
+        // StatusPage doesn't have incident severity, take "severity" of affected component/service
+        let severity = undefined;
+        for (const component of incident.components) {
+            const thisSeverity = this.getSeverity(component.status);
+            if (!severity)
+                severity = thisSeverity;
+            if (thisSeverity.category < severity.category)
+                severity = thisSeverity;
+        }
+        res.push({
+            model: 'ims_Incident',
+            record: {
+                ...incidentRef,
+                title: incident.name,
+                description: incident.postmortem_body,
+                url: incident.shortlink,
+                createdAt,
+                updatedAt,
+                acknowledgedAt,
+                resolvedAt,
+                priority: this.getPriority(incident.impact),
+                severity,
+                status: this.getIncidentStatus(incident.status),
+            },
+        });
+        for (const service of incident.components) {
+            let application = { name: service.name, platform: '' };
+            if (service.name in applicationMapping &&
+                applicationMapping[service.name].name) {
+                const mappedApp = applicationMapping[service.name];
+                application = {
+                    name: mappedApp.name,
+                    platform: (_a = mappedApp.platform) !== null && _a !== void 0 ? _a : application.platform,
+                };
+            }
+            res.push({ model: 'compute_Application', record: application });
+            res.push({
+                model: 'ims_IncidentApplicationImpact',
+                record: {
+                    incident: incidentRef,
+                    application,
+                },
+            });
+        }
+        return res;
+    }
+    getPriority(impact) {
+        const detail = impact;
+        switch (impact) {
+            case common_1.StatuspageIncidentImpact.Critical:
+                return { category: common_1.IncidentPriorityCategory.Critical, detail };
+            case common_1.StatuspageIncidentImpact.Major:
+                return { category: common_1.IncidentPriorityCategory.High, detail };
+            case common_1.StatuspageIncidentImpact.Minor:
+                return { category: common_1.IncidentPriorityCategory.Medium, detail };
+            case common_1.StatuspageIncidentImpact.None:
+                return { category: common_1.IncidentPriorityCategory.Low, detail };
+            default:
+                return { category: common_1.IncidentPriorityCategory.Custom, detail };
+        }
+    }
+    getSeverity(componentStatus) {
+        const detail = componentStatus;
+        switch (componentStatus) {
+            case common_1.ComponentStatus.major_outage:
+                return { category: common_1.IncidentSeverityCategory.Sev1, detail };
+            case common_1.ComponentStatus.partial_outage:
+                return { category: common_1.IncidentSeverityCategory.Sev2, detail };
+            case common_1.ComponentStatus.degraded_performance:
+                return { category: common_1.IncidentSeverityCategory.Sev3, detail };
+            case common_1.ComponentStatus.under_maintenance:
+                return { category: common_1.IncidentSeverityCategory.Sev4, detail };
+            case common_1.ComponentStatus.operational:
+                return { category: common_1.IncidentSeverityCategory.Sev5, detail };
+            default:
+                return { category: common_1.IncidentSeverityCategory.Custom, detail };
+        }
+    }
+    getIncidentStatus(incidentState) {
+        const detail = incidentState;
+        switch (incidentState) {
+            case common_1.StatuspageIncidentStatus.Investigating:
+                return { category: common_1.IncidentStatusCategory.Investigating, detail };
+            case common_1.StatuspageIncidentStatus.Identified:
+                return { category: common_1.IncidentStatusCategory.Identified, detail };
+            case common_1.StatuspageIncidentStatus.Monitoring:
+            case common_1.StatuspageIncidentStatus.Postmortem:
+                return { category: common_1.IncidentStatusCategory.Monitoring, detail };
+            case common_1.StatuspageIncidentStatus.Resolved:
+                return { category: common_1.IncidentStatusCategory.Resolved, detail };
+            default:
+                return { category: common_1.IncidentStatusCategory.Custom, detail };
+        }
+    }
+}
+exports.Incidents = Incidents;

package/lib/converters/statuspage/users.d.ts

@@ -0,0 +1,7 @@
+import { AirbyteRecord } from 'faros-airbyte-cdk';
+import { DestinationModel, DestinationRecord, StreamContext } from '../converter';
+import { StatusPageConverter } from './common';
+export declare class Users extends StatusPageConverter {
+    readonly destinationModels: ReadonlyArray<DestinationModel>;
+    convert(record: AirbyteRecord, ctx: StreamContext): Promise<ReadonlyArray<DestinationRecord>>;
+}

package/lib/converters/statuspage/users.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Users = void 0;
+const common_1 = require("./common");
+class Users extends common_1.StatusPageConverter {
+    constructor() {
+        super(...arguments);
+        this.destinationModels = ['ims_User'];
+    }
+    async convert(record, ctx) {
+        const source = this.streamName.source;
+        const user = record.record.data;
+        return [
+            {
+                model: 'ims_User',
+                record: {
+                    uid: user.id,
+                    email: user.email,
+                    name: `${user.first_name} ${user.last_name}`,
+                    source,
+                },
+            },
+        ];
+    }
+}
+exports.Users = Users;

package/lib/converters/victorops/common.d.ts

@@ -0,0 +1,16 @@
+import { Converter, StreamContext } from '../converter';
+declare type ApplicationMapping = Record<string, {
+    name: string;
+    platform?: string;
+}>;
+interface VictorOpsConfig {
+    readonly application_mapping?: ApplicationMapping;
+    readonly application_field?: string;
+}
+export declare abstract class VictorOpsConverter extends Converter {
+    source: string;
+    protected victoropsConfig(ctx: StreamContext): VictorOpsConfig;
+    protected applicationMapping(ctx: StreamContext): ApplicationMapping;
+    protected applicationField(ctx: StreamContext): string;
+}
+export {};

package/lib/converters/victorops/common.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VictorOpsConverter = void 0;
+const converter_1 = require("../converter");
+const DEFAULT_APPLICATION_FIELD = 'service';
+class VictorOpsConverter extends converter_1.Converter {
+    constructor() {
+        super(...arguments);
+        this.source = 'VictorOps';
+    }
+    victoropsConfig(ctx) {
+        var _a, _b;
+        return (_b = (_a = ctx.config.source_specific_configs) === null || _a === void 0 ? void 0 : _a.victorops) !== null && _b !== void 0 ? _b : {};
+    }
+    applicationMapping(ctx) {
+        var _a, _b;
+        return ((_b = (0, converter_1.parseObjectConfig)((_a = this.victoropsConfig(ctx)) === null || _a === void 0 ? void 0 : _a.application_mapping, 'Application Mapping')) !== null && _b !== void 0 ? _b : {});
+    }
+    applicationField(ctx) {
+        var _a;
+        return ((_a = this.victoropsConfig(ctx).application_field) !== null && _a !== void 0 ? _a : DEFAULT_APPLICATION_FIELD);
+    }
+}
+exports.VictorOpsConverter = VictorOpsConverter;

package/lib/converters/victorops/incidents.d.ts

@@ -0,0 +1,12 @@
+import { AirbyteRecord } from 'faros-airbyte-cdk';
+import { DestinationModel, DestinationRecord, StreamContext } from '../converter';
+import { VictorOpsConverter } from './common';
+export declare class Incidents extends VictorOpsConverter {
+    private readonly logger;
+    readonly destinationModels: ReadonlyArray<DestinationModel>;
+    id(record: AirbyteRecord): any;
+    convert(record: AirbyteRecord, ctx: StreamContext): Promise<ReadonlyArray<DestinationRecord>>;
+    private getSeverity;
+    private eventType;
+    private getIncidentStatus;
+}

package/lib/converters/victorops/incidents.js

@@ -0,0 +1,209 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Incidents = void 0;
+const faros_airbyte_cdk_1 = require("faros-airbyte-cdk");
+const faros_feeds_sdk_1 = require("faros-feeds-sdk");
+const common_1 = require("./common");
+var IncidentStatusCategory;
+(function (IncidentStatusCategory) {
+    IncidentStatusCategory["Created"] = "Created";
+    IncidentStatusCategory["Identified"] = "Identified";
+    IncidentStatusCategory["Investigating"] = "Investigating";
+    IncidentStatusCategory["Resolved"] = "Resolved";
+    IncidentStatusCategory["Custom"] = "Custom";
+})(IncidentStatusCategory || (IncidentStatusCategory = {}));
+var IncidentSeverityCategory;
+(function (IncidentSeverityCategory) {
+    IncidentSeverityCategory["Sev1"] = "Sev1";
+    IncidentSeverityCategory["Sev2"] = "Sev2";
+    IncidentSeverityCategory["Sev3"] = "Sev3";
+    IncidentSeverityCategory["Sev4"] = "Sev4";
+    IncidentSeverityCategory["Sev5"] = "Sev5";
+    IncidentSeverityCategory["Custom"] = "Custom";
+})(IncidentSeverityCategory || (IncidentSeverityCategory = {}));
+var IncidentEventTypeCategory;
+(function (IncidentEventTypeCategory) {
+    IncidentEventTypeCategory["Created"] = "Created";
+    IncidentEventTypeCategory["Acknowledged"] = "Acknowledged";
+    IncidentEventTypeCategory["Resolved"] = "Resolved";
+    IncidentEventTypeCategory["Custom"] = "Custom";
+})(IncidentEventTypeCategory || (IncidentEventTypeCategory = {}));
+class Incidents extends common_1.VictorOpsConverter {
+    constructor() {
+        super(...arguments);
+        this.logger = new faros_airbyte_cdk_1.AirbyteLogger();
+        this.destinationModels = [
+            'compute_Application',
+            'ims_Incident',
+            'ims_IncidentApplicationImpact',
+            'ims_IncidentAssignment',
+            'ims_IncidentEvent',
+            'ims_TeamIncidentAssociation',
+        ];
+    }
+    id(record) {
+        var _a, _b;
+        return (_b = (_a = record === null || record === void 0 ? void 0 : record.record) === null || _a === void 0 ? void 0 : _a.data) === null || _b === void 0 ? void 0 : _b.incidentNumber;
+    }
+    async convert(record, ctx) {
+        var _a, _b, _c;
+        const source = this.streamName.source;
+        const incident = record.record.data;
+        const res = [];
+        const incidentRef = { uid: incident.incidentNumber, source };
+        const createdAt = faros_feeds_sdk_1.Utils.toDate(incident.startTime);
+        //VO has service states, e.g. CRITICAL
+        let severity = incident.entityState
+            ? this.getSeverity(incident.entityState)
+            : undefined;
+        let acknowledgedAt = undefined, resolvedAt = undefined, updatedAt = faros_feeds_sdk_1.Utils.toDate(incident.startTime);
+        for (const transition of incident.transitions) {
+            const transitionTime = faros_feeds_sdk_1.Utils.toDate(transition.at);
+            res.push({
+                model: 'ims_IncidentEvent',
+                record: {
+                    uid: `${transition.name}_${transition.at}`,
+                    type: this.eventType(transition.name),
+                    createdAt: transitionTime,
+                    detail: (_a = transition.message) !== null && _a !== void 0 ? _a : incident.entityDisplayName,
+                    incident: incidentRef,
+                },
+            });
+            if (['ACKED', 'acknowledged'].includes(transition.name)) {
+                //use earliest acknowledgement
+                if (!acknowledgedAt || transitionTime < acknowledgedAt) {
+                    acknowledgedAt = transitionTime;
+                }
+                if (transition.by) {
+                    res.push({
+                        model: 'ims_IncidentAssignment',
+                        record: {
+                            incident: incidentRef,
+                            assignee: {
+                                uid: transition.by,
+                                source,
+                            },
+                        },
+                    });
+                }
+            }
+            if (transition.name.toLowerCase() === 'resolved') {
+                resolvedAt = faros_feeds_sdk_1.Utils.toDate(transition.at);
+                // hopefully we've pulled this incident before it got resolved, and have severity.
+                // Once incident is resolved, the service status field resets to 'OK'
+                severity = undefined;
+            }
+            if (updatedAt < transitionTime) {
+                updatedAt = transitionTime;
+            }
+        }
+        if ((_b = incident.pagedTeams) === null || _b === void 0 ? void 0 : _b.length) {
+            for (const pagedTeam of incident.pagedTeams) {
+                const team = {
+                    uid: pagedTeam,
+                    source,
+                };
+                res.push({
+                    model: 'ims_TeamIncidentAssociation',
+                    record: {
+                        incident: incidentRef,
+                        team,
+                    },
+                });
+            }
+        }
+        res.push({
+            model: 'ims_Incident',
+            record: {
+                ...incidentRef,
+                title: incident.entityId,
+                description: incident.entityDisplayName,
+                url: incident.incidentLink,
+                createdAt,
+                updatedAt,
+                acknowledgedAt,
+                resolvedAt,
+                priority: undefined,
+                severity,
+                status: this.getIncidentStatus(incident.currentPhase),
+            },
+        });
+        const appMapping = this.applicationMapping(ctx);
+        const appField = this.applicationField(ctx);
+        // check optional application field parameter
+        const service = appField in incident && typeof incident[appField] === 'string'
+            ? incident[appField]
+            : incident.service;
+        // if we have an app mapping specified, only then write the application and impact records
+        if (service && service in appMapping && appMapping[service].name) {
+            this.logger.info(`Incident ${incident.incidentNumber} impacted service: ${service}`);
+            const application = {
+                name: appMapping[service].name,
+                platform: (_c = appMapping[service].platform) !== null && _c !== void 0 ? _c : '',
+            };
+            res.push({
+                model: 'compute_Application',
+                record: application,
+            });
+            res.push({
+                model: 'ims_IncidentApplicationImpact',
+                record: {
+                    incident: incidentRef,
+                    application,
+                },
+            });
+        }
+        return res;
+    }
+    getSeverity(state) {
+        const detail = state;
+        switch (state.toLowerCase()) {
+            case 'critical':
+                return { category: IncidentSeverityCategory.Sev1, detail };
+            case 'warn':
+                return { category: IncidentSeverityCategory.Sev3, detail };
+            case 'info':
+            case 'ok':
+                return { category: IncidentSeverityCategory.Sev5, detail };
+            default:
+                return { category: IncidentSeverityCategory.Custom, detail };
+        }
+    }
+    eventType(transitionType) {
+        let eventTypeCategory;
+        switch (transitionType) {
+            case 'UNACKED':
+            case 'triggered':
+                eventTypeCategory = IncidentEventTypeCategory.Created;
+                break;
+            case 'ACKED':
+            case 'acknowledged':
+                eventTypeCategory = IncidentEventTypeCategory.Acknowledged;
+                break;
+            case 'RESOLVED':
+            case 'resolved':
+                eventTypeCategory = IncidentEventTypeCategory.Resolved;
+                break;
+            default:
+                eventTypeCategory = IncidentEventTypeCategory.Custom;
+                break;
+        }
+        return { category: eventTypeCategory, detail: transitionType };
+    }
+    getIncidentStatus(incidentState) {
+        const detail = incidentState;
+        switch (incidentState) {
+            case 'ACKED':
+            case 'acknowledged':
+                return { category: IncidentStatusCategory.Identified, detail };
+            case 'RESOLVED':
+            case 'resolved':
+                return { category: IncidentStatusCategory.Resolved, detail };
+            case 'UNACKED':
+            case 'triggered':
+            default:
+                return { category: IncidentStatusCategory.Investigating, detail };
+        }
+    }
+}
+exports.Incidents = Incidents;

package/lib/converters/victorops/teams.d.ts

@@ -0,0 +1,8 @@
+import { AirbyteRecord } from 'faros-airbyte-cdk';
+import { DestinationModel, DestinationRecord, StreamContext } from '../converter';
+import { VictorOpsConverter } from './common';
+export declare class Teams extends VictorOpsConverter {
+    readonly destinationModels: ReadonlyArray<DestinationModel>;
+    id(record: AirbyteRecord): any;
+    convert(record: AirbyteRecord, ctx: StreamContext): Promise<ReadonlyArray<DestinationRecord>>;
+}

package/lib/converters/victorops/teams.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Teams = void 0;
+const common_1 = require("./common");
+class Teams extends common_1.VictorOpsConverter {
+    constructor() {
+        super(...arguments);
+        this.destinationModels = ['ims_Team'];
+    }
+    id(record) {
+        var _a, _b;
+        return (_b = (_a = record === null || record === void 0 ? void 0 : record.record) === null || _a === void 0 ? void 0 : _a.data) === null || _b === void 0 ? void 0 : _b.slug;
+    }
+    async convert(record, ctx) {
+        const source = this.streamName.source;
+        const team = record.record.data;
+        return [
+            {
+                model: 'ims_Team',
+                record: {
+                    uid: team.slug,
+                    name: team.name,
+                    url: team._selfUrl,
+                    source,
+                },
+            },
+        ];
+    }
+}
+exports.Teams = Teams;

package/lib/converters/victorops/users.d.ts

@@ -0,0 +1,8 @@
+import { AirbyteRecord } from 'faros-airbyte-cdk';
+import { DestinationModel, DestinationRecord, StreamContext } from '../converter';
+import { VictorOpsConverter } from './common';
+export declare class Users extends VictorOpsConverter {
+    readonly destinationModels: ReadonlyArray<DestinationModel>;
+    id(record: AirbyteRecord): any;
+    convert(record: AirbyteRecord, ctx: StreamContext): Promise<ReadonlyArray<DestinationRecord>>;
+}

package/lib/converters/victorops/users.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Users = void 0;
+const common_1 = require("./common");
+class Users extends common_1.VictorOpsConverter {
+    constructor() {
+        super(...arguments);
+        this.destinationModels = ['ims_User'];
+    }
+    id(record) {
+        var _a, _b;
+        return (_b = (_a = record === null || record === void 0 ? void 0 : record.record) === null || _a === void 0 ? void 0 : _a.data) === null || _b === void 0 ? void 0 : _b.username;
+    }
+    async convert(record, ctx) {
+        const source = this.streamName.source;
+        const user = record.record.data;
+        if (user.username.startsWith('invited')) {
+            return [];
+        }
+        return [
+            {
+                model: 'ims_User',
+                record: {
+                    uid: user.username,
+                    email: user.email,
+                    name: user.displayName,
+                    source,
+                },
+            },
+        ];
+    }
+}
+exports.Users = Users;