airbyte-faros-destination 0.1.53

package/lib/converters/jira/project_versions.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProjectVersions = void 0;
+const faros_feeds_sdk_1 = require("faros-feeds-sdk");
+const converter_1 = require("../converter");
+const common_1 = require("./common");
+class ProjectVersions extends common_1.JiraConverter {
+    constructor() {
+        super(...arguments);
+        this.destinationModels = [
+            'tms_Release',
+            'tms_ProjectReleaseRelationship',
+        ];
+    }
+    get dependencies() {
+        return [ProjectVersions.projectsStream];
+    }
+    async convert(record, ctx) {
+        const projectVersion = record.record.data;
+        const source = this.streamName.source;
+        const results = [
+            {
+                model: 'tms_Release',
+                record: {
+                    uid: projectVersion.id,
+                    name: projectVersion.name,
+                    description: this.truncate(projectVersion.description),
+                    startedAt: faros_feeds_sdk_1.Utils.toDate(projectVersion.startDate),
+                    releasedAt: faros_feeds_sdk_1.Utils.toDate(projectVersion.releaseDate),
+                    source,
+                },
+            },
+        ];
+        const project = ctx.get(ProjectVersions.projectsStream.asString, String(projectVersion.projectId));
+        if (project) {
+            results.push({
+                model: 'tms_ProjectReleaseRelationship',
+                record: {
+                    project: { uid: project.record.data.key, source },
+                    release: { uid: projectVersion.id, source },
+                },
+            });
+        }
+        return results;
+    }
+}
+exports.ProjectVersions = ProjectVersions;
+ProjectVersions.projectsStream = new converter_1.StreamName('jira', 'projects');

package/lib/converters/jira/projects.d.ts

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

package/lib/converters/jira/projects.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Projects = void 0;
+const common_1 = require("./common");
+class Projects extends common_1.JiraConverter {
+    constructor() {
+        super(...arguments);
+        this.destinationModels = [
+            'tms_Project',
+            'tms_TaskBoard',
+            'tms_TaskBoardProjectRelationship',
+        ];
+    }
+    async convert(record, ctx) {
+        const project = record.record.data;
+        const source = this.streamName.source;
+        const uid = project.key;
+        const results = [];
+        results.push({
+            model: 'tms_Project',
+            record: {
+                uid,
+                name: project.name,
+                description: this.truncate(ctx, project.description),
+                source,
+            },
+        });
+        if (!this.useBoardOwnership(ctx)) {
+            results.push({
+                model: 'tms_TaskBoard',
+                record: { uid, name: project.name, source },
+            }, {
+                model: 'tms_TaskBoardProjectRelationship',
+                record: { board: { uid, source }, project: { uid, source } },
+            });
+        }
+        return results;
+    }
+}
+exports.Projects = Projects;

package/lib/converters/jira/pull_requests.d.ts

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

package/lib/converters/jira/pull_requests.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PullRequests = void 0;
+const common_1 = require("./common");
+// Required as dependency by Issues converter
+class PullRequests extends common_1.JiraConverter {
+    constructor() {
+        super(...arguments);
+        this.destinationModels = [];
+    }
+    async convert(record, ctx) {
+        return [];
+    }
+}
+exports.PullRequests = PullRequests;

package/lib/converters/jira/sprint_issues.d.ts

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

package/lib/converters/jira/sprint_issues.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SprintIssues = void 0;
+const common_1 = require("./common");
+// Required as dependency Sprints converter
+class SprintIssues extends common_1.JiraConverter {
+    constructor() {
+        super(...arguments);
+        this.destinationModels = [];
+    }
+    async convert(record, ctx) {
+        return [];
+    }
+}
+exports.SprintIssues = SprintIssues;

package/lib/converters/jira/sprints.d.ts

