@seeka-labs/cli-apps 3.7.0 → 3.8.2

package/dist/ai-context/internal/examples/v1/me-and-u-connect/src/lib/jobs/index.ts

@@ -0,0 +1,96 @@
+import { QueueClient } from "@azure/storage-queue";
+import { isArray } from 'lodash';
+import type { Logger } from 'winston';
+import winston from 'winston';
+
+export interface BackgroundJobRequestContext {
+    organisationId?: string;
+    organisationBrandId?: string;
+    applicationInstallId?: string;
+    causationId: string
+    correlationId: string
+}
+
+export const signatureHeaderName = 'x-signature-hmac';
+export const apiKeyHeaderName = 'x-api-key';
+
+export const jobNames = {
+    scheduledPollMeAndUContactSyncJobName: 'poll-meandu-new-contacts-scheduled',
+}
+
+export const queueNames = {
+    backgroundMeAndUContactSyncQueueName: 'meandu-contact-sync-queue'
+}
+
+export const triggerBackgroundJob = async (queueName: string, context: BackgroundJobRequestContext, logger: Logger): Promise<void> => {
+    const queueClient = new QueueClient(process.env.AzureWebJobsStorage as string, queueName);
+    return triggerBackgroundJobWithQueue(queueClient, context, logger);
+}
+
+const serialiseQueuePayload = (payload: unknown): string => {
+    const jsonString = JSON.stringify(payload)
+    return Buffer.from(jsonString).toString('base64')
+}
+
+export const deserialiseQueuePayload = <TPayload>(queueItem: any, logger: Logger): TPayload[] => {
+    try {
+        if (typeof queueItem !== 'string') {
+            if (isArray(queueItem)) {
+                return queueItem
+            }
+            return [queueItem]
+        }
+        else {
+            const jsonString = Buffer.from(queueItem, 'base64').toString()
+            const parsed = JSON.parse(jsonString);
+
+            if (isArray(parsed)) {
+                return parsed
+            }
+            return [parsed]
+        }
+    }
+    catch (err) {
+        logger.error('Failed to deserialise queue payload', { ex: winston.exceptions.getAllInfo(err), queueItem });
+        throw new Error(`Failed to deserialise queue payload`);
+    }
+}
+
+export const triggerBackgroundJobWithQueue = async (queueClient: QueueClient, context: BackgroundJobRequestContext, logger: Logger): Promise<void> => {
+    const body = {
+        ...context
+    }
+    const bodyStr = serialiseQueuePayload(body);
+
+    const response = await queueClient.sendMessage(bodyStr, { messageTimeToLive: -1 });
+
+    if (response.errorCode) {
+        const { requestId, date, errorCode } = response;
+        logger.error("Failed to trigger background job", { body, requestId, date, errorCode })
+        throw new Error(`Failed to trigger background job: ${response.errorCode}`);
+    }
+    else {
+        logger.debug("Background job triggered", { body, messageId: response.messageId, context })
+    }
+}
+
+export const sendQueueMessageToPoisonQueue = async (queueName: string, context: BackgroundJobRequestContext, logger: Logger): Promise<void> => {
+    const body = {
+        ...context
+    }
+    const bodyStr = serialiseQueuePayload(body);
+
+    // https://learn.microsoft.com/en-us/azure/azure-functions/functions-bindings-storage-queue-trigger?tabs=python-v2%2Cisolated-process%2Cnodejs-v4%2Cextensionv5&pivots=programming-language-typescript#poison-messages
+    const queueClient = new QueueClient(process.env.AzureWebJobsStorage as string, `${queueName}-poison`);
+
+    const response = await queueClient.sendMessage(bodyStr, { messageTimeToLive: -1 });
+
+    if (response.errorCode) {
+        const { requestId, date, errorCode } = response;
+        logger.error("Failed to push to poison queue", { body, requestId, date, errorCode })
+        throw new Error(`Failed to push to poison queue: ${response.errorCode}`);
+    }
+    else {
+        logger.verbose("Message pushed to poison queue", { body, messageId: response.messageId, context })
+    }
+}

package/dist/ai-context/internal/examples/v1/me-and-u-connect/src/lib/logging/index.ts

