airbyte-faros-destination 0.1.53

package/lib/converters/bitbucket/workspace_users.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WorkspaceUsers = void 0;
+const common_1 = require("./common");
+class WorkspaceUsers extends common_1.BitbucketConverter {
+    constructor() {
+        super(...arguments);
+        this.destinationModels = [
+            'vcs_User',
+            'vcs_Membership',
+        ];
+    }
+    async convert(record, ctx) {
+        const source = this.streamName.source;
+        const workspaceUser = record.record.data;
+        const res = [];
+        const user = common_1.BitbucketCommon.vcsUser(workspaceUser.user, source);
+        if (!user)
+            return res;
+        res.push(user);
+        res.push({
+            model: 'vcs_Membership',
+            record: {
+                user: { uid: workspaceUser.user.accountId, source },
+                organization: { uid: workspaceUser.workspace.slug.toLowerCase(), source },
+            },
+        });
+        return res;
+    }
+}
+exports.WorkspaceUsers = WorkspaceUsers;

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

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

package/lib/converters/bitbucket/workspaces.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Workspaces = void 0;
+const faros_feeds_sdk_1 = require("faros-feeds-sdk");
+const common_1 = require("./common");
+var OrgTypeCategory;
+(function (OrgTypeCategory) {
+    OrgTypeCategory["ORGANIZATION"] = "Organization";
+    OrgTypeCategory["WORKSPACE"] = "Workspace";
+    OrgTypeCategory["GROUP"] = "Group";
+    OrgTypeCategory["CUSTOM"] = "Custom";
+})(OrgTypeCategory || (OrgTypeCategory = {}));
+class Workspaces extends common_1.BitbucketConverter {
+    constructor() {
+        super(...arguments);
+        this.destinationModels = [
+            'cicd_Organization',
+            'vcs_Organization',
+        ];
+    }
+    async convert(record, ctx) {
+        const source = this.streamName.source;
+        const workspace = record.record.data;
+        return [
+            {
+                model: 'cicd_Organization',
+                record: {
+                    uid: workspace.slug.toLowerCase(),
+                    name: workspace.name,
+                    url: workspace.links.htmlUrl,
+                    source,
+                },
+            },
+            {
+                model: 'vcs_Organization',
+                record: {
+                    uid: workspace.slug.toLowerCase(),
+                    name: workspace.name,
+                    type: this.VCSOrgType(workspace.type),
+                    htmlUrl: workspace.links.htmlUrl,
+                    createdAt: faros_feeds_sdk_1.Utils.toDate(workspace.createdOn),
+                    source,
+                },
+            },
+        ];
+    }
+    VCSOrgType(type) {
+        const detail = type === null || type === void 0 ? void 0 : type.toLowerCase();
+        if (detail === 'organization') {
+            return { category: OrgTypeCategory.ORGANIZATION, detail };
+        }
+        else if (detail === 'workspace') {
+            return { category: OrgTypeCategory.WORKSPACE, detail };
+        }
+        else if (detail === 'group') {
+            return { category: OrgTypeCategory.GROUP, detail };
+        }
+        return { category: OrgTypeCategory.CUSTOM, detail };
+    }
+}
+exports.Workspaces = Workspaces;

package/lib/converters/converter-registry.d.ts

@@ -0,0 +1,25 @@
+import { Converter, StreamName } from './converter';
+/**
+ * A handy converter registry to get registered converters by stream name
+ */
+export declare class ConverterRegistry {
+    private static convertersByStream;
+    /**
+     * Get converter by stream name.
+     *
+     * Dynamically loads and creates converter by stream.
+     *
+     * Example: for stream { source: 'github', name: 'pull_request_stats' }
+     * we dynamically import module './github/pull_request_stats'
+     * and create a class GithubPullRequestStats.
+     *
+     * @param streamName stream name
+     * @param onLoadError handler to call on converter loading error
+     * @returns converter if any
+     */
+    static getConverter(streamName: StreamName, onLoadError?: (err: Error) => void): Converter | undefined;
+    /**
+     * Add a convertor to the registory.
+     */
+    static addConverter(converter: Converter): void;
+}

