airbyte-faros-destination 0.1.53

package/lib/converters/harness/executions.js

@@ -0,0 +1,245 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Executions = 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");
+const DEFAULT_CICD_ORGANIZATION_UID = 'default';
+const DEFAULT_EXECUTION_TAG_APPLICATION_PLATFORM = 'faros_app_platform';
+const DEFAULT_EXECUTION_TAG_ARTIFACT_ORG = 'faros_artifact_org';
+const DEFAULT_EXECUTION_TAG_ARTIFACT_SOURCE = 'faros_artifact_source';
+const DEFAULT_EXECUTION_TAG_ARTIFACT_REPO = 'faros_artifact_repo';
+class Executions extends common_1.HarnessConverter {
+    constructor() {
+        super(...arguments);
+        this.logger = new faros_airbyte_cdk_1.AirbyteLogger();
+        this.destinationModels = [
+            'cicd_ArtifactDeployment',
+            'cicd_Build',
+            'cicd_Deployment',
+            'compute_Application',
+        ];
+    }
+    async convert(record, ctx) {
+        var _a;
+        const executionRaw = record.record.data;
+        const source = this.streamName.source;
+        const res = [];
+        const execution = this.toExecution(executionRaw, source);
+        const application = {
+            name: execution.application.name,
+            platform: (_a = execution.application.platform) !== null && _a !== void 0 ? _a : '',
+        };
+        res.push({ model: 'compute_Application', record: application });
+        const deploymentStatus = this.toDeploymentStatus(execution.status);
+        const buildStatus = this.toBuildStatus(execution.status);
+        const deployment = {
+            uid: execution.uid,
+            source,
+        };
+        res.push({
+            model: 'cicd_Deployment',
+            record: {
+                ...deployment,
+                application,
+                build: execution.build,
+                startedAt: faros_feeds_sdk_1.Utils.toDate(execution.startedAt),
+                endedAt: faros_feeds_sdk_1.Utils.toDate(execution.endedAt),
+                env: this.toEnvironmentStatus(execution.env),
+                status: deploymentStatus,
+            },
+        });
+        if (execution.build) {
+            res.push({
+                model: 'cicd_Build',
+                record: {
+                    ...execution.build,
+                    startedAt: faros_feeds_sdk_1.Utils.toDate(execution.startedAt),
+                    endedAt: faros_feeds_sdk_1.Utils.toDate(execution.endedAt),
+                    status: buildStatus,
+                },
+            });
+        }
+        if (execution.artifact) {
+            this.logger.debug(`Writing Artifact ${execution.artifact.uid} deployment association`);
+            res.push({
+                model: 'cicd_ArtifactDeployment',
+                record: {
+                    artifact: execution.artifact,
+                    deployment,
+                },
+            });
+        }
+        return res;
+    }
+    parseArtifactFromTags(execution) {
+        var _a, _b, _c, _d;
+        if (!execution.artifacts || !execution.artifacts.length) {
+            return undefined;
+        }
+        const executionArtifact = execution.artifacts[0];
+        // artifact repo organization pulled from application tags
+        const organization = {
+            uid: (_a = execution.application.tags.find((t) => t.name === DEFAULT_EXECUTION_TAG_ARTIFACT_ORG)) === null || _a === void 0 ? void 0 : _a.value,
+            source: (_c = (_b = execution.application.tags.find((t) => t.name === DEFAULT_EXECUTION_TAG_ARTIFACT_SOURCE)) === null || _b === void 0 ? void 0 : _b.value) !== null && _c !== void 0 ? _c : executionArtifact === null || executionArtifact === void 0 ? void 0 : executionArtifact.artifactSource.name,
+        };
+        const repository = {
+            uid: (_d = execution.application.tags.find((t) => t.name === DEFAULT_EXECUTION_TAG_ARTIFACT_REPO)) === null || _d === void 0 ? void 0 : _d.value,
+            organization,
+        };
+        const artifact = {
+            uid: executionArtifact === null || executionArtifact === void 0 ? void 0 : executionArtifact.buildNo,
+            repository,
+        };
+        if (artifact.uid &&
+            artifact.repository.uid &&
+            artifact.repository.organization.uid &&
+            artifact.repository.organization.source) {
+            return artifact;
+        }
+        else {
+            return undefined;
+        }
+    }
+    parseWorkflow(execution, source) {
+        var _a, _b, _c, _d, _e, _f, _g, _h;
+        const outcome = (_a = execution.outcomes) === null || _a === void 0 ? void 0 : _a.nodes.find((o) => { var _a; return (_a = o.service) === null || _a === void 0 ? void 0 : _a.artifactType; });
+        if (!outcome) {
+            return undefined;
+        }
+        const artifactSource = outcome.service.artifactSources.find((a) => a.name);
+        if (!artifactSource) {
+            return undefined;
+        }
+        const build = {
+            uid: execution.id,
+            pipeline: {
+                uid: (_c = (_b = outcome.service.name) !== null && _b !== void 0 ? _b : execution.application.name) !== null && _c !== void 0 ? _c : artifactSource.name,
+                organization: {
+                    uid: DEFAULT_CICD_ORGANIZATION_UID,
+                    source,
+                },
+            },
+        };
+        let artifact = undefined;
+        // artifact computation needs to have application tags
+        if (execution.application.tags) {
+            artifact = this.parseArtifactFromTags(execution);
+        }
+        return {
+            application: {
+                name: (_d = execution.application.name) !== null && _d !== void 0 ? _d : artifactSource.name,
+                platform: (_g = (_f = (_e = execution.application.tags) === null || _e === void 0 ? void 0 : _e.find((t) => t.name === DEFAULT_EXECUTION_TAG_APPLICATION_PLATFORM)) === null || _f === void 0 ? void 0 : _f.value) !== null && _g !== void 0 ? _g : '',
+            },
+            env: (_h = outcome.environment.name) !== null && _h !== void 0 ? _h : outcome.environment.type,
+            build,
+            artifact,
+        };
+    }
+    parsePipeline(execution) {
+        var _a, _b, _c;
+        const service = (_a = execution.application.services) === null || _a === void 0 ? void 0 : _a.nodes.find((s) => s.artifactType);
+        if (!service) {
+            return;
+        }
+        const artifactSource = service.artifactSources.find((a) => a.name);
+        const environment = (_b = execution.application.environments) === null || _b === void 0 ? void 0 : _b.nodes.find((e) => e.type);
+        if (!artifactSource || !environment) {
+            return;
+        }
+        return {
+            application: {
+                name: artifactSource.name,
+                platform: service.artifactType,
+            },
+            env: (_c = environment.name) !== null && _c !== void 0 ? _c : environment.type,
+        };
+    }
+    toBuildStatus(status) {
+        const statusLower = status.toLowerCase();
+        switch (statusLower) {
+            case 'aborted':
+            case 'rejected':
+                return { category: 'Canceled', detail: status };
+            case 'error':
+            case 'expired':
+            case 'failed':
+                return { category: 'Failed', detail: status };
+            case 'paused':
+            case 'queued':
+            case 'waiting':
+                return { category: 'Queued', detail: status };
+            case 'resumed':
+            case 'running':
+                return { category: 'Running', detail: status };
+            case 'success':
+                return { category: 'Success', detail: status };
+            case 'skipped':
+            default:
+                return { category: 'Custom', detail: status };
+        }
+    }
+    toEnvironmentStatus(status) {
+        const statusLower = status.toLowerCase();
+        if (statusLower.startsWith('prod')) {
+            return { category: 'Prod', detail: status };
+        }
+        if (statusLower === 'staging') {
+            return { category: 'Staging', detail: status };
+        }
+        if (statusLower.startsWith('dev')) {
+            return { category: 'Dev', detail: status };
+        }
+        if (statusLower === 'qa') {
+            return { category: 'QA', detail: status };
+        }
+        return { category: 'Custom', detail: status };
+    }
+    toExecution(item, source) {
+        let implementation;
+        if (item.outcomes) {
+            implementation = this.parseWorkflow(item, source);
+        }
+        else {
+            implementation = this.parsePipeline(item);
+        }
+        if (!implementation) {
+            return;
+        }
+        return {
+            uid: item.id,
+            application: implementation.application,
+            startedAt: item.startedAt,
+            endedAt: item.endedAt,
+            env: implementation.env,
+            status: item.status,
+            build: implementation.build,
+            artifact: implementation.artifact,
+        };
+    }
+    toDeploymentStatus(status) {
+        const statusLower = status.toLowerCase();
+        switch (statusLower) {
+            case 'aborted':
+            case 'rejected':
+                return { category: 'Canceled', detail: status };
+            case 'error':
+            case 'expired':
+            case 'failed':
+                return { category: 'Failed', detail: status };
+            case 'paused':
+            case 'queued':
+            case 'waiting':
+                return { category: 'Queued', detail: status };
+            case 'resumed':
+            case 'running':
+                return { category: 'Running', detail: status };
+            case 'success':
+                return { category: 'Success', detail: status };
+            case 'skipped':
+            default:
+                return { category: 'Custom', detail: status };
+        }
+    }
+}
+exports.Executions = Executions;

