airbyte-faros-destination 0.1.53

package/lib/destination-runner.d.ts

@@ -0,0 +1,12 @@
+import { Command } from 'commander';
+import { AirbyteDestinationRunner } from 'faros-airbyte-cdk';
+import { Converter } from './converters/converter';
+/** Faros destination runner. */
+export declare class FarosDestinationRunner extends AirbyteDestinationRunner {
+    readonly program: Command;
+    constructor();
+    /**
+     * Register converters for custom streams
+     */
+    registerConverters(...converters: ReadonlyArray<Converter>): void;
+}

package/lib/destination-runner.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FarosDestinationRunner = void 0;
+const faros_airbyte_cdk_1 = require("faros-airbyte-cdk");
+const converter_registry_1 = require("./converters/converter-registry");
+const destination_1 = require("./destination");
+/** Faros destination runner. */
+class FarosDestinationRunner extends faros_airbyte_cdk_1.AirbyteDestinationRunner {
+    constructor() {
+        const logger = new faros_airbyte_cdk_1.AirbyteLogger();
+        const destination = new destination_1.FarosDestination(logger);
+        super(logger, destination);
+        this.program = super.mainCommand();
+    }
+    /**
+     * Register converters for custom streams
+     */
+    registerConverters(...converters) {
+        converters.forEach(converter_registry_1.ConverterRegistry.addConverter);
+    }
+}
+exports.FarosDestinationRunner = FarosDestinationRunner;

package/lib/destination.d.ts

@@ -0,0 +1,42 @@
+/// <reference types="node" />
+import Analytics from 'analytics-node';
+import { AirbyteConfig, AirbyteConfiguredCatalog, AirbyteConnectionStatusMessage, AirbyteDestination, AirbyteLogger, AirbyteSpec, AirbyteStateMessage } from 'faros-airbyte-cdk';
+import { FarosClient } from 'faros-feeds-sdk';
+import { HasuraClient } from './community/hasura-client';
+import { Converter } from './converters/converter';
+import { JSONataApplyMode } from './converters/jsonata';
+export declare enum InvalidRecordStrategy {
+    FAIL = "FAIL",
+    SKIP = "SKIP"
+}
+export declare enum Edition {
+    COMMUNITY = "community",
+    CLOUD = "cloud"
+}
+/** Faros destination implementation. */
+export declare class FarosDestination extends AirbyteDestination {
+    private readonly logger;
+    private edition;
+    private farosClient;
+    private jsonataConverter;
+    private jsonataMode;
+    private invalidRecordStrategy;
+    private hasuraClient;
+    private analytics;
+    constructor(logger: AirbyteLogger, edition?: Edition, farosClient?: FarosClient, jsonataConverter?: Converter | undefined, jsonataMode?: JSONataApplyMode, invalidRecordStrategy?: InvalidRecordStrategy, hasuraClient?: HasuraClient, analytics?: Analytics);
+    getFarosClient(): FarosClient;
+    getHasuraClient(): HasuraClient;
+    spec(): Promise<AirbyteSpec>;
+    check(config: AirbyteConfig): Promise<AirbyteConnectionStatusMessage>;
+    private initCommunity;
+    private initCloud;
+    private initGlobal;
+    private init;
+    private getOrigin;
+    write(config: AirbyteConfig, catalog: AirbyteConfiguredCatalog, stdin: NodeJS.ReadStream, dryRun: boolean): AsyncGenerator<AirbyteStateMessage>;
+    private writeEntries;
+    private handleRecordProcessingError;
+    private initStreamsCheckConverters;
+    private getConverter;
+    private writeRecord;
+}

package/lib/destination.js

