edmand46
333 lines
12 KiB
TypeScript
333 lines
12 KiB
TypeScript
// Production seed: registers an operator, creates a project, configures staging
|
|
// content (counter, item, remote configs, leaderboard, store with free+paid offers, a
|
|
// global quest, a scenario), and promotes it to the prod snapshot the runtime SDK serves.
|
|
//
|
|
// The scenario flow uses the server engine's node types, `data` keys and handle names —
|
|
// the server walks the graph itself (see liveops-backend/internal/domain/scenario/engine/planbuilder
|
|
// and .../fsm), so what we store is what the server runs.
|
|
|
|
import { createAdminClient, type AdminClient } from './adminClient.js';
|
|
import type { SeedArtifact } from './types.js';
|
|
|
|
const sleep = (ms: number) => new Promise((r) => setTimeout(r, ms));
|
|
|
|
interface ReleaseResponse {
|
|
id: string;
|
|
status: string;
|
|
version: number;
|
|
}
|
|
|
|
interface QuestResponse {
|
|
id: string;
|
|
name: string;
|
|
status: string;
|
|
objectives?: Array<{ id: string; metric: string; target: number }>;
|
|
rewards?: Array<{ itemId?: string; currency?: string; amount: number }>;
|
|
}
|
|
|
|
interface StoreResponse {
|
|
id: string;
|
|
name: string;
|
|
slug?: string;
|
|
data?: { slug?: string };
|
|
offers?: Array<{
|
|
id: string;
|
|
name: string;
|
|
contents?: Array<{ itemId: string; amount: number }>;
|
|
}>;
|
|
}
|
|
|
|
function buildFlow(scenarioSlug: string) {
|
|
return {
|
|
nodes: [
|
|
{ id: 'trigger_1', type: 'trigger', data: { triggerType: 'event', onEvent: 'session_start' } },
|
|
{ id: 'notify_1', type: 'notification', data: { title: 'Welcome', message: 'Welcome to the game!' } },
|
|
{
|
|
id: 'rc_1',
|
|
type: 'remote_config_override',
|
|
data: { patches: [{ path: 'spawn_rate', valueType: 'float', value: '3.0' }] },
|
|
},
|
|
{ id: 'store_1', type: 'store', data: { storeSlug: scenarioSlug } },
|
|
{ id: 'cond_1', type: 'condition', data: { logic: 'AND', rules: [] } },
|
|
{ id: 'notify_2', type: 'notification', data: { title: 'Thanks', message: 'Enjoy your purchase!' } },
|
|
],
|
|
edges: [
|
|
{ id: 'e1', source: 'trigger_1', sourceHandle: 'onActivate', target: 'notify_1' },
|
|
{ id: 'e2', source: 'notify_1', sourceHandle: 'output', target: 'rc_1' },
|
|
{ id: 'e3', source: 'rc_1', sourceHandle: 'output', target: 'store_1' },
|
|
{ id: 'e4', source: 'store_1', sourceHandle: 'onPurchase', target: 'cond_1' },
|
|
{ id: 'e5', source: 'cond_1', sourceHandle: 'true', target: 'notify_2' },
|
|
],
|
|
};
|
|
}
|
|
|
|
async function pollRelease(
|
|
api: AdminClient,
|
|
projPath: string,
|
|
env: string,
|
|
releaseId: string,
|
|
log: (m: string) => void,
|
|
): Promise<void> {
|
|
const deadline = Date.now() + 60_000;
|
|
while (Date.now() < deadline) {
|
|
const releases = await api.get<ReleaseResponse[]>(
|
|
`${projPath}/releases?environment=${env}&limit=20&offset=0`,
|
|
);
|
|
const rel = releases.find((r) => r.id === releaseId);
|
|
if (rel) {
|
|
if (rel.status === 'completed') {
|
|
log(`release ${releaseId} completed (v${rel.version})`);
|
|
return;
|
|
}
|
|
if (rel.status === 'failed') {
|
|
throw new Error(`release ${releaseId} failed`);
|
|
}
|
|
}
|
|
await sleep(1500);
|
|
}
|
|
throw new Error(`release ${releaseId} did not complete within 60s`);
|
|
}
|
|
|
|
export async function runSeed(
|
|
baseUrl: string,
|
|
log: (m: string) => void = () => {},
|
|
): Promise<SeedArtifact> {
|
|
const api = createAdminClient(baseUrl);
|
|
const ts = Date.now();
|
|
const authoringEnv = 'staging';
|
|
const runtimeEnv = 'prod';
|
|
const q = `?environment=${authoringEnv}`;
|
|
const prodQ = `?environment=${runtimeEnv}`;
|
|
const adminEmail = `e2e+${ts}@rudder.build`;
|
|
const password = `Passw0rd!e2e-${ts}`;
|
|
|
|
// 1. Register operator (open registration; no approval gate at the API layer).
|
|
const auth = await api.post<{ accessToken: string; refreshToken: string }>(
|
|
'/platform/v1/authorization/register',
|
|
{ email: adminEmail, password, fullName: 'E2E Bot' },
|
|
{ auth: false },
|
|
);
|
|
api.setToken(auth.accessToken);
|
|
log(`registered ${adminEmail}`);
|
|
|
|
// 2. Project. Creating one provisions the staging + prod environments, each with
|
|
// its own SDK key — that key is what the runtime SDK sends as projectKey.
|
|
const project = await api.post<{ id: string; name: string }>('/platform/v1/projects', {
|
|
name: `e2e-${ts}`,
|
|
});
|
|
const projPath = `/platform/v1/projects/${project.id}`;
|
|
const environments = await api.get<Array<{ name: string; sdkKey: string }>>(
|
|
`${projPath}/environments`,
|
|
);
|
|
const projectKey = environments.find((e) => e.name === runtimeEnv)?.sdkKey;
|
|
if (!projectKey) {
|
|
throw new Error(`project ${project.id} has no ${runtimeEnv} environment sdk key`);
|
|
}
|
|
log(`project ${project.id} ${runtimeEnv}Key=${projectKey}`);
|
|
|
|
// 3. Soft currency counter — offer prices are validated against counter slugs, and
|
|
// the purchase debit resolves the currency through the catalog counter cache.
|
|
const currency = 'soft';
|
|
await api.post(`${projPath}/counters${q}`, {
|
|
projectId: project.id,
|
|
environment: authoringEnv,
|
|
name: 'Soft Currency',
|
|
slug: currency,
|
|
kind: 'currency',
|
|
});
|
|
|
|
// 4. Item (granted as a paid offer's contents).
|
|
const item = await api.post<{ id: string; name: string }>(`${projPath}/items${q}`, {
|
|
projectId: project.id,
|
|
environment: authoringEnv,
|
|
name: 'Gold Coin',
|
|
slug: 'gold-coin',
|
|
});
|
|
|
|
// 5. Remote configs — one per value type. RCs are live per-env flags served
|
|
// straight from the cache and are not copied by a promote, so they go directly
|
|
// into the runtime env.
|
|
const remoteConfigs: Array<{ key: string; value: string; valueType: string }> = [
|
|
{ key: 'max_energy', value: '100', valueType: 'int' },
|
|
{ key: 'spawn_rate', value: '1.5', valueType: 'float' },
|
|
{ key: 'feature_x', value: 'true', valueType: 'bool' },
|
|
{ key: 'welcome_text', value: 'hi', valueType: 'string' },
|
|
{ key: 'shop_layout', value: '{"cols":3}', valueType: 'json' },
|
|
];
|
|
for (const rc of remoteConfigs) {
|
|
await api.post(`${projPath}/remote-configs${prodQ}`, {
|
|
projectId: project.id,
|
|
environment: runtimeEnv,
|
|
...rc,
|
|
});
|
|
}
|
|
log(`created ${remoteConfigs.length} remote configs`);
|
|
|
|
// 6. Leaderboard.
|
|
await api.post(`${projPath}/leaderboards${q}`, {
|
|
projectId: project.id,
|
|
environment: authoringEnv,
|
|
name: 'Weekly Score',
|
|
slug: 'weekly-score',
|
|
metric: 'score',
|
|
resetPeriod: 'weekly',
|
|
sortingOrder: 'desc',
|
|
maxEntries: 100,
|
|
});
|
|
|
|
// 7. Store with a free offer and a paid (currency) offer with a purchase limit.
|
|
// The runtime resolves a store's slug from data.slug, and the CreateStore API has
|
|
// no slug field — so we set it via data.
|
|
const storeSlug = 'starter-shop';
|
|
const store = await api.post<StoreResponse>(`${projPath}/stores${q}`, {
|
|
projectId: project.id,
|
|
environment: authoringEnv,
|
|
name: 'Starter Shop',
|
|
description: 'E2E shop',
|
|
data: { slug: storeSlug },
|
|
offers: [
|
|
{ name: 'Welcome Gift', contents: [{ itemId: item.id, amount: 10 }], price: { currency, amount: 0 } },
|
|
{
|
|
name: 'Gold Pack',
|
|
contents: [{ itemId: item.id, amount: 50 }],
|
|
price: { currency, amount: 100 },
|
|
maxPurchases: 2,
|
|
},
|
|
],
|
|
});
|
|
log(`store ${storeSlug} (${store.id}) with ${store.offers?.length ?? 0} offers`);
|
|
const paidOffer = store.offers?.find((o) => o.name === 'Gold Pack');
|
|
if (!paidOffer?.id) {
|
|
throw new Error('seeded paid offer did not return an id');
|
|
}
|
|
|
|
// 8. Global quest: buying the paid offer completes it; claim grants extra item reward.
|
|
const questName = 'Buy Gold Pack Quest';
|
|
const questObjectiveId = 'buy-gold-pack';
|
|
const questTarget = 1;
|
|
const questMetric = `purchase.offer:${paidOffer.id}`;
|
|
const questRewardAmount = 7;
|
|
const quest = await api.post<QuestResponse>(`${projPath}/quests${q}`, {
|
|
projectId: project.id,
|
|
environment: authoringEnv,
|
|
name: questName,
|
|
objectives: [{ id: questObjectiveId, metric: questMetric, target: questTarget }],
|
|
rewards: [{ itemId: item.id, amount: questRewardAmount }],
|
|
});
|
|
log(`quest ${quest.id} staged for metric ${questMetric}`);
|
|
|
|
// 9. Scenario (must be live now: startAt <= now <= endAt).
|
|
const startAt = new Date(ts - 3600_000).toISOString();
|
|
const endAt = new Date(ts + 365 * 24 * 3600_000).toISOString();
|
|
const scenarioEvent = 'session_start';
|
|
const scenario = await api.post<{ id: string }>(`${projPath}/scenarios${q}`, {
|
|
projectId: project.id,
|
|
environment: authoringEnv,
|
|
name: 'Onboarding',
|
|
description: 'e2e onboarding',
|
|
startAt,
|
|
endAt,
|
|
});
|
|
|
|
// 10. Scenario flow (trigger -> notification -> rc override -> store -> condition -> notification).
|
|
await api.put(`${projPath}/scenarios/${scenario.id}`, {
|
|
projectId: project.id,
|
|
scenarioId: scenario.id,
|
|
flow: buildFlow(storeSlug),
|
|
});
|
|
log(`scenario ${scenario.id} flow set`);
|
|
|
|
// 11. Promote staging content to prod (the runtime serves the prod snapshot).
|
|
const release = await api.post<ReleaseResponse>(`${projPath}/releases/promote`, {
|
|
projectId: project.id,
|
|
fromEnvironment: authoringEnv,
|
|
toEnvironment: runtimeEnv,
|
|
});
|
|
await pollRelease(api, projPath, runtimeEnv, release.id, log);
|
|
|
|
// Promotion re-creates every entity with fresh ids — read the prod ones back.
|
|
const prodStores = await api.get<StoreResponse[]>(`${projPath}/stores${prodQ}`);
|
|
const prodStore = prodStores.find((s) => s.data?.slug === storeSlug || s.name === 'Starter Shop');
|
|
if (!prodStore) {
|
|
throw new Error(`promoted store ${storeSlug} was not found in ${runtimeEnv}`);
|
|
}
|
|
const prodPaidOffer = prodStore.offers?.find((o) => o.name === 'Gold Pack');
|
|
if (!prodPaidOffer?.id) {
|
|
throw new Error('promoted paid offer did not return an id');
|
|
}
|
|
const prodRewardItemId = prodPaidOffer.contents?.[0]?.itemId;
|
|
if (!prodRewardItemId) {
|
|
throw new Error('promoted paid offer did not return a reward item id');
|
|
}
|
|
|
|
const prodQuests = await api.get<QuestResponse[]>(`${projPath}/quests${prodQ}`);
|
|
const prodQuest = prodQuests.find((q) => q.name === questName);
|
|
if (!prodQuest?.id) {
|
|
throw new Error(`promoted quest ${questName} was not found in ${runtimeEnv}`);
|
|
}
|
|
const prodQuestMetric = prodQuest.objectives?.find((o) => o.id === questObjectiveId)?.metric;
|
|
if (!prodQuestMetric) {
|
|
throw new Error(`promoted quest ${questName} did not return metric ${questObjectiveId}`);
|
|
}
|
|
const prodQuestRewardItemId = prodQuest.rewards?.[0]?.itemId;
|
|
if (!prodQuestRewardItemId) {
|
|
throw new Error(`promoted quest ${questName} did not return reward item id`);
|
|
}
|
|
|
|
const prodScenarios = await api.get<Array<{ id: string; name: string }>>(
|
|
`${projPath}/scenarios${prodQ}`,
|
|
);
|
|
const prodScenario = prodScenarios.find((s) => s.name === 'Onboarding');
|
|
if (!prodScenario?.id) {
|
|
throw new Error(`promoted scenario Onboarding was not found in ${runtimeEnv}`);
|
|
}
|
|
|
|
return {
|
|
baseUrl,
|
|
projectId: project.id,
|
|
projectKey,
|
|
adminToken: auth.accessToken,
|
|
adminEmail,
|
|
environment: runtimeEnv,
|
|
seededAt: new Date(ts).toISOString(),
|
|
releaseId: release.id,
|
|
store: {
|
|
name: 'Starter Shop',
|
|
slug: storeSlug,
|
|
freeOfferName: 'Welcome Gift',
|
|
paidOfferName: 'Gold Pack',
|
|
paidOfferId: prodPaidOffer.id,
|
|
paidPrice: { currency, amount: 100 },
|
|
paidMaxPurchases: 2,
|
|
grantedItemName: 'Gold Coin',
|
|
paidGrantAmount: 50,
|
|
},
|
|
quest: {
|
|
id: prodQuest.id,
|
|
name: questName,
|
|
objectiveId: questObjectiveId,
|
|
metric: prodQuestMetric,
|
|
target: questTarget,
|
|
rewardItemId: prodQuestRewardItemId,
|
|
rewardAmount: questRewardAmount,
|
|
},
|
|
leaderboard: { slug: 'weekly-score', metric: 'score' },
|
|
item: { id: prodRewardItemId, name: item.name },
|
|
remoteConfigs: {
|
|
maxEnergy: 100,
|
|
spawnRate: 1.5,
|
|
featureX: true,
|
|
welcomeText: 'hi',
|
|
shopLayout: { cols: 3 },
|
|
spawnRateOverride: 3.0,
|
|
},
|
|
scenario: { id: prodScenario.id, event: scenarioEvent },
|
|
};
|
|
}
|
|
|
|
export async function deleteProject(artifact: SeedArtifact): Promise<void> {
|
|
const api = createAdminClient(artifact.baseUrl);
|
|
api.setToken(artifact.adminToken);
|
|
await api.del(`/platform/v1/projects/${artifact.projectId}`);
|
|
}
|