@learncard/network-brain-service 4.0.3 → 4.1.0

package/src/accesslayer/campaign/audience.ts

@@ -0,0 +1,152 @@
+import { TRPCError } from '@trpc/server';
+import { int } from 'neo4j-driver';
+import {
+    CampaignAudienceSourceValidator,
+    type CampaignAudienceSource,
+    type PaginatedCampaignAudience,
+} from '@learncard/types';
+
+import { neogma } from '@instance';
+import { traceDb } from '@tracing';
+import { getDidWeb } from '@helpers/did.helpers';
+import { constructUri, getUriParts } from '@helpers/uri.helpers';
+import type { CampaignAudienceQuery } from 'types/campaign';
+import {
+    assertCampaignEditable,
+    campaignAgePredicate,
+    campaignTimeParams,
+    lockCampaign,
+    withCampaignTransaction,
+} from './shared';
+import { getCampaign } from './read';
+
+const canonicalNetworkDomain = (domain: string): string => {
+    const decodedDomain = domain.replace(/\/trpc$/, '').replace(/%3A/gi, ':');
+
+    return getUriParts(constructUri('boost', 'domain-check', decodedDomain)).domain;
+};
+
+export const buildCampaignAudienceQuery = (
+    rawSource: CampaignAudienceSource,
+    domain: string
+): CampaignAudienceQuery => {
+    const source = CampaignAudienceSourceValidator.parse(rawSource);
+    switch (source.type) {
+        case 'dids':
+            return {
+                match: `MATCH (p:Profile) WHERE p.did IN $dids OR ($didWebPrefix + p.profileId) IN $dids`,
+                params: { dids: source.dids, didWebPrefix: getDidWeb(domain, '') },
+            };
+        case 'emails':
+            return {
+                match: `MATCH (p:Profile)-[:HAS_CONTACT_METHOD]->(contact:ContactMethod)
+                    WHERE contact.type = 'email' AND contact.isVerified = true
+                      AND toLower(trim(contact.value)) IN $emails`,
+                params: { emails: source.emails },
+            };
+        case 'inboxClaims':
+            return {
+                match: `MATCH (p:Profile)-[claim:CLAIMED_INBOX_CREDENTIAL]->(inbox:InboxCredential)
+                    WHERE inbox.issuerDid = $issuerDid AND ($since IS NULL OR claim.timestamp >= $since)`,
+                params: { issuerDid: source.issuerDid, since: source.since ?? null },
+            };
+        default: {
+            let match: string;
+            const params: Record<string, unknown> = { includePending: source.includePending };
+            if (source.type === 'boostRecipients') {
+                const uri = getUriParts(source.boostUri);
+                if (
+                    uri.type !== 'boost' ||
+                    canonicalNetworkDomain(uri.domain) !== canonicalNetworkDomain(domain)
+                ) {
+                    throw new TRPCError({
+                        code: 'BAD_REQUEST',
+                        message: 'A boost URI from this network is required',
+                    });
+                }
+                match = `MATCH (boost:Boost {id: $boostId})<-[:INSTANCE_OF]-(credential:Credential)<-[sent:CREDENTIAL_SENT]-(sender)
+                    WHERE sender:Profile OR sender:AppStoreListing`;
+                params.boostId = uri.id;
+            } else {
+                match = source.senderProfileId
+                    ? `MATCH (sender:Profile {profileId: $senderId})-[sent:CREDENTIAL_SENT]->(credential:Credential)`
+                    : `MATCH (sender:AppStoreListing {listing_id: $senderId})-[sent:CREDENTIAL_SENT]->(credential:Credential)`;
+                params.senderId = source.senderProfileId ?? source.listingId;
+                params.since = source.since ?? null;
+                params.metadata = source.metadata ?? {};
+                match += ` WHERE ($since IS NULL OR sent.date >= $since)
+                    AND all(key IN keys($metadata) WHERE sent['metadata.' + key] = $metadata[key])`;
+            }
+            return {
+                match: `${match}
+                MATCH (p:Profile {profileId: sent.to})
+                OPTIONAL MATCH (credential)-[received:CREDENTIAL_RECEIVED]->(p)
+                WITH p, sent, received
+                WHERE coalesce(sent.status, '') <> 'revoked'
+                  AND coalesce(received.status, '') <> 'revoked'
+                  AND ($includePending OR (received IS NOT NULL AND coalesce(received.status, '') <> 'pending'))`,
+                params,
+            };
+        }
+    }
+};
+
+export const previewCampaignAudience = async (
+    campaignId: string,
+    source: CampaignAudienceSource,
+    domain: string
+): Promise<number> => {
+    await getCampaign(campaignId);
+    const query = buildCampaignAudienceQuery(source, domain);
+    const result = await traceDb('campaign:previewAudience', () =>
+        neogma.queryRunner.run(
+            `${query.match} WITH DISTINCT p MATCH (c:Campaign {id: $campaignId})
+         WHERE ${campaignAgePredicate} RETURN count(p) AS count`,
+            { ...query.params, campaignId, ...campaignTimeParams() }
+        )
+    );
+    return result.records[0]!.get('count').toNumber();
+};
+
+export const addCampaignAudience = async (
+    campaignId: string,
+    source: CampaignAudienceSource,
+    domain: string
+): Promise<number> => {
+    const query = buildCampaignAudienceQuery(source, domain);
+    return withCampaignTransaction('campaign:addAudience', async transaction => {
+        assertCampaignEditable(await lockCampaign(transaction, campaignId));
+        const result = await transaction.run(
+            `${query.match} WITH DISTINCT p MATCH (c:Campaign {id: $campaignId})
+             WHERE ${campaignAgePredicate}
+             MERGE (p)-[audience:IN_CAMPAIGN_AUDIENCE]->(c)
+             ON CREATE SET audience.addedAt = $now, audience.source = $source
+             RETURN count(p) AS count`,
+            { ...query.params, campaignId, source: source.type, ...campaignTimeParams() }
+        );
+        return result.records[0]!.get('count').toNumber();
+    });
+};
+
+export const pageCampaignAudience = async (
+    campaignId: string,
+    cursor?: string,
+    limit = 100
+): Promise<PaginatedCampaignAudience> => {
+    await getCampaign(campaignId);
+    const result = await traceDb('campaign:pageAudience', () =>
+        neogma.queryRunner.run(
+            `MATCH (p:Profile)-[:IN_CAMPAIGN_AUDIENCE]->(c:Campaign {id: $campaignId})
+         WHERE ($cursor IS NULL OR p.profileId > $cursor) AND ${campaignAgePredicate}
+         RETURN DISTINCT p.profileId AS profileId, p.did AS did ORDER BY profileId LIMIT $limit`,
+            { campaignId, cursor: cursor ?? null, limit: int(limit + 1), ...campaignTimeParams() }
+        )
+    );
+    const rows = result.records.map(record => ({
+        profileId: record.get('profileId') as string,
+        did: record.get('did') as string,
+    }));
+    const hasMore = rows.length > limit;
+    const records = rows.slice(0, limit);
+    return { records, hasMore, cursor: hasMore ? records.at(-1)?.profileId : undefined };
+};