package/lib/converters/jenkins/builds.d.ts

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

package/lib/converters/jenkins/builds.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Builds = void 0;
+const faros_feeds_sdk_1 = require("faros-feeds-sdk");
+const common_1 = require("./common");
+class Builds extends common_1.JenkinsConverter {
+    constructor() {
+        super(...arguments);
+        this.destinationModels = [
+            'cicd_Organization',
+            'cicd_Pipeline',
+            'cicd_Build',
+        ];
+    }
+    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;
+    }
+    async convert(record, ctx) {
+        const source = this.streamName.source;
+        const build = record.record.data;
+        const jenkinsUrl = common_1.JenkinsCommon.parseJenkinsUrl(build.url);
+        if (!jenkinsUrl)
+            return [];
+        const organization = common_1.JenkinsCommon.cicd_Organization(jenkinsUrl, source);
+        const orgKey = { uid: organization.record.uid, source };
+        const jobFullName = build.fullDisplayName.replace(/ #.*/, '');
+        const job = {
+            fullName: jobFullName,
+            name: jobFullName,
+            url: jenkinsUrl.url.replace(/[^/]*(\/)?$/, ''),
+        };
+        const pipeline = common_1.JenkinsCommon.cicd_Pipeline(job, orgKey);
+        const buildRecord = {
+            model: 'cicd_Build',
+            record: {
+                uid: build.id,
+                name: build.displayName,
+                number: build.number,
+                startedAt: faros_feeds_sdk_1.Utils.toDate(build.timestamp),
+                endedAt: faros_feeds_sdk_1.Utils.toDate(build.timestamp + build.duration),
+                status: this.convertBuildStatus(build.result),
+                url: jenkinsUrl.url,
+                pipeline: {
+                    uid: pipeline.record.uid,
+                    organization: orgKey,
+                },
+            },
+        };
+        return [organization, pipeline, buildRecord];
+    }
+    convertBuildStatus(status) {
+        if (!status) {
+            return { category: 'Unknown', detail: null };
+        }
+        const detail = status.toLowerCase();
+        // Read more on Jenkins build results:
+        // 1. https://wiki.jenkins.io/display/jenkins/terminology
+        // 2. https://github.com/jenkinsci/jenkins/blob/master/core/src/main/java/hudson/model/Result.java
+        switch (detail) {
+            case 'not_built':
+            case 'aborted':
+                return { category: 'Canceled', detail };
+            case 'failure':
+            case 'unstable':
+                return { category: 'Failed', detail };
+            case 'success':
+                return { category: 'Success', detail };
+            default:
+                return { category: 'Unknown', detail };
+        }
+    }
+}
+exports.Builds = Builds;

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

