@seeka-labs/cli-apps 3.7.0 → 3.8.2

package/dist/ai-context/internal/examples/v2/google-bigquery/app/server/src/functions/pushRowsToBigQueryTable.ts

@@ -0,0 +1,149 @@
+import winston from 'winston';
+
+import { app, InvocationContext } from '@azure/functions';
+
+import groupBy from 'lodash/groupBy';
+import { checkGoogleBigQueryDataSetAndTableExists, sendDataToGoogleBigQuery } from '../lib/google-big-query';
+import { SeekaActivityBigQueryRecord, SeekaIdentityChangedBigQueryRecord } from '../lib/google-big-query/models';
+import { isErrorDueToNoBillingOnProject } from '../lib/google-big-query/utils';
+import { deserialiseQueuePayload, queueNames, sendQueueMessageToPoisonQueue } from '../lib/jobs';
+import { backgroundJobLogger } from '../lib/logging';
+import type { PushRowsToBigQueryTableQueueItem } from '../lib/model';
+import { startServices } from '../lib/services';
+import { createOrUpdateInstallation, SeekaAppInstallState, tryGetInstallation } from '../lib/state/seeka/installations';
+
+app.storageQueue('pushRowsToBigQueryTable', {
+    queueName: queueNames.pushRowsToBigQueryTable,
+    connection: 'AzureWebJobsStorage',
+    handler: pushRowsToBigQueryTable,
+});
+
+export async function pushRowsToBigQueryTable(queueItem: any, context: InvocationContext): Promise<void> {
+    let logger = backgroundJobLogger(queueNames.pushRowsToBigQueryTable, undefined, context);
+    logger.profile(`queue.${queueNames.pushRowsToBigQueryTable}`)
+    try {
+        // queueItem can either be a single item or an array of items
+        const payload = deserialiseQueuePayload<PushRowsToBigQueryTableQueueItem>(queueItem, logger);
+
+        // Group by applicationInstallId
+        const grouped = groupBy(payload, e => e.applicationInstallId);
+
+        logger.verbose('Received queue batch to trigger push data to big query', { batchSize: payload.length });
+
+        // Process each group
+        await startServices(logger);
+
+        for (const [applicationInstallId, items] of Object.entries(grouped)) {
+            if (items.length === 0) {
+                logger.warn('No items to process for applicationInstallId', { applicationInstallId });
+                continue;
+            }
+            const thisLogger = backgroundJobLogger(queueNames.pushRowsToBigQueryTable, { ...items[0], rows: undefined } as any, context);
+            const oneDayAgo = new Date();
+            oneDayAgo.setDate(oneDayAgo.getDate() - 1);
+            try {
+                const installation = await tryGetInstallation(applicationInstallId, true, thisLogger) as SeekaAppInstallState;
+
+                // Check if need to maintain the schema
+                // This allows for new fields to be added to the Seeka activity and identity model 
+                // So the BigQuery schema can be kept up to date
+                if (!installation.installationState.bigQuerySchemaLastMaintainedAt || new Date(installation.installationState.bigQuerySchemaLastMaintainedAt) < oneDayAgo) {
+                    try {
+                        thisLogger.info("Schema not maintained in the last 24 hours, updating schema for periodical maintenance");
+
+                        const errorMessage = await checkGoogleBigQueryDataSetAndTableExists(thisLogger, installation.installationSettings);
+
+                        if (errorMessage) {
+                            thisLogger.error('Error maintaining BigQuery schema for periodical maintenance', { errorMessage });
+                        } else {
+                            await createOrUpdateInstallation({
+                                ...installation,
+                                installationState:
+                                {
+                                    ...installation.installationState,
+                                    bigQuerySchemaLastMaintainedAt: new Date().toISOString()
+                                }
+                            }, thisLogger);
+                        }
+                    }
+                    catch (ex) {
+                        thisLogger.error('Unexpected error maintaining BigQuery schema for periodical maintenance', { ex: winston.exceptions.getAllInfo(ex) });
+                    }
+                }
+
+                const flatRows: SeekaActivityBigQueryRecord[] | SeekaIdentityChangedBigQueryRecord[] = items.flatMap(e => e.rows || []).filter(Boolean)
+                const activityIds = flatRows.map((e: SeekaActivityBigQueryRecord) => e?.activity?.activityId).filter(Boolean)
+                activityIds.forEach(aId => {
+                    logger.verbose('Processing activity on BigQuery queue', { Activity_ActivityIdentifier: aId })
+                })
+
+                await sendDataToGoogleBigQuery(thisLogger, installation, flatRows);
+            }
+            catch (err) {
+                const ex = winston.exceptions.getAllInfo(err) as any;
+                if (ex.error && ex.error.code == "403") {
+                    if (isErrorDueToNoBillingOnProject(ex)) {
+                        thisLogger.warn('Streaming insert is not allowed in the free tier for big query', { ex })
+                    }
+                    else if (ex.error && ex.error.errors && ex.error.errors.length > 0 && ex.error.errors[0] && ex.error.errors[0].errors && ex.error.errors[0].errors.length > 0 &&
+                        ex.error.errors[0].errors[0] && ex.error.errors[0].errors[0].message &&
+                        (ex.error.errors[0].errors[0].message as string).toLowerCase().includes('no such field')
+                    ) {
+                        // Maintain schema
+                        thisLogger.warn('Big query schema is not up to date, maintaining', { ex })
+
+                        const installation = await tryGetInstallation(applicationInstallId, true, thisLogger) as SeekaAppInstallState;
+
+                        // Check if need to maintain the schema
+                        // This allows for new fields to be added to the Seeka activity and identity model 
+                        // So the BigQuery schema can be kept up to date
+                        const oneHourAgo = new Date();
+                        oneHourAgo.setHours(oneHourAgo.getHours() - 1);
+                        if (!installation.installationState.bigQuerySchemaLastMaintainedAt || new Date(installation.installationState.bigQuerySchemaLastMaintainedAt) < oneHourAgo) {
+                            try {
+                                thisLogger.info("Schema not maintained in the last 1 hour, updating schema for forced maintenance");
+                                await createOrUpdateInstallation({
+                                    ...installation,
+                                    installationState:
+                                    {
+                                        ...installation.installationState,
+                                        bigQuerySchemaLastMaintainedAt: new Date().toISOString()
+                                    }
+                                }, thisLogger);
+
+                                const errorMessage = await checkGoogleBigQueryDataSetAndTableExists(thisLogger, installation.installationSettings);
+
+                                if (errorMessage) {
+                                    thisLogger.error('Error maintaining BigQuery schema for forced maintenance', { errorMessage });
+                                }
+                            }
+                            catch (ex) {
+                                thisLogger.error('Unexpected error maintaining BigQuery schema for forced maintenance', { ex });
+                            }
+                        }
+                    }
+                    else {
+                        thisLogger.warn('Auth error handling queue item to trigger push data to big query', { ex })
+                    }
+                }
+                else {
+                    thisLogger.error('Error handling queue item to trigger push data to big query', { ex })
+                }
+
+                await sendQueueMessageToPoisonQueue(queueNames.pushRowsToBigQueryTable, {
+                    ...items[0],
+                    causationId: items[0].causationId,
+                    correlationId: context.invocationId,
+                    rows: items.flatMap(e => e.rows || []).filter(Boolean)
+                } as PushRowsToBigQueryTableQueueItem, ex, thisLogger);
+            }
+        }
+    }
+    catch (err) {
+        logger.error('Error handling queue item to trigger push data to big query', { ex: winston.exceptions.getAllInfo(err) })
+        throw err; // Will retry based on host.json > extensions.queues.maxDequeueCount and then push to poison queue
+    }
+    finally {
+        logger.profile(`queue.${queueNames.pushRowsToBigQueryTable}`)
+    }
+}

