pokemon/scripts/indexing.ts

import chalk from 'chalk';
import { client } from '../src/db/typesense.ts';
import type { DBInstance } from '../src/db/index.ts';

const DollarToInt = (dollar: any) => {
    if (dollar === null) return null;
    return Math.round(dollar * 100);
}


// Delete and recreate the 'cards' index
export const createCardCollection = async () => {
    try {
        await client.collections('cards').delete();
    } catch (error) {
        // Ignore error, just means collection doesn't exist
    }
    await client.collections().create({
        name: 'cards',
        fields: [
            { name: 'id', type: 'string' },
            { name: 'cardId', type: 'int32' },
            { name: 'productId', type: 'int32' },
            { name: 'variant', type: 'string', facet: true },
            { name: 'productName', type: 'string' },
            { name: 'productLineName', type: 'string', facet: true },
            { name: 'rarityName', type: 'string', facet: true },
            { name: 'setName', type: 'string', facet: true },
            { name: 'cardType', type: 'string', facet: true },
            { name: 'energyType', type: 'string', facet: true },
            { name: 'number', type: 'string', sort: true },
            { name: 'Artist', type: 'string' },
            { name: 'sealed', type: 'bool' },
            { name: 'releaseDate', type: 'int32' },
            { name: 'marketPrice', type: 'int32', optional: true, sort: true },
            { name: 'content', type: 'string', token_separators: ['/'] },
            { name: 'sku_id', type: 'string[]', optional: true, reference: 'skus.id', async_reference: true }
        ],
    });
    console.log(chalk.green('Collection "cards" created successfully.'));
}

// Delete and recreate the 'skus' index
export const createSkuCollection = async () => {
    try {
        await client.collections('skus').delete();
    } catch (error) {
        // Ignore error, just means collection doesn't exist
    }
    await client.collections().create({
        name: 'skus',
        fields: [
            { name: 'id', type: 'string' },
            { name: 'condition', type: 'string' },
            { name: 'highestPrice', type: 'int32', optional: true },
            { name: 'lowestPrice', type: 'int32', optional: true },
            { name: 'marketPrice', type: 'int32', optional: true },
        ]
    });
    console.log(chalk.green('Collection "skus" created successfully.'));
}


export const upsertCardCollection = async (db:DBInstance) => {
    const pokemon = await db.query.cards.findMany({
        with: { set: true, tcgdata: true, prices: true },
    });
    await client.collections('cards').documents().import(pokemon.map(card => {
        const marketPrice = card.tcgdata?.marketPrice ? DollarToInt(card.tcgdata.marketPrice) : null;

        return {
            id: card.cardId.toString(),
            cardId: card.cardId,
            productId: card.productId,
            variant: card.variant,
            productName: card.productName,
            productLineName: card.productLineName,
            rarityName: card.rarityName,
            setName: card.set?.setName || "",
            cardType: card.cardType || "",
            energyType: card.energyType || "",
            number: card.number,
            Artist: card.artist || "",
            sealed: card.sealed,
            content: [card.productName, card.productLineName, card.set?.setName || "", card.number, card.rarityName, card.artist || ""].join(' '),
            releaseDate: card.tcgdata?.releaseDate ? Math.floor(new Date(card.tcgdata.releaseDate).getTime() / 1000) : 0,
            ...(marketPrice !== null && { marketPrice }),
            sku_id: card.prices.map(price => price.skuId.toString())
        };
    }), { action: 'upsert' });
    console.log(chalk.green('Collection "cards" indexed successfully.'));
}

export const upsertSkuCollection = async (db:DBInstance) => {
    const skus = await db.query.skus.findMany();
    await client.collections('skus').documents().import(skus.map(sku => ({
        id: sku.skuId.toString(),
        condition: sku.condition,
        highestPrice: DollarToInt(sku.highestPrice),
        lowestPrice: DollarToInt(sku.lowestPrice),
        marketPrice: DollarToInt(sku.marketPrice),
    })), { action: 'upsert' });
    console.log(chalk.green('Collection "skus" indexed successfully.'));
}