d803bfe2b1
git-subtree-dir: vendor/ruvector git-subtree-split: b64c21726f2bb37286d9ee36a7869fef60cc6900
569 lines
17 KiB
TypeScript
569 lines
17 KiB
TypeScript
/**
|
|
* Ad Campaign Performance Data Generation
|
|
*
|
|
* Generates realistic ad campaign data including:
|
|
* - Campaign metrics (impressions, clicks, conversions, spend)
|
|
* - Multi-channel attribution data
|
|
* - Customer journey tracking
|
|
* - A/B test results
|
|
* - Cohort analysis data
|
|
*/
|
|
|
|
import { AgenticSynth, createSynth } from '../../src/index.js';
|
|
|
|
// Example 1: Google Ads campaign metrics
|
|
async function generateGoogleAdsCampaign() {
|
|
const synth = createSynth({
|
|
provider: 'gemini',
|
|
apiKey: process.env.GEMINI_API_KEY
|
|
});
|
|
|
|
const campaignSchema = {
|
|
campaignId: { type: 'string', required: true },
|
|
campaignName: { type: 'string', required: true },
|
|
date: { type: 'string', required: true },
|
|
platform: { type: 'string', required: true },
|
|
adGroup: { type: 'string', required: true },
|
|
keyword: { type: 'string', required: true },
|
|
impressions: { type: 'number', required: true },
|
|
clicks: { type: 'number', required: true },
|
|
conversions: { type: 'number', required: true },
|
|
cost: { type: 'number', required: true },
|
|
revenue: { type: 'number', required: true },
|
|
ctr: { type: 'number', required: true },
|
|
cpc: { type: 'number', required: true },
|
|
cpa: { type: 'number', required: true },
|
|
roas: { type: 'number', required: true },
|
|
qualityScore: { type: 'number', required: true },
|
|
avgPosition: { type: 'number', required: true }
|
|
};
|
|
|
|
const result = await synth.generateStructured({
|
|
count: 100,
|
|
schema: campaignSchema,
|
|
constraints: {
|
|
platform: 'Google Ads',
|
|
impressions: { min: 1000, max: 100000 },
|
|
ctr: { min: 0.01, max: 0.15 },
|
|
cpc: { min: 0.50, max: 10.00 },
|
|
roas: { min: 0.5, max: 8.0 },
|
|
qualityScore: { min: 1, max: 10 },
|
|
avgPosition: { min: 1.0, max: 5.0 }
|
|
},
|
|
format: 'json'
|
|
});
|
|
|
|
console.log('Google Ads Campaign Data:');
|
|
console.log(result.data.slice(0, 3));
|
|
console.log('Metadata:', result.metadata);
|
|
|
|
return result;
|
|
}
|
|
|
|
// Example 2: Facebook/Meta Ads campaign performance
|
|
async function generateFacebookAdsCampaign() {
|
|
const synth = createSynth({
|
|
provider: 'gemini'
|
|
});
|
|
|
|
const facebookSchema = {
|
|
adSetId: { type: 'string', required: true },
|
|
adSetName: { type: 'string', required: true },
|
|
adId: { type: 'string', required: true },
|
|
adName: { type: 'string', required: true },
|
|
date: { type: 'string', required: true },
|
|
platform: { type: 'string', required: true },
|
|
objective: { type: 'string', required: true },
|
|
impressions: { type: 'number', required: true },
|
|
reach: { type: 'number', required: true },
|
|
frequency: { type: 'number', required: true },
|
|
clicks: { type: 'number', required: true },
|
|
linkClicks: { type: 'number', required: true },
|
|
ctr: { type: 'number', required: true },
|
|
spend: { type: 'number', required: true },
|
|
purchases: { type: 'number', required: true },
|
|
revenue: { type: 'number', required: true },
|
|
cpc: { type: 'number', required: true },
|
|
cpm: { type: 'number', required: true },
|
|
costPerPurchase: { type: 'number', required: true },
|
|
roas: { type: 'number', required: true },
|
|
addToCarts: { type: 'number', required: true },
|
|
initiateCheckout: { type: 'number', required: true },
|
|
relevanceScore: { type: 'number', required: true }
|
|
};
|
|
|
|
const result = await synth.generateStructured({
|
|
count: 150,
|
|
schema: facebookSchema,
|
|
constraints: {
|
|
platform: 'Facebook Ads',
|
|
objective: ['conversions', 'traffic', 'brand_awareness', 'video_views'],
|
|
impressions: { min: 5000, max: 500000 },
|
|
frequency: { min: 1.0, max: 5.0 },
|
|
cpm: { min: 5.00, max: 50.00 },
|
|
roas: { min: 0.8, max: 6.0 },
|
|
relevanceScore: { min: 1, max: 10 }
|
|
}
|
|
});
|
|
|
|
console.log('Facebook Ads Campaign Data:');
|
|
console.log(result.data.slice(0, 3));
|
|
|
|
return result;
|
|
}
|
|
|
|
// Example 3: TikTok Ads campaign performance
|
|
async function generateTikTokAdsCampaign() {
|
|
const synth = createSynth({
|
|
provider: 'gemini'
|
|
});
|
|
|
|
const tiktokSchema = {
|
|
campaignId: { type: 'string', required: true },
|
|
campaignName: { type: 'string', required: true },
|
|
adGroupId: { type: 'string', required: true },
|
|
adId: { type: 'string', required: true },
|
|
date: { type: 'string', required: true },
|
|
platform: { type: 'string', required: true },
|
|
objective: { type: 'string', required: true },
|
|
impressions: { type: 'number', required: true },
|
|
clicks: { type: 'number', required: true },
|
|
spend: { type: 'number', required: true },
|
|
conversions: { type: 'number', required: true },
|
|
revenue: { type: 'number', required: true },
|
|
videoViews: { type: 'number', required: true },
|
|
videoWatchTime: { type: 'number', required: true },
|
|
videoCompletionRate: { type: 'number', required: true },
|
|
engagement: { type: 'number', required: true },
|
|
shares: { type: 'number', required: true },
|
|
comments: { type: 'number', required: true },
|
|
likes: { type: 'number', required: true },
|
|
follows: { type: 'number', required: true },
|
|
ctr: { type: 'number', required: true },
|
|
cpc: { type: 'number', required: true },
|
|
cpm: { type: 'number', required: true },
|
|
cpa: { type: 'number', required: true },
|
|
roas: { type: 'number', required: true }
|
|
};
|
|
|
|
const result = await synth.generateStructured({
|
|
count: 120,
|
|
schema: tiktokSchema,
|
|
constraints: {
|
|
platform: 'TikTok Ads',
|
|
objective: ['app_promotion', 'conversions', 'traffic', 'video_views'],
|
|
impressions: { min: 10000, max: 1000000 },
|
|
videoCompletionRate: { min: 0.1, max: 0.8 },
|
|
cpm: { min: 3.00, max: 30.00 },
|
|
roas: { min: 0.6, max: 7.0 }
|
|
}
|
|
});
|
|
|
|
console.log('TikTok Ads Campaign Data:');
|
|
console.log(result.data.slice(0, 3));
|
|
|
|
return result;
|
|
}
|
|
|
|
// Example 4: Multi-channel attribution data
|
|
async function generateAttributionData() {
|
|
const synth = createSynth({
|
|
provider: 'gemini'
|
|
});
|
|
|
|
const attributionSchema = {
|
|
userId: { type: 'string', required: true },
|
|
conversionId: { type: 'string', required: true },
|
|
conversionDate: { type: 'string', required: true },
|
|
conversionValue: { type: 'number', required: true },
|
|
touchpoints: {
|
|
type: 'array',
|
|
required: true,
|
|
items: {
|
|
type: 'object',
|
|
properties: {
|
|
channel: { type: 'string' },
|
|
campaign: { type: 'string' },
|
|
timestamp: { type: 'string' },
|
|
touchpointPosition: { type: 'number' },
|
|
attributionWeight: { type: 'number' }
|
|
}
|
|
}
|
|
},
|
|
attributionModel: { type: 'string', required: true },
|
|
firstTouch: {
|
|
type: 'object',
|
|
properties: {
|
|
channel: { type: 'string' },
|
|
value: { type: 'number' }
|
|
}
|
|
},
|
|
lastTouch: {
|
|
type: 'object',
|
|
properties: {
|
|
channel: { type: 'string' },
|
|
value: { type: 'number' }
|
|
}
|
|
},
|
|
linearAttribution: { type: 'object', required: false },
|
|
timeDecayAttribution: { type: 'object', required: false },
|
|
positionBasedAttribution: { type: 'object', required: false }
|
|
};
|
|
|
|
const result = await synth.generateStructured({
|
|
count: 80,
|
|
schema: attributionSchema,
|
|
constraints: {
|
|
attributionModel: ['first_touch', 'last_touch', 'linear', 'time_decay', 'position_based'],
|
|
touchpoints: { minLength: 2, maxLength: 8 },
|
|
conversionValue: { min: 10, max: 5000 }
|
|
}
|
|
});
|
|
|
|
console.log('Multi-Channel Attribution Data:');
|
|
console.log(result.data.slice(0, 2));
|
|
|
|
return result;
|
|
}
|
|
|
|
// Example 5: Customer journey tracking
|
|
async function generateCustomerJourneys() {
|
|
const synth = createSynth({
|
|
provider: 'gemini'
|
|
});
|
|
|
|
const journeySchema = {
|
|
journeyId: { type: 'string', required: true },
|
|
userId: { type: 'string', required: true },
|
|
startDate: { type: 'string', required: true },
|
|
endDate: { type: 'string', required: true },
|
|
journeyLength: { type: 'number', required: true },
|
|
touchpointCount: { type: 'number', required: true },
|
|
events: {
|
|
type: 'array',
|
|
required: true,
|
|
items: {
|
|
type: 'object',
|
|
properties: {
|
|
timestamp: { type: 'string' },
|
|
eventType: { type: 'string' },
|
|
channel: { type: 'string' },
|
|
campaign: { type: 'string' },
|
|
device: { type: 'string' },
|
|
location: { type: 'string' },
|
|
pageUrl: { type: 'string' },
|
|
duration: { type: 'number' }
|
|
}
|
|
}
|
|
},
|
|
converted: { type: 'boolean', required: true },
|
|
conversionValue: { type: 'number', required: false },
|
|
conversionType: { type: 'string', required: false },
|
|
totalAdSpend: { type: 'number', required: true },
|
|
roi: { type: 'number', required: false }
|
|
};
|
|
|
|
const result = await synth.generateStructured({
|
|
count: 60,
|
|
schema: journeySchema,
|
|
constraints: {
|
|
journeyLength: { min: 1, max: 30 },
|
|
touchpointCount: { min: 1, max: 15 },
|
|
channel: ['google_ads', 'facebook_ads', 'tiktok_ads', 'email', 'organic_search', 'direct'],
|
|
device: ['mobile', 'desktop', 'tablet'],
|
|
conversionType: ['purchase', 'signup', 'download', 'lead']
|
|
}
|
|
});
|
|
|
|
console.log('Customer Journey Data:');
|
|
console.log(result.data.slice(0, 2));
|
|
|
|
return result;
|
|
}
|
|
|
|
// Example 6: A/B test results
|
|
async function generateABTestResults() {
|
|
const synth = createSynth({
|
|
provider: 'gemini'
|
|
});
|
|
|
|
const abTestSchema = {
|
|
testId: { type: 'string', required: true },
|
|
testName: { type: 'string', required: true },
|
|
startDate: { type: 'string', required: true },
|
|
endDate: { type: 'string', required: true },
|
|
platform: { type: 'string', required: true },
|
|
testType: { type: 'string', required: true },
|
|
variants: {
|
|
type: 'array',
|
|
required: true,
|
|
items: {
|
|
type: 'object',
|
|
properties: {
|
|
variantId: { type: 'string' },
|
|
variantName: { type: 'string' },
|
|
trafficAllocation: { type: 'number' },
|
|
impressions: { type: 'number' },
|
|
clicks: { type: 'number' },
|
|
conversions: { type: 'number' },
|
|
spend: { type: 'number' },
|
|
revenue: { type: 'number' },
|
|
ctr: { type: 'number' },
|
|
cvr: { type: 'number' },
|
|
cpa: { type: 'number' },
|
|
roas: { type: 'number' }
|
|
}
|
|
}
|
|
},
|
|
winner: { type: 'string', required: false },
|
|
confidenceLevel: { type: 'number', required: true },
|
|
statistically_significant: { type: 'boolean', required: true },
|
|
liftPercent: { type: 'number', required: false }
|
|
};
|
|
|
|
const result = await synth.generateStructured({
|
|
count: 40,
|
|
schema: abTestSchema,
|
|
constraints: {
|
|
platform: ['Google Ads', 'Facebook Ads', 'TikTok Ads'],
|
|
testType: ['creative', 'audience', 'bidding', 'landing_page', 'headline', 'cta'],
|
|
variants: { minLength: 2, maxLength: 4 },
|
|
confidenceLevel: { min: 0.5, max: 0.99 }
|
|
}
|
|
});
|
|
|
|
console.log('A/B Test Results:');
|
|
console.log(result.data.slice(0, 2));
|
|
|
|
return result;
|
|
}
|
|
|
|
// Example 7: Cohort analysis data
|
|
async function generateCohortAnalysis() {
|
|
const synth = createSynth({
|
|
provider: 'gemini'
|
|
});
|
|
|
|
const cohortSchema = {
|
|
cohortId: { type: 'string', required: true },
|
|
cohortName: { type: 'string', required: true },
|
|
acquisitionDate: { type: 'string', required: true },
|
|
channel: { type: 'string', required: true },
|
|
campaign: { type: 'string', required: true },
|
|
initialUsers: { type: 'number', required: true },
|
|
retentionData: {
|
|
type: 'array',
|
|
required: true,
|
|
items: {
|
|
type: 'object',
|
|
properties: {
|
|
period: { type: 'number' },
|
|
activeUsers: { type: 'number' },
|
|
retentionRate: { type: 'number' },
|
|
revenue: { type: 'number' },
|
|
avgOrderValue: { type: 'number' },
|
|
purchaseFrequency: { type: 'number' }
|
|
}
|
|
}
|
|
},
|
|
totalSpend: { type: 'number', required: true },
|
|
totalRevenue: { type: 'number', required: true },
|
|
ltv: { type: 'number', required: true },
|
|
cac: { type: 'number', required: true },
|
|
ltvCacRatio: { type: 'number', required: true },
|
|
paybackPeriod: { type: 'number', required: true }
|
|
};
|
|
|
|
const result = await synth.generateStructured({
|
|
count: 30,
|
|
schema: cohortSchema,
|
|
constraints: {
|
|
channel: ['google_ads', 'facebook_ads', 'tiktok_ads', 'email', 'organic'],
|
|
initialUsers: { min: 100, max: 10000 },
|
|
retentionData: { minLength: 6, maxLength: 12 },
|
|
ltvCacRatio: { min: 0.5, max: 10.0 },
|
|
paybackPeriod: { min: 1, max: 24 }
|
|
}
|
|
});
|
|
|
|
console.log('Cohort Analysis Data:');
|
|
console.log(result.data.slice(0, 2));
|
|
|
|
return result;
|
|
}
|
|
|
|
// Example 8: Time-series campaign performance
|
|
async function generateTimeSeriesCampaignData() {
|
|
const synth = createSynth({
|
|
provider: 'gemini'
|
|
});
|
|
|
|
const result = await synth.generateTimeSeries({
|
|
count: 90,
|
|
startDate: new Date(Date.now() - 90 * 24 * 60 * 60 * 1000),
|
|
endDate: new Date(),
|
|
interval: '1d',
|
|
metrics: [
|
|
'impressions',
|
|
'clicks',
|
|
'conversions',
|
|
'spend',
|
|
'revenue',
|
|
'roas',
|
|
'ctr',
|
|
'cvr'
|
|
],
|
|
trend: 'up',
|
|
seasonality: true,
|
|
noise: 0.15,
|
|
constraints: {
|
|
impressions: { min: 10000, max: 100000 },
|
|
clicks: { min: 100, max: 5000 },
|
|
conversions: { min: 10, max: 500 },
|
|
spend: { min: 100, max: 5000 },
|
|
revenue: { min: 0, max: 25000 },
|
|
roas: { min: 0.5, max: 8.0 },
|
|
ctr: { min: 0.01, max: 0.1 },
|
|
cvr: { min: 0.01, max: 0.15 }
|
|
}
|
|
});
|
|
|
|
console.log('Time-Series Campaign Data:');
|
|
console.log(result.data.slice(0, 7));
|
|
console.log('Metadata:', result.metadata);
|
|
|
|
return result;
|
|
}
|
|
|
|
// Example 9: Streaming real-time campaign data
|
|
async function streamCampaignData() {
|
|
const synth = createSynth({
|
|
provider: 'gemini',
|
|
streaming: true
|
|
});
|
|
|
|
console.log('Streaming campaign data:');
|
|
|
|
let count = 0;
|
|
for await (const dataPoint of synth.generateStream('structured', {
|
|
count: 20,
|
|
schema: {
|
|
timestamp: { type: 'string', required: true },
|
|
campaignId: { type: 'string', required: true },
|
|
impressions: { type: 'number', required: true },
|
|
clicks: { type: 'number', required: true },
|
|
conversions: { type: 'number', required: true },
|
|
spend: { type: 'number', required: true },
|
|
revenue: { type: 'number', required: true },
|
|
roas: { type: 'number', required: true }
|
|
}
|
|
})) {
|
|
count++;
|
|
console.log(`[${count}] Received:`, dataPoint);
|
|
}
|
|
}
|
|
|
|
// Example 10: Batch generation for multiple platforms
|
|
async function generateMultiPlatformBatch() {
|
|
const synth = createSynth({
|
|
provider: 'gemini'
|
|
});
|
|
|
|
const platformConfigs = [
|
|
{
|
|
count: 50,
|
|
schema: {
|
|
platform: { type: 'string' },
|
|
impressions: { type: 'number' },
|
|
clicks: { type: 'number' },
|
|
spend: { type: 'number' },
|
|
revenue: { type: 'number' },
|
|
roas: { type: 'number' }
|
|
},
|
|
constraints: { platform: 'Google Ads' }
|
|
},
|
|
{
|
|
count: 50,
|
|
schema: {
|
|
platform: { type: 'string' },
|
|
impressions: { type: 'number' },
|
|
clicks: { type: 'number' },
|
|
spend: { type: 'number' },
|
|
revenue: { type: 'number' },
|
|
roas: { type: 'number' }
|
|
},
|
|
constraints: { platform: 'Facebook Ads' }
|
|
},
|
|
{
|
|
count: 50,
|
|
schema: {
|
|
platform: { type: 'string' },
|
|
impressions: { type: 'number' },
|
|
clicks: { type: 'number' },
|
|
spend: { type: 'number' },
|
|
revenue: { type: 'number' },
|
|
roas: { type: 'number' }
|
|
},
|
|
constraints: { platform: 'TikTok Ads' }
|
|
}
|
|
];
|
|
|
|
const results = await synth.generateBatch('structured', platformConfigs, 3);
|
|
|
|
console.log('Multi-Platform Batch Results:');
|
|
results.forEach((result, i) => {
|
|
const platforms = ['Google Ads', 'Facebook Ads', 'TikTok Ads'];
|
|
console.log(`${platforms[i]}: ${result.metadata.count} records in ${result.metadata.duration}ms`);
|
|
console.log('Sample:', result.data.slice(0, 2));
|
|
});
|
|
|
|
return results;
|
|
}
|
|
|
|
// Run all examples
|
|
export async function runCampaignDataExamples() {
|
|
console.log('=== Example 1: Google Ads Campaign ===');
|
|
await generateGoogleAdsCampaign();
|
|
|
|
console.log('\n=== Example 2: Facebook Ads Campaign ===');
|
|
await generateFacebookAdsCampaign();
|
|
|
|
console.log('\n=== Example 3: TikTok Ads Campaign ===');
|
|
await generateTikTokAdsCampaign();
|
|
|
|
console.log('\n=== Example 4: Multi-Channel Attribution ===');
|
|
await generateAttributionData();
|
|
|
|
console.log('\n=== Example 5: Customer Journeys ===');
|
|
await generateCustomerJourneys();
|
|
|
|
console.log('\n=== Example 6: A/B Test Results ===');
|
|
await generateABTestResults();
|
|
|
|
console.log('\n=== Example 7: Cohort Analysis ===');
|
|
await generateCohortAnalysis();
|
|
|
|
console.log('\n=== Example 8: Time-Series Campaign Data ===');
|
|
await generateTimeSeriesCampaignData();
|
|
|
|
console.log('\n=== Example 10: Multi-Platform Batch ===');
|
|
await generateMultiPlatformBatch();
|
|
}
|
|
|
|
// Export individual functions
|
|
export {
|
|
generateGoogleAdsCampaign,
|
|
generateFacebookAdsCampaign,
|
|
generateTikTokAdsCampaign,
|
|
generateAttributionData,
|
|
generateCustomerJourneys,
|
|
generateABTestResults,
|
|
generateCohortAnalysis,
|
|
generateTimeSeriesCampaignData,
|
|
streamCampaignData,
|
|
generateMultiPlatformBatch
|
|
};
|
|
|
|
// Uncomment to run
|
|
// runCampaignDataExamples().catch(console.error);
|