@@ -0,0 +1,508 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FarosDestination = exports.Edition = exports.InvalidRecordStrategy = void 0;
+const analytics_node_1 = __importDefault(require("analytics-node"));
+const faros_airbyte_cdk_1 = require("faros-airbyte-cdk");
+const faros_feeds_sdk_1 = require("faros-feeds-sdk");
+const lodash_1 = require("lodash");
+const readline_1 = __importDefault(require("readline"));
+const util_1 = __importDefault(require("util"));
+const uuid_1 = require("uuid");
+const verror_1 = require("verror");
+const write_stats_1 = require("./common/write-stats");
+const hasura_client_1 = require("./community/hasura-client");
+const hasura_writer_1 = require("./community/hasura-writer");
+const converter_1 = require("./converters/converter");
+const converter_registry_1 = require("./converters/converter-registry");
+const jsonata_1 = require("./converters/jsonata");
+var InvalidRecordStrategy;
+(function (InvalidRecordStrategy) {
+    InvalidRecordStrategy["FAIL"] = "FAIL";
+    InvalidRecordStrategy["SKIP"] = "SKIP";
+})(InvalidRecordStrategy = exports.InvalidRecordStrategy || (exports.InvalidRecordStrategy = {}));
+var Edition;
+(function (Edition) {
+    Edition["COMMUNITY"] = "community";
+    Edition["CLOUD"] = "cloud";
+})(Edition = exports.Edition || (exports.Edition = {}));
+/** Faros destination implementation. */
+class FarosDestination extends faros_airbyte_cdk_1.AirbyteDestination {
+    constructor(logger, edition = undefined, farosClient = undefined, jsonataConverter = undefined, jsonataMode = jsonata_1.JSONataApplyMode.FALLBACK, invalidRecordStrategy = InvalidRecordStrategy.SKIP, hasuraClient = undefined, analytics = undefined) {
+        super();
+        this.logger = logger;
+        this.edition = edition;
+        this.farosClient = farosClient;
+        this.jsonataConverter = jsonataConverter;
+        this.jsonataMode = jsonataMode;
+        this.invalidRecordStrategy = invalidRecordStrategy;
+        this.hasuraClient = hasuraClient;
+        this.analytics = analytics;
+    }
+    getFarosClient() {
+        if (this.farosClient)
+            return this.farosClient;
+        throw new verror_1.VError('Faros client is not initialized');
+    }
+    getHasuraClient() {
+        if (this.hasuraClient)
+            return this.hasuraClient;
+        throw new verror_1.VError('Hasura client is not initialized');
+    }
+    async spec() {
+        // eslint-disable-next-line @typescript-eslint/no-var-requires
+        return new faros_airbyte_cdk_1.AirbyteSpec(require('../resources/spec.json'));
+    }
+    async check(config) {
+        try {
+            await this.init(config);
+        }
+        catch (e) {
+            return new faros_airbyte_cdk_1.AirbyteConnectionStatusMessage({
+                status: faros_airbyte_cdk_1.AirbyteConnectionStatus.FAILED,
+                message: e.message,
+            });
+        }
+        return new faros_airbyte_cdk_1.AirbyteConnectionStatusMessage({
+            status: faros_airbyte_cdk_1.AirbyteConnectionStatus.SUCCEEDED,
+        });
+    }
+    async initCommunity(config) {
+        var _a;
+        if (!config.edition_configs.hasura_url) {
+            throw new verror_1.VError('Community Edition Hasura URL is not set');
+        }
+        try {
+            this.hasuraClient = new hasura_client_1.HasuraClient(config.edition_configs.hasura_url);
+        }
+        catch (e) {
+            throw new verror_1.VError(`Failed to initialize Hasura Client. Error: ${e}`);
+        }
+        try {
+            if (config.dry_run !== true) {
+                await this.getHasuraClient().healthCheck();
+            }
+        }
+        catch (e) {
+            throw new verror_1.VError(`Invalid Hasura url. Error: ${e}`);
+        }
+        const segmentUserId = config.edition_configs.segment_user_id;
+        if (segmentUserId) {
+            if (!(0, uuid_1.validate)(segmentUserId)) {
+                throw new verror_1.VError(`Segment User Id ${segmentUserId} is not a valid UUID. Example: ${(0, uuid_1.v4)()}`);
+            }
+            // Segment host is used for testing purposes only
+            const host = (_a = config.edition_configs) === null || _a === void 0 ? void 0 : _a.segment_test_host;
+            // Only create the client if there's a user id specified
+            this.analytics = new analytics_node_1.default('YEu7VC65n9dIR85pQ1tgV2RHQHjo2bwn', {
+                host,
+            });
+        }
+    }
+    async initCloud(config) {
+        if (!config.edition_configs.api_url) {
+            throw new verror_1.VError('API URL is not set');
+        }
+        if (!config.edition_configs.api_key) {
+            throw new verror_1.VError('API key is not set');
+        }
+        try {
+            this.farosClient = new faros_feeds_sdk_1.FarosClient({
+                url: config.edition_configs.api_url,
+                apiKey: config.edition_configs.api_key,
+            });
+        }
+        catch (e) {
+            throw new verror_1.VError(`Failed to initialize Faros Client. Error: ${e}`);
+        }
+        try {
+            if (config.dry_run !== true) {
+                await this.getFarosClient().tenant();
+            }
+        }
+        catch (e) {
+            throw new verror_1.VError(`Invalid Faros API url or API key. Error: ${e}`);
+        }
+        const graph = config.edition_configs.graph;
+        try {
+            const exists = await this.getFarosClient().graphExists(graph);
+            if (!exists) {
+                throw new verror_1.VError(`Faros graph ${graph} does not exist`);
+            }
+        }
+        catch (e) {
+            throw new verror_1.VError(`Invalid Faros graph ${graph}. Error: ${e}`);
+        }
+    }
+    initGlobal(config) {
+        var _a, _b;
+        try {
+            this.jsonataConverter = config.jsonata_expression
+                ? jsonata_1.JSONataConverter.make(config.jsonata_expression, config.jsonata_destination_models)
+                : undefined;
+        }
+        catch (e) {
+            throw new verror_1.VError(`Failed to initialize JSONata converter. Error: ${e}`);
+        }
+        if (config.invalid_record_strategy &&
+            !Object.values(InvalidRecordStrategy).includes(config.invalid_record_strategy)) {
+            throw new verror_1.VError(`Invalid strategy ${config.invalid_record_strategy}. ` +
+                `Possible values are ${Object.values(InvalidRecordStrategy).join(',')}`);
+        }
+        if (config.invalid_record_strategy) {
+            this.invalidRecordStrategy = config.invalid_record_strategy;
+        }
+        if (config.jsonata_mode &&
+            !Object.values(jsonata_1.JSONataApplyMode).includes(config.jsonata_mode)) {
+            throw new verror_1.VError(`Invalid JSONata mode ${config.jsonata_mode}. ` +
+                `Possible values are ${Object.values(jsonata_1.JSONataApplyMode).join(',')}`);
+        }
+        if (config.jsonata_mode) {
+            this.jsonataMode = config.jsonata_mode;
+        }
+        if (config.jsonata_expression &&
+            (!Array.isArray(config.jsonata_destination_models) ||
+                !config.jsonata_destination_models.length)) {
+            throw new verror_1.VError('JSONata destination models must be set when using JSONata expression');
+        }
+        const jira_configs = (_b = (_a = config.source_specific_configs) === null || _a === void 0 ? void 0 : _a.jira) !== null && _b !== void 0 ? _b : {};
+        if (typeof jira_configs.truncate_limit === 'number' &&
+            jira_configs.truncate_limit < 0) {
+            throw new verror_1.VError('Jira Truncate Limit must be a non-negative number');
+        }
+        if (typeof jira_configs.additional_fields_array_limit === 'number' &&
+            jira_configs.additional_fields_array_limit < 0) {
+            throw new verror_1.VError('Jira Additional Fields Array Limit must be a non-negative number');
+        }
+        const objectTypeConfigKeys = [
+            ['bitbucket', 'application_mapping'],
+            ['pagerduty', 'application_mapping'],
+            ['squadcast', 'application_mapping'],
+            ['statuspage', 'application_mapping'],
+            ['victorops', 'application_mapping'],
+        ];
+        objectTypeConfigKeys.forEach((k) => {
+            var _a, _b;
+            return (0, converter_1.parseObjectConfig)((_b = (_a = config.source_specific_configs) === null || _a === void 0 ? void 0 : _a[k[0]]) === null || _b === void 0 ? void 0 : _b[k[1]], k.join('.'));
+        });
+    }
+    async init(config) {
+        var _a;
+        const edition = (_a = config.edition_configs) === null || _a === void 0 ? void 0 : _a.edition;
+        if (!edition) {
+            throw new verror_1.VError('Faros Edition is not set');
+        }
+        this.edition = edition;
+        if (edition === Edition.COMMUNITY) {
+            await this.initCommunity(config);
+        }
+        else if (edition === Edition.CLOUD) {
+            await this.initCloud(config);
+        }
+        else {
+            throw new verror_1.VError(`Invalid run mode ${edition}. ` +
+                `Possible values are ${Object.values(Edition).join(',')}`);
+        }
+        this.initGlobal(config);
+    }
+    getOrigin(config, catalog) {
+        if (config.origin) {
+            this.logger.info(`Using origin ${config.origin} found in config`);
+            return config.origin;
+        }
+        // Determine origin from stream prefixes
+        const origins = (0, lodash_1.uniq)(catalog.streams.map((s) => s.stream.name.split(converter_1.StreamNameSeparator, 1)[0]));
+        if (origins.length === 0) {
+            throw new verror_1.VError('Could not determine origin from catalog');
+        }
+        else if (origins.length > 1) {
+            throw new verror_1.VError(`Found multiple possible origins from catalog: ${origins.join(',')}`);
+        }
+        this.logger.info(`Determined origin ${origins[0]} from stream prefixes`);
+        return origins[0];
+    }
+    async *write(config, catalog, stdin, dryRun) {
+        await this.init(config);
+        const origin = this.getOrigin(config, catalog);
+        const { streams, deleteModelEntries, converterDependencies } = this.initStreamsCheckConverters(catalog);
+        const stateMessages = [];
+        const stats = new write_stats_1.WriteStats();
+        const dryRunEnabled = config.dry_run === true || dryRun;
+        // Avoid creating a new revision and writer when dry run or community edition is enabled
+        try {
+            if (dryRunEnabled) {
+                this.logger.info("Dry run is ENABLED. Won't write any records");
+                await this.writeEntries(config, stdin, streams, stateMessages, converterDependencies, stats);
+            }
+            else if (this.edition === Edition.COMMUNITY) {
+                const hasura = this.getHasuraClient();
+                await hasura.loadSchema();
+                await hasura.resetData(origin, deleteModelEntries);
+                const writer = new hasura_writer_1.HasuraWriter(hasura, origin, stats, this.handleRecordProcessingError);
+                await this.writeEntries(config, stdin, streams, stateMessages, converterDependencies, stats, writer);
+            }
+            else {
+                this.logger.info(`Opening a new revision on graph ${config.edition_configs.graph} ` +
+                    `with expiration of ${config.edition_configs.expiration}`);
+                // Log all models to be deleted (if any)
+                if (deleteModelEntries.length > 0) {
+                    const modelsToDelete = (0, lodash_1.sortBy)(deleteModelEntries).join(',');
+                    this.logger.info(`Deleting records in destination graph ${config.edition_configs.graph} for models: ${modelsToDelete}`);
+                }
+                // Create an entry uploader for the destination graph
+                const entryUploaderConfig = {
+                    name: origin,
+                    url: config.edition_configs.api_url,
+                    authHeader: config.edition_configs.api_key,
+                    expiration: config.edition_configs.expiration,
+                    graphName: config.edition_configs.graph,
+                    deleteModelEntries,
+                    logger: this.logger.asPino('debug'),
+                };
+                await (0, faros_feeds_sdk_1.withEntryUploader)(entryUploaderConfig, async (writer, state) => {
+                    try {
+                        // Log last synced time
+                        const lastSynced = (state === null || state === void 0 ? void 0 : state.lastSynced)
+                            ? `last synced at ${state.lastSynced}`
+                            : 'not synced yet';
+                        this.logger.info(`Destination graph ${config.edition_configs.graph} was ${lastSynced}`);
+                        // Process input and write entries
+                        await this.writeEntries(config, stdin, streams, stateMessages, converterDependencies, stats, writer);
+                        // Return the current time
+                        return { lastSynced: new Date().toISOString() };
+                    }
+                    finally {
+                        // Don't forget to close the writer
+                        if (!writer.writableEnded)
+                            writer.end();
+                    }
+                });
+            }
+            if (this.analytics) {
+                this.logger.info('Sending write stats to Segment.');
+                const fn = (callback) => {
+                    this.analytics
+                        .track({
+                        event: 'Write Stats',
+                        userId: config.edition_configs.segment_user_id,
+                        properties: stats,
+                    }, callback)
+                        .flush(callback);
+                };
+                await util_1.default
+                    .promisify(fn)()
+                    .catch((err) => this.logger.error(`Failed to send write stats to Segment: ${err.message}`));
+            }
+            // Since we are writing all records in a single revision,
+            // we should be ok to return all the state messages at the end,
+            // once the revision has been closed.
+            for (const state of stateMessages)
+                yield state;
+        }
+        finally {
+            // Log collected statistics
+            stats.log(this.logger, dryRunEnabled ? 'Would write' : 'Wrote');
+        }
+    }
+    async writeEntries(config, stdin, streams, stateMessages, converterDependencies, stats, writer) {
+        const ctx = new converter_1.StreamContext(config, this.edition === Edition.COMMUNITY ? undefined : this.getFarosClient());
+        const recordsToBeProcessedLast = [];
+        // NOTE: readline.createInterface() will start to consume the input stream once invoked.
+        // Having asynchronous operations between interface creation and asynchronous iteration may
+        // result in missed lines.
+        const input = readline_1.default.createInterface({
+            input: stdin,
+            terminal: stdin.isTTY,
+        });
+        try {
+            // Process input & write records
+            for await (const line of input) {
+                await this.handleRecordProcessingError(stats, async () => {
+                    const msg = (0, faros_airbyte_cdk_1.parseAirbyteMessage)(line);
+                    stats.messagesRead++;
+                    if (msg.type === faros_airbyte_cdk_1.AirbyteMessageType.STATE) {
+                        stateMessages.push(msg);
+                    }
+                    else if (msg.type === faros_airbyte_cdk_1.AirbyteMessageType.RECORD) {
+                        stats.recordsRead++;
+                        const recordMessage = msg;
+                        if (!recordMessage.record) {
+                            throw new verror_1.VError('Empty record');
+                        }
+                        if (!streams[recordMessage.record.stream]) {
+                            throw new verror_1.VError(`Undefined stream ${recordMessage.record.stream}`);
+                        }
+                        const unpacked = recordMessage.unpackRaw();
+                        if (!unpacked.record) {
+                            throw new verror_1.VError('Empty unpacked record');
+                        }
+                        const stream = unpacked.record.stream;
+                        stats.incrementProcessedByStream(stream);
+                        const converter = this.getConverter(stream);
+                        // No need to fail on records we don't have a converter yet
+                        if (!converter) {
+                            stats.recordsSkipped++;
+                            return;
+                        }
+                        const writeRecord = async (context) => {
+                            stats.recordsWritten += await this.writeRecord(converter, unpacked, stats, context, writer);
+                            stats.recordsProcessed++;
+                        };
+                        // Check if any converters depend on this record stream.
+                        // If yes, keep the record in the stream context for other converters to get.
+                        const streamName = converter_1.StreamName.fromString(stream).asString;
+                        const recordId = converter.id(unpacked);
+                        if (converterDependencies.has(streamName) && recordId) {
+                            ctx.set(streamName, String(recordId), unpacked);
+                            // Print stream context stats every so often
+                            if (stats.recordsProcessed % 1000 == 0) {
+                                this.logger.info(`Stream context stats: ${ctx.stats(false)}`);
+                            }
+                        }
+                        // Process the record immediately if converter has no dependencies,
+                        // otherwise process it later once all streams are processed.
+                        if (converter.dependencies.length === 0) {
+                            await writeRecord(ctx);
+                        }
+                        else {
+                            recordsToBeProcessedLast.push(writeRecord);
+                        }
+                    }
+                });
+            }
+            // Process all the remaining records
+            if (recordsToBeProcessedLast.length > 0) {
+                this.logger.info(`Stdin processing completed, but still have ${recordsToBeProcessedLast.length} records to process`);
+                this.logger.info(`Stream context stats: ${ctx.stats(true)}`);
+                for await (const process of recordsToBeProcessedLast) {
+                    await this.handleRecordProcessingError(stats, () => process(ctx));
+                }
+            }
+            // Don't forget to close the writer
+            await (writer === null || writer === void 0 ? void 0 : writer.end());
+        }
+        finally {
+            input.close();
+        }
+    }
+    async handleRecordProcessingError(stats, processRecord) {
+        var _a;
+        try {
+            await processRecord();
+        }
+        catch (e) {
+            stats.recordsErrored++;
+            this.logger.error(`Error processing input: ${(_a = e.message) !== null && _a !== void 0 ? _a : JSON.stringify(e)}`);
+            switch (this.invalidRecordStrategy) {
+                case InvalidRecordStrategy.SKIP:
+                    stats.recordsSkipped++;
+                    break;
+                case InvalidRecordStrategy.FAIL:
+                    throw e;
+            }
+        }
+    }
+    initStreamsCheckConverters(catalog) {
+        const streams = (0, lodash_1.keyBy)(catalog.streams, (s) => s.stream.name);
+        const streamKeys = Object.keys(streams);
+        const deleteModelEntries = [];
+        const dependenciesByStream = {};
+        // Check input streams & initialize record converters
+        for (const stream of streamKeys) {
+            const destinationSyncMode = streams[stream].destination_sync_mode;
+            if (!destinationSyncMode) {
+                throw new verror_1.VError(`Undefined destination sync mode for stream ${stream}`);
+            }
+            const converter = this.getConverter(stream, (err) => {
+                if (err.message.includes('Cannot find module ')) {
+                    this.logger.info(`No converter found for ${stream}`);
+                }
+                else {
+                    this.logger.error(err.message);
+                }
+            });
+            if (converter) {
+                this.logger.info(`Using ${converter.constructor.name} converter to convert ${stream} stream records`);
+                // Collect all converter dependencies
+                if (converter.dependencies.length > 0) {
+                    const streamName = converter.streamName.asString;
+                    if (!dependenciesByStream[streamName]) {
+                        dependenciesByStream[streamName] = new Set();
+                    }
+                    const deps = dependenciesByStream[streamName];
+                    converter.dependencies.forEach((d) => deps.add(d.asString));
+                }
+                // Prepare destination models to delete if any
+                if (destinationSyncMode === faros_airbyte_cdk_1.DestinationSyncMode.OVERWRITE) {
+                    deleteModelEntries.push(...converter.destinationModels);
+                }
+            }
+        }
+        // Check for circular dependencies and error early if any
+        const deps = Object.keys(dependenciesByStream);
+        for (const d of deps) {
+            const dd = [...dependenciesByStream[d].values()];
+            this.logger.info(`Records of stream ${d} will be accumulated and processed last, ` +
+                `since their converter has dependencies on streams: ${dd.join(',')}`);
+            const res = (0, lodash_1.intersection)(deps, dd);
+            if (res.length > 0) {
+                throw new verror_1.VError(`Circular converter dependency detected: ${res.join(',')}`);
+            }
+        }
+        // Collect all converter dependencies
+        const converterDependencies = new Set();
+        Object.keys(dependenciesByStream).forEach((k) => dependenciesByStream[k].forEach((v) => converterDependencies.add(v)));
+        return {
+            streams,
+            deleteModelEntries: (0, lodash_1.uniq)(deleteModelEntries),
+            converterDependencies,
+        };
+    }
+    getConverter(stream, onLoadError) {
+        var _a;
+        const converter = converter_registry_1.ConverterRegistry.getConverter(converter_1.StreamName.fromString(stream), onLoadError);
+        return this.jsonataMode === jsonata_1.JSONataApplyMode.OVERRIDE
+            ? (_a = this.jsonataConverter) !== null && _a !== void 0 ? _a : converter
+            : converter !== null && converter !== void 0 ? converter : this.jsonataConverter;
+    }
+    async writeRecord(converter, recordMessage, stats, ctx, writer) {
+        // Apply conversion on the input record
+        const results = await converter.convert(recordMessage, ctx);
+        if (!Array.isArray(results)) {
+            throw new verror_1.VError('Invalid results: not an array');
+        }
+        let recordsWritten = 0;
+        // Write out the results to the output stream
+        for (const result of results) {
+            if (!result.model)
+                throw new verror_1.VError('Invalid result: undefined model');
+            if (!result.record)
+                throw new verror_1.VError('Invalid result: undefined record');
+            if (typeof result.record !== 'object')
+                throw new verror_1.VError('Invalid result: record is not an object');
+            // Set the source if missing
+            if (!result.record['source']) {
+                result.record['source'] = converter.streamName.source;
+            }
+            let isTimestamped = false;
+            if (writer) {
+                if (writer instanceof hasura_writer_1.HasuraWriter) {
+                    isTimestamped = await writer.write(result);
+                }
+                else {
+                    const obj = {};
+                    obj[result.model] = result.record;
+                    writer.write(obj);
+                }
+            }
+            if (!isTimestamped) {
+                recordsWritten++;
+                stats.incrementWrittenByModel(result.model);
+            }
+        }
+        return recordsWritten;
+    }
+}
+exports.FarosDestination = FarosDestination;

