cache

src/market/RegionalMarketCache.spec.ts

@@ -0,0 +1,35 @@
+import { describe, expect, it } from 'vitest'
+import { RegionalMarketCache } from './RegionalMarketCache'
+
+describe('RegionalMarketCache', () => {
+    it('should cache and retrieve values', async () => {
+        const cache = new RegionalMarketCache<string>(1000)
+
+        cache.set(1, 1, 'test')
+        expect(cache.get(1, 1)).toBe('test')
+    })
+
+    it('should remove values', async () => {
+        const cache = new RegionalMarketCache<string>(1000)
+
+        cache.set(1, 1, 'test')
+        cache.remove(1, 1)
+        expect(cache.get(1, 1)).toBeUndefined()
+    })
+
+    it('should compute values if absent', async () => {
+        const cache = new RegionalMarketCache<string>(1000)
+        const value = await cache.computeIfAbsent(1, 1, () => Promise.resolve('test'))
+
+        expect(value).toBe('test')
+        expect(cache.get(1, 1)).toBe('test')
+    })
+
+    it('should expire values', async () => {
+        const cache = new RegionalMarketCache<string>(1)
+        
+        cache.set(1, 1, 'test')
+        await new Promise(resolve => setTimeout(resolve, 10))
+        expect(cache.get(1, 1)).toBeUndefined()
+    })
+})

src/market/RegionalMarketCache.ts

@@ -0,0 +1,50 @@
+class CacheEntry<T> {
+    public value: T;
+    public expiration: Date;
+
+    constructor(value: T, expiration: Date) {
+        this.value = value;
+        this.expiration = expiration;
+    }
+}
+
+export type ExpirationSupplier<T> = (v: T) => Date;
+
+export class RegionalMarketCache<T>  {
+    private cache: Record<number, Record<number, CacheEntry<T>>>;
+    private expirationSupplier: (v: T) => Date;
+
+    constructor(expiration: ExpirationSupplier<T> | number) {
+        this.cache = {};
+        this.expirationSupplier = expiration instanceof Function ? expiration : () => new Date(Date.now() + expiration);
+    }
+
+    public get(regionId: number, typeId: number): T | undefined {
+        const entry = this.cache[regionId]?.[typeId];
+
+        if (entry && entry.expiration > new Date()) {
+            return entry.value;
+        }
+        this.remove(regionId, typeId);
+        return undefined;
+    }
+
+    public set(regionId: number, typeId: number, value: T): void {
+        this.cache[regionId] = this.cache[regionId] ?? {};
+        this.cache[regionId][typeId] = new CacheEntry(value, this.expirationSupplier(value));
+    }
+
+    public remove(regionId: number, typeId: number): void {
+        delete this.cache[regionId]?.[typeId];
+    }
+
+    public async computeIfAbsent(regionId: number, typeId: number, supplier: () => (Promise<T> | T)): Promise<T> {
+        let value = this.get(regionId, typeId);
+
+        if (!value) {
+            value = await supplier();
+            this.set(regionId, typeId, value);
+        }
+        return value;
+    }
+};

src/market/acquisition/AcquisitionQuantilsTooltip.vue

@@ -1,7 +1,7 @@
 <script setup lang="ts">
 import { LoadingSpinner, Tooltip } from '@/components';
 import { formatIsk } from '@/formaters';
-import { getHistory, getHistoryQuartils, jitaId } from '@/market';
+import { getHistory, getHistoryQuartils } from '@/market';
 import { ArrowTrendingDownIcon, ArrowTrendingUpIcon } from '@heroicons/vue/24/outline';
 import { computedAsync } from '@vueuse/core';
 import { ref, watchEffect } from 'vue';
@@ -22,7 +22,7 @@ const q1 = ref(0);
 const median = ref(0);
 const q3 = ref(0);
 const lineColor = ref('');