@@ -0,0 +1,16 @@
+import { AirbyteRecord } from 'faros-airbyte-cdk';
+import { DestinationModel, DestinationRecord, StreamContext, StreamName } from '../converter';
+import { JiraConverter } from './common';
+export declare class Sprints extends JiraConverter {
+    private logger;
+    readonly destinationModels: ReadonlyArray<DestinationModel>;
+    private static readonly issueFieldsStream;
+    private static readonly sprintIssuesStream;
+    private pointsFieldIdsByName?;
+    private sprintIssueRecords?;
+    get dependencies(): ReadonlyArray<StreamName>;
+    private static getFieldIdsByName;
+    private static getSprintIssueRecords;
+    private getPoints;
+    convert(record: AirbyteRecord, ctx: StreamContext): Promise<ReadonlyArray<DestinationRecord>>;
+}

package/lib/converters/jira/sprints.js

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Sprints = void 0;
+const faros_airbyte_cdk_1 = require("faros-airbyte-cdk");
+const faros_feeds_sdk_1 = require("faros-feeds-sdk");
+const lodash_1 = require("lodash");
+const converter_1 = require("../converter");
+const common_1 = require("./common");
+class Sprints extends common_1.JiraConverter {
+    constructor() {
+        super(...arguments);
+        this.logger = new faros_airbyte_cdk_1.AirbyteLogger();
+        this.destinationModels = ['tms_Sprint'];
+    }
+    get dependencies() {
+        return [Sprints.issueFieldsStream, Sprints.sprintIssuesStream];
+    }
+    static getFieldIdsByName(ctx) {
+        const records = ctx.getAll(Sprints.issueFieldsStream.asString);
+        return (0, lodash_1.invertBy)((0, lodash_1.pickBy)((0, lodash_1.mapValues)(records, (r) => r.record.data.name), (name) => common_1.JiraCommon.POINTS_FIELD_NAMES.includes(name)));
+    }
+    static getSprintIssueRecords(ctx) {
+        const records = ctx.getAll(Sprints.sprintIssuesStream.asString);
+        return (0, lodash_1.groupBy)(Object.values(records).map((r) => r.record.data), (si) => si.sprintId);
+    }
+    getPoints(issue) {
+        var _a;
+        let points = 0;
+        for (const fieldName of common_1.JiraCommon.POINTS_FIELD_NAMES) {
+            const fieldIds = (_a = this.pointsFieldIdsByName[fieldName]) !== null && _a !== void 0 ? _a : [];
+            for (const fieldId of fieldIds) {
+                const pointsString = issue.fields[fieldId];
+                if (!pointsString)
+                    continue;
+                try {
+                    points = faros_feeds_sdk_1.Utils.parseFloatFixedPoint(pointsString);
+                }
+                catch (err) {
+                    this.logger.warn(`Failed to get story points for issue ${issue.key}: ${err.message}`);
+                }
+                return points;
+            }
+        }
+        return points;
+    }
+    async convert(record, ctx) {
+        var _a, _b, _c;
+        const sprint = record.record.data;
+        if (!this.pointsFieldIdsByName) {
+            this.pointsFieldIdsByName = Sprints.getFieldIdsByName(ctx);
+        }
+        if (!this.sprintIssueRecords) {
+            this.sprintIssueRecords = Sprints.getSprintIssueRecords(ctx);
+        }
+        let completedPoints = 0;
+        for (const issue of (_a = this.sprintIssueRecords[sprint.id]) !== null && _a !== void 0 ? _a : []) {
+            const status = (_c = (_b = issue.fields.status) === null || _b === void 0 ? void 0 : _b.statusCategory) === null || _c === void 0 ? void 0 : _c.name;
+            if (status && common_1.JiraCommon.normalize(status) === 'done') {
+                completedPoints += this.getPoints(issue);
+            }
+        }
+        return [
+            {
+                model: 'tms_Sprint',
+                record: {
+                    uid: String(sprint.id),
+                    name: sprint.name,
+                    state: (0, lodash_1.upperFirst)((0, lodash_1.camelCase)(sprint.state)),
+                    completedPoints,
+                    startedAt: faros_feeds_sdk_1.Utils.toDate(sprint.startDate),
+                    endedAt: faros_feeds_sdk_1.Utils.toDate(sprint.endDate),
+                    source: this.streamName.source,
+                },
+            },
+        ];
+    }
+}
+exports.Sprints = Sprints;
+Sprints.issueFieldsStream = new converter_1.StreamName('jira', 'issue_fields');
+Sprints.sprintIssuesStream = new converter_1.StreamName('jira', 'sprint_issues');

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

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