package/lib/converters/converter-registry.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConverterRegistry = void 0;
+const lodash_1 = require("lodash");
+const verror_1 = require("verror");
+/**
+ * A handy converter registry to get registered converters by stream name
+ */
+class ConverterRegistry {
+    /**
+     * Get converter by stream name.
+     *
+     * Dynamically loads and creates converter by stream.
+     *
+     * Example: for stream { source: 'github', name: 'pull_request_stats' }
+     * we dynamically import module './github/pull_request_stats'
+     * and create a class GithubPullRequestStats.
+     *
+     * @param streamName stream name
+     * @param onLoadError handler to call on converter loading error
+     * @returns converter if any
+     */
+    static getConverter(streamName, onLoadError) {
+        var _a;
+        const name = streamName.asString;
+        const res = ConverterRegistry.convertersByStream[name];
+        if (res && typeof res !== 'boolean')
+            return res;
+        if (res)
+            return undefined;
+        try {
+            // Load the necessary module dynamically
+            // eslint-disable-next-line @typescript-eslint/no-var-requires
+            const mod = require(`./${streamName.source}/${streamName.name}`);
+            // Create converter instance by name
+            const converterClass = mod[(0, lodash_1.upperFirst)((0, lodash_1.camelCase)(streamName.name))];
+            if (!converterClass) {
+                throw new verror_1.VError(`Could not find converter from module for stream ${name}`);
+            }
+            const converter = new converterClass();
+            // Keep the converter instance in the registry
+            ConverterRegistry.convertersByStream[name] = converter;
+            return converter;
+        }
+        catch (e) {
+            // Tried loading the converter but failed - no need to retry
+            ConverterRegistry.convertersByStream[name] = true;
+            if (onLoadError) {
+                const err = (_a = e.message) !== null && _a !== void 0 ? _a : String(e);
+                onLoadError(new verror_1.VError(`Failed loading converter for stream ${name}: ${err}`));
+            }
+            return undefined;
+        }
+    }
+    /**
+     * Add a convertor to the registory.
+     */
+    static addConverter(converter) {
+        const name = converter.streamName.asString;
+        ConverterRegistry.convertersByStream[name] = converter;
+    }
+}
+exports.ConverterRegistry = ConverterRegistry;
+ConverterRegistry.convertersByStream = {};

package/lib/converters/converter.d.ts

@@ -0,0 +1,63 @@
+import { AirbyteConfig, AirbyteRecord } from 'faros-airbyte-cdk';
+import { FarosClient } from 'faros-feeds-sdk';
+import { Dictionary } from 'ts-essentials';
+/** Airbyte -> Faros record converter */
+export declare abstract class Converter {
+    private stream;
+    /** Name of the source system that records were fetched from (e.g. GitHub) **/
+    abstract readonly source: string;
+    /** Input stream supported by converter */
+    get streamName(): StreamName;
+    get dependencies(): ReadonlyArray<StreamName>;
+    /** Function to extract record id */
+    abstract id(record: AirbyteRecord): any;
+    /** All the record models produced by converter */
+    abstract get destinationModels(): ReadonlyArray<DestinationModel>;
+    /** Function converts an input Airbyte record to Faros destination canonical record */
+    abstract convert(record: AirbyteRecord, ctx: StreamContext): Promise<ReadonlyArray<DestinationRecord>>;
+}
+export declare function parseObjectConfig<T>(obj: any, name: string): T | undefined;
+/** Stream context to store records by stream and other helpers */
+export declare class StreamContext {
+    readonly config: AirbyteConfig;
+    readonly farosClient?: FarosClient;
+    constructor(config: AirbyteConfig, farosClient?: FarosClient);
+    private readonly recordsByStreamName;
+    getAll(streamName: string): Dictionary<AirbyteRecord>;
+    get(streamName: string, id: string): AirbyteRecord | undefined;
+    set(streamName: string, id: string, record: AirbyteRecord): void;
+    stats(includeIds?: boolean): string;
+}
+export declare const StreamNameSeparator = "__";
+/**
+ * Stream name with source prefix, e.g
+ * {
+ *   source: 'github',
+ *   name:   'commits'
+ * }
+ */
+export declare class StreamName {
+    readonly source: string;
+    readonly name: string;
+    constructor(source: string, name: string);
+    private str;
+    get asString(): string;
+    static fromString(s: string): StreamName;
+}
+/**
+ * Faros record with the destination canonical model, e.g
+ * {
+ *   model: 'identity_Identity',
+ *   record: {
+ *     uid:          '123',
+ *     fullName:     'John Doe',
+ *     primaryEmail: 'john@example.com'
+ *   }
+ * }
+ */
+export declare type DestinationRecord = {
+    readonly model: DestinationModel;
+    readonly record: Dictionary<any>;
+};
+/** Faros destination model name, e.g identity_Identity, vcs_Commit */
+export declare type DestinationModel = string;

package/lib/converters/converter.js