package/src/accesslayer/campaign/create.ts

@@ -0,0 +1,47 @@
+import { TRPCError } from '@trpc/server';
+import {
+    CampaignValidator,
+    CreateCampaignInputValidator,
+    type Campaign,
+    type CreateCampaignInput,
+} from '@learncard/types';
+
+import { neogma } from '@instance';
+import { traceDb } from '@tracing';
+import { ensureCampaignConstraints } from '../../models/campaign-constraints';
+import { campaignProperties } from './shared';
+
+export const createCampaign = async (
+    input: CreateCampaignInput,
+    createdByProfileId: string
+): Promise<Campaign> => {
+    const parsed = CreateCampaignInputValidator.parse(input);
+    const now = new Date().toISOString();
+    const campaign = CampaignValidator.parse({
+        ...parsed,
+        message: { ...parsed.message, id: parsed.id },
+        createdAt: now,
+        updatedAt: now,
+    });
+    await ensureCampaignConstraints();
+    try {
+        await traceDb('campaign:create', () =>
+            neogma.queryRunner.run('CREATE (c:Campaign) SET c = $properties', {
+                properties: { ...campaignProperties(campaign), createdByProfileId },
+            })
+        );
+    } catch (error) {
+        if (
+            (error as { code?: string })?.code ===
+            'Neo.ClientError.Schema.ConstraintValidationFailed'
+        ) {
+            throw new TRPCError({
+                code: 'CONFLICT',
+                message: 'Campaign ID already exists',
+                cause: error,
+            });
+        }
+        throw error;
+    }
+    return campaign;
+};