package/dist/ai-context/internal/examples/v2/google-bigquery/app/server/src/functions/seekaAppWebhook.ts

@@ -0,0 +1,219 @@
+import winston from 'winston';
+
+import { app, HttpRequest, HttpResponseInit, InvocationContext } from '@azure/functions';
+import {
+    SeekaActivityAcceptedWebhookPayload,
+    SeekaAppInstalledWebhookPayload,
+    SeekaAppInstallSettingsUpdatedWebhookPayload, SeekaAppUninstalledWebhookPayload,
+    SeekaIdentityChangedWebhookPayload, SeekaWebhookCallType, SeekaWebhookPayload,
+    throwOnInvalidWebhookSignature
+} from '@seeka-labs/sdk-apps-server';
+import { checkGoogleBigQueryDataSetAndTableExists } from '../lib/google-big-query/index';
+
+import { webhookLogger } from '../lib/logging';
+import { startServices } from '../lib/services';
+import {
+    createOrUpdateInstallation, deleteInstallation, SeekaAppInstallState, tryGetInstallation
+} from '../lib/state/seeka/installations';
+
+import type { Logger } from 'winston';
+import { sanitiseBigQueryRecord } from '../lib/google-big-query/schema';
+import { activityPayloadFieldsToJsonStringify, activityPayloadFieldsToRemove } from '../lib/google-big-query/schema/activities';
+import { queueNames, triggerBackgroundJob } from '../lib/jobs';
+import type { PushRowsToBigQueryTableQueueItem } from '../lib/model';
+
+app.http('seekaAppWebhook', {
+    methods: ['POST'],
+    authLevel: 'anonymous',
+    route: 'webhook/seeka/app',
+    handler: seekaAppWebhook
+});
+
+export async function seekaAppWebhook(req: HttpRequest, context: InvocationContext): Promise<HttpResponseInit> {
+    const bodyStr = (await req.text()) as string;
+    if (!bodyStr) {
+        return {
+            status: 400,
+            jsonBody: { error: "Body missing. Ensure body is present and either specify the Content-Length request header OR set Transfer-Encoding request header to 'chunked'" }
+        }
+    }
+    const body = JSON.parse(bodyStr) as SeekaWebhookPayload;
+
+    const logger = webhookLogger(body, context);
+    logger.profile('http.seeka.webhook.app')
+    logger.verbose('Received webhook from Seeka', { body });
+
+    // Handle probe
+    if (body.type === SeekaWebhookCallType.Probe) {
+        return {
+            status: 204
+        }
+    }
+
+    // Validate webhook
+    try {
+        throwOnInvalidWebhookSignature(process.env.SEEKA_APP_SECRET as string, req.headers, bodyStr);
+        logger.debug('Webhook signature validated', { body });
+    }
+    catch {
+        logger.warn('Webhook signature invalid', { body });
+        if (process.env.DISABLE_WEBHOOK_SIGNATURE_VALIDATION !== "true") {
+            return {
+                status: 401,
+                jsonBody: { error: "Webhook call invalaid" }
+            }
+        }
+    }
+
+    if (body.isTest && body.type !== SeekaWebhookCallType.ActivityAccepted && body.type !== SeekaWebhookCallType.IdentityChanged) {
+        // This is a test webhook call
+        return {
+            status: 204
+        }
+    }
+
+    await startServices(logger);
+
+    // Check if the webhook is for an app we have installed
+    let installation: SeekaAppInstallState | null = null;
+    if (body.type != SeekaWebhookCallType.AppInstalled) {
+        installation = await tryGetInstallation((body as SeekaAppInstalledWebhookPayload).context?.applicationInstallId as string, false, logger);
+        if (installation == null) {
+            logger.warn('Webhook call cannot be processed as the installation ID is not known by this app', { body });
+
+            return {
+                status: 422,
+                jsonBody: { error: "App not installed" }
+            }
+        }
+    }
+
+    let errorMessage: string | undefined;
+    try {
+        switch (body.type) {
+            case SeekaWebhookCallType.AppInstalled:
+                {
+                    const webhookBody = body as SeekaAppInstalledWebhookPayload;
+                    errorMessage = await checkGoogleBigQueryDataSetAndTableExists(logger, webhookBody.content.installationSettings);
+                    if (!errorMessage) installation = await onInstallation(webhookBody, logger);
+                    break;
+                }
+            case SeekaWebhookCallType.AppInstallSettingsUpdated:
+                {
+                    const webhookBody = body as SeekaAppInstallSettingsUpdatedWebhookPayload;
+                    errorMessage = await checkGoogleBigQueryDataSetAndTableExists(logger, webhookBody.content.installationSettings);
+                    if (!errorMessage) installation = await onInstallationSettingsUpdate(webhookBody, logger);
+
+                    break;
+                }
+            case SeekaWebhookCallType.AppUninstalled:
+                {
+                    if (!body.isTest) {
+                        const payload = body as SeekaAppUninstalledWebhookPayload;
+                        await deleteInstallation(payload.context?.applicationInstallId as string, logger)
+                    }
+                    break;
+                }
+            case SeekaWebhookCallType.ActivityAccepted:
+                {
+                    const payload = body as SeekaActivityAcceptedWebhookPayload;
+                    // await sendSeekaActivityToGoogleBigQuery(logger, installation, payload);
+
+                    // push to a queue and pushRowsToBigQueryTable handler will send to bigquery
+
+                    logger.verbose('Pushing activity to BigQuery queue', { Activity_ActivityIdentifier: payload.content.activity.activityId })
+
+                    await triggerBackgroundJob(queueNames.pushRowsToBigQueryTable, {
+                        ...payload.context,
+                        causationId: payload.causationId,
+                        correlationId: payload.requestId,
+                        rows: [sanitiseBigQueryRecord(payload.content, activityPayloadFieldsToRemove, activityPayloadFieldsToJsonStringify, logger)]
+                    } as PushRowsToBigQueryTableQueueItem, logger)
+
+                    // start testing
+                    // const shouldTest = payload.content.activity?.activityId?.indexOf('testtyy')
+                    // if (shouldTest === -1 || shouldTest === undefined || shouldTest === null) {
+                    //     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: 'testy', version: '1.0.0' }, installation.installationState.grantedPermissions, logger);
+                    //     const newPayload: ActivityPayload = {
+                    //         activityName: TrackingActivityNames.Lead,
+                    //         activityId: `testtyy-` + new Date().getTime(),
+                    //         properties: {
+                    //             testy: '1'
+                    //         }
+                    //     }
+                    //     logger.info('Tracking activity for enrollment form', { payload })
+
+                    //     await helper.api.trackActivityForProfileId(newPayload, undefined, {
+                    //         origin: TrackingEventSourceOriginType.Server,
+                    //         // loc: sourceUrl || undefined
+                    //     })
+                    // }
+                    // end testing
+
+                    break;
+                }
+            case SeekaWebhookCallType.IdentityChanged:
+                {
+                    const payload = body as SeekaIdentityChangedWebhookPayload;
+                    break;
+                }
+        }
+    }
+    catch (err) {
+        logger.error('Failed to handle webhook', { ex: winston.exceptions.getAllInfo(err) });
+        return {
+            status: 500,
+            jsonBody: { error: "Request failed" }
+        }
+    }
+    finally {
+        logger.profile('http.seeka.webhook.app')
+        logger.verbose('Seeka webhook handled');
+    }
+
+    if (errorMessage) {
+        logger.warn('Failed to handle webhook', { errorMessage });
+        return {
+            status: 400,
+            jsonBody: { error: { message: errorMessage } }
+        }
+    }
+
+    return {
+        status: 204
+    }
+}
+
+const onInstallation = async (payload: SeekaAppInstalledWebhookPayload, logger: Logger): Promise<SeekaAppInstallState> => {
+    if (payload.isTest) return;
+
+    return await createOrUpdateInstallation({
+        ...payload.context,
+        installationState: {
+            grantedPermissions: payload.content?.grantedPermissions || []
+        },
+        applicationInstallId: payload.context?.applicationInstallId as string,
+        organisationBrandId: payload.context?.organisationBrandId as string,
+        organisationId: payload.context?.organisationId as string,
+        installedAt: new Date().toISOString(),
+        installationSettings: payload.content?.installationSettings || {}
+    }, logger)
+}
+
+const onInstallationSettingsUpdate = async (payload: SeekaAppInstallSettingsUpdatedWebhookPayload, logger: Logger): Promise<SeekaAppInstallState> => {
+    if (payload.isTest) return;
+
+    const existingInstallation = await tryGetInstallation(payload.context?.applicationInstallId as string, true, logger) as SeekaAppInstallState;
+    return await createOrUpdateInstallation({
+        ...existingInstallation,
+        installationState: {
+            ...existingInstallation.installationState,
+            grantedPermissions: payload.content?.grantedPermissions || []
+        },
+        installationSettings: payload.content?.installationSettings || {},
+    }, logger)
+}

