Edelog Sync Service

This package provides an abstract implementation for syncing customer data between their APIs and our Edelog Software.

Setting up

npm install
# starting dev server with logging enabled
LOGGING=TRUE npm run dev 

# start production server
npm start

Environment Variables

Variable	Values
LOGGING	true or false
SYNC_SERVICE_API_DOMAIN	https://app.edelog.com
ACCESS_KEY	String; The key needed to authorize to this api
SYNC_SERVICE_ID	String; The Edelog sync service ID
SYNC_SERVICE_SECRET_KEY	String; The Edelog secret key
ALLOWED_IP_ADDRESSES	::1, 127.0.0.1, 10.0.0.1 (separated with , `)

Minimal Configuration

Warning: This assumes that you have configured the Enviroment Variables described above.

import provideSyncService from './src/server';
import {NotMatchedRecordsAction, TargetDataFormat} from './src/interfaces/schema.interface'; import {NotFoundAction} from './schema.interface';

provideSyncService({
    mapping: (inputFilePaths) => mappingFunction(inputFilePaths),
});

async function mappingFunction(inputFilePaths: string[]): Promise<TargetDataFormat> {
    console.log(inputFilePaths)
    return {
        version: 1,
        updateCollections: [
            {
                databaseName: '',
                performOnNotMatchedRecords: NotMatchedRecordsAction.Skip,
                tasks: [
                    {
                        type: 'update-data',
                        where: {},
                        update: {
                            test: 'd'
                        },
                        ifNotFound: NotFoundAction.CreateNewRecord
                    }
                ]
            }
        ],
    }
}

Full Configuration

import provideSyncService from './src/server';
import {NotMatchedRecordsAction, TargetDataFormat} from './src/interfaces/schema.interface';
import {Configuration} from './src/interfaces/configuration.interface'; import {NotFoundAction} from './schema.interface';

provideSyncService({
    accessKey: 'efrgtidhsnfuwe',
    allowedIpAddresses:
        process.env.ALLOWED_IP_ADDRESSES == null || process.env.ALLOWED_IP_ADDRESSES === ''
            ? [] : (process.env.ALLOWED_IP_ADDRESSES).split(', '),
    mapping: (inputFilePaths) => mappingFunction(inputFilePaths),
    errorHandler: (errorMessage, config) => handleError(errorMessage, config),
    target: {
        syncServiceId: '',
        syncServiceSecretKey: ''
    },
    webserviceConfig: {
        logging: process.env.LOGGING === 'true',
    },
});

async function mappingFunction(inputFilePaths: string[]): Promise<TargetDataFormat> {
    return {
        version: 1,
        updateCollections: [
            {
                databaseName: '',
                performOnNotMatchedRecords: NotMatchedRecordsAction.Skip,
                tasks: [
                    {
                        type: 'update-data',
                        where: {},
                        update: {
                            test: 'd'
                        },
                        ifNotFound: NotFoundAction.CreateNewRecord
                    }
                ]
            }
        ],
    }
}

async function handleError(errorMessage: string, config: Configuration) {
    // handle errors here
}

Todo

• Send request to Copy Server if something fails
• Send request to Master Server if something fails