@@ -0,0 +1,91 @@
+import * as winston from 'winston';
+import { SeqTransport } from '@datalust/winston-seq';
+import { InvocationContext } from "@azure/functions";
+import type {
+    SeekaWebhookPayload, SeekaWebhookPayloadOfSeekaAppWebhookContext
+} from '@seeka-labs/sdk-apps-server';
+
+import * as packageJson from '../../../package.json';
+import { BackgroundJobRequestContext } from '../jobs';
+
+const loggerTransports: winston.transport[] = [
+    new winston.transports.Console({
+        level: process.env.LOGGING_LEVEL,
+        format: winston.format.combine(
+            winston.format.errors({ stack: true }),
+            winston.format.cli(),
+            winston.format.splat(),
+        ),
+        handleExceptions: true,
+        handleRejections: true,
+    }),
+]
+if (process.env.LOGGING_SEQ_SERVERURL) {
+    loggerTransports.push(
+        new SeqTransport({
+            level: process.env.LOGGING_LEVEL,
+            serverUrl: process.env.LOGGING_SEQ_SERVERURL,
+            apiKey: process.env.LOGGING_SEQ_APIKEY,
+            onError: ((e) => { console.error('Failed to configure Seq logging transport', e) }),
+            format: winston.format.combine(
+                winston.format.errors({ stack: true }),
+                winston.format.json(),
+            ),
+            handleExceptions: true,
+            handleRejections: true,
+        })
+    )
+}
+
+export const logger = winston.createLogger({
+    level: process.env.LOGGING_LEVEL,
+    defaultMeta: {
+        seekaAppId: process.env.SEEKA_APP_ID,
+        Hosting_Provider: 'azure',
+        Release_Version: `v${packageJson.version}`,
+        Hosting_Region: process.env.REGION_NAME,
+        Service_Instance_Id: process.env.WEBSITE_ROLE_INSTANCE_ID,
+        AzureFunctions_FunctionName: process.env.WEBSITE_SITE_NAME,
+        Service: `app/${packageJson.name}`,
+    },
+    transports: loggerTransports,
+    exitOnError: false,
+});
+
+export const childLogger = (meta: object) => logger.child(meta);
+
+export const webhookLogger = (payload: SeekaWebhookPayload, functionContext: InvocationContext) => {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const meta: any = {
+        seekaWebhookType: payload.type,
+        seekaWebhookIsTest: payload.isTest,
+        RequestId: payload.requestId,
+        AzureFunctions_InvocationId: functionContext.invocationId,
+        CausationId: payload.causationId,
+        CorrelationId: payload.causationId,
+    }
+
+    const context = (payload as SeekaWebhookPayloadOfSeekaAppWebhookContext).context;
+    if (context) {
+        meta.seekaAppInstallId = context.applicationInstallId;
+        meta.seekaAppInstallOrganisationBrandId = context.organisationBrandId;
+        meta.seekaAppInstallOrganisationId = context.organisationId;
+    }
+
+    return childLogger(meta)
+}
+
+export const backgroundJobLogger = (jobName: string, jobContext: BackgroundJobRequestContext | undefined, functionContext: InvocationContext) => {
+    const meta: object = {
+        jobContext,
+        jobName,
+        AzureFunctions_InvocationId: functionContext.invocationId,
+        CausationId: jobContext?.causationId,
+        CorrelationId: jobContext?.causationId,
+        seekaAppInstallId: jobContext?.applicationInstallId,
+        seekaAppInstallOrganisationBrandId: jobContext?.organisationBrandId,
+        seekaAppInstallOrganisationId: jobContext?.organisationId
+    }
+
+    return childLogger(meta)
+}

package/dist/ai-context/internal/examples/v1/me-and-u-connect/src/lib/meandu/api/index.ts

