airbyte-faros-destination 0.1.53

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

@@ -0,0 +1,52 @@
+import { AirbyteRecord } from 'faros-airbyte-cdk';
+import { Converter } from '../converter';
+import { Schema$CalendarListEntry, Schema$Event } from './calendar_models';
+export declare type Event = Schema$Event;
+export declare type Calendar = Schema$CalendarListEntry;
+export interface CategoryRef {
+    category: string;
+    detail: string;
+}
+export declare enum EventGuestStatusCategory {
+    NEEDS_ACTION = "NeedsAction",
+    ACCEPTED = "Accepted",
+    TENTATIVE = "Tentative",
+    CANCELED = "Canceled",
+    CUSTOM = "Custom"
+}
+export declare enum EventTypeCategory {
+    REGULAR = "Regular",
+    RECURRING = "Recurring",
+    CUSTOM = "Custom"
+}
+export declare enum EventStatusCategory {
+    CONFIRMED = "Confirmed",
+    TENTATIVE = "Tentative",
+    CANCELED = "Canceled",
+    CUSTOM = "Custom"
+}
+export declare enum EventPrivacyCategory {
+    PRIVATE = "Private",
+    PUBLIC = "Public",
+    CUSTOM = "Custom"
+}
+export declare enum EventVisibilityCategory {
+    FREE = "Free",
+    BUSY = "Busy",
+    CUSTOM = "Custom"
+}
+/** Common functions shares across GoogleCalendar converters */
+export declare class GoogleCalendarCommon {
+    static readonly MAX_DESCRIPTION_LENGTH = 1000;
+    static EventType(type: string): CategoryRef;
+    static EventPrivacy(privacy: string): CategoryRef;
+    static EventVisibility(visibility: string): CategoryRef;
+    static EventStatus(status: string): CategoryRef;
+    static EventGuestStatus(status: string): CategoryRef;
+}
+/** GoogleCalendar converter base */
+export declare abstract class GoogleCalendarConverter extends Converter {
+    source: string;
+    /** Every GoogleCalendar record have id property */
+    id(record: AirbyteRecord): any;
+}

package/lib/converters/googlecalendar/common.js