@@ -0,0 +1,122 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StreamName = exports.StreamNameSeparator = exports.StreamContext = exports.parseObjectConfig = exports.Converter = void 0;
+const lodash_1 = require("lodash");
+const object_sizeof_1 = __importDefault(require("object-sizeof"));
+const verror_1 = require("verror");
+/** Airbyte -> Faros record converter */
+class Converter {
+    /** Input stream supported by converter */
+    get streamName() {
+        if (this.stream)
+            return this.stream;
+        this.stream = StreamName.fromString(`${this.source}${exports.StreamNameSeparator}${(0, lodash_1.snakeCase)(this.constructor.name)}`);
+        return this.stream;
+    }
+    // Dependencies on other streams (if any).
+    // !!! Use with caution !!! Will result in increased memory usage
+    // due to accumulation of records in StreamContext (ctx)
+    get dependencies() {
+        return [];
+    }
+}
+exports.Converter = Converter;
+// Helper function for reading object type configurations that
+// may be inputted as proper JSON via API or stringified JSON via Airbyte UI
+function parseObjectConfig(obj, name) {
+    if (!obj)
+        return undefined;
+    if (typeof obj === 'object')
+        return obj;
+    if (typeof obj === 'string') {
+        try {
+            return JSON.parse(obj);
+        }
+        catch (e) {
+            throw new verror_1.VError(`Could not parse JSON object from ${name} ${obj}. Error: ${e}`);
+        }
+    }
+    throw new verror_1.VError(`${name} must be a JSON object or stringified JSON object`);
+}
+exports.parseObjectConfig = parseObjectConfig;
+/** Stream context to store records by stream and other helpers */
+class StreamContext {
+    constructor(config, farosClient) {
+        this.config = config;
+        this.farosClient = farosClient;
+        this.recordsByStreamName = {};
+    }
+    getAll(streamName) {
+        const recs = this.recordsByStreamName[streamName];
+        if (recs) {
+            return recs;
+        }
+        return {};
+    }
+    get(streamName, id) {
+        const recs = this.recordsByStreamName[streamName];
+        if (recs) {
+            const rec = recs[id];
+            if (rec)
+                return rec;
+        }
+        return undefined;
+    }
+    set(streamName, id, record) {
+        const recs = this.recordsByStreamName[streamName];
+        if (!recs)
+            this.recordsByStreamName[streamName] = {};
+        this.recordsByStreamName[streamName][id] = record;
+    }
+    stats(includeIds = false) {
+        const sizeInBytes = (0, object_sizeof_1.default)(this.recordsByStreamName);
+        const res = { sizeInBytes };
+        for (const s of Object.keys(this.recordsByStreamName)) {
+            const ids = Object.keys(this.recordsByStreamName[s]);
+            if (includeIds) {
+                res[s] = {
+                    count: ids.length,
+                    ids,
+                };
+            }
+            else
+                res[s] = { count: ids.length };
+        }
+        return JSON.stringify(res);
+    }
+}
+exports.StreamContext = StreamContext;
+exports.StreamNameSeparator = '__';
+/**
+ * Stream name with source prefix, e.g
+ * {
+ *   source: 'github',
+ *   name:   'commits'
+ * }
+ */
+class StreamName {
+    constructor(source, name) {
+        this.source = source;
+        this.name = name;
+    }
+    get asString() {
+        if (this.str)
+            return this.str;
+        this.str = `${this.source}${exports.StreamNameSeparator}${this.name}`;
+        return this.str;
+    }
+    static fromString(s) {
+        if (!s) {
+            throw new verror_1.VError(`Empty stream name ${s}`);
+        }
+        const res = s.split(exports.StreamNameSeparator);
+        if (res.length < 2) {
+            throw new verror_1.VError(`Invalid stream name ${s}: missing source prefix (e.g 'github${exports.StreamNameSeparator}')`);
+        }
+        return new StreamName(res[res.length - 2], res[res.length - 1]);
+    }
+}
+exports.StreamName = StreamName;

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

@@ -0,0 +1,27 @@
+import { AirbyteRecord } from 'faros-airbyte-cdk';
+import { Converter, StreamContext } from '../converter';
+export declare enum IncidentSeverityCategory {
+    Sev1 = "Sev1",
+    Sev2 = "Sev2",
+    Sev3 = "Sev3",
+    Sev4 = "Sev4",
+    Sev5 = "Sev5",
+    Custom = "Custom"
+}
+interface DatadogConfig {
+    application_mapping?: ApplicationMapping;
+    default_severity?: IncidentSeverityCategory;
+}
+declare type ApplicationMapping = Record<string, {
+    name: string;
+    platform?: string;
+}>;
+/** Datadog converter base */
+export declare abstract class DatadogConverter extends Converter {
+    source: string;
+    /** Almost every Datadog record has an id property */
+    id(record: AirbyteRecord): any;
+    protected applicationMapping(ctx: StreamContext): ApplicationMapping;
+    protected config(ctx: StreamContext): DatadogConfig;
+}
+export {};

