airbyte-faros-destination 0.1.53

package/lib/converters/backlog/issues.js

@@ -0,0 +1,119 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Issues = void 0;
+const faros_feeds_sdk_1 = require("faros-feeds-sdk");
+const common_1 = require("./common");
+class Issues extends common_1.BacklogConverter {
+    constructor() {
+        super(...arguments);
+        this.destinationModels = [
+            'tms_Label',
+            'tms_Task',
+            'tms_TaskAssignment',
+            'tms_TaskBoardRelationship',
+            'tms_TaskDependency',
+            'tms_TaskProjectRelationship',
+            'tms_TaskTag',
+        ];
+    }
+    async convert(record, ctx) {
+        var _a, _b, _c, _d, _e, _f;
+        const source = this.streamName.source;
+        const issue = record.record.data;
+        const res = [];
+        const maxDescriptionLength = this.maxDescriptionLength(ctx);
+        const taskKey = { uid: String(issue.id), source };
+        const statusChangelog = [];
+        const additionalFields = [];
+        let statusChangedAt = undefined;
+        for (const comment of (_a = issue.comments) !== null && _a !== void 0 ? _a : []) {
+            for (const changeLog of (_b = comment.changeLog) !== null && _b !== void 0 ? _b : []) {
+                if (changeLog.field === 'status' && changeLog.newValue) {
+                    if (!statusChangedAt) {
+                        statusChangedAt = faros_feeds_sdk_1.Utils.toDate(comment.created);
+                    }
+                    statusChangelog.push({
+                        status: common_1.BacklogCommon.getTaskStatus(changeLog.newValue),
+                        changedAt: faros_feeds_sdk_1.Utils.toDate(comment.created),
+                    });
+                }
+                else if (changeLog.field === 'assigner' && changeLog.newValue) {
+                    let assignUserId = 0;
+                    for (const notification of (_c = comment.notifications) !== null && _c !== void 0 ? _c : []) {
+                        if (notification.user.name === changeLog.newValue) {
+                            assignUserId = notification.user.id;
+                            break;
+                        }
+                    }
+                    res.push({
+                        model: 'tms_TaskAssignment',
+                        record: {
+                            task: taskKey,
+                            assignee: { uid: String(assignUserId), source },
+                            assignedAt: faros_feeds_sdk_1.Utils.toDate(comment.created),
+                        },
+                    });
+                }
+            }
+        }
+        for (const additionalField of (_d = issue.customFields) !== null && _d !== void 0 ? _d : []) {
+            additionalFields.push({
+                name: additionalField.name,
+                value: additionalField.value,
+            });
+        }
+        const status = common_1.BacklogCommon.getTaskStatus(issue.status.name);
+        res.push({
+            model: 'tms_Task',
+            record: {
+                ...taskKey,
+                name: issue.summary,
+                description: (_e = issue.description) === null || _e === void 0 ? void 0 : _e.substring(0, maxDescriptionLength),
+                priority: (_f = issue.priority) === null || _f === void 0 ? void 0 : _f.name,
+                type: common_1.BacklogCommon.getTaskType(issue.issueType),
+                status,
+                additionalFields,
+                createdAt: faros_feeds_sdk_1.Utils.toDate(issue.created),
+                updatedAt: faros_feeds_sdk_1.Utils.toDate(issue.updated),
+                statusChangedAt,
+                statusChangelog,
+                parent: issue.parentIssueId
+                    ? { uid: String(issue.parentIssueId), source }
+                    : undefined,
+                creator: issue.createdUser
+                    ? { uid: String(issue.createdUser.id), source }
+                    : undefined,
+                sprint: issue.milestone.length
+                    ? { uid: String(issue.milestone[0].id), source }
+                    : undefined,
+            },
+        });
+        const projectRef = { uid: String(issue.projectId), source };
+        res.push({
+            model: 'tms_TaskProjectRelationship',
+            record: {
+                task: taskKey,
+                project: projectRef,
+            },
+        });
+        res.push({
+            model: 'tms_TaskBoardRelationship',
+            record: {
+                task: taskKey,
+                board: projectRef,
+            },
+        });
+        if (issue.parentIssueId) {
+            res.push({
+                model: 'tms_TaskDependency',
+                record: {
+                    dependentTask: { uid: String(issue.parentIssueId), source },
+                    fulfillingTask: { uid: String(issue.id), source },
+                    blocking: false,
+                },
+            });
+        }
+        return res;
+    }
+}
+exports.Issues = Issues;

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

