airbyte-faros-destination 0.1.53

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

@@ -0,0 +1,87 @@
+import { AirbyteRecord } from 'faros-airbyte-cdk';
+import { Converter, StreamContext } from '../converter';
+export declare const ARTIFACT_TYPE = "Docker";
+interface DockerConfig {
+    label_prefix?: string;
+    skip_tags?: string[];
+    organization?: string;
+}
+interface LayerConfig {
+    mediaType: string;
+    size: number;
+    digest: string;
+}
+interface ImageManifest {
+    schemaVersion: number;
+    mediaType: string;
+    config: LayerConfig;
+    layers: LayerConfig[];
+    /**
+     * Optional for backwards compatibility. This field is not directly returned by the container registry,
+     * it is appended before returning the ImageManifest.
+     * It is only applicable to multi-platform images.
+     */
+    indexDigest?: string;
+    /**
+     * Optional for backwards compatibility. This field is not directly returned by the container registry,
+     * it is appended before returning the ImageManifest.
+     */
+    manifestDigest?: string;
+}
+interface ImageConfigContainer {
+    Labels: Record<string, string>;
+}
+interface ImageConfig {
+    config: ImageConfigContainer;
+    created: string;
+}
+export interface Tag {
+    name: string;
+    projectName: string;
+    imageConfig?: ImageConfig;
+    imageManifest?: ImageManifest;
+}
+export interface OrganizationKey {
+    readonly uid: string;
+    readonly source: string;
+}
+interface PipelineKey {
+    readonly uid: string;
+    readonly organization: OrganizationKey;
+}
+interface BuildKey {
+    readonly uid: string;
+    readonly pipeline: PipelineKey;
+}
+export interface RepositoryKey {
+    readonly uid: string;
+    readonly organization: OrganizationKey;
+}
+interface VCSRepositoryKey {
+    readonly name: string;
+    readonly organization: OrganizationKey;
+}
+interface CommitKey {
+    readonly sha: string;
+    readonly repository: VCSRepositoryKey;
+}
+export interface CICDTag {
+    name: string;
+    value: string;
+}
+export declare class DockerCommon {
+    static ALLOWED_MANIFEST_SCHEMA_VERSION: number;
+    static getBuildKey(tags: CICDTag[], prefix: string): BuildKey | undefined;
+    static getCommitKey(tags: CICDTag[], prefix: string): CommitKey | undefined;
+}
+/** Docker converter base */
+export declare abstract class DockerConverter extends Converter {
+    source: string;
+    /** Every Docker record have id property */
+    id(record: AirbyteRecord): any;
+    protected dockerConfig(ctx: StreamContext): DockerConfig;
+    protected labelPrefix(ctx: StreamContext): string;
+    protected skipTags(ctx: StreamContext): string[];
+    protected organization(ctx: StreamContext): string | undefined;
+}
+export {};

