setup.js

import { Client, TablesDB, Query } from 'node-appwrite';
import {
    ENDPOINT,
    PROJECT_ID,
    API_KEY,
    DATABASE_ID,
    DATABASE_NAME,
    TABLE_ID,
    TABLE_NAME,
    TOTAL_ROWS,
    SEED_BATCH_SIZE
} from './config.js';
import { generateRows, CATEGORIES } from './data.js';

const client = new Client()
    .setEndpoint(ENDPOINT)
    .setProject(PROJECT_ID)
    .setKey(API_KEY);

const db = new TablesDB(client);

function log(step, msg) {
    const ts = new Date().toISOString().slice(11, 19);
    console.log(`[${ts}] ${step.padEnd(14)} ${msg}`);
}

async function safe(label, fn, { ignore } = {}) {
    try {
        return await fn();
    } catch (e) {
        const code = e?.code ?? e?.response?.code;
        if (ignore && ignore.includes(code)) {
            log(label, `skipped (${code}: ${e.type ?? 'exists'})`);
            return null;
        }
        console.error(`FAIL ${label}:`, e.message, code ? `(code ${code})` : '');
        throw e;
    }
}

async function ensureDatabase() {
    await safe('database', () => db.create({
        databaseId: DATABASE_ID,
        name: DATABASE_NAME
    }), { ignore: [409] });
    log('database', `${DATABASE_ID} ready`);
}

async function ensureTable() {
    await safe('table', () => db.createTable({
        databaseId: DATABASE_ID,
        tableId: TABLE_ID,
        name: TABLE_NAME,
        permissions: ['read("any")'],
        rowSecurity: false,
        enabled: true
    }), { ignore: [409] });
    log('table', `${TABLE_ID} ready`);
}

async function ensureColumns() {
    const cols = [
        () => db.createTextColumn({ databaseId: DATABASE_ID, tableId: TABLE_ID, key: 'name', required: true }),
        () => db.createTextColumn({ databaseId: DATABASE_ID, tableId: TABLE_ID, key: 'description', required: true }),
        () => db.createTextColumn({ databaseId: DATABASE_ID, tableId: TABLE_ID, key: 'sku', required: true }),
        () => db.createEnumColumn({ databaseId: DATABASE_ID, tableId: TABLE_ID, key: 'category', elements: CATEGORIES, required: true }),
        () => db.createTextColumn({ databaseId: DATABASE_ID, tableId: TABLE_ID, key: 'brand', required: true }),
        () => db.createFloatColumn({ databaseId: DATABASE_ID, tableId: TABLE_ID, key: 'price', required: true, min: 0 }),
        () => db.createIntegerColumn({ databaseId: DATABASE_ID, tableId: TABLE_ID, key: 'stock', required: true, min: 0 }),
        () => db.createBooleanColumn({ databaseId: DATABASE_ID, tableId: TABLE_ID, key: 'inStock', required: true }),
        () => db.createFloatColumn({ databaseId: DATABASE_ID, tableId: TABLE_ID, key: 'rating', required: false, min: 0, max: 5 }),
        () => db.createIntegerColumn({ databaseId: DATABASE_ID, tableId: TABLE_ID, key: 'reviewCount', required: false, min: 0 }),
        () => db.createEmailColumn({ databaseId: DATABASE_ID, tableId: TABLE_ID, key: 'manufacturerEmail', required: false }),
        () => db.createUrlColumn({ databaseId: DATABASE_ID, tableId: TABLE_ID, key: 'manufacturerUrl', required: false }),
        () => db.createDatetimeColumn({ databaseId: DATABASE_ID, tableId: TABLE_ID, key: 'releasedAt', required: false }),
        () => db.createIpColumn({ databaseId: DATABASE_ID, tableId: TABLE_ID, key: 'warehouseIp', required: false }),
        () => db.createTextColumn({ databaseId: DATABASE_ID, tableId: TABLE_ID, key: 'tags', required: false, array: true })
    ];
    for (const make of cols) {
        await safe('column', make, { ignore: [409] });
    }
    log('columns', `${cols.length} columns requested`);
    await waitColumnsAvailable();
}

async function waitColumnsAvailable() {
    const started = Date.now();
    while (true) {
        const res = await db.listColumns({ databaseId: DATABASE_ID, tableId: TABLE_ID });
        const total = res.total;
        const pending = res.columns.filter(c => c.status !== 'available');
        if (pending.length === 0 && total > 0) {
            log('columns', `${total} columns available`);
            return;
        }
        if (Date.now() - started > 120_000) {
            throw new Error(`columns not ready: ${pending.map(c => `${c.key}=${c.status}`).join(', ')}`);
        }
        await new Promise(r => setTimeout(r, 500));
    }
}

async function existingRowCount() {
    const res = await db.listRows({
        databaseId: DATABASE_ID,
        tableId: TABLE_ID,
        queries: [Query.limit(1)],
        total: true
    });
    return res.total ?? 0;
}

async function seedRows() {
    const existing = await existingRowCount();
    if (existing >= TOTAL_ROWS) {
        log('seed', `found ${existing} existing rows, skipping seed`);
        return;
    }
    log('seed', `existing rows: ${existing}; generating ${TOTAL_ROWS - existing} more`);
    const rows = generateRows(TOTAL_ROWS - existing);

    const started = Date.now();
    let inserted = 0;
    for (let i = 0; i < rows.length; i += SEED_BATCH_SIZE) {
        const chunk = rows.slice(i, i + SEED_BATCH_SIZE);
        await db.createRows({
            databaseId: DATABASE_ID,
            tableId: TABLE_ID,
            rows: chunk
        });
        inserted += chunk.length;
        const pct = ((inserted / rows.length) * 100).toFixed(1);
        const elapsed = ((Date.now() - started) / 1000).toFixed(1);
        process.stdout.write(`\r[seed] inserted ${inserted}/${rows.length} (${pct}%) in ${elapsed}s   `);
    }
    process.stdout.write('\n');
    log('seed', `done in ${((Date.now() - started) / 1000).toFixed(1)}s`);
}

async function main() {
    log('start', `endpoint=${ENDPOINT} project=${PROJECT_ID}`);
    await ensureDatabase();
    await ensureTable();
    await ensureColumns();
    await seedRows();
    log('done', 'setup complete');
}

main().catch(err => {
    console.error('\nsetup failed:', err);
    process.exit(1);
});