@@ -0,0 +1,25 @@
+import { Converter, DestinationRecord } from '../converter';
+interface JenkinsUrl {
+    hostname: string;
+    url: string;
+    baseUrl: string;
+}
+export interface Job {
+    readonly fullName: string;
+    readonly name: string;
+    readonly url: string;
+}
+interface OrganizationKey {
+    uid: string;
+    source: string;
+}
+/** Common functions shares across Jenkins converters */
+export declare class JenkinsCommon {
+    static cicd_Organization(jenkinsUrl: JenkinsUrl, source: string): DestinationRecord;
+    static cicd_Pipeline(job: Job, organization: OrganizationKey): DestinationRecord;
+    static parseJenkinsUrl(initUrl: string): undefined | JenkinsUrl;
+}
+export declare abstract class JenkinsConverter extends Converter {
+    source: string;
+}
+export {};

package/lib/converters/jenkins/common.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JenkinsConverter = exports.JenkinsCommon = void 0;
+const url_1 = require("url");
+const converter_1 = require("../converter");
+/** Common functions shares across Jenkins converters */
+class JenkinsCommon {
+    static cicd_Organization(jenkinsUrl, source) {
+        return {
+            model: 'cicd_Organization',
+            record: {
+                uid: jenkinsUrl.hostname.toLowerCase(),
+                name: jenkinsUrl.hostname,
+                url: jenkinsUrl.baseUrl,
+                source,
+            },
+        };
+    }
+    static cicd_Pipeline(job, organization) {
+        return {
+            model: 'cicd_Pipeline',
+            record: {
+                uid: job.fullName.toLowerCase(),
+                name: job.name,
+                url: job.url,
+                organization,
+            },
+        };
+    }
+    static parseJenkinsUrl(initUrl) {
+        try {
+            const urlParsed = new url_1.URL(initUrl);
+            const hostname = urlParsed.hostname;
+            const url = urlParsed.toString();
+            urlParsed.pathname = '';
+            const baseUrl = urlParsed.toString();
+            if (!hostname) {
+                return undefined;
+            }
+            return { hostname, url, baseUrl };
+        }
+        catch (error) {
+            return undefined;
+        }
+    }
+}
+exports.JenkinsCommon = JenkinsCommon;
+class JenkinsConverter extends converter_1.Converter {
+    constructor() {
+        super(...arguments);
+        this.source = 'Jenkins';
+    }
+}
+exports.JenkinsConverter = JenkinsConverter;