@@ -0,0 +1,130 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GoogleCalendarConverter = exports.GoogleCalendarCommon = exports.EventVisibilityCategory = exports.EventPrivacyCategory = exports.EventStatusCategory = exports.EventTypeCategory = exports.EventGuestStatusCategory = void 0;
+const converter_1 = require("../converter");
+var EventGuestStatusCategory;
+(function (EventGuestStatusCategory) {
+    EventGuestStatusCategory["NEEDS_ACTION"] = "NeedsAction";
+    EventGuestStatusCategory["ACCEPTED"] = "Accepted";
+    EventGuestStatusCategory["TENTATIVE"] = "Tentative";
+    EventGuestStatusCategory["CANCELED"] = "Canceled";
+    EventGuestStatusCategory["CUSTOM"] = "Custom";
+})(EventGuestStatusCategory = exports.EventGuestStatusCategory || (exports.EventGuestStatusCategory = {}));
+var EventTypeCategory;
+(function (EventTypeCategory) {
+    EventTypeCategory["REGULAR"] = "Regular";
+    EventTypeCategory["RECURRING"] = "Recurring";
+    EventTypeCategory["CUSTOM"] = "Custom";
+})(EventTypeCategory = exports.EventTypeCategory || (exports.EventTypeCategory = {}));
+var EventStatusCategory;
+(function (EventStatusCategory) {
+    EventStatusCategory["CONFIRMED"] = "Confirmed";
+    EventStatusCategory["TENTATIVE"] = "Tentative";
+    EventStatusCategory["CANCELED"] = "Canceled";
+    EventStatusCategory["CUSTOM"] = "Custom";
+})(EventStatusCategory = exports.EventStatusCategory || (exports.EventStatusCategory = {}));
+var EventPrivacyCategory;
+(function (EventPrivacyCategory) {
+    EventPrivacyCategory["PRIVATE"] = "Private";
+    EventPrivacyCategory["PUBLIC"] = "Public";
+    EventPrivacyCategory["CUSTOM"] = "Custom";
+})(EventPrivacyCategory = exports.EventPrivacyCategory || (exports.EventPrivacyCategory = {}));
+var EventVisibilityCategory;
+(function (EventVisibilityCategory) {
+    EventVisibilityCategory["FREE"] = "Free";
+    EventVisibilityCategory["BUSY"] = "Busy";
+    EventVisibilityCategory["CUSTOM"] = "Custom";
+})(EventVisibilityCategory = exports.EventVisibilityCategory || (exports.EventVisibilityCategory = {}));
+/** Common functions shares across GoogleCalendar converters */
+class GoogleCalendarCommon {
+    static EventType(type) {
+        if (!type)
+            return null;
+        const detail = type === null || type === void 0 ? void 0 : type.toLowerCase();
+        switch (detail) {
+            case 'default':
+                return { category: EventTypeCategory.REGULAR, detail };
+            case 'focusTime':
+                return { category: EventTypeCategory.RECURRING, detail };
+            default:
+                return { category: EventTypeCategory.CUSTOM, detail };
+        }
+    }
+    static EventPrivacy(privacy) {
+        if (!privacy)
+            return null;
+        const detail = privacy === null || privacy === void 0 ? void 0 : privacy.toLowerCase();
+        switch (detail) {
+            case 'public':
+                return { category: EventPrivacyCategory.PUBLIC, detail };
+            case 'private':
+            case 'confidential':
+                return { category: EventPrivacyCategory.PRIVATE, detail };
+            default:
+                return { category: EventPrivacyCategory.CUSTOM, detail };
+        }
+    }
+    static EventVisibility(visibility) {
+        if (!visibility)
+            return null;
+        const detail = visibility === null || visibility === void 0 ? void 0 : visibility.toLowerCase();
+        switch (detail) {
+            case 'opaque':
+                return { category: EventVisibilityCategory.BUSY, detail };
+            case 'transparent':
+                return { category: EventVisibilityCategory.FREE, detail };
+            default:
+                return { category: EventVisibilityCategory.CUSTOM, detail };
+        }
+    }
+    static EventStatus(status) {
+        if (!status)
+            return null;
+        const detail = status === null || status === void 0 ? void 0 : status.toLowerCase();
+        switch (detail) {
+            case 'confirmed':
+                return { category: EventStatusCategory.CONFIRMED, detail };
+            case 'tentative':
+                return { category: EventStatusCategory.TENTATIVE, detail };
+            case 'cancelled':
+                return { category: EventStatusCategory.CANCELED, detail };
+            default:
+                return { category: EventStatusCategory.CUSTOM, detail };
+        }
+    }
+    static EventGuestStatus(status) {
+        if (!status)
+            return null;
+        const detail = status === null || status === void 0 ? void 0 : status.toLowerCase();
+        switch (detail) {
+            case 'accepted':
+                return { category: EventGuestStatusCategory.ACCEPTED, detail };
+            case 'tentative':
+                return { category: EventGuestStatusCategory.TENTATIVE, detail };
+            case 'needs_action':
+            case 'needsaction':
+                return { category: EventGuestStatusCategory.NEEDS_ACTION, detail };
+            case 'declined':
+            case 'canceled':
+                return { category: EventGuestStatusCategory.CANCELED, detail };
+            default:
+                return { category: EventGuestStatusCategory.CUSTOM, detail };
+        }
+    }
+}
+exports.GoogleCalendarCommon = GoogleCalendarCommon;
+// Max length for free-form description text fields such as issue body
+GoogleCalendarCommon.MAX_DESCRIPTION_LENGTH = 1000;
+/** GoogleCalendar converter base */
+class GoogleCalendarConverter extends converter_1.Converter {
+    constructor() {
+        super(...arguments);
+        this.source = 'GoogleCalendar';
+    }
+    /** Every GoogleCalendar 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;
+    }
+}
+exports.GoogleCalendarConverter = GoogleCalendarConverter;

package/lib/converters/googlecalendar/events.d.ts

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

package/lib/converters/googlecalendar/events.js

@@ -0,0 +1,117 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Events = void 0;
+const faros_feeds_sdk_1 = require("faros-feeds-sdk");
+const common_1 = require("./common");
+class Events extends common_1.GoogleCalendarConverter {
+    constructor() {
+        super(...arguments);
+        // Locations cache to avoid querying the API for the same location
+        this.locationsCache = new Map();
+        this.destinationModels = [
+            'cal_Event',
+            'cal_EventGuestAssociation',
+            'cal_User',
+            'geo_Address',
+            'geo_Location',
+        ];
+    }
+    async convert(record, ctx) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m;
+        const source = this.streamName.source;
+        const event = record.record.data;
+        const res = [];
+        const eventRef = { uid: event.id, calendar: { uid: event.id, source } };
+        (_a = event.attendees) === null || _a === void 0 ? void 0 : _a.forEach((attender) => {
+            const attenderRef = { uid: attender.id, source };
+            res.push({
+                model: 'cal_User',
+                record: {
+                    ...attenderRef,
+                    email: attender.email,
+                    displayName: attender.displayName,
+                },
+            });
+            res.push({
+                model: 'cal_EventGuestAssociation',
+                record: {
+                    event: eventRef,
+                    guest: attenderRef,
+                    status: common_1.GoogleCalendarCommon.EventGuestStatus(attender.responseStatus),
+                },
+            });
+        });
+        let organizer = null;
+        if (event.organizer) {
+            organizer = { uid: ((_b = event.organizer) === null || _b === void 0 ? void 0 : _b.id) || ((_c = event.organizer) === null || _c === void 0 ? void 0 : _c.email), source };
+            res.push({
+                model: 'cal_User',
+                record: {
+                    ...organizer,
+                    email: (_d = event.organizer) === null || _d === void 0 ? void 0 : _d.email,
+                    displayName: (_e = event.organizer) === null || _e === void 0 ? void 0 : _e.displayName,
+                },
+            });
+        }
+        const start = faros_feeds_sdk_1.Utils.toDate(((_f = event === null || event === void 0 ? void 0 : event.start) === null || _f === void 0 ? void 0 : _f.date)
+            ? event.start.date.concat('T00:00:00.000Z')
+            : (_g = event === null || event === void 0 ? void 0 : event.start) === null || _g === void 0 ? void 0 : _g.dateTime);
+        const end = faros_feeds_sdk_1.Utils.toDate(((_h = event === null || event === void 0 ? void 0 : event.end) === null || _h === void 0 ? void 0 : _h.date)
+            ? event.end.date.concat('T24:00:00.000Z')
+            : (_j = event === null || event === void 0 ? void 0 : event.end) === null || _j === void 0 ? void 0 : _j.dateTime);
+        let durationMs;
+        if (start && end) {
+            durationMs = end.getTime() - start.getTime();
+        }
+        let location = null;
+        if (event.location) {
+            const cachedLocation = this.locationsCache.get(event.location);
+            if (cachedLocation) {
+                location = { uid: cachedLocation.uid };
+            }
+            else {
+                const locations = await ((_k = ctx.farosClient) === null || _k === void 0 ? void 0 : _k.geocode(event.location));
+                if (locations.length > 0) {
+                    const loc = locations[0];
+                    this.locationsCache.set(event.location, loc);
+                    if (loc.coordinates) {
+                        res.push({ model: 'geo_Coordinates', record: loc.coordinates });
+                    }
+                    if (loc.address) {
+                        res.push({ model: 'geo_Address', record: loc.address });
+                    }
+                    const geo_Location = {
+                        uid: loc.uid,
+                        name: loc.raw,
+                        raw: loc.raw,
+                        room: loc.room,
+                        coordinates: loc.coordinates ? loc.coordinates : null,
+                        address: loc.address ? { uid: loc.address.uid } : null,
+                    };
+                    res.push({ model: 'geo_Location', record: geo_Location });
+                    location = { uid: loc.uid };
+                }
+            }
+        }
+        res.push({
+            model: 'cal_Event',
+            record: {
+                ...eventRef,
+                title: (_l = event.summary) === null || _l === void 0 ? void 0 : _l.substring(0, common_1.GoogleCalendarCommon.MAX_DESCRIPTION_LENGTH),
+                description: (_m = event.description) === null || _m === void 0 ? void 0 : _m.substring(0, common_1.GoogleCalendarCommon.MAX_DESCRIPTION_LENGTH),
+                start,
+                end,
+                durationMs,
+                url: event.htmlLink,
+                location,
+                organizer,
+                type: common_1.GoogleCalendarCommon.EventType(event.eventType),
+                visibility: common_1.GoogleCalendarCommon.EventVisibility(event.transparency),
+                privacy: common_1.GoogleCalendarCommon.EventPrivacy(event.visibility),
+                status: common_1.GoogleCalendarCommon.EventStatus(event.status),
+            },
+        });
+        return res;
+    }
+}
+exports.Events = Events;

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

@@ -0,0 +1,105 @@
+import { AirbyteRecord } from 'faros-airbyte-cdk';
+import { Converter } from '../converter';
+export interface ComputeApplication {
+    name: string;
+    platform: string;
+}
+interface CICDOrganization {
+    uid: string;
+    source: string;
+}
+interface CICDPipeline {
+    uid: string;
+    organization: CICDOrganization;
+}
+export interface CICDBuild {
+    uid: string;
+    pipeline: CICDPipeline;
+}
+interface CICDRepository {
+    uid: string;
+    organization: CICDOrganization;
+}
+export interface CICDArtifact {
+    readonly uid: string;
+    readonly repository: CICDRepository;
+}
+export interface Execution {
+    uid: string;
+    application: ComputeApplication;
+    startedAt: number;
+    endedAt: number;
+    env: string;
+    status: string;
+    build: CICDBuild;
+    artifact: CICDArtifact;
+}
+export interface ExecutionImplementation {
+    application: ComputeApplication;
+    env: string;
+    build?: CICDBuild;
+    artifact?: CICDArtifact;
+}
+interface HarnessService {
+    id: string;
+    name?: string;
+    artifactType: string;
+    artifactSources: {
+        name: string;
+    }[];
+}
+interface HarnessEnvironment {
+    type: string;
+    name: string;
+}
+export interface HarnessExecutionNode {
+    id: string;
+    application: {
+        id: string;
+        name?: string;
+        services?: {
+            nodes: HarnessService[];
+        };
+        environments?: {
+            nodes: HarnessEnvironment[];
+        };
+        tags?: {
+            name: string;
+            value: string;
+        }[];
+    };
+    status: string;
+    createdAt: number;
+    startedAt: number;
+    endedAt: number;
+    artifacts?: {
+        id: string;
+        buildNo: string;
+        artifactSource: {
+            id: string;
+            name: string;
+        };
+    }[];
+    outcomes?: {
+        nodes: {
+            service: HarnessService;
+            environment: HarnessEnvironment;
+        }[];
+    };
+}
+export interface ExecutionWorkflow {
+    application: ComputeApplication;
+    env: string;
+    build: CICDBuild;
+    artifact: CICDArtifact;
+}
+export interface ExecutionPipeline {
+    application: ComputeApplication;
+    env: string;
+}
+/** Harness converter base */
+export declare abstract class HarnessConverter extends Converter {
+    source: string;
+    id(record: AirbyteRecord): any;
+}
+export {};

package/lib/converters/harness/common.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HarnessConverter = void 0;
+const converter_1 = require("../converter");
+/** Harness converter base */
+class HarnessConverter extends converter_1.Converter {
+    constructor() {
+        super(...arguments);
+        this.source = 'Harness';
+    }
+    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;
+    }
+}
+exports.HarnessConverter = HarnessConverter;

package/lib/converters/harness/executions.d.ts

@@ -0,0 +1,15 @@
+import { AirbyteRecord } from 'faros-airbyte-cdk';
+import { DestinationModel, DestinationRecord, StreamContext } from '../converter';
+import { HarnessConverter } from './common';
+export declare class Executions extends HarnessConverter {
+    private readonly logger;
+    readonly destinationModels: ReadonlyArray<DestinationModel>;
+    convert(record: AirbyteRecord, ctx: StreamContext): Promise<ReadonlyArray<DestinationRecord>>;
+    private parseArtifactFromTags;
+    private parseWorkflow;
+    private parsePipeline;
+    private toBuildStatus;
+    private toEnvironmentStatus;
+    private toExecution;
+    private toDeploymentStatus;
+}