@@ -0,0 +1,46 @@
+import fetchRetry from 'fetch-retry'
+import winston, { Logger } from 'winston';
+const fetch = fetchRetry(global.fetch);
+export const maxPageSize = 200;
+
+export const meAndUFetch = async (url: string, request: RequestInit, logger: Logger): Promise<Response> => {
+    let response: Response;
+
+    logger.debug('Calling MeAndU API', { url, method: request.method });
+    try {
+        response = await fetch(url, {
+            ...request,
+            retryOn: async function (attempt, error, response) {
+                if (attempt > 3) return false;
+
+                if (error !== null) {
+                    logger.warn('MeAndU API call failed, retrying', { url, error, method: request.method, attempt });
+                }
+
+                if (error !== null || (response.status && [500, 502, 503, 504, 524].indexOf(response.status) !== -1)) {
+                    return true;
+                }
+            }
+        })
+    }
+    catch (err) {
+        logger.error('MeAndU API call failed', { url, ex: winston.exceptions.getAllInfo(err), method: request.method });
+        throw err;
+    }
+
+    if (!response.ok) {
+        if (response.status === 429) {
+            logger.warn('MeAndU API call rate limit reached', { url, status: response.status, statusText: response.statusText, responseBody: await response.text(), requestBody: request.body, method: request.method });
+            throw new Error(`MeAndU API call rate limit reached: ${response.statusText} ${response.status}`)
+        }
+        else {
+            logger.error('MeAndU API call response error', { url, status: response.status, statusText: response.statusText, responseBody: await response.text(), requestBody: request.body, method: request.method });
+            throw new Error(`MeAndU API call response error: ${response.statusText} ${response.status}`)
+        }
+    }
+    else {
+        logger.http('MeAndU API call succeeded', { url, status: response.status, method: request.method })
+    }
+
+    return response;
+}

package/dist/ai-context/internal/examples/v1/me-and-u-connect/src/lib/meandu/auth/index.ts

@@ -0,0 +1,32 @@
+import { Issuer, TokenSet } from 'openid-client';
+import type { Logger } from 'winston';
+
+import { SeekaAppInstallState, tryGetInstallation } from '../../state/seeka/installations';
+
+const getAuthClient = async (installation: SeekaAppInstallState) => {
+    // https://apidocs.sproutsend.com/#authentication
+    const issuer = new Issuer({
+        issuer: 'https://api.sproutsend.com',
+        authorization_endpoint: 'https://api.sproutsend.com/oauth',
+        token_endpoint: 'https://api.sproutsend.com/oauth/token',
+        revocation_endpoint: 'https://api.sproutsend.com/oauth/revoke',
+    });
+    return new issuer.Client({
+        client_id: installation.installationSettings.meAndUAppClientId as string,
+        client_secret: installation.installationSettings.meAndUAppClientSecret as string,
+    });
+}
+
+export const getAccessToken = async (installationId: string, logger: Logger): Promise<TokenSet> => {
+    const installation = await tryGetInstallation(installationId, true, logger) as SeekaAppInstallState;
+    const client = await getAuthClient(installation);
+
+    // TODO: Cache access token and error handling
+
+    // https://apidocs.sproutsend.com/#requests
+    return await client.grant({
+        grant_type: 'client_credentials',
+        client_id: installation.installationSettings.meAndUAppClientId,
+        client_secret: installation.installationSettings.meAndUAppClientSecret,
+    });
+}

package/dist/ai-context/internal/examples/v1/me-and-u-connect/src/lib/meandu/contacts/index.ts