package/lib/converters/jira/users.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Users = void 0;
+const faros_airbyte_cdk_1 = require("faros-airbyte-cdk");
+const common_1 = require("./common");
+class Users extends common_1.JiraConverter {
+    constructor() {
+        super(...arguments);
+        this.logger = new faros_airbyte_cdk_1.AirbyteLogger();
+        this.destinationModels = ['tms_User'];
+    }
+    async convert(record, ctx) {
+        var _a;
+        const user = record.record.data;
+        const uid = (_a = user.accountId) !== null && _a !== void 0 ? _a : user.name;
+        if (!uid) {
+            this.logger.warn(`Skipping user. User has no accountId or name defined: ${JSON.stringify(user)}`);
+            return [];
+        }
+        return [
+            {
+                model: 'tms_User',
+                record: {
+                    uid,
+                    name: user.displayName,
+                    emailAddress: user.emailAddress,
+                    source: this.streamName.source,
+                },
+            },
+        ];
+    }
+}
+exports.Users = Users;

package/lib/converters/jira/workflow_statuses.d.ts

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

package/lib/converters/jira/workflow_statuses.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WorkflowStatuses = void 0;
+const common_1 = require("./common");
+// Required as dependency by Issues converter
+class WorkflowStatuses extends common_1.JiraConverter {
+    constructor() {
+        super(...arguments);
+        this.destinationModels = [];
+    }
+    async convert(record, ctx) {
+        return [];
+    }
+}
+exports.WorkflowStatuses = WorkflowStatuses;

package/lib/converters/jsonata.d.ts

@@ -0,0 +1,17 @@
+import { AirbyteRecord } from 'faros-airbyte-cdk';
+import jsonata from 'jsonata';
+import { Converter, DestinationModel, DestinationRecord, StreamContext } from './converter';
+/** Record converter to convert records using provided JSONata expression */
+export declare class JSONataConverter extends Converter {
+    private readonly jsonataExpr;
+    readonly destinationModels: ReadonlyArray<DestinationModel>;
+    source: string;
+    constructor(jsonataExpr: jsonata.Expression, destinationModels: ReadonlyArray<DestinationModel>);
+    id(record: AirbyteRecord): any;
+    convert(record: AirbyteRecord, ctx: StreamContext): Promise<ReadonlyArray<DestinationRecord>>;
+    static make(expression: string, destinationModels: ReadonlyArray<DestinationModel>): JSONataConverter;
+}
+export declare enum JSONataApplyMode {
+    FALLBACK = "FALLBACK",
+    OVERRIDE = "OVERRIDE"
+}

package/lib/converters/jsonata.js