@@ -0,0 +1,156 @@
+interface CommonKey {
+    id: number;
+    name: string;
+}
+export interface Project extends CommonKey {
+    projectKey: string;
+    chartEnabled: boolean;
+    subtaskingEnabled: boolean;
+    projectLeaderCanEditProjectLeader: boolean;
+    useWikiTreeView: boolean;
+    textFormattingRule: string;
+    archived: boolean;
+    displayOrder: number;
+    useDevAttributes: boolean;
+    versionMilestones: VersionMilestone[];
+}
+export interface IssueType extends CommonKey {
+    projectId: number;
+    color: string;
+    displayOrder: number;
+}
+interface Status extends CommonKey {
+    projectId: number;
+    color: string;
+    displayOrder: number;
+}
+interface NulabAccount {
+    nulabId: string;
+    name: string;
+    uniqueId?: string;
+}
+export interface User extends CommonKey {
+    userId: string;
+    roleType: number;
+    lang: string;
+    mailAddress: string;
+    nulabAccount?: NulabAccount;
+    keyword: string;
+}
+interface Category extends CommonKey {
+    displayOrder: number;
+}
+export interface VersionMilestone extends CommonKey {
+    projectId: number;
+    description?: string;
+    startDate?: string;
+    releaseDueDate?: string;
+    archived: boolean;
+    displayOrder: number;
+}
+interface Attachment extends CommonKey {
+    size: number;
+    createdUser: User;
+    created: string;
+}
+interface Star {
+    id: number;
+    comment?: string;
+    url: string;
+    title: string;
+    presenter: User;
+    created: string;
+}
+interface ChangeLog {
+    field: string;
+    newValue?: string;
+    originalValue?: string;
+    attachmentInfo?: CommonKey;
+    attributeInfo?: any;
+    notificationInfo?: any;
+}
+export interface customFields {
+    name: string;
+    value: string;
+}
+export interface Notification {
+    id: number;
+    alreadyRead: boolean;
+    reason: number;
+    user: User;
+    resourceAlreadyRead: boolean;
+}
+export interface Comment {
+    id: number;
+    content?: string;
+    changeLog: ChangeLog[];
+    createdUser: User;
+    created: string;
+    updated: string;
+    stars: Star[];
+    notifications: Notification[];
+}
+export interface Issue {
+    id: number;
+    projectId: number;
+    issueKey: string;
+    keyId: number;
+    issueType: IssueType;
+    summary: string;
+    description?: string;
+    resolution?: CommonKey;
+    priority?: CommonKey;
+    status: Status;
+    assignee?: User;
+    category: Category[];
+    versions: VersionMilestone[];
+    milestone: VersionMilestone[];
+    startDate?: string;
+    dueDate?: string;
+    estimatedHours?: number;
+    actualHours?: number;
+    parentIssueId?: number;
+    createdUser: User;
+    created: string;
+    updatedUser: User;
+    updated: string;
+    customFields: customFields[];
+    attachments: Attachment[];
+    sharedFiles: any;
+    stars: Star[];
+    comments: Comment[];
+}
+export interface TaskType {
+    category: string;
+    detail?: string;
+}
+export declare enum TaskCategory {
+    Bug = "Bug",
+    Custom = "Custom",
+    Story = "Story",
+    Task = "Task"
+}
+export declare enum TaskStatusCategory {
+    Done = "Done",
+    InProgress = "InProgress",
+    Todo = "Todo"
+}
+export interface TaskStatus {
+    category: TaskStatusCategory;
+    detail: string;
+}
+export interface TaskStatusChange {
+    status: TaskStatus;
+    changedAt: Date;
+}
+export interface TaskField {
+    name: string;
+    value: string;
+}
+export declare enum SprintState {
+    Active = "Active",
+    Closed = "Closed",
+    Future = "Future",
+    Default = "Default"
+}
+export {};

package/lib/converters/backlog/models.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SprintState = exports.TaskStatusCategory = exports.TaskCategory = void 0;
+var TaskCategory;
+(function (TaskCategory) {
+    TaskCategory["Bug"] = "Bug";
+    TaskCategory["Custom"] = "Custom";
+    TaskCategory["Story"] = "Story";
+    TaskCategory["Task"] = "Task";
+})(TaskCategory = exports.TaskCategory || (exports.TaskCategory = {}));
+var TaskStatusCategory;
+(function (TaskStatusCategory) {
+    TaskStatusCategory["Done"] = "Done";
+    TaskStatusCategory["InProgress"] = "InProgress";
+    TaskStatusCategory["Todo"] = "Todo";
+})(TaskStatusCategory = exports.TaskStatusCategory || (exports.TaskStatusCategory = {}));
+var SprintState;
+(function (SprintState) {
+    SprintState["Active"] = "Active";
+    SprintState["Closed"] = "Closed";
+    SprintState["Future"] = "Future";
+    SprintState["Default"] = "Default";
+})(SprintState = exports.SprintState || (exports.SprintState = {}));

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

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