package/src/accesslayer/campaign/delete.ts

@@ -0,0 +1,18 @@
+import { TRPCError } from '@trpc/server';
+
+import { lockCampaign, withCampaignTransaction } from './shared';
+
+export const deleteCampaign = async (campaignId: string): Promise<boolean> =>
+    withCampaignTransaction('campaign:delete', async transaction => {
+        const campaign = await lockCampaign(transaction, campaignId);
+        if (campaign.status === 'live' || campaign.status === 'paused') {
+            throw new TRPCError({
+                code: 'BAD_REQUEST',
+                message: 'Archive live or paused campaigns before deleting them',
+            });
+        }
+        await transaction.run('MATCH (c:Campaign {id: $campaignId}) DETACH DELETE c', {
+            campaignId,
+        });
+        return true;
+    });

package/src/accesslayer/campaign/read.ts

@@ -0,0 +1,125 @@
+import { TRPCError } from '@trpc/server';
+import { int, isInt } from 'neo4j-driver';
+import {
+    CampaignUserStateValidator,
+    type Campaign,
+    type CampaignStats,
+    type ListCampaignsInput,
+    type MyCampaign,
+    type PaginatedCampaigns,
+} from '@learncard/types';
+
+import { neogma } from '@instance';
+import { traceDb } from '@tracing';
+import {
+    campaignAgePredicate,
+    campaignTimeParams,
+    liveCampaignPredicate,
+    parseCampaign,
+    safeParseCampaign,
+} from './shared';
+
+export const getCampaign = async (campaignId: string): Promise<Campaign> => {
+    const result = await traceDb('campaign:get', () =>
+        neogma.queryRunner.run(
+            'MATCH (c:Campaign {id: $campaignId}) RETURN c.definition AS definition',
+            { campaignId }
+        )
+    );
+    if (!result.records.length)
+        throw new TRPCError({ code: 'NOT_FOUND', message: 'Campaign not found' });
+    return parseCampaign(result.records[0]!.get('definition'));
+};
+
+export const listCampaigns = async ({
+    cursor,
+    limit = 100,
+    status,
+}: ListCampaignsInput): Promise<PaginatedCampaigns> => {
+    const result = await traceDb('campaign:list', () =>
+        neogma.queryRunner.run(
+            `MATCH (c:Campaign) WHERE ($cursor IS NULL OR c.id > $cursor)
+         AND ($status IS NULL OR c.status = $status)
+         RETURN c.definition AS definition ORDER BY c.id LIMIT $limit`,
+            { cursor: cursor ?? null, status: status ?? null, limit: int(limit + 1) }
+        )
+    );
+    const rows = result.records.map(record => parseCampaign(record.get('definition')));
+    const hasMore = rows.length > limit;
+    const records = rows.slice(0, limit);
+    return { records, hasMore, cursor: hasMore ? records.at(-1)?.id : undefined };
+};
+
+export const getLiveCampaignsForProfile = async (
+    profileId: string,
+    now = new Date()
+): Promise<MyCampaign[]> => {
+    const result = await traceDb('campaign:getMyCampaigns', () =>
+        neogma.queryRunner.run(
+            `MATCH (p:Profile {profileId: $profileId}), (c:Campaign)
+         WHERE ${liveCampaignPredicate} AND ${campaignAgePredicate}
+           AND (c.selfEnroll = true OR EXISTS { MATCH (p)-[:IN_CAMPAIGN_AUDIENCE]->(c) })
+         OPTIONAL MATCH (p)-[state:CAMPAIGN_STATE]->(c)
+         RETURN c.id AS campaignId, c.definition AS definition, properties(state) AS state
+         ORDER BY c.id`,
+            { profileId, ...campaignTimeParams(now) }
+        )
+    );
+    return result.records.flatMap(record => {
+        const campaign = safeParseCampaign(record.get('definition'));
+        if (!campaign) {
+            console.warn('campaign:getMyCampaigns skipped invalid stored definition', {
+                campaignId: record.get('campaignId'),
+            });
+            return [];
+        }
+        if (!campaign.channels.includes('inApp') || !campaign.message.enabled) return [];
+        const state = Object.fromEntries(
+            Object.entries(record.get('state') ?? {}).map(([key, value]) => [
+                key,
+                isInt(value) ? value.toNumber() : value,
+            ])
+        );
+        return [
+            {
+                campaign: {
+                    id: campaign.id,
+                    message: campaign.message,
+                    startsAt: campaign.startsAt,
+                    endsAt: campaign.endsAt,
+                    selfEnroll: campaign.selfEnroll,
+                },
+                state: CampaignUserStateValidator.parse(state),
+            },
+        ];
+    });
+};
+
+export const getCampaignStats = async (campaignId: string): Promise<CampaignStats> => {
+    await getCampaign(campaignId);
+    const result = await traceDb('campaign:stats', () =>
+        neogma.queryRunner.run(
+            `MATCH (c:Campaign {id: $campaignId})
+         OPTIONAL MATCH (p:Profile)-[audience:IN_CAMPAIGN_AUDIENCE]->(c)
+         OPTIONAL MATCH (p)-[state:CAMPAIGN_STATE]->(c)
+         RETURN count(DISTINCT p) AS audience,
+           count(DISTINCT CASE WHEN audience.source = 'selfEnrolled' THEN p END) AS enrolled,
+           count(DISTINCT CASE WHEN state.notifiedAt IS NOT NULL THEN p END) AS notified,
+           count(DISTINCT CASE WHEN state.firstShownAt IS NOT NULL THEN p END) AS shown,
+           count(DISTINCT CASE WHEN state.clickedAt IS NOT NULL THEN p END) AS clicked,
+           count(DISTINCT CASE WHEN state.dismissedAt IS NOT NULL THEN p END) AS dismissed,
+           count(DISTINCT CASE WHEN state.convertedAt IS NOT NULL THEN p END) AS converted`,
+            { campaignId }
+        )
+    );
+    const record = result.records[0]!;
+    return {
+        audience: record.get('audience').toNumber(),
+        enrolled: record.get('enrolled').toNumber(),
+        notified: record.get('notified').toNumber(),
+        shown: record.get('shown').toNumber(),
+        clicked: record.get('clicked').toNumber(),
+        dismissed: record.get('dismissed').toNumber(),
+        converted: record.get('converted').toNumber(),
+    };
+};