@@ -0,0 +1,47 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JSONataApplyMode = exports.JSONataConverter = void 0;
+const jsonata_1 = __importDefault(require("jsonata"));
+const verror_1 = require("verror");
+const converter_1 = require("./converter");
+/** Record converter to convert records using provided JSONata expression */
+class JSONataConverter extends converter_1.Converter {
+    constructor(jsonataExpr, destinationModels) {
+        super();
+        this.jsonataExpr = jsonataExpr;
+        this.destinationModels = destinationModels;
+        this.source = 'JSONata';
+    }
+    id(record) {
+        return undefined;
+    }
+    async convert(record, ctx) {
+        const res = this.jsonataExpr.evaluate(record.record);
+        if (!res)
+            return [];
+        if (!Array.isArray(res))
+            return [res];
+        return res;
+    }
+    static make(expression, destinationModels) {
+        if (!Array.isArray(destinationModels) || !destinationModels.length) {
+            throw new verror_1.VError('Destination models cannot be empty');
+        }
+        try {
+            const jsonataExpr = (0, jsonata_1.default)(expression);
+            return new JSONataConverter(jsonataExpr, destinationModels);
+        }
+        catch (error) {
+            throw new verror_1.VError(error, 'Failed to parse JSONata expression: %s (code: %s, position: %s, token: %s)', error.message, error.code, error.position, error.token);
+        }
+    }
+}
+exports.JSONataConverter = JSONataConverter;
+var JSONataApplyMode;
+(function (JSONataApplyMode) {
+    JSONataApplyMode["FALLBACK"] = "FALLBACK";
+    JSONataApplyMode["OVERRIDE"] = "OVERRIDE";
+})(JSONataApplyMode = exports.JSONataApplyMode || (exports.JSONataApplyMode = {}));

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

@@ -0,0 +1,8 @@
+import { AirbyteRecord } from 'faros-airbyte-cdk';
+import { Converter } from '../converter';
+/** Okta converter base */
+export declare abstract class OktaConverter extends Converter {
+    source: string;
+    /** Almost every Okta record have id property */
+    id(record: AirbyteRecord): any;
+}

package/lib/converters/okta/common.js

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

package/lib/converters/okta/groups.d.ts

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

package/lib/converters/okta/groups.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Groups = void 0;
+const common_1 = require("./common");
+class Groups extends common_1.OktaConverter {
+    constructor() {
+        super(...arguments);
+        this.destinationModels = [
+            'org_Team',
+            'org_TeamMembership',
+        ];
+    }
+    async convert(record, ctx) {
+        var _a, _b, _c;
+        const source = this.streamName.source;
+        const group = record.record.data;
+        const res = [];
+        const profile = group.profile;
+        const uid = group.id;
+        res.push({
+            model: 'org_Team',
+            record: {
+                uid,
+                name: (_a = profile.name) !== null && _a !== void 0 ? _a : null,
+                description: (_b = profile.description) !== null && _b !== void 0 ? _b : null,
+                lead: null,
+                parentTeam: { uid: 'all_teams' },
+                teamChain: ['all_teams'],
+                tags: null,
+                color: null,
+                photoUrl: null,
+                source,
+            },
+        });
+        for (const userId of (_c = group === null || group === void 0 ? void 0 : group.usersOfGroup) !== null && _c !== void 0 ? _c : []) {
+            res.push({
+                model: 'org_TeamMembership',
+                record: {
+                    team: { uid },
+                    member: { uid: userId },
+                },
+            });
+        }
+        return res;
+    }
+}
+exports.Groups = Groups;

package/lib/converters/okta/models.d.ts