package/lib/converters/backlog/projects.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Projects = void 0;
+const faros_feeds_sdk_1 = require("faros-feeds-sdk");
+const common_1 = require("./common");
+class Projects extends common_1.BacklogConverter {
+    constructor() {
+        super(...arguments);
+        this.destinationModels = [
+            'tms_Project',
+            'tms_Release',
+            'tms_Sprint',
+            'tms_TaskBoard',
+            'tms_TaskBoardProjectRelationship',
+        ];
+    }
+    async convert(record, ctx) {
+        var _a, _b;
+        const source = this.streamName.source;
+        const project = record.record.data;
+        const uid = String(project.id);
+        const res = [];
+        const maxDescriptionLength = this.maxDescriptionLength(ctx);
+        res.push({
+            model: 'tms_Project',
+            record: {
+                uid,
+                name: project.name,
+                description: null,
+                source,
+            },
+        });
+        res.push({
+            model: 'tms_TaskBoard',
+            record: {
+                uid,
+                name: project.name,
+                source,
+            },
+        });
+        res.push({
+            model: 'tms_TaskBoardProjectRelationship',
+            record: {
+                board: { uid, source },
+                project: { uid, source },
+            },
+        });
+        for (const versionMilestone of project.versionMilestones) {
+            res.push({
+                model: 'tms_Sprint',
+                record: {
+                    uid: String(versionMilestone.id),
+                    name: versionMilestone.name,
+                    description: (_a = versionMilestone.description) === null || _a === void 0 ? void 0 : _a.substring(0, maxDescriptionLength),
+                    startedAt: faros_feeds_sdk_1.Utils.toDate(versionMilestone.startDate),
+                    endedAt: faros_feeds_sdk_1.Utils.toDate(versionMilestone.releaseDueDate),
+                    state: common_1.BacklogCommon.getSprintState(versionMilestone),
+                    source,
+                },
+            });
+            if (versionMilestone.releaseDueDate) {
+                res.push({
+                    model: 'tms_Release',
+                    record: {
+                        uid: String(versionMilestone.id),
+                        name: versionMilestone.name,
+                        description: (_b = versionMilestone.description) === null || _b === void 0 ? void 0 : _b.substring(0, maxDescriptionLength),
+                        startedAt: faros_feeds_sdk_1.Utils.toDate(versionMilestone.startDate),
+                        releasedAt: faros_feeds_sdk_1.Utils.toDate(versionMilestone.releaseDueDate),
+                        source,
+                    },
+                });
+            }
+        }
+        return res;
+    }
+}
+exports.Projects = Projects;

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

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

package/lib/converters/backlog/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.BacklogConverter {
+    constructor() {
+        super(...arguments);
+        this.destinationModels = ['tms_User'];
+    }
+    async convert(record, ctx) {
+        const source = this.streamName.source;
+        const user = record.record.data;
+        return [
+            {
+                model: 'tms_User',
+                record: {
+                    uid: String(user.id),
+                    name: user.name,
+                    emailAddress: user.mailAddress,
+                    source,
+                },
+            },
+        ];
+    }
+}
+exports.Users = Users;

package/lib/converters/bitbucket/branches.d.ts

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

package/lib/converters/bitbucket/branches.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Branches = void 0;
+const common_1 = require("./common");
+class Branches extends common_1.BitbucketConverter {
+    constructor() {
+        super(...arguments);
+        this.destinationModels = ['vcs_Branch'];
+    }
+    async convert(record, ctx) {
+        const source = this.streamName.source;
+        const branch = record.record.data;
+        const [workspace, repo] = branch.target.repository.fullName.split('/');
+        if (!workspace || !repo)
+            return [];
+        return [
+            {
+                model: 'vcs_Branch',
+                record: {
+                    name: branch.name,
+                    uid: branch.name,
+                    repository: {
+                        organization: { uid: workspace.toLowerCase(), source },
+                        name: repo.toLowerCase(),
+                    },
+                },
+            },
+        ];
+    }
+}
+exports.Branches = Branches;

package/lib/converters/bitbucket/commits.d.ts

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

package/lib/converters/bitbucket/commits.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Commits = void 0;
+const faros_feeds_sdk_1 = require("faros-feeds-sdk");
+const common_1 = require("./common");
+class Commits extends common_1.BitbucketConverter {
+    constructor() {
+        super(...arguments);
+        this.destinationModels = [
+            'vcs_Commit',
+            'vcs_User',
+        ];
+    }
+    async convert(record, ctx) {
+        var _a, _b;
+        const source = this.streamName.source;
+        const commit = record.record.data;
+        const res = [];
+        const [workspace, repo] = commit.repository.fullName.split('/');
+        let author = null;
+        if ((_b = (_a = commit === null || commit === void 0 ? void 0 : commit.author) === null || _a === void 0 ? void 0 : _a.user) === null || _b === void 0 ? void 0 : _b.accountId) {
+            const commitUser = commit.author.user;
+            const user = common_1.BitbucketCommon.vcsUser(commitUser, source);
+            if (user) {
+                res.push(user);
+                author = { uid: commitUser.accountId, source };
+            }
+        }
+        if (!workspace || !repo) {
+            return res;
+        }
+        res.push({
+            model: 'vcs_Commit',
+            record: {
+                sha: commit.hash,
+                uid: commit.hash,
+                message: commit.message,
+                htmlUrl: commit.links.htmlUrl,
+                createdAt: faros_feeds_sdk_1.Utils.toDate(commit.date),
+                author,
+                repository: {
+                    organization: { uid: workspace.toLowerCase(), source },
+                    name: repo.toLowerCase(),
+                },
+            },
+        });
+        return res;
+    }
+}
+exports.Commits = Commits;

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