package/lib/converters/jenkins/jobs.d.ts

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

package/lib/converters/jenkins/jobs.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Jobs = void 0;
+const common_1 = require("./common");
+class Jobs extends common_1.JenkinsConverter {
+    constructor() {
+        super(...arguments);
+        this.destinationModels = [
+            'cicd_Organization',
+            'cicd_Pipeline',
+        ];
+    }
+    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.fullName;
+    }
+    async convert(record, ctx) {
+        const source = this.streamName.source;
+        const job = record.record.data;
+        const jenkinsUrl = common_1.JenkinsCommon.parseJenkinsUrl(job.url);
+        if (!jenkinsUrl)
+            return [];
+        const organization = common_1.JenkinsCommon.cicd_Organization(jenkinsUrl, source);
+        const orgKey = { uid: organization.record.uid, source };
+        const pipeline = common_1.JenkinsCommon.cicd_Pipeline(job, orgKey);
+        return [organization, pipeline];
+    }
+}
+exports.Jobs = Jobs;

package/lib/converters/jira/board_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 BoardIssues extends JiraConverter {
+    readonly destinationModels: ReadonlyArray<DestinationModel>;
+    convert(record: AirbyteRecord, ctx: StreamContext): Promise<ReadonlyArray<DestinationRecord>>;
+}

package/lib/converters/jira/board_issues.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BoardIssues = void 0;
+const common_1 = require("./common");
+class BoardIssues extends common_1.JiraConverter {
+    constructor() {
+        super(...arguments);
+        this.destinationModels = [
+            'tms_TaskBoardRelationship',
+        ];
+    }
+    async convert(record, ctx) {
+        if (!this.useBoardOwnership(ctx))
+            return [];
+        const issue = record.record.data;
+        const source = this.streamName.source;
+        return [
+            {
+                model: 'tms_TaskBoardRelationship',
+                record: {
+                    task: { uid: issue.key, source },
+                    board: { uid: String(issue.boardId), source },
+                },
+            },
+        ];
+    }
+}
+exports.BoardIssues = BoardIssues;

package/lib/converters/jira/boards.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 Boards extends JiraConverter {
+    readonly destinationModels: ReadonlyArray<DestinationModel>;
+    convert(record: AirbyteRecord, ctx: StreamContext): Promise<ReadonlyArray<DestinationRecord>>;
+}

package/lib/converters/jira/boards.js

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

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

@@ -0,0 +1,61 @@
+import { AirbyteRecord } from 'faros-airbyte-cdk';
+import { Dictionary } from 'ts-essentials';
+import { Converter, StreamContext } from '../converter';
+export interface Assignee {
+    readonly uid: string;
+    readonly assignedAt: Date;
+}
+export declare enum RepoSource {
+    BITBUCKET = "Bitbucket",
+    GITHUB = "GitHub",
+    GITLAB = "GitLab",
+    VCS = "VCS"
+}
+export interface Repo {
+    readonly source: RepoSource;
+    readonly org: string;
+    readonly name: string;
+}
+export interface PullRequest {
+    readonly repo: Repo;
+    readonly number: number;
+}
+export interface Status {
+    readonly category: string;
+    readonly detail: string;
+}
+export interface SprintIssue {
+    id: number;
+    key: string;
+    fields: Dictionary<any>;
+    issueId: string;
+    sprintId: number;
+}
+export declare class JiraCommon {
+    static POINTS_FIELD_NAMES: string[];
+    static DEV_FIELD_NAME: string;
+    static EPIC_LINK_FIELD_NAME: string;
+    static EPIC_TYPE_NAME: string;
+    static SPRINT_FIELD_NAME: string;
+    static DEFAULT_ADDITIONAL_FIELDS_ARRAY_LIMIT: number;
+    static DEFAULT_TRUNCATE_LIMIT: number;
+    static normalize(str: string): string;
+}
+export declare const JiraStatusCategories: ReadonlyMap<string, string>;
+export interface JiraConfig {
+    additional_fields_array_limit?: number;
+    exclude_fields?: string[];
+    use_board_ownership?: boolean;
+    truncate_limit?: number;
+}
+export declare abstract class JiraConverter extends Converter {
+    source: string;
+    /** All Jira records should have id property */
+    id(record: AirbyteRecord): any;
+    protected jiraConfig(ctx: StreamContext): JiraConfig;
+    protected additionalFieldsArrayLimit(ctx: StreamContext): number;
+    protected excludeFields(ctx: StreamContext): Set<string>;
+    protected truncateLimit(ctx: StreamContext): number;
+    protected truncate(ctx: StreamContext, str?: string): string | undefined;
+    protected useBoardOwnership(ctx: StreamContext): boolean;
+}