package/src/accesslayer/campaign/shared.ts

@@ -0,0 +1,92 @@
+import { TRPCError } from '@trpc/server';
+import { CampaignValidator, type Campaign } from '@learncard/types';
+import type { ManagedTransaction } from 'neo4j-driver';
+
+import { neogma } from '@instance';
+import { traceDb } from '@tracing';
+
+const knownBirthdayPredicate = `p.dob IS NOT NULL
+    AND p.dob =~ '[0-9]{4}-(0[1-9]|1[0-2])-(0[1-9]|[12][0-9]|3[01])'`;
+const managedProfilePredicate = `(EXISTS { MATCH (p)-[:MANAGED_BY]->(:Profile) }
+    OR EXISTS { MATCH (:ProfileManager)-[:MANAGES]->(p) })`;
+const serviceProfilePredicate = `(p.isServiceProfile = true AND coalesce(p.type, '') <> 'child')`;
+export const adultProfilePredicate = `${knownBirthdayPredicate}
+    AND coalesce(p.type, '') <> 'child' AND p.dob <= $adultCutoff
+    AND (${serviceProfilePredicate} OR NOT ${managedProfilePredicate})`;
+export const campaignAgePredicate = `(${knownBirthdayPredicate}
+    AND (c.excludeMinors = false OR (${adultProfilePredicate})))`;
+export const liveCampaignPredicate = `c.status = 'live'
+    AND (c.startsAt IS NULL OR c.startsAt <= $now)
+    AND (c.endsAt IS NULL OR c.endsAt > $now)`;
+
+export const campaignTimeParams = (now = new Date()): { now: string; adultCutoff: string } => {
+    const timestamp = now.toISOString();
+    // Compare calendar dates, not elapsed milliseconds. Keeping the month/day avoids
+    // JS rolling Feb 29 into March 1 and admitting March 1 birthdays a day early.
+    const adultCutoff = `${now.getUTCFullYear() - 18}${timestamp.slice(4, 10)}`;
+    return { now: timestamp, adultCutoff };
+};
+
+export const parseCampaign = (definition: string): Campaign =>
+    CampaignValidator.parse(JSON.parse(definition));
+
+export const safeParseCampaign = (definition: unknown): Campaign | undefined => {
+    if (typeof definition !== 'string') return undefined;
+    try {
+        const result = CampaignValidator.safeParse(JSON.parse(definition));
+        return result.success ? result.data : undefined;
+    } catch {
+        return undefined;
+    }
+};
+
+export const campaignProperties = (campaign: Campaign): Record<string, unknown> => ({
+    id: campaign.id,
+    name: campaign.name,
+    status: campaign.status,
+    excludeMinors: campaign.excludeMinors,
+    selfEnroll: campaign.selfEnroll,
+    createdAt: campaign.createdAt,
+    updatedAt: campaign.updatedAt,
+    definition: JSON.stringify(campaign),
+    startsAt: campaign.startsAt ?? null,
+    endsAt: campaign.endsAt ?? null,
+});
+
+export const withCampaignTransaction = async <Result>(
+    name: string,
+    work: (transaction: ManagedTransaction) => Promise<Result>
+): Promise<Result> =>
+    traceDb(name, async () => {
+        const session = neogma.queryRunner.getDriver().session();
+        try {
+            return await session.executeWrite(work);
+        } finally {
+            await session.close();
+        }
+    });
+
+/** Serialize campaign edits/audience enrollment before reading their current definition. */
+export const lockCampaign = async (
+    transaction: ManagedTransaction,
+    campaignId: string
+): Promise<Campaign> => {
+    const result = await transaction.run(
+        `MATCH (c:Campaign {id: $campaignId})
+         SET c.lockVersion = coalesce(c.lockVersion, 0) + 1
+         RETURN c.definition AS definition`,
+        { campaignId }
+    );
+    if (!result.records.length)
+        throw new TRPCError({ code: 'NOT_FOUND', message: 'Campaign not found' });
+    return parseCampaign(result.records[0]!.get('definition'));
+};
+
+export const assertCampaignEditable = (campaign: Campaign): void => {
+    if (campaign.status === 'archived') {
+        throw new TRPCError({
+            code: 'BAD_REQUEST',
+            message: 'Archived campaigns cannot be changed',
+        });
+    }
+};