@@ -0,0 +1,102 @@
+interface Type {
+    id: string;
+}
+interface Profile {
+    profileUrl?: string;
+    lastName: string;
+    zipCode?: string;
+    preferredLanguage?: string;
+    manager?: string;
+    managerId?: string;
+    city?: string;
+    displayName?: string;
+    nickName?: string;
+    secondEmail?: string;
+    honorificPrefix?: string;
+    title?: string;
+    locale?: string;
+    login?: string;
+    honorificSuffix?: string;
+    firstName?: string;
+    primaryPhone?: string;
+    postalAddress?: string;
+    mobilePhone?: string;
+    streetAddress?: string;
+    countryCode?: string;
+    middleName?: string;
+    state?: string;
+    department?: string;
+    email?: string;
+    userType?: string;
+    startDate?: string;
+}
+interface Email {
+    value: string;
+    status: string;
+    type: string;
+}
+interface Provider {
+    type: string;
+    name: string;
+}
+interface Credentials {
+    password?: string;
+    emails: Email[];
+    provider: Provider;
+}
+interface Self {
+    href: string;
+}
+interface Links {
+    self: Self;
+}
+export interface User {
+    id: string;
+    status: string;
+    created: string;
+    activated?: any;
+    statusChanged: string;
+    lastLogin: string;
+    lastUpdated: string;
+    passwordChanged: string;
+    type: Type;
+    profile: Profile;
+    credentials: Credentials;
+    _links: Links;
+}
+export interface GroupProfile {
+    name: string;
+    description?: any;
+}
+export interface Logo {
+    name: string;
+    href: string;
+    type: string;
+}
+export interface Users {
+    href: string;
+}
+export interface Apps {
+    href: string;
+}
+export interface GroupLinks {
+    logo: Logo[];
+    users: Users;
+    apps: Apps;
+}
+export interface UserOfGroup {
+    id: string;
+}
+export interface Group {
+    item: any;
+    id: string;
+    created: string;
+    lastUpdated: string;
+    lastMembershipUpdated: string;
+    objectClass: string[];
+    type: string;
+    profile: GroupProfile;
+    _links: GroupLinks;
+    usersOfGroup: string[];
+}
+export {};

package/lib/converters/okta/models.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

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

package/lib/converters/okta/users.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Users = void 0;
+const faros_feeds_sdk_1 = require("faros-feeds-sdk");
+const lodash_1 = require("lodash");
+const common_1 = require("./common");
+class Users extends common_1.OktaConverter {
+    constructor() {
+        super(...arguments);
+        this.destinationModels = [
+            'identity_Identity',
+            'org_Department',
+            'org_Employee',
+        ];
+        this.seenDepartments = new Set();
+    }
+    async convert(record, ctx) {
+        var _a, _b, _c, _d;
+        const source = this.streamName.source;
+        const user = record.record.data;
+        const profile = user.profile;
+        const uid = user.id;
+        const res = [];
+        const fullName = [profile.firstName, profile.middleName, profile.lastName]
+            .filter((x) => x)
+            .join(' ');
+        const joinedAt = (_b = (_a = faros_feeds_sdk_1.Utils.toDate(profile.startDate)) !== null && _a !== void 0 ? _a : faros_feeds_sdk_1.Utils.toDate(user.created)) !== null && _b !== void 0 ? _b : null;
+        const departments = (0, lodash_1.sortBy)(Object.entries(profile).filter(([k, v]) => k.toLowerCase().includes('department')), ([k, v]) => k).map(([k, v]) => v);
+        const department = (_d = (_c = (departments.length > 0 ? departments[0] : null)) !== null && _c !== void 0 ? _c : profile.department) !== null && _d !== void 0 ? _d : null;
+        if (!this.seenDepartments.has(department)) {
+            this.seenDepartments.add(department);
+            res.push({
+                model: 'org_Department',
+                record: {
+                    uid: department,
+                    name: department,
+                    description: null,
+                },
+            });
+        }
+        res.push({
+            model: 'identity_Identity',
+            record: {
+                uid,
+                firstName: profile.firstName,
+                lastName: profile.lastName,
+                fullName,
+                photoUrl: null,
+                primaryEmail: profile.email,
+                emails: [profile.email],
+                createdAt: null,
+                updatedAt: null,
+            },
+        }, {
+            model: 'org_Employee',
+            record: {
+                uid,
+                title: profile.title,
+                level: null,
+                joinedAt,
+                terminatedAt: null,
+                department: { uid: department },
+                identity: { uid, source },
+                manager: profile.manager ? { uid: profile.manager, source } : null,
+                reportingChain: null,
+                location: null,
+                source,
+            },
+        });
+        return res;
+    }
+}
+exports.Users = Users;

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

@@ -0,0 +1,4 @@
+import { Converter } from '../converter';
+export declare abstract class OktaFarosConverter extends Converter {
+    source: string;
+}