package/dist/ai-context/internal/examples/v2/google-bigquery/app/server/src/lib/google-big-query/index.ts

@@ -0,0 +1,162 @@
+import { BigQuery } from '@google-cloud/bigquery';
+import { SeekaActivityAcceptedWebhookPayload } from '@seeka-labs/sdk-apps-server';
+import { Logger } from 'winston';
+import { GoogleBigqueryAppInstallSettings, SeekaAppInstallState } from '../../lib/state/seeka/installations';
+import { applyMigrations } from './migrations';
+import { SeekaActivityBigQueryRecord, SeekaIdentityChangedBigQueryRecord } from './models';
+import { getBigQueryActivityTableSchema } from './schema/activities';
+
+export const checkGoogleBigQueryDataSetAndTableExists = async (logger: Logger, installationSettings: GoogleBigqueryAppInstallSettings): Promise<string> => {
+    // Create a client instance
+    const bigquery = new BigQuery({
+        projectId: installationSettings.googleProjectId,
+        credentials: JSON.parse(installationSettings.googleServiceAccountJson)
+
+    });
+
+    // Check dataset exists
+    let dataSetExists = false;
+    try {
+        logger.verbose('Checking if dataset ' + installationSettings.bigQueryActivityDatasetId + ' exists in BigQuery');
+
+        // https://github.com/googleapis/nodejs-bigquery/blob/main/samples/listDatasets.js
+        const dataset = await bigquery.dataset(installationSettings.bigQueryActivityDatasetId);
+        const [exists] = await dataset.exists();
+        if (!exists) {
+            logger.verbose('Dataset ' + installationSettings.bigQueryActivityDatasetId + ' does not exist');
+        }
+        else {
+            dataSetExists = true;
+            logger.verbose('Dataset ' + installationSettings.bigQueryActivityDatasetId + ' exists');
+        }
+    }
+    catch (e) {
+        logger.error('There was an error checking if dataset ' + installationSettings.bigQueryActivityDatasetId + ' exists in BigQuery. Error: ' + (e as Error).message);
+        return 'Failed to check dataset existence';
+    }
+
+    // Create dataset if not exists
+    if (!dataSetExists) {
+        try {
+            logger.verbose('Creating dataset ' + installationSettings.bigQueryActivityDatasetId + ' in BigQuery');
+
+            // https://github.com/googleapis/nodejs-bigquery/blob/main/samples/createDataset.js
+            await bigquery.createDataset(installationSettings.bigQueryActivityDatasetId);
+            logger.verbose('Dataset ' + installationSettings.bigQueryActivityDatasetId + ' created succesfully');
+        }
+        catch (e) {
+            logger.error('There was an error creating dataset in ' + installationSettings.bigQueryActivityDatasetId + ' in BigQuery. Error: ' + (e as Error).message);
+            return 'Failed to create dataset';
+        }
+    }
+
+    // Check table exists
+    let isNewTable = false;
+    try {
+        logger.verbose('Checking if table ' + installationSettings.bigQueryActivityTableName + ' exists in BigQuery');
+
+        // https://github.com/googleapis/nodejs-bigquery/blob/main/samples/getDataset.js
+        const dataset = await bigquery.dataset(installationSettings.bigQueryActivityDatasetId);
+        if (dataset == null) {
+            logger.error('Could not get dataset ' + installationSettings.bigQueryActivityDatasetId + ' while checking if table ' + installationSettings.bigQueryActivityTableName + ' exists');
+            return 'Failed to get dataset';
+        }
+        else {
+            const table = await dataset.table(installationSettings.bigQueryActivityTableName)
+            try {
+                const [exists] = await table.exists();
+                if (exists) {
+                    logger.verbose('Table ' + installationSettings.bigQueryActivityTableName + ' exists');
+                }
+                else {
+                    logger.verbose('Table ' + installationSettings.bigQueryActivityTableName + ' does not exist');
+                    logger.verbose('Creating table ' + installationSettings.bigQueryActivityTableName);
+                    await table.create(installationSettings.bigQueryActivityTableName);
+                    isNewTable = true;
+                    logger.verbose('Table ' + installationSettings.bigQueryActivityTableName + ' succesfully created');
+                }
+            } catch (e) {
+                logger.error('There was an error checking if table ' + installationSettings.bigQueryActivityTableName + ' exists in BigQuery. Error: ' + (e as Error).message);
+                return 'Failed to check dataset existence';
+            }
+        }
+    }
+    catch (e) {
+        logger.error('There was an error checking if table ' + installationSettings.bigQueryActivityTableName + ' exists in BigQuery. Error: ' + (e as Error).message);
+        return 'Failed to check dataset existence';
+    }
+
+    // Maintain activity schema
+    const errorMessage = await maintainBigQueryActivityTableSchema(logger, installationSettings, isNewTable);
+    if (errorMessage) return errorMessage;
+
+    return null;
+}
+
+const maintainBigQueryActivityTableSchema = async (logger: Logger, installationSettings: GoogleBigqueryAppInstallSettings, isNewTable: boolean): Promise<string | null> => {
+    const schema = await getBigQueryActivityTableSchema(logger);
+    if (schema == null) {
+        return 'Failed to generate schema for activity table';
+    }
+
+    const bigquery = createBigQueryClient(installationSettings);
+    let table = bigquery.dataset(installationSettings.bigQueryActivityDatasetId).table(installationSettings.bigQueryActivityTableName);
+    const [exists] = await table.exists()
+
+    if (!exists) {
+        logger.verbose('Creating table as doesnt exist')
+        await table.create();
+    }
+
+    const [metadata] = await table.getMetadata();
+
+    const [result] = await table.setMetadata({
+        ...metadata,
+        schema: schema
+    });
+    if (result === null) return 'Error maintaining table schema';
+
+    const migrationResult = await applyMigrations('activities', logger, installationSettings, isNewTable);
+    if (!migrationResult.success) {
+        if (!migrationResult.isErrorDueToNoBillingOnProject) {
+            return migrationResult.errors?.join(", ") || "Migrations failed"
+        }
+        else return null
+    }
+
+    logger.verbose('Table schema maintained');
+
+    return null;
+}
+
+export const sendSeekaActivityToGoogleBigQuery = async (logger: Logger, installation: SeekaAppInstallState, payload: SeekaActivityAcceptedWebhookPayload) => {
+    if (!payload.content) {
+        logger.error("Content is empty");
+        return
+    }
+
+    await sendDataToGoogleBigQuery(logger, installation, [payload.content])
+};
+
+export const sendDataToGoogleBigQuery = async (logger: Logger, installation: SeekaAppInstallState, rows: SeekaActivityBigQueryRecord[] | SeekaIdentityChangedBigQueryRecord[]) => {
+    // Create a client instance
+    const bigquery = createBigQueryClient(installation.installationSettings);
+
+    // Assumption is dataset and table exist, as they'be been valdiated on appInstallation
+    // Insert data into a table
+
+    // const schema = await getBigQueryActivityTableSchema(logger); // TODO: Is this needed to insert into table?
+
+    logger.verbose('Inserting rows into BigQuery', { rowCount: rows.length, dataset: installation.installationSettings.bigQueryActivityDatasetId, table: installation.installationSettings.bigQueryActivityTableName });
+
+    // await bigquery.dataset(installation.installationSettings.bigQueryActivityDatasetId).table(installation.installationSettings.bigQueryActivityTableName).insert(rows, { schema: schema });
+    await bigquery.dataset(installation.installationSettings.bigQueryActivityDatasetId).table(installation.installationSettings.bigQueryActivityTableName).insert(rows);
+    //console.log(`Inserted ${rows.} rows`);
+};
+
+const createBigQueryClient = (installationSettings: GoogleBigqueryAppInstallSettings): BigQuery => {
+    return new BigQuery({
+        projectId: installationSettings.googleProjectId,
+        credentials: JSON.parse(installationSettings.googleServiceAccountJson)
+    });
+}