package/src/accesslayer/campaign/state.ts

@@ -0,0 +1,80 @@
+import { TRPCError } from '@trpc/server';
+import { CampaignEventValidator, type CampaignEvent } from '@learncard/types';
+
+import {
+    adultProfilePredicate,
+    campaignAgePredicate,
+    campaignTimeParams,
+    liveCampaignPredicate,
+    lockCampaign,
+    withCampaignTransaction,
+} from './shared';
+
+export const enrollInCampaign = async (profileId: string, campaignId: string): Promise<boolean> =>
+    withCampaignTransaction('campaign:enroll', async transaction => {
+        const campaign = await lockCampaign(transaction, campaignId);
+        const params = campaignTimeParams();
+        if (
+            !campaign.selfEnroll ||
+            campaign.status !== 'live' ||
+            !campaign.message.enabled ||
+            !campaign.channels.includes('inApp') ||
+            (campaign.startsAt && campaign.startsAt > params.now) ||
+            (campaign.endsAt && campaign.endsAt <= params.now)
+        ) {
+            throw new TRPCError({
+                code: 'FORBIDDEN',
+                message: 'Campaign is not accepting enrollment',
+            });
+        }
+        const result = await transaction.run(
+            `MATCH (p:Profile {profileId: $profileId}), (c:Campaign {id: $campaignId})
+             WHERE ${adultProfilePredicate}
+             MERGE (p)-[audience:IN_CAMPAIGN_AUDIENCE]->(c)
+             ON CREATE SET audience.addedAt = $now, audience.source = 'selfEnrolled'
+             RETURN p.profileId AS profileId`,
+            { profileId, campaignId, ...params }
+        );
+        if (!result.records.length)
+            throw new TRPCError({
+                code: 'FORBIDDEN',
+                message: 'Profile is not eligible for enrollment',
+            });
+        return true;
+    });
+
+export const recordCampaignEvent = async (
+    profileId: string,
+    campaignId: string,
+    rawEvent: CampaignEvent
+): Promise<boolean> => {
+    const event = CampaignEventValidator.parse(rawEvent);
+    const assignments: Record<CampaignEvent, string> = {
+        shown: `state.firstShownAt = coalesce(state.firstShownAt, $now), state.lastShownAt = $now,
+                state.shownCount = coalesce(state.shownCount, 0) + 1`,
+        clicked: 'state.clickedAt = $now',
+        dismissed: 'state.dismissedAt = $now',
+        converted: 'state.convertedAt = $now',
+    };
+    return withCampaignTransaction('campaign:recordEvent', async transaction => {
+        const params = { profileId, campaignId, ...campaignTimeParams() };
+        // A profile lock prevents concurrent devices from creating duplicate state edges
+        // or losing shown increments, without locking the entire campaign audience.
+        const locked = await transaction.run(
+            `MATCH (p:Profile {profileId: $profileId})-[:IN_CAMPAIGN_AUDIENCE]->(c:Campaign {id: $campaignId})
+             WHERE ${liveCampaignPredicate} AND ${campaignAgePredicate}
+             SET p.campaignStateLock = coalesce(p.campaignStateLock, 0) + 1
+             RETURN p.profileId AS profileId`,
+            params
+        );
+        if (!locked.records.length) return false;
+        const result = await transaction.run(
+            `MATCH (p:Profile {profileId: $profileId})-[:IN_CAMPAIGN_AUDIENCE]->(c:Campaign {id: $campaignId})
+             WHERE ${liveCampaignPredicate} AND ${campaignAgePredicate}
+             MERGE (p)-[state:CAMPAIGN_STATE]->(c) SET ${assignments[event]}
+             RETURN state`,
+            params
+        );
+        return result.records.length > 0;
+    });
+};