package/lib/index.d.ts

@@ -0,0 +1,16 @@
+import { Command } from 'commander';
+/**
+ * The main entry point
+ *
+ * You can optionally provide options `exitOverride` and `configureOutput` to
+ * override default behavior of the CLI when it detects an error and where it
+ * writes to respectively. See https://github.com/tj/commander.js#override-exit-and-output-handling
+ * for detailed info on how these options work.
+ */
+export declare function mainCommand(options?: {
+    exitOverride?: boolean;
+    suppressOutput?: boolean;
+}): Command;
+export { Converter, DestinationRecord, DestinationModel, StreamContext, StreamName, StreamNameSeparator, } from './converters/converter';
+export { Edition, InvalidRecordStrategy } from './destination';
+export { FarosDestinationRunner } from './destination-runner';

package/lib/index.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FarosDestinationRunner = exports.InvalidRecordStrategy = exports.Edition = exports.StreamNameSeparator = exports.StreamName = exports.StreamContext = exports.Converter = exports.mainCommand = void 0;
+const destination_runner_1 = require("./destination-runner");
+/**
+ * The main entry point
+ *
+ * You can optionally provide options `exitOverride` and `configureOutput` to
+ * override default behavior of the CLI when it detects an error and where it
+ * writes to respectively. See https://github.com/tj/commander.js#override-exit-and-output-handling
+ * for detailed info on how these options work.
+ */
+function mainCommand(options) {
+    const destinationRunner = new destination_runner_1.FarosDestinationRunner();
+    const program = destinationRunner.mainCommand();
+    if (options === null || options === void 0 ? void 0 : options.exitOverride) {
+        program.exitOverride();
+    }
+    if (options === null || options === void 0 ? void 0 : options.suppressOutput) {
+        program.configureOutput({
+            // eslint-disable-next-line @typescript-eslint/no-empty-function
+            writeOut: () => { },
+            // eslint-disable-next-line @typescript-eslint/no-empty-function
+            writeErr: () => { },
+        });
+    }
+    return program;
+}
+exports.mainCommand = mainCommand;
+var converter_1 = require("./converters/converter");
+Object.defineProperty(exports, "Converter", { enumerable: true, get: function () { return converter_1.Converter; } });
+Object.defineProperty(exports, "StreamContext", { enumerable: true, get: function () { return converter_1.StreamContext; } });
+Object.defineProperty(exports, "StreamName", { enumerable: true, get: function () { return converter_1.StreamName; } });
+Object.defineProperty(exports, "StreamNameSeparator", { enumerable: true, get: function () { return converter_1.StreamNameSeparator; } });
+var destination_1 = require("./destination");
+Object.defineProperty(exports, "Edition", { enumerable: true, get: function () { return destination_1.Edition; } });
+Object.defineProperty(exports, "InvalidRecordStrategy", { enumerable: true, get: function () { return destination_1.InvalidRecordStrategy; } });
+var destination_runner_2 = require("./destination-runner");
+Object.defineProperty(exports, "FarosDestinationRunner", { enumerable: true, get: function () { return destination_runner_2.FarosDestinationRunner; } });