Align prod schema and deploy tooling

This commit is contained in:
jjbrunton committed 2026-01-24 20:16:01 +00:00
1 parent d2db86ec7f
commit 7e2e723880
105 files changed
+19014 -131

No files matched your search

+220
View File
@@ -0,0 +1,220 @@
/**
* Script to sync content from production to non-production Supabase
*
* Usage: npx ts-node scripts/sync-content-to-nonprod.ts
*
* Make sure you have the following environment variables set:
* - PROD_SUPABASE_URL (or uses default)
* - PROD_SUPABASE_SERVICE_KEY
* - NONPROD_SUPABASE_URL (or uses default)
* - NONPROD_SUPABASE_SERVICE_KEY
*/
import { createClient, SupabaseClient } from '@supabase/supabase-js';
// Configuration
const PROD_URL = process.env.PROD_SUPABASE_URL || 'https://ckjcrkjpmhqhiucifukx.supabase.co';
const PROD_KEY = process.env.PROD_SUPABASE_SERVICE_KEY;
const NONPROD_URL = process.env.NONPROD_SUPABASE_URL || 'https://itbzhrvlgvdmzbnhzhyx.supabase.co';
const NONPROD_KEY = process.env.NONPROD_SUPABASE_SERVICE_KEY;
if (!PROD_KEY || !NONPROD_KEY) {
console.error('Missing required environment variables:');
if (!PROD_KEY) console.error(' - PROD_SUPABASE_SERVICE_KEY');
if (!NONPROD_KEY) console.error(' - NONPROD_SUPABASE_SERVICE_KEY');
process.exit(1);
}
const prodClient = createClient(PROD_URL, PROD_KEY);
const nonprodClient = createClient(NONPROD_URL, NONPROD_KEY);
async function fetchAll<T>(client: SupabaseClient, table: string, orderBy?: string): Promise<T[]> {
let allData: T[] = [];
let offset = 0;
const limit = 1000;
while (true) {
let query = client.from(table).select('*').range(offset, offset + limit - 1);
if (orderBy) {
query = query.order(orderBy);
}
const { data, error } = await query;
if (error) {
throw new Error(`Error fetching ${table}: ${error.message}`);
}
if (!data || data.length === 0) break;
allData = allData.concat(data as T[]);
offset += limit;
if (data.length < limit) break;
}
return allData;
}
async function clearTable(client: SupabaseClient, table: string) {
// Use RPC to bypass RLS for deletion
const { error } = await client.rpc('truncate_table', { table_name: table });
if (error) {
// If RPC doesn't exist, try direct delete
const { error: deleteError } = await client.from(table).delete().gte('id', '00000000-0000-0000-0000-000000000000');
if (deleteError) {
console.warn(`Warning: Could not clear ${table}: ${deleteError.message}`);
}
}
}
async function insertBatch<T extends Record<string, any>>(
client: SupabaseClient,
table: string,
data: T[],
batchSize = 100
): Promise<void> {
for (let i = 0; i < data.length; i += batchSize) {
const batch = data.slice(i, i + batchSize);
const { error } = await client.from(table).upsert(batch, { onConflict: 'id' });
if (error) {
console.error(`Error inserting into ${table} at batch ${i / batchSize}:`, error.message);
// Try inserting one by one to find the problematic row
for (const row of batch) {
const { error: singleError } = await client.from(table).upsert(row, { onConflict: 'id' });
if (singleError) {
console.error(` Failed row:`, row.id, singleError.message);
}
}
}
process.stdout.write(`\r Inserted ${Math.min(i + batchSize, data.length)}/${data.length}`);
}
console.log();
}
async function main() {
console.log('=== Content Sync: Production -> Non-Production ===\n');
try {
// 1. Fetch all content from production
console.log('Fetching content from production...');
console.log(' - Categories...');
const categories = await fetchAll(prodClient, 'categories', 'sort_order');
console.log(` Found ${categories.length} categories`);
console.log(' - Topics...');
const topics = await fetchAll(prodClient, 'topics', 'sort_order');
console.log(` Found ${topics.length} topics`);
console.log(' - Question Packs...');
const questionPacks = await fetchAll(prodClient, 'question_packs', 'sort_order');
console.log(` Found ${questionPacks.length} question packs`);
console.log(' - Dare Packs...');
const darePacks = await fetchAll(prodClient, 'dare_packs', 'sort_order');
console.log(` Found ${darePacks.length} dare packs`);
console.log(' - Questions...');
const questions = await fetchAll(prodClient, 'questions', 'pack_id');
console.log(` Found ${questions.length} questions`);
console.log(' - Dares...');
const dares = await fetchAll(prodClient, 'dares', 'pack_id');
console.log(` Found ${dares.length} dares`);
console.log(' - Pack Topics...');
const packTopics = await fetchAll(prodClient, 'pack_topics');
console.log(` Found ${packTopics.length} pack-topic associations`);
// 2. Clear existing content in non-prod (in reverse dependency order)
console.log('\nClearing existing content in non-production...');
console.log(' - pack_topics...');
await clearTable(nonprodClient, 'pack_topics');
console.log(' - questions...');
await clearTable(nonprodClient, 'questions');
console.log(' - dares...');
await clearTable(nonprodClient, 'dares');
console.log(' - question_packs...');
await clearTable(nonprodClient, 'question_packs');
console.log(' - dare_packs...');
await clearTable(nonprodClient, 'dare_packs');
console.log(' - topics...');
await clearTable(nonprodClient, 'topics');
console.log(' - categories...');
await clearTable(nonprodClient, 'categories');
// 3. Insert content into non-prod (in dependency order)
console.log('\nInserting content into non-production...');
console.log(' - Categories...');
await insertBatch(nonprodClient, 'categories', categories);
console.log(' - Topics...');
await insertBatch(nonprodClient, 'topics', topics);
console.log(' - Question Packs...');
await insertBatch(nonprodClient, 'question_packs', questionPacks);
console.log(' - Dare Packs...');
await insertBatch(nonprodClient, 'dare_packs', darePacks);
// Handle questions with inverse_of self-reference
// First insert all questions with inverse_of set to NULL
console.log(' - Questions (pass 1: without inverse_of)...');
const questionsWithoutInverse = questions.map((q: any) => ({ ...q, inverse_of: null }));
await insertBatch(nonprodClient, 'questions', questionsWithoutInverse);
// Then update the inverse_of references
const questionsWithInverse = (questions as any[]).filter(q => q.inverse_of !== null);
if (questionsWithInverse.length > 0) {
console.log(` - Questions (pass 2: updating ${questionsWithInverse.length} inverse_of references)...`);
for (const q of questionsWithInverse) {
const { error } = await nonprodClient
.from('questions')
.update({ inverse_of: q.inverse_of })
.eq('id', q.id);
if (error) {
console.error(` Failed to update inverse_of for ${q.id}:`, error.message);
}
}
console.log(` Updated ${questionsWithInverse.length} references`);
}
console.log(' - Dares...');
await insertBatch(nonprodClient, 'dares', dares);
console.log(' - Pack Topics...');
// pack_topics has composite primary key, need different upsert strategy
for (const pt of packTopics as any[]) {
const { error } = await nonprodClient
.from('pack_topics')
.upsert(pt, { onConflict: 'pack_id,topic_id' });
if (error) {
console.error(` Failed pack_topic:`, pt, error.message);
}
}
console.log(` Inserted ${(packTopics as any[]).length} pack-topic associations`);
console.log('\n=== Sync Complete! ===');
console.log(`
Summary:
- ${categories.length} categories
- ${topics.length} topics
- ${questionPacks.length} question packs
- ${darePacks.length} dare packs
- ${questions.length} questions
- ${dares.length} dares
- ${(packTopics as any[]).length} pack-topic associations
`);
} catch (error) {
console.error('Sync failed:', error);
process.exit(1);
}
}
main();