@@ -0,0 +1,149 @@
+import type { Logger } from 'winston';
+
+import type { PersonIdentifiers } from '@seeka-labs/sdk-apps-server';
+
+import * as packageJson from '../../../../package.json';
+import { SeekaAppInstallState } from '../../state/seeka/installations';
+import { maxPageSize, meAndUFetch } from '../api';
+
+export const createOrUpdateContactFromSeekaPerson = async (installation: SeekaAppInstallState, seekaPerson: PersonIdentifiers, logger: Logger): Promise<void> => {
+    if ((!seekaPerson.email || seekaPerson.email.length === 0) && (!seekaPerson.phone || seekaPerson.phone.length === 0)) {
+        // No email or phone number, don't create contact
+        logger.verbose('No email or phone number on seeka person, not creating me&u contact', { seekaPerson });
+        return;
+    }
+    if (!seekaPerson.consent?.marketing || (!seekaPerson.consent?.marketing?.sms?.consentGrantedAt && !seekaPerson.consent?.marketing?.email?.consentGrantedAt)) {
+        // No marketing consent, don't create contact
+        logger.verbose('No marketing consent on seeka person, not creating me&u contact');
+        return;
+    }
+
+    const seekaPersonIdFieldId = installation.installationState.seekaPersonIdMeAndUFieldId;
+    if (!seekaPersonIdFieldId) {
+        logger.error('Seeka Person ID field ID not found on installation state, not syncing contact')
+        return;
+    }
+
+    await createOrUpdateContact(installation, seekaPersonToMeAndUContact(seekaPerson, false, seekaPersonIdFieldId), logger);
+}
+
+export const createOrUpdateContact = async (installation: SeekaAppInstallState, contact: MeAndUContact, logger: Logger): Promise<void> => {
+    if ((!contact.email || contact.email.length === 0) && (!contact.mobile || contact.mobile.length === 0)) {
+        // No email or phone number, don't create contact
+        logger.verbose('No email or phone number provided, not creating me&u contact', { contact });
+        return;
+    }
+
+    const meAndUtoken = installation.installationSettings.meAndUAppAccessToken as string;
+
+    await meAndUFetch('https://api.sproutsend.com/contacts', {
+        method: 'POST',
+        headers: {
+            'Authorization': `Bearer ${meAndUtoken}`,
+            'Content-Type': 'application/json',
+            'Accept': 'application/json',
+            'User-Agent': `Seeka/${packageJson.name}/${packageJson.version}`,
+            'Accept-Version': '1.0',
+            'Timestamp': new Date().getTime().toString(),
+        },
+        body: JSON.stringify({
+            data: contact
+        })
+    }, logger)
+}
+
+export const updateContact = async (installation: SeekaAppInstallState, contactId: string, contact: MeAndUContact, logger: Logger): Promise<void> => {
+    const meAndUtoken = installation.installationSettings.meAndUAppAccessToken as string;
+
+    await meAndUFetch(`https://api.sproutsend.com/contacts/${contactId}`, {
+        method: 'PUT',
+        headers: {
+            'Authorization': `Bearer ${meAndUtoken}`,
+            'Content-Type': 'application/json',
+            'Accept': 'application/json',
+            'User-Agent': `Seeka/${packageJson.name}/${packageJson.version}`,
+            'Accept-Version': '1.0',
+            'Timestamp': new Date().getTime().toString(),
+        },
+        body: JSON.stringify({
+            data: contact
+        })
+    }, logger)
+}
+
+export const getContactListPage = async (installation: SeekaAppInstallState, page: number, lastCreatedFrom: Date | undefined, logger: Logger): Promise<MeAndUContactListResponse> => {
+    const meAndUtoken = installation.installationSettings.meAndUAppAccessToken as string;
+
+    // https://apidocs.sproutsend.com/#request
+    // https://apidocs.sproutsend.com/#get-contacts
+
+    const response = await meAndUFetch(`https://api.sproutsend.com/contacts?page=${page}&pageSize=${maxPageSize}&sortBy=created:asc${(lastCreatedFrom ? `&created__gte=${lastCreatedFrom.toISOString()}` : '')}`, {
+        method: 'GET',
+        headers: {
+            'Authorization': `Bearer ${meAndUtoken}`,
+            'Content-Type': 'application/json',
+            'Accept': 'application/json',
+            'User-Agent': `Seeka/${packageJson.name}/${packageJson.version}`,
+            'Accept-Version': '1.0',
+            'Timestamp': new Date().getTime().toString(),
+        }
+    }, logger)
+
+    const items = (await response.json()).items.map((e: { data: MeAndUContact }) => e.data);
+
+    return {
+        items,
+        noMorePages: items.length < maxPageSize
+    }
+}
+
+const seekaPersonToMeAndUContact = (seekaPerson: PersonIdentifiers, setConsentFields: boolean, seekaPersonIdFieldId: string): MeAndUContact => {
+    const contact = {} as MeAndUContact;
+    if (seekaPerson.firstName && seekaPerson.firstName.length > 0) contact.firstName = seekaPerson.firstName[0];
+    if (seekaPerson.lastName && seekaPerson.lastName.length > 0) contact.surname = seekaPerson.lastName[0];
+    if (seekaPerson.email && seekaPerson.email.length > 0) contact.email = seekaPerson.email[0];
+    if (seekaPerson.phone && seekaPerson.phone.length > 0) contact.mobile = seekaPerson.phone[0];
+    if (seekaPerson.dob && seekaPerson.dob.length > 0) {
+        if (typeof seekaPerson.dob[0] === 'string') {
+            contact.dob = seekaPerson.dob[0] as string;
+        }
+        else {
+            contact.dob = seekaPerson.dob[0].toISOString();
+        }
+    }
+
+    if (setConsentFields) {
+        contact.smsOptOut = seekaPerson.consent?.marketing?.sms?.consentGrantedAt ? false : true;
+        contact.emailOptOut = seekaPerson.consent?.marketing?.email?.consentGrantedAt ? false : true;
+    }
+
+    contact.customFields = {
+        [seekaPersonIdFieldId]: seekaPerson.seekaPId
+    }
+
+    return contact;
+}
+
+export interface MeAndUContact {
+    _id?: string
+    account?: string
+    accountName?: string
+    firstName?: string
+    surname?: string
+    email?: string
+    mobile?: string
+    dob?: string
+    gender?: string
+    smsOptOut?: boolean
+    emailOptOut?: boolean
+    tags?: string[]
+    customFields?: { [key: string]: string | number | undefined; };
+    source?: string
+    modified?: string
+    created?: string
+}
+
+export interface MeAndUContactListResponse {
+    items: MeAndUContact[]
+    noMorePages: boolean
+}

package/dist/ai-context/internal/examples/v1/me-and-u-connect/src/lib/meandu/fields/index.ts

@@ -0,0 +1,105 @@
+import type { Logger } from 'winston';
+
+import {
+    createOrUpdateInstallation, SeekaAppInstallState
+} from '../../state/seeka/installations';
+import { meAndUFetch } from '../api';
+import * as packageJson from '../../../../package.json';
+
+export const seekaPersonIdCustomFieldLabel = 'Seeka Profile ID';
+
+export const createOrGetSeekaPersonIdCustomFieldExists = async (installation: SeekaAppInstallState, logger: Logger): Promise<string> => {
+    const fields = await getFieldsList(installation, logger);
+    const seekaPersonIdField = fields.find(f => f.label === seekaPersonIdCustomFieldLabel);
+
+    let fieldId: string;
+    if (seekaPersonIdField == null) {
+        const newField = await createField(installation, 'string', seekaPersonIdCustomFieldLabel, false, logger);
+        fieldId = newField.name;
+    }
+    else {
+        fieldId = seekaPersonIdField.name;
+    }
+
+    if (!installation.installationState.seekaPersonIdMeAndUFieldId) {
+        installation.installationState.seekaPersonIdMeAndUFieldId = fieldId;
+        await createOrUpdateInstallation(installation, logger);
+    }
+    else if (installation.installationState.seekaPersonIdMeAndUFieldId != fieldId) {
+        logger.warn('Seeka Person ID field ID has changed', { oldFieldId: installation.installationState.seekaPersonIdMeAndUFieldId, newFieldId: fieldId });
+        installation.installationState.seekaPersonIdMeAndUFieldId = fieldId;
+        await createOrUpdateInstallation(installation, logger);
+    }
+
+    return fieldId;
+}
+
+const getFieldsList = async (installation: SeekaAppInstallState, logger: Logger): Promise<MeAndUField[]> => {
+    const meAndUtoken = installation.installationSettings.meAndUAppAccessToken as string;
+
+    const response = await meAndUFetch('https://api.sproutsend.com/fields', {
+        method: 'GET',
+        headers: {
+            'Authorization': `Bearer ${meAndUtoken}`,
+            'Content-Type': 'application/json',
+            'Accept': 'application/json',
+            'User-Agent': `Seeka/${packageJson.name}/${packageJson.version}`,
+            'Accept-Version': '1.0',
+            'Timestamp': new Date().getTime().toString(),
+        }
+    }, logger)
+
+    return (await response.json()).items.map((e: { data: MeAndUField }) => e.data)
+}
+
+const createField = async (installation: SeekaAppInstallState, fieldType: string, label: string, isRequired: boolean, logger: Logger): Promise<MeAndUField> => {
+    const meAndUtoken = installation.installationSettings.meAndUAppAccessToken as string;
+
+    const response = await meAndUFetch('https://api.sproutsend.com/fields', {
+        method: 'POST',
+        headers: {
+            'Authorization': `Bearer ${meAndUtoken}`,
+            'Content-Type': 'application/json',
+            'Accept': 'application/json',
+            'User-Agent': `Seeka/${packageJson.name}/${packageJson.version}`,
+            'Accept-Version': '1.0',
+            'Timestamp': new Date().getTime().toString(),
+        },
+        body: JSON.stringify({
+            data: {
+                fieldType,
+                label,
+                required: isRequired
+            }
+        })
+    }, logger)
+
+    return (await response.json() as { data: MeAndUField }).data
+}
+
+export interface MeAndUField {
+    _id: string
+    account: string
+    collectionType: string
+    fieldType: string
+    name: string
+    label: string
+    order: number
+    defaultValue: string
+    required: boolean
+    hidden: boolean
+    readOnly: boolean
+    systemField: boolean
+    deleted: boolean
+    created: string
+    createdBy: string
+    modified: string
+    modifiedBy: string
+    options: MeAndUFieldOption[]
+}
+
+export interface MeAndUFieldOption {
+    value: string
+    order: number
+    deleted: boolean
+}

package/dist/ai-context/internal/examples/v1/me-and-u-connect/src/lib/meandu/jobs/contact-sync/index.ts

@@ -0,0 +1,143 @@
+import type { Logger } from 'winston';
+
+import { SeekaAppHelper, TrackingEventSourceOriginType } from '@seeka-labs/sdk-apps-server';
+import winston from 'winston';
+import * as packageJson from '../../../../../package.json';
+import { getContactListPage, MeAndUContact, updateContact } from '../../../meandu/contacts';
+import {
+    createOrGetSeekaPersonIdCustomFieldExists
+} from '../../../meandu/fields';
+import {
+    createOrUpdateInstallation, SeekaAppInstallState, tryGetInstallation
+} from '../../../state/seeka/installations';
+
+export const executeMeAndUContactSync = async (installation: SeekaAppInstallState, logger: Logger) => {
+    logger.info("Starting me&u contact sync", { context: installation });
+
+    let currentPage = 1;
+    const lastCreatedFrom = installation?.installationState.meAndUContactSyncUpToLastCreated ? new Date(installation?.installationState.meAndUContactSyncUpToLastCreated) : undefined;
+    const seekaPersonIdFieldId = await createOrGetSeekaPersonIdCustomFieldExists(installation, logger)
+
+    const helper = SeekaAppHelper.create(process.env['SEEKA_APP_SECRET'] as string, {
+        organisationId: installation.organisationId as string,
+        applicationInstallId: installation.applicationInstallId as string,
+        applicationId: process.env['SEEKA_APP_ID'] as string,
+    }, { name: packageJson.name, version: packageJson.version }, installation.installationState.grantedPermissions, logger);
+
+    await helper.api.refreshOrPrimeTokenCache();
+
+    // eslint-disable-next-line no-constant-condition
+    while (true) {
+        const results = await getContactListPage(installation, currentPage, lastCreatedFrom, logger);
+
+        if (results.items.length === 0) break;
+
+        // Process the page in parallel
+        const promises = (results.items.map((c) => syncContact(c, seekaPersonIdFieldId, installation, helper, logger)));
+        let succeeded: boolean;
+        try {
+            await Promise.all(promises);
+            succeeded = true;
+        }
+        catch (err) {
+            logger.error('Error syncing me&u contact batch', { error: winston.exceptions.getAllInfo(err) });
+            succeeded = false;
+        }
+
+        // Update the last page we processed to enable re-entry to the background job - in case the max time limit on azure function execution of 15 minutes is reached
+        installation = await tryGetInstallation(installation.applicationInstallId as string, true, logger) as SeekaAppInstallState;
+        if (succeeded) {
+            // Set to last processed
+            installation.installationState.meAndUContactSyncUpToLastCreated = results.items.slice(-1)[0].created;
+            logger.debug("Updated last processed date for successful batch process", { lastProcessed: installation.installationState.meAndUContactSyncUpToLastCreated });
+        }
+        else {
+            // Set to the first item in the page which will have the earliest date created
+            installation.installationState.meAndUContactSyncUpToLastCreated = results.items[0].created;
+            logger.debug("Updated last processed date for unsuccessful batch process", { lastProcessed: installation.installationState.meAndUContactSyncUpToLastCreated });
+        }
+        await createOrUpdateInstallation(installation, logger);
+
+        if (results.noMorePages) break;
+
+        currentPage++;
+    }
+
+    logger.info("Completed me&u contact sync");
+}
+
+export const isValidEmail = (email: string): boolean => {
+    const match = email.match(/^[\w-.]+@([\w-]+\.)+[\w-]{2,5}$/g);
+    return match && match.length > 0;
+}
+
+const syncContact = async (contact: MeAndUContact, seekaPersonIdFieldId: string, installation: SeekaAppInstallState, helper: SeekaAppHelper, logger: Logger): Promise<void> => {
+    const fieldId = installation.installationState.seekaPersonIdMeAndUFieldId;
+    if (!fieldId) {
+        logger.error('Seeka Person ID field ID not found on installation state, not syncing contact', { meAndUContactId: contact._id });
+        return;
+    }
+
+    const existingSeekaId = contact.customFields ? contact.customFields[fieldId] as string : undefined;
+    if (!existingSeekaId) {
+        logger.debug("No seeka person ID found for contact", { meAndUContactId: contact._id })
+    }
+
+    // Sprout allows invalid emails
+    if (contact.email) {
+        // Sprout allows single quotes in email addresses sometimes
+        contact.email = contact.email.replace(/'/g, '');
+    }
+    if (contact.email && !isValidEmail(contact.email)) {
+        if (!contact.mobile) {
+            logger.warn('Invalid email address in me&u and no mobile on contact, not syncing contact', { meAndUContactId: contact._id, email: contact.email });
+            return;
+        }
+        else {
+            logger.warn('Invalid email address in me&u but contact has phone, removing email', { meAndUContactId: contact._id, email: contact.email });
+            contact.email = null;
+        }
+    }
+
+    // Push identity to seeka
+    const newSeekaId = await helper.api.mergeIdentity(
+        {
+            seekaPId: existingSeekaId,
+            firstName: contact.firstName ? [contact.firstName] : [],
+            lastName: contact.surname ? [contact.surname] : [],
+            email: contact.email ? [contact.email] : [],
+            phone: contact.mobile ? [contact.mobile] : [],
+            dob: contact.dob ? [new Date(contact.dob)] : [],
+            consent: {
+                marketing: {
+                    sms: {
+                        consentGrantedAt: !contact.smsOptOut ? undefined : new Date(),
+                        consentGrantedSourceName: !contact.smsOptOut ? undefined : 'me&u',
+                        consentNotGrantedAt: contact.smsOptOut ? new Date() : undefined,
+                        consentNotGrantedSourceName: contact.smsOptOut ? 'me&u' : undefined,
+                    },
+                    email: {
+                        consentGrantedAt: !contact.emailOptOut ? undefined : new Date(),
+                        consentGrantedSourceName: !contact.emailOptOut ? undefined : 'me&u',
+                        consentNotGrantedAt: contact.emailOptOut ? new Date() : undefined,
+                        consentNotGrantedSourceName: contact.emailOptOut ? 'me&u' : undefined,
+                    }
+                }
+            }
+        },
+        {
+            origin: TrackingEventSourceOriginType.Server
+        }
+    )
+
+    // Update contact with seeka ID
+    if (!existingSeekaId) {
+        logger.info('Updating me&u contact with seeka ID', { meAndUContactId: contact._id, seekaPersonId: newSeekaId });
+        await updateContact(installation, contact._id as string, {
+            customFields: {
+                ...contact.customFields,
+                [seekaPersonIdFieldId]: newSeekaId
+            }
+        }, logger)
+    }
+}