package/lib/converters/datadog/common.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DatadogConverter = exports.IncidentSeverityCategory = void 0;
+const converter_1 = require("../converter");
+var IncidentSeverityCategory;
+(function (IncidentSeverityCategory) {
+    IncidentSeverityCategory["Sev1"] = "Sev1";
+    IncidentSeverityCategory["Sev2"] = "Sev2";
+    IncidentSeverityCategory["Sev3"] = "Sev3";
+    IncidentSeverityCategory["Sev4"] = "Sev4";
+    IncidentSeverityCategory["Sev5"] = "Sev5";
+    IncidentSeverityCategory["Custom"] = "Custom";
+})(IncidentSeverityCategory = exports.IncidentSeverityCategory || (exports.IncidentSeverityCategory = {}));
+/** Datadog converter base */
+class DatadogConverter extends converter_1.Converter {
+    constructor() {
+        super(...arguments);
+        this.source = 'Datadog';
+    }
+    /** Almost every Datadog record has an 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;
+    }
+    applicationMapping(ctx) {
+        var _a, _b;
+        return ((_b = (0, converter_1.parseObjectConfig)((_a = this.config(ctx)) === null || _a === void 0 ? void 0 : _a.application_mapping, 'Application Mapping')) !== null && _b !== void 0 ? _b : {});
+    }
+    config(ctx) {
+        var _a, _b;
+        return (_b = (_a = ctx.config.source_specific_configs) === null || _a === void 0 ? void 0 : _a.datadog) !== null && _b !== void 0 ? _b : {};
+    }
+}
+exports.DatadogConverter = DatadogConverter;

package/lib/converters/datadog/incidents.d.ts

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

package/lib/converters/datadog/incidents.js

@@ -0,0 +1,128 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Incidents = void 0;
+const faros_feeds_sdk_1 = require("faros-feeds-sdk");
+const common_1 = require("./common");
+var IncidentStatusCategory;
+(function (IncidentStatusCategory) {
+    IncidentStatusCategory["Created"] = "Created";
+    IncidentStatusCategory["Identified"] = "Identified";
+    IncidentStatusCategory["Investigating"] = "Investigating";
+    IncidentStatusCategory["Resolved"] = "Resolved";
+    IncidentStatusCategory["Custom"] = "Custom";
+})(IncidentStatusCategory || (IncidentStatusCategory = {}));
+class Incidents extends common_1.DatadogConverter {
+    constructor() {
+        super(...arguments);
+        this.destinationModels = [
+            'ims_Incident',
+            'ims_IncidentAssignment',
+        ];
+    }
+    async convert(record, ctx) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t, _u, _v, _w, _x, _y, _z, _0, _1;
+        const config = this.config(ctx);
+        const source = this.streamName.source;
+        const incident = record.record.data;
+        const incidentKey = {
+            uid: incident.id,
+            source,
+        };
+        const defaultSeverityCategory = config.default_severity;
+        const defaultSeverity = defaultSeverityCategory
+            ? {
+                category: defaultSeverityCategory,
+                detail: 'default',
+            }
+            : null;
+        const res = [];
+        res.push({
+            model: 'ims_Incident',
+            record: {
+                ...incidentKey,
+                title: (_a = incident.attributes) === null || _a === void 0 ? void 0 : _a.title,
+                description: (_d = (_c = (_b = incident.attributes) === null || _b === void 0 ? void 0 : _b.fields) === null || _c === void 0 ? void 0 : _c.summary) === null || _d === void 0 ? void 0 : _d.value,
+                url: null,
+                severity: (_h = this.getSeverity((_g = (_f = (_e = incident.attributes) === null || _e === void 0 ? void 0 : _e.fields) === null || _f === void 0 ? void 0 : _f.severity) === null || _g === void 0 ? void 0 : _g.value)) !== null && _h !== void 0 ? _h : defaultSeverity,
+                priority: null,
+                status: (_m = this.getStatus((_l = (_k = (_j = incident.attributes) === null || _j === void 0 ? void 0 : _j.fields) === null || _k === void 0 ? void 0 : _k.state) === null || _l === void 0 ? void 0 : _l.value)) !== null && _m !== void 0 ? _m : null,
+                createdAt: (_p = faros_feeds_sdk_1.Utils.toDate((_o = incident.attributes) === null || _o === void 0 ? void 0 : _o.created)) !== null && _p !== void 0 ? _p : null,
+                updatedAt: (_r = faros_feeds_sdk_1.Utils.toDate((_q = incident.attributes) === null || _q === void 0 ? void 0 : _q.modified)) !== null && _r !== void 0 ? _r : null,
+                resolvedAt: (_t = faros_feeds_sdk_1.Utils.toDate((_s = incident.attributes) === null || _s === void 0 ? void 0 : _s.resolved)) !== null && _t !== void 0 ? _t : null,
+            },
+        });
+        const assigneeUid = (_w = (_v = (_u = incident.relationships) === null || _u === void 0 ? void 0 : _u.commanderUser) === null || _v === void 0 ? void 0 : _v.data) === null || _w === void 0 ? void 0 : _w.id;
+        if (assigneeUid) {
+            res.push({
+                model: 'ims_IncidentAssignment',
+                record: {
+                    incident: incidentKey,
+                    assignee: {
+                        uid: assigneeUid,
+                        source,
+                    },
+                },
+            });
+        }
+        const applicationMapping = this.applicationMapping(ctx);
+        const services = (_z = (_y = (_x = incident.attributes) === null || _x === void 0 ? void 0 : _x.fields) === null || _y === void 0 ? void 0 : _y.services) === null || _z === void 0 ? void 0 : _z.value;
+        if (services) {
+            for (const service of services) {
+                if ((_0 = applicationMapping === null || applicationMapping === void 0 ? void 0 : applicationMapping[service]) === null || _0 === void 0 ? void 0 : _0.name) {
+                    const mappedApp = applicationMapping[service];
+                    const application = {
+                        name: mappedApp.name,
+                        platform: (_1 = mappedApp.platform) !== null && _1 !== void 0 ? _1 : '',
+                    };
+                    res.push({ model: 'compute_Application', record: application });
+                    res.push({
+                        model: 'ims_IncidentApplicationImpact',
+                        record: {
+                            incident: incidentKey,
+                            application,
+                        },
+                    });
+                }
+            }
+        }
+        return res;
+    }
+    getSeverity(severity) {
+        if (severity) {
+            switch (severity) {
+                case 'SEV-1':
+                    return { category: common_1.IncidentSeverityCategory.Sev1, detail: severity };
+                case 'SEV-2':
+                    return { category: common_1.IncidentSeverityCategory.Sev2, detail: severity };
+                case 'SEV-3':
+                    return { category: common_1.IncidentSeverityCategory.Sev3, detail: severity };
+                case 'SEV-4':
+                    return { category: common_1.IncidentSeverityCategory.Sev4, detail: severity };
+                case 'SEV-5':
+                    return { category: common_1.IncidentSeverityCategory.Sev5, detail: severity };
+                default:
+                    return { category: common_1.IncidentSeverityCategory.Custom, detail: severity };
+            }
+        }
+    }
+    getStatus(state) {
+        if (state) {
+            switch (state) {
+                case 'declared':
+                    return { category: IncidentStatusCategory.Created, detail: state };
+                case 'active':
+                    return {
+                        category: IncidentStatusCategory.Investigating,
+                        detail: state,
+                    };
+                case 'stable':
+                    return { category: IncidentStatusCategory.Identified, detail: state };
+                case 'resolved':
+                    return { category: IncidentStatusCategory.Resolved, detail: state };
+                default:
+                    return { category: IncidentStatusCategory.Custom, detail: state };
+            }
+        }
+    }
+}
+exports.Incidents = Incidents;

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

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

package/lib/converters/datadog/users.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Users = void 0;
+const common_1 = require("./common");
+class Users extends common_1.DatadogConverter {
+    constructor() {
+        super(...arguments);
+        this.destinationModels = ['ims_User'];
+    }
+    async convert(record, _ctx) {
+        var _a, _b;
+        const source = this.streamName.source;
+        const user = record.record.data;
+        return [
+            {
+                model: 'ims_User',
+                record: {
+                    uid: user === null || user === void 0 ? void 0 : user.id,
+                    email: (_a = user === null || user === void 0 ? void 0 : user.attributes) === null || _a === void 0 ? void 0 : _a.email,
+                    name: (_b = user === null || user === void 0 ? void 0 : user.attributes) === null || _b === void 0 ? void 0 : _b.name,
+                    source,
+                },
+            },
+        ];
+    }
+}
+exports.Users = Users;