unomi-sdk-node/src/main.ts

Node module to interact with unomi.

import * as profile from "./actions/profiles";
import * as rule from "./actions/rules";
import * as segment from "./actions/segments";
import * as comparisonOperator from "./actions/comparisonOperators";
import * as matchType from "./actions/matchTypes";
import * as dateExpression from "./actions/dateExpression";
import { Connection, ConnectionData } from "./../src/types/main.d";

export function connect(connectionData: ConnectionData): Connection {

    // connection details for unomi/elasticsearch 
    const baseUrlUnomi = connectionData.urlUnomi
    const baseUrlElasticsearch = connectionData.urlElasticsearch
    const auth = {
        username: connectionData.auth.username,
        password: connectionData.auth.password,
        bearerToken: connectionData.auth.bearerToken
    }

    // headers for API calls
    let headers = {
        "Authorization": "",
        "Content-Type": "application/json"
    }

    // no bearer token
    if (auth.bearerToken === "" || typeof auth.bearerToken === "undefined") {
        headers.Authorization = "Basic " + btoa(auth.username + ":" + auth.password)
    }

    // bearer token
    else {
        headers.Authorization = "Bearer " + auth.bearerToken
    }

    return { // all functions that can be used
        profile: {
            get: (profileId) => profile.get(baseUrlUnomi, headers, profileId),
            allUsedProperties: () => profile.allUsedProperties(baseUrlElasticsearch, headers),
            count: () => profile.count(baseUrlUnomi, headers)
        },
        rule: {
            getAll: () => rule.getAll(baseUrlUnomi, headers),
            get: (ruleId) => rule.get(baseUrlUnomi, headers, ruleId),
            create: (params) => rule.create(baseUrlUnomi, headers, params)
        },
        segment: {
            getAll: (sortOrder, limit, offset) => segment.getAll(baseUrlUnomi, headers, sortOrder, limit, offset),
            get: (segmentId) => segment.get(baseUrlUnomi, headers, segmentId),
            create: (params) => segment.create(baseUrlUnomi, headers, params),
            update: (params) => segment.update(baseUrlUnomi, headers, params),
            delete: (segmentId) => segment.deleteSegment(baseUrlUnomi, headers, segmentId),
            profileCount: (params) => segment.profileCount(baseUrlElasticsearch, headers, params)
        },
        comparisonOperator: {
            getAll: () => comparisonOperator.getAll()
        },
        matchType: {
            getAll: () => matchType.getAll()
        },
        dateExpression: {
            isValid: (dateExpr) => dateExpression.isValid(dateExpr)
        }
    }
}