@seeka-labs/cli-apps 3.8.7 → 3.8.10

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

@@ -1,149 +0,0 @@
-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

@@ -1,219 +0,0 @@
-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

@@ -1,162 +0,0 @@
-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

@@ -1,14 +0,0 @@
-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

@@ -1,14 +0,0 @@
-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);