package/lib/converters/docker/common.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DockerConverter = exports.DockerCommon = exports.ARTIFACT_TYPE = void 0;
+const converter_1 = require("../converter");
+exports.ARTIFACT_TYPE = 'Docker';
+const DEFAULT_LABEL_PREFIX = 'faros-';
+class DockerCommon {
+    static getBuildKey(tags, prefix) {
+        var _a, _b, _c;
+        const buildId = tags.find(({ name }) => name === `${prefix}build-id`);
+        const ciPipeline = (_a = tags.find(({ name }) => name === `${prefix}ci-pipeline`)) !== null && _a !== void 0 ? _a : tags.find(({ name }) => name === `${prefix}pipeline-id`);
+        const ciOrg = (_b = tags.find(({ name }) => name === `${prefix}ci-org`)) !== null && _b !== void 0 ? _b : tags.find(({ name }) => name === `${prefix}org-id`);
+        const ciSource = (_c = tags.find(({ name }) => name === `${prefix}ci-source`)) !== null && _c !== void 0 ? _c : tags.find(({ name }) => name === `${prefix}org-source`);
+        if (buildId && ciPipeline && ciOrg && ciSource) {
+            return {
+                uid: buildId.value,
+                pipeline: {
+                    uid: ciPipeline.value,
+                    organization: {
+                        uid: ciOrg.value,
+                        source: ciSource.value,
+                    },
+                },
+            };
+        }
+        return undefined;
+    }
+    static getCommitKey(tags, prefix) {
+        const commitSha = tags.find(({ name }) => name === `${prefix}commit-sha`);
+        const vcsRepo = tags.find(({ name }) => name === `${prefix}vcs-repo`);
+        const vcsOrg = tags.find(({ name }) => name === `${prefix}vcs-org`);
+        const vcsSource = tags.find(({ name }) => name === `${prefix}vcs-source`);
+        if (commitSha && vcsRepo && vcsOrg && vcsSource) {
+            return {
+                sha: commitSha.value,
+                repository: {
+                    name: vcsRepo.value,
+                    organization: {
+                        uid: vcsOrg.value,
+                        source: vcsSource.value,
+                    },
+                },
+            };
+        }
+        return undefined;
+    }
+}
+exports.DockerCommon = DockerCommon;
+DockerCommon.ALLOWED_MANIFEST_SCHEMA_VERSION = 2;
+/** Docker converter base */
+class DockerConverter extends converter_1.Converter {
+    constructor() {
+        super(...arguments);
+        this.source = 'Docker';
+    }
+    /** Every Docker 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;
+    }
+    dockerConfig(ctx) {
+        var _a, _b;
+        return (_b = (_a = ctx.config.source_specific_configs) === null || _a === void 0 ? void 0 : _a.docker) !== null && _b !== void 0 ? _b : {};
+    }
+    labelPrefix(ctx) {
+        return this.dockerConfig(ctx).label_prefix || DEFAULT_LABEL_PREFIX;
+    }
+    skipTags(ctx) {
+        var _a;
+        return (_a = this.dockerConfig(ctx).skip_tags) !== null && _a !== void 0 ? _a : [];
+    }
+    organization(ctx) {
+        return this.dockerConfig(ctx).organization;
+    }
+}
+exports.DockerConverter = DockerConverter;

package/lib/converters/docker/tags.d.ts

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

package/lib/converters/docker/tags.js

@@ -0,0 +1,98 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Tags = 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");
+class Tags extends common_1.DockerConverter {
+    constructor() {
+        super(...arguments);
+        this.logger = new faros_airbyte_cdk_1.AirbyteLogger();
+        this.destinationModels = [
+            'cicd_Artifact',
+            'cicd_ArtifactCommitAssociation',
+            'cicd_Organization',
+            'cicd_Repository',
+        ];
+    }
+    async convert(record, ctx) {
+        var _a;
+        const source = this.streamName.source;
+        const tag = record.record.data;
+        const res = [];
+        const org = this.organization(ctx);
+        if (!org) {
+            return res;
+        }
+        const organizationKey = {
+            uid: org.toLowerCase(),
+            source,
+        };
+        res.push({
+            model: 'cicd_Organization',
+            record: {
+                ...organizationKey,
+                name: org,
+            },
+        });
+        const [repoName] = tag.projectName.toLowerCase().split('/').slice(-1);
+        const repositoryKey = {
+            uid: repoName.toLowerCase(),
+            organization: organizationKey,
+        };
+        res.push({
+            model: 'cicd_Repository',
+            record: {
+                ...repositoryKey,
+                name: repoName,
+            },
+        });
+        const cicdTags = [];
+        const imageInfo = `(${tag.projectName}:${tag.name})`;
+        if (((_a = tag.imageManifest) === null || _a === void 0 ? void 0 : _a.schemaVersion) !==
+            common_1.DockerCommon.ALLOWED_MANIFEST_SCHEMA_VERSION) {
+            this.logger.info(`Image schema version is not supported: ${tag.imageManifest.schemaVersion} != expected ${common_1.DockerCommon.ALLOWED_MANIFEST_SCHEMA_VERSION} ${imageInfo}`);
+            return res;
+        }
+        if (tag.imageConfig.config.Labels) {
+            Object.entries(tag.imageConfig.config.Labels).forEach(([name, value]) => {
+                cicdTags.push({ name, value });
+            });
+        }
+        const skipTags = this.skipTags(ctx);
+        if (!skipTags || !skipTags.includes(tag.name)) {
+            const labelPrefix = this.labelPrefix(ctx);
+            const buildKey = common_1.DockerCommon.getBuildKey(cicdTags, labelPrefix);
+            const commitKey = common_1.DockerCommon.getCommitKey(cicdTags, labelPrefix);
+            res.push({
+                model: 'cicd_Artifact',
+                record: {
+                    uid: tag.name,
+                    name: tag.name,
+                    type: common_1.ARTIFACT_TYPE,
+                    createdAt: faros_feeds_sdk_1.Utils.toDate(tag.imageConfig.created),
+                    build: buildKey,
+                    tags: cicdTags,
+                    repository: repositoryKey,
+                },
+            });
+            if (commitKey) {
+                res.push({
+                    model: 'cicd_ArtifactCommitAssociation',
+                    record: {
+                        artifact: {
+                            uid: tag.name,
+                            repository: repositoryKey,
+                        },
+                        commit: commitKey,
+                    },
+                });
+            }
+        }
+        else {
+            this.logger.info(`Skipped artifact in repo ${repositoryKey.uid} (uid: ${tag.name})`);
+        }
+        return res;
+    }
+}
+exports.Tags = Tags;

package/lib/converters/github/assignees.d.ts

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

package/lib/converters/github/assignees.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Assignees = void 0;
+const common_1 = require("./common");
+class Assignees extends common_1.GitHubConverter {
+    constructor() {
+        super(...arguments);
+        this.destinationModels = ['tms_User'];
+    }
+    async convert(record, ctx) {
+        const source = this.streamName.source;
+        const user = record.record.data;
+        return [common_1.GitHubCommon.tms_User(user, source)];
+    }
+}
+exports.Assignees = Assignees;

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

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

package/lib/converters/github/branches.js

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

package/lib/converters/github/collaborators.d.ts

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

package/lib/converters/github/collaborators.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Collaborators = void 0;
+const common_1 = require("./common");
+class Collaborators extends common_1.GitHubConverter {
+    constructor() {
+        super(...arguments);
+        this.destinationModels = [
+            'vcs_Membership',
+            'vcs_User',
+        ];
+    }
+    async convert(record, ctx) {
+        const source = this.streamName.source;
+        const user = record.record.data;
+        return common_1.GitHubCommon.vcs_User_with_Membership(user, source);
+    }
+}
+exports.Collaborators = Collaborators;

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

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

package/lib/converters/github/commits.js

@@ -0,0 +1,48 @@
+"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.GitHubConverter {
+    constructor() {
+        super(...arguments);
+        this.destinationModels = [
+            'vcs_BranchCommitAssociation',
+            'vcs_Commit',
+        ];
+    }
+    async convert(record, ctx) {
+        var _a;
+        const source = this.streamName.source;
+        const commit = record.record.data;
+        const res = [];
+        const repository = common_1.GitHubCommon.parseRepositoryKey(commit.repository, source);
+        if (!repository)
+            return res;
+        const author = commit.author ? { uid: commit.author.login, source } : null;
+        res.push({
+            model: 'vcs_Commit',
+            record: {
+                uid: commit.sha,
+                sha: commit.sha,
+                message: commit.commit.message,
+                author,
+                htmlUrl: commit.html_url,
+                createdAt: faros_feeds_sdk_1.Utils.toDate((_a = commit.commit.author) === null || _a === void 0 ? void 0 : _a.date),
+                repository,
+                source,
+            },
+        });
+        if (commit.branch) {
+            res.push({
+                model: 'vcs_BranchCommitAssociation',
+                record: {
+                    commit: { sha: commit.sha, uid: commit.sha, repository },
+                    branch: { name: commit.branch, uid: commit.branch, repository },
+                },
+            });
+        }
+        return res;
+    }
+}
+exports.Commits = Commits;

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

@@ -0,0 +1,37 @@
+import { AirbyteRecord } from 'faros-airbyte-cdk';
+import { Dictionary } from 'ts-essentials';
+import { Converter, DestinationRecord } from '../converter';
+/** Common functions shares across GitHub converters */
+export declare class GitHubCommon {
+    static readonly MAX_DESCRIPTION_LENGTH = 1000;
+    static vcs_User_with_Membership(user: Dictionary<any>, source: string): DestinationRecord[];
+    static vcs_UserType(user: Dictionary<any>): {
+        category: string;
+        detail: string;
+    };
+    static vcs_User(user: Dictionary<any>, source: string): DestinationRecord;
+    static vcs_Membership(userUid: string, org: string, source: string): DestinationRecord;
+    static tms_User(user: Dictionary<any>, source: string): DestinationRecord;
+    static tms_ProjectBoard_with_TaskBoard(projectKey: ProjectKey, name: string, description: string | null, createdAt: string | null | undefined, updatedAt: string | null | undefined): DestinationRecord[];
+    static parseRepositoryKey(repository: string, source: string): undefined | RepositoryKey;
+    static parsePRnumber(pull_request_url: string): number;
+}
+/** Github converter base */
+export declare abstract class GitHubConverter extends Converter {
+    source: string;
+    /** All Github records should have id property */
+    id(record: AirbyteRecord): any;
+}
+export interface RepositoryKey {
+    name: string;
+    uid: string;
+    organization: OrgKey;
+}
+export interface OrgKey {
+    uid: string;
+    source: string;
+}
+export interface ProjectKey {
+    uid: string;
+    source: string;
+}

package/lib/converters/github/common.js

@@ -0,0 +1,130 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GitHubConverter = exports.GitHubCommon = void 0;
+const faros_feeds_sdk_1 = require("faros-feeds-sdk");
+const lodash_1 = require("lodash");
+const converter_1 = require("../converter");
+/** Common functions shares across GitHub converters */
+class GitHubCommon {
+    static vcs_User_with_Membership(user, source) {
+        const vcsUser = GitHubCommon.vcs_User(user, source);
+        const repository = GitHubCommon.parseRepositoryKey(user.repository, source);
+        if (!repository)
+            return [vcsUser];
+        const vcsMembership = GitHubCommon.vcs_Membership(vcsUser.record.uid, repository.organization.uid, repository.organization.source);
+        return [vcsUser, vcsMembership];
+    }
+    static vcs_UserType(user) {
+        if (!user.type) {
+            return { category: 'Custom', detail: 'unknown' };
+        }
+        const userTypeLower = user.type.toLowerCase();
+        switch (userTypeLower) {
+            case 'enterpriseuseraccount':
+            case 'user':
+                return { category: 'User', detail: userTypeLower };
+            case 'bot':
+                return { category: 'Bot', detail: userTypeLower };
+            case 'organization':
+                return { category: 'Organization', detail: userTypeLower };
+            case 'mannequin':
+                return { category: 'Mannequin', detail: userTypeLower };
+            default:
+                return { category: 'Custom', detail: userTypeLower };
+        }
+    }
+    static vcs_User(user, source) {
+        var _a, _b, _c;
+        const type = GitHubCommon.vcs_UserType(user);
+        return {
+            model: 'vcs_User',
+            record: {
+                uid: user.login,
+                name: (_b = (_a = user.name) !== null && _a !== void 0 ? _a : user.login) !== null && _b !== void 0 ? _b : null,
+                htmlUrl: (_c = user.html_url) !== null && _c !== void 0 ? _c : null,
+                type,
+                source,
+            },
+        };
+    }
+    static vcs_Membership(userUid, org, source) {
+        return {
+            model: 'vcs_Membership',
+            record: {
+                user: { uid: userUid, source },
+                organization: { uid: (0, lodash_1.toLower)(org), source },
+            },
+        };
+    }
+    static tms_User(user, source) {
+        var _a, _b;
+        return {
+            model: 'tms_User',
+            record: {
+                uid: user.login,
+                name: (_b = (_a = user.name) !== null && _a !== void 0 ? _a : user.login) !== null && _b !== void 0 ? _b : null,
+                source,
+            },
+        };
+    }
+    static tms_ProjectBoard_with_TaskBoard(projectKey, name, description, createdAt, updatedAt) {
+        return [
+            {
+                model: 'tms_Project',
+                record: {
+                    ...projectKey,
+                    name: name,
+                    description: description === null || description === void 0 ? void 0 : description.substring(0, GitHubCommon.MAX_DESCRIPTION_LENGTH),
+                    createdAt: faros_feeds_sdk_1.Utils.toDate(createdAt),
+                    updatedAt: faros_feeds_sdk_1.Utils.toDate(updatedAt),
+                },
+            },
+            {
+                model: 'tms_TaskBoard',
+                record: {
+                    ...projectKey,
+                    name,
+                },
+            },
+            {
+                model: 'tms_TaskBoardProjectRelationship',
+                record: {
+                    board: projectKey,
+                    project: projectKey,
+                },
+            },
+        ];
+    }
+    static parseRepositoryKey(repository, source) {
+        if (!repository)
+            return undefined;
+        const orgRepo = repository.split('/');
+        if (orgRepo.length != 2)
+            return undefined;
+        const [organization, repositoryName] = orgRepo;
+        return {
+            name: (0, lodash_1.toLower)(repositoryName),
+            uid: (0, lodash_1.toLower)(repositoryName),
+            organization: { uid: (0, lodash_1.toLower)(organization), source },
+        };
+    }
+    static parsePRnumber(pull_request_url) {
+        return faros_feeds_sdk_1.Utils.parseInteger(pull_request_url.substring(pull_request_url.lastIndexOf('/') + 1));
+    }
+}
+exports.GitHubCommon = GitHubCommon;
+// Max length for free-form description text fields such as issue body
+GitHubCommon.MAX_DESCRIPTION_LENGTH = 1000;
+/** Github converter base */
+class GitHubConverter extends converter_1.Converter {
+    constructor() {
+        super(...arguments);
+        this.source = 'GitHub';
+    }
+    /** All Github 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;
+    }
+}
+exports.GitHubConverter = GitHubConverter;

package/lib/converters/github/issue_labels.d.ts

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

package/lib/converters/github/issue_labels.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IssueLabels = void 0;
+const common_1 = require("./common");
+class IssueLabels extends common_1.GitHubConverter {
+    constructor() {
+        super(...arguments);
+        this.destinationModels = ['tms_Label'];
+    }
+    async convert(record, ctx) {
+        const label = record.record.data;
+        return [
+            {
+                model: 'tms_Label',
+                record: { name: label.name },
+            },
+        ];
+    }
+}
+exports.IssueLabels = IssueLabels;

package/lib/converters/github/issue_milestones.d.ts

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

package/lib/converters/github/issue_milestones.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IssueMilestones = void 0;
+const common_1 = require("./common");
+class IssueMilestones extends common_1.GitHubConverter {
+    constructor() {
+        super(...arguments);
+        this.destinationModels = ['tms_Epic'];
+    }
+    async convert(record, ctx) {
+        var _a;
+        const source = this.streamName.source;
+        const milestone = record.record.data;
+        const repository = common_1.GitHubCommon.parseRepositoryKey(milestone.repository, source);
+        if (!repository)
+            return [];
+        return [
+            {
+                model: 'tms_Epic',
+                record: {
+                    uid: `${milestone.id}`,
+                    name: milestone.title,
+                    description: (_a = milestone.description) === null || _a === void 0 ? void 0 : _a.substring(0, common_1.GitHubCommon.MAX_DESCRIPTION_LENGTH),
+                    project: { uid: repository.name, source },
+                    status: this.epicStatus(milestone.state),
+                    source,
+                },
+            },
+        ];
+    }
+    epicStatus(state) {
+        switch (state) {
+            case 'open':
+                return { category: 'InProgress', detail: state };
+            case 'closed':
+                return { category: 'Done', detail: state };
+            default:
+                return { category: 'Custom', detail: state };
+        }
+    }
+}
+exports.IssueMilestones = IssueMilestones;