@@ -0,0 +1,28 @@
+import { AirbyteRecord } from 'faros-airbyte-cdk';
+import { Converter, DestinationRecord, StreamContext } from '../converter';
+import { User } from './types';
+interface BitbucketConfig {
+    application_mapping?: ApplicationMapping;
+}
+declare type ApplicationMapping = Record<string, {
+    name: string;
+    platform: string;
+}>;
+export interface CategoryRef {
+    readonly category: string;
+    readonly detail: string;
+}
+/** Common functions shares across Bitbucket converters */
+export declare class BitbucketCommon {
+    static MAX_DESCRIPTION_LENGTH: number;
+    static vcsUser(user: User, source: string): DestinationRecord | undefined;
+}
+/** Bitbucket converter base */
+export declare abstract class BitbucketConverter extends Converter {
+    source: string;
+    /** Almost all Bitbucket records should have id property */
+    id(record: AirbyteRecord): any;
+    protected bitbucketConfig(ctx: StreamContext): BitbucketConfig;
+    protected applicationMapping(ctx: StreamContext): ApplicationMapping;
+}
+export {};

package/lib/converters/bitbucket/common.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BitbucketConverter = exports.BitbucketCommon = void 0;
+const converter_1 = require("../converter");
+var UserTypeCategory;
+(function (UserTypeCategory) {
+    UserTypeCategory["BOT"] = "Bot";
+    UserTypeCategory["ORGANIZATION"] = "Organization";
+    UserTypeCategory["USER"] = "User";
+    UserTypeCategory["CUSTOM"] = "Custom";
+})(UserTypeCategory || (UserTypeCategory = {}));
+/** Common functions shares across Bitbucket converters */
+class BitbucketCommon {
+    static vcsUser(user, source) {
+        var _a;
+        if (!user.accountId)
+            return undefined;
+        const userType = user.type === 'user'
+            ? { category: UserTypeCategory.USER, detail: 'user' }
+            : { category: UserTypeCategory.CUSTOM, detail: user.type };
+        return {
+            model: 'vcs_User',
+            record: {
+                uid: user.accountId,
+                name: user.displayName,
+                type: userType,
+                htmlUrl: (_a = user.links) === null || _a === void 0 ? void 0 : _a.htmlUrl,
+                source,
+            },
+        };
+    }
+}
+exports.BitbucketCommon = BitbucketCommon;
+// max length for free-form description text field
+BitbucketCommon.MAX_DESCRIPTION_LENGTH = 1000;
+/** Bitbucket converter base */
+class BitbucketConverter extends converter_1.Converter {
+    constructor() {
+        super(...arguments);
+        this.source = 'Bitbucket';
+    }
+    /** Almost all Bitbucket records should 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;
+    }
+    bitbucketConfig(ctx) {
+        var _a, _b;
+        return (_b = (_a = ctx.config) === null || _a === void 0 ? void 0 : _a.source_specific_configs) === null || _b === void 0 ? void 0 : _b.bitbucket;
+    }
+    applicationMapping(ctx) {
+        var _a, _b;
+        return ((_b = (0, converter_1.parseObjectConfig)((_a = this.bitbucketConfig(ctx)) === null || _a === void 0 ? void 0 : _a.application_mapping, 'Application Mapping')) !== null && _b !== void 0 ? _b : {});
+    }
+}
+exports.BitbucketConverter = BitbucketConverter;

package/lib/converters/bitbucket/deployments.d.ts

@@ -0,0 +1,11 @@
+import { AirbyteRecord } from 'faros-airbyte-cdk';
+import { DestinationModel, DestinationRecord, StreamContext, StreamName } from '../converter';
+import { BitbucketConverter } from './common';
+export declare class Deployments extends BitbucketConverter {
+    readonly destinationModels: ReadonlyArray<DestinationModel>;
+    private readonly pipelinesStream;
+    get dependencies(): ReadonlyArray<StreamName>;
+    convert(record: AirbyteRecord, ctx: StreamContext): Promise<ReadonlyArray<DestinationRecord>>;
+    private convertEnvironment;
+    private convertDeploymentStatus;
+}