package/dist/ai-context/internal/examples/v2/google-bigquery/app/server/src/lib/google-big-query/migrations/activities/001_addtimestamp.sql

@@ -0,0 +1,14 @@
+ALTER TABLE `${PROJECT_ID}.${DATASET_ID}.${TABLE_NAME}`
+ADD COLUMN `timestamp` TIMESTAMP;
+
+ALTER TABLE `${PROJECT_ID}.${DATASET_ID}.${TABLE_NAME}`
+ALTER COLUMN `timestamp`
+SET
+    DEFAULT CURRENT_TIMESTAMP();
+
+UPDATE `${PROJECT_ID}.${DATASET_ID}.${TABLE_NAME}`
+SET
+    timestamp = CURRENT_TIMESTAMP()
+where
+    timestamp IS NULL
+    AND activity.time < TIMESTAMP_SUB(CURRENT_TIMESTAMP(), INTERVAL 480 MINUTE)

package/dist/ai-context/internal/examples/v2/google-bigquery/app/server/src/lib/google-big-query/migrations/activities/002_addrowversion.sql

@@ -0,0 +1,14 @@
+ALTER TABLE `${PROJECT_ID}.${DATASET_ID}.${TABLE_NAME}`
+ADD COLUMN `rowVersion` INT64;
+
+ALTER TABLE `${PROJECT_ID}.${DATASET_ID}.${TABLE_NAME}`
+ALTER COLUMN `rowVersion`
+SET
+    DEFAULT 1;
+
+UPDATE `${PROJECT_ID}.${DATASET_ID}.${TABLE_NAME}`
+SET
+    rowVersion = 1
+where
+    rowVersion IS NULL
+    AND activity.time < TIMESTAMP_SUB(CURRENT_TIMESTAMP(), INTERVAL 480 MINUTE);