-const history = computedAsync(() => getHistory(jitaId, props.id), []);
+const history = computedAsync(() => getHistory(props.id), []);
 
 watchEffect(async () => {
     if (!open.value || !props.id) {

src/market/appraisal/appraisal.ts

@@ -1,15 +1,11 @@
 import { defineStore } from 'pinia';
-import { ref } from 'vue';
+import { RegionalMarketCache } from '../RegionalMarketCache';
+import { jitaId } from '../market';
 import { MarketType } from "../type";
 import { MarketTypePrice } from './MarketTypePrice';
 import { getEvepraisalPrices } from './evepraisal';
 import { getfuzzworkPrices } from './fuzzwork';
 
-type MarketTypePriceCache = {
-    price: MarketTypePrice,
-    date: Date
-}
-
 const cacheDuration = 1000 * 60 * 5; // 5 minutes
 const priceGetters = {
     evepraisal: getEvepraisalPrices,
@@ -17,21 +13,21 @@ const priceGetters = {
 }
 
 export const useApraisalStore = defineStore('appraisal', () => {
-    const cache = ref<Record<number, MarketTypePriceCache>>({});
+    const cache: RegionalMarketCache<MarketTypePrice> = new RegionalMarketCache(cacheDuration);
 
     const getPricesUncached = priceGetters.fuzzwork;
 
-    const getPrice = async (type: MarketType): Promise<MarketTypePrice> => (await getPrices([type]))[0];
-    const getPrices = async (types: MarketType[]): Promise<MarketTypePrice[]> => {
-        const now = new Date();
+    const getPrice = async (type: MarketType, regionId?: number): Promise<MarketTypePrice> => (await getPrices([type], regionId))[0];
+    const getPrices = async (types: MarketType[], regionId?: number): Promise<MarketTypePrice[]> => {
         const cached: MarketTypePrice[] = [];
         const uncached: MarketType[] = [];
+        const rId = regionId ?? jitaId;
 
         types.forEach(t => {
-            const cachedPrice = cache.value[t.id];
+            const cachedPrice = cache.get(rId, t.id);
 
-            if (cachedPrice && now.getTime() - cachedPrice.date.getTime() < cacheDuration) {
-                cached.push(cachedPrice.price);
+            if (cachedPrice) {
+                cached.push(cachedPrice);
             } else {
                 uncached.push(t);
             }
@@ -40,8 +36,8 @@ export const useApraisalStore = defineStore('appraisal', () => {
         if (uncached.length > 0) {
             const prices = await getPricesUncached(uncached);
 
-            prices.forEach(p => cache.value[p.type.id] = { price: p, date: now });
-            return [...cached, ...prices];
+            prices.forEach(p => cache.set(rId, p.type.id, p));
+            return [ ...cached, ...prices ];
         }
         return cached;
     };

src/market/history/EsiMarketOrderHistory.ts

@@ -1,4 +1,6 @@
 import { esiAxiosInstance } from "@/service";
+import { RegionalMarketCache } from '../RegionalMarketCache';
+import { jitaId } from "../market";
 
 
 export type EsiMarketOrderHistory = {
@@ -11,16 +13,18 @@ export type EsiMarketOrderHistory = {
 }
 
 // TODO use pinia store
-const historyCache: Record<number, Record<number, EsiMarketOrderHistory[]>> = {};
+const historyCache: RegionalMarketCache<EsiMarketOrderHistory[]> = new RegionalMarketCache(() => {
+    const date = new Date();
 
-export const getHistory = async (regionId: number, tyeId: number): Promise<EsiMarketOrderHistory[]> => {
-    if (historyCache[regionId]?.[tyeId]) {
-        return historyCache[regionId][tyeId];
+    if (date.getUTCHours() < 11) {
+        date.setUTCDate(date.getUTCDate() - 1);
     }
+    date.setUTCHours(11, 0, 0, 0);
+    return date;
+});
 
-    const value = (await esiAxiosInstance.get(`/markets/${regionId}/history/`, { params: { type_id: tyeId } })).data;
+export const getHistory = async (tyeId: number, regionId?: number): Promise<EsiMarketOrderHistory[]> => {
+    const rId = regionId ?? jitaId;
 
-    historyCache[regionId] = historyCache[regionId] ?? {};
-    historyCache[regionId][tyeId] = value;
-    return value;
+    return historyCache.computeIfAbsent(rId, tyeId, async () => (await esiAxiosInstance.get(`/markets/${rId}/history/`, { params: { type_id: tyeId } })).data);
 }

src/market/index.ts

@@ -1,3 +1,4 @@
+export * from './RegionalMarketCache';
 export * from './history';
 export * from './tax';
 export * from './type';

src/market/tracking/tracking.ts

@@ -1,5 +1,5 @@
 import { marbasAxiosInstance, MarbasObject } from "@/marbas";
-import { EsiMarketOrderHistory, getHistory, jitaId, MarketType, MarketTypePrice } from "@/market";
+import { EsiMarketOrderHistory, getHistory, MarketType, MarketTypePrice } from "@/market";
 import log from "loglevel";
 import { defineStore } from "pinia";
 import { computed, ref } from "vue";
@@ -47,4 +47,4 @@ export const useMarketTrackingStore = defineStore('marketTracking', () => {
     return { types, addType, removeType };
 });
 
-export const createResult = async (id: number, price: MarketTypePrice): Promise<TrackingResult> => ({ history: await getHistory(jitaId, id), ...price });
+export const createResult = async (id: number, price: MarketTypePrice): Promise<TrackingResult> => ({ history: await getHistory(id), ...price });

src/pages/market/Tracking.vue

@@ -1,5 +1,5 @@
 <script setup lang="ts">
-import { MarketType, MarketTypeInput, MarketTypePrice, getHistory, getMarketTypes, jitaId, useApraisalStore } from "@/market";
+import { MarketType, MarketTypeInput, MarketTypePrice, getHistory, getMarketTypes, useApraisalStore } from "@/market";
 import { BuyModal } from '@/market/acquisition';
 import { TrackingResult, TrackingResultTable, createResult, useMarketTrackingStore } from '@/market/tracking';
 import { ref, watch } from 'vue';
@@ -15,7 +15,7 @@ const items = ref<TrackingResult[]>([]);
 const addOrRelaod = async (type: MarketType) => {
     const typeID = type.id;
     const [history, price] = await Promise.all([
-        getHistory(jitaId, typeID),
+        getHistory(typeID),
         apraisalStore.getPrice(type)
     ]);
     const itm = {