package/lib/converters/jira/common.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JiraConverter = exports.JiraStatusCategories = exports.JiraCommon = exports.RepoSource = void 0;
+const lodash_1 = require("lodash");
+const converter_1 = require("../converter");
+var RepoSource;
+(function (RepoSource) {
+    RepoSource["BITBUCKET"] = "Bitbucket";
+    RepoSource["GITHUB"] = "GitHub";
+    RepoSource["GITLAB"] = "GitLab";
+    RepoSource["VCS"] = "VCS";
+})(RepoSource = exports.RepoSource || (exports.RepoSource = {}));
+class JiraCommon {
+    static normalize(str) {
+        return str.replace(/\s/g, '').toLowerCase();
+    }
+}
+exports.JiraCommon = JiraCommon;
+JiraCommon.POINTS_FIELD_NAMES = ['Story Points', 'Story point estimate'];
+JiraCommon.DEV_FIELD_NAME = 'Development';
+JiraCommon.EPIC_LINK_FIELD_NAME = 'Epic Link';
+JiraCommon.EPIC_TYPE_NAME = 'Epic';
+JiraCommon.SPRINT_FIELD_NAME = 'Sprint';
+JiraCommon.DEFAULT_ADDITIONAL_FIELDS_ARRAY_LIMIT = 50;
+JiraCommon.DEFAULT_TRUNCATE_LIMIT = 10000;
+exports.JiraStatusCategories = new Map(['Todo', 'InProgress', 'Done'].map((s) => [JiraCommon.normalize(s), s]));
+class JiraConverter extends converter_1.Converter {
+    constructor() {
+        super(...arguments);
+        this.source = 'Jira';
+    }
+    /** All Jira 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;
+    }
+    jiraConfig(ctx) {
+        var _a, _b;
+        return (_b = (_a = ctx.config.source_specific_configs) === null || _a === void 0 ? void 0 : _a.jira) !== null && _b !== void 0 ? _b : {};
+    }
+    additionalFieldsArrayLimit(ctx) {
+        var _a;
+        return ((_a = this.jiraConfig(ctx).additional_fields_array_limit) !== null && _a !== void 0 ? _a : JiraCommon.DEFAULT_ADDITIONAL_FIELDS_ARRAY_LIMIT);
+    }
+    excludeFields(ctx) {
+        var _a;
+        return new Set((_a = this.jiraConfig(ctx).exclude_fields) !== null && _a !== void 0 ? _a : []);
+    }
+    truncateLimit(ctx) {
+        var _a;
+        return ((_a = this.jiraConfig(ctx).truncate_limit) !== null && _a !== void 0 ? _a : JiraCommon.DEFAULT_TRUNCATE_LIMIT);
+    }
+    truncate(ctx, str) {
+        if ((0, lodash_1.isString)(str) && str.length > this.truncateLimit(ctx)) {
+            return str.substring(0, this.truncateLimit(ctx));
+        }
+        return str;
+    }
+    useBoardOwnership(ctx) {
+        var _a;
+        return (_a = this.jiraConfig(ctx).use_board_ownership) !== null && _a !== void 0 ? _a : false;
+    }
+}
+exports.JiraConverter = JiraConverter;

package/lib/converters/jira/epics.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 Epics extends JiraConverter {
+    readonly destinationModels: ReadonlyArray<DestinationModel>;
+    private turndown;
+    convert(record: AirbyteRecord, ctx: StreamContext): Promise<ReadonlyArray<DestinationRecord>>;
+}