package/src/accesslayer/campaign/update.ts

@@ -0,0 +1,50 @@
+import { TRPCError } from '@trpc/server';
+import {
+    CampaignValidator,
+    UpdateCampaignInputValidator,
+    type Campaign,
+    type UpdateCampaignInput,
+} from '@learncard/types';
+
+import {
+    assertCampaignEditable,
+    campaignProperties,
+    lockCampaign,
+    withCampaignTransaction,
+} from './shared';
+
+export const updateCampaign = async (input: UpdateCampaignInput): Promise<Campaign> => {
+    const { campaignId, updates } = UpdateCampaignInputValidator.parse(input);
+    return withCampaignTransaction('campaign:update', async transaction => {
+        const existing = await lockCampaign(transaction, campaignId);
+        assertCampaignEditable(existing);
+        const message = updates.message ?? existing.message;
+        const result = CampaignValidator.safeParse({
+            ...existing,
+            ...updates,
+            id: campaignId,
+            message: { ...message, id: campaignId },
+            notification:
+                updates.notification === null
+                    ? undefined
+                    : (updates.notification ?? existing.notification),
+            startsAt:
+                updates.startsAt === null ? undefined : (updates.startsAt ?? existing.startsAt),
+            endsAt: updates.endsAt === null ? undefined : (updates.endsAt ?? existing.endsAt),
+            updatedAt: new Date().toISOString(),
+        });
+        if (!result.success)
+            throw new TRPCError({ code: 'BAD_REQUEST', message: result.error.message });
+        if (existing.status !== 'draft' && result.data.status === 'draft') {
+            throw new TRPCError({
+                code: 'BAD_REQUEST',
+                message: `Campaign status cannot transition from ${existing.status} to draft`,
+            });
+        }
+        await transaction.run('MATCH (c:Campaign {id: $campaignId}) SET c += $properties', {
+            campaignId,
+            properties: campaignProperties(result.data),
+        });
+        return result.data;
+    });
+};

package/src/accesslayer/consentflowcontract/relationships/create.ts

@@ -21,7 +21,7 @@ import { BoostType } from 'types/boost';
 import { flattenObject, inflateObject } from '@helpers/objects.helpers';
 import { convertQueryResultToPropertiesObjectArray } from '@helpers/neo4j.helpers';
 import { reconsentTerms } from './update';
-import { getBoostUri, sendBoost } from '@helpers/boost.helpers';
+import { getBoostUri, sendBoost, stampIssuanceDate } from '@helpers/boost.helpers';
 import { setCredentialSubjectIds } from '@helpers/credentialSubject.helpers';
 import { getDidWeb } from '@helpers/did.helpers';
 import { getSigningAuthorityForUserByName } from '@accesslayer/signing-authority/relationships/read';
@@ -296,6 +296,8 @@ export const consentToContract = async (
 
                     boostCredential.issuer = { id: contractOwnerSigningAuthority.relationship.did };
 
+                    stampIssuanceDate(boostCredential);
+
                     if (boostCredential.type.includes('BoostCredential')) {
                         boostCredential.boostId = getBoostUri(boost.target.id, domain);
                     }

package/src/accesslayer/consentflowcontract/relationships/update.ts

@@ -15,7 +15,7 @@ import { ConsentFlowTerms, ConsentFlowTransaction, ConsentFlowContract } from '@
 import { neogma } from '@instance';
 import { flattenObject } from '@helpers/objects.helpers';
 import { DbContractType, DbTermsType } from 'types/consentflowcontract';
-import { getBoostUri, sendBoost } from '@helpers/boost.helpers';
+import { getBoostUri, sendBoost, stampIssuanceDate } from '@helpers/boost.helpers';
 import { setCredentialSubjectIds } from '@helpers/credentialSubject.helpers';
 import { getDidWeb } from '@helpers/did.helpers';
 import { getSigningAuthorityForUserByName } from '@accesslayer/signing-authority/relationships/read';
@@ -201,6 +201,8 @@ export const reconsentTerms = async (
                     // Set the issuer and subject
                     boostCredential.issuer = { id: contractOwnerSigningAuthority.relationship.did };
 
+                    stampIssuanceDate(boostCredential);
+
                     if (boostCredential.type.includes('BoostCredential')) {
                         boostCredential.boostId = getBoostUri(boost.dataValues.id, domain);
                     }
@@ -439,6 +441,8 @@ export const updateTerms = async (
                     // Set the issuer and subject
                     boostCredential.issuer = { id: contractOwnerSigningAuthority.relationship.did };
 
+                    stampIssuanceDate(boostCredential);
+
                     if (boostCredential.type.includes('BoostCredential')) {
                         boostCredential.boostId = getBoostUri(boost.target.id, domain);
                     }