epicweb-dev / cachified Goto Github PK

import * as YAML from 'yaml'
import {markdownToHtmlUnwrapped} from './markdown.server'
import {cachified} from 'cachified'
import {downloadDirList, downloadFile} from './github.server'
import {typedBoolean} from './misc'
import type {Workshop} from '~/types'
import {cache, shouldForceFresh} from './cache.server'

type RawWorkshop = {
  title?: string
  description?: string
  meta?: Record<string, unknown>
  events?: Array<Omit<Workshop['events'][number], 'type'>>
  convertKitTag?: string
  categories?: Array<string>
  problemStatements?: Workshop['problemStatementHTMLs']
  keyTakeaways?: Workshop['keyTakeawayHTMLs']
  topics?: Array<string>
  prerequisite?: string
}

async function getWorkshops({
  request,
  forceFresh,
}: {
  request?: Request
  forceFresh?: boolean
}) {
  const key = 'content:workshops'
  return cachified({
    cache,
    key,
    ttl: 1000 * 60 * 60 * 24 * 7,
    forceFresh: forceFresh ?? (await shouldForceFresh({request, key})),
    getFreshValue: async () => {
      const dirList = await downloadDirList(`content/workshops`)
      const workshopFileList = dirList
        .filter(
          listing => listing.type === 'file' && listing.name.endsWith('.yml'),
        )
        .map(listing => listing.name.replace(/\.yml$/, ''))
      const workshops = await Promise.all(
        workshopFileList.map(slug => getWorkshop(slug)),
      )
      return workshops.filter(typedBoolean)
    },
    checkValue: (value: unknown) => Array.isArray(value),
  })
}

async function getWorkshop(slug: string): Promise<null | Workshop> {
  const {default: pProps} = await import('p-props')

  const rawWorkshopString = await downloadFile(
    `content/workshops/${slug}.yml`,
  ).catch(() => null)
  if (!rawWorkshopString) return null
  let rawWorkshop
  try {
    rawWorkshop = YAML.parse(rawWorkshopString) as RawWorkshop
  } catch (error: unknown) {
    console.error(`Error parsing YAML`, error, rawWorkshopString)
    return null
  }
  if (!rawWorkshop.title) {
    console.error('Workshop has no title', rawWorkshop)
    return null
  }
  const {
    title,
    convertKitTag,
    description = 'This workshop is... indescribeable',
    categories = [],
    events = [],
    topics,
    meta = {},
  } = rawWorkshop

  if (!convertKitTag) {
    throw new Error('All workshops must have a convertKitTag')
  }

  const [
    problemStatementHTMLs,
    keyTakeawayHTMLs,
    topicHTMLs,
    prerequisiteHTML,
  ] = await Promise.all([
    rawWorkshop.problemStatements
      ? pProps({
          part1: markdownToHtmlUnwrapped(rawWorkshop.problemStatements.part1),
          part2: markdownToHtmlUnwrapped(rawWorkshop.problemStatements.part2),
          part3: markdownToHtmlUnwrapped(rawWorkshop.problemStatements.part3),
          part4: markdownToHtmlUnwrapped(rawWorkshop.problemStatements.part4),
        })
      : {part1: '', part2: '', part3: '', part4: ''},
    Promise.all(
      rawWorkshop.keyTakeaways?.map(keyTakeaway =>
        pProps({
          title: markdownToHtmlUnwrapped(keyTakeaway.title),
          description: markdownToHtmlUnwrapped(keyTakeaway.description),
        }),
      ) ?? [],
    ),
    Promise.all(topics?.map(r => markdownToHtmlUnwrapped(r)) ?? []),
    rawWorkshop.prerequisite
      ? markdownToHtmlUnwrapped(rawWorkshop.prerequisite)
      : '',
  ])

  return {
    slug,
    title,
    events: events.map(e => ({type: 'manual', ...e})),
    meta,
    description,
    convertKitTag,
    categories,
    problemStatementHTMLs,
    keyTakeawayHTMLs,
    topicHTMLs,
    prerequisiteHTML,
  }
}

export {getWorkshops}

export const cache: Cache<unknown> = {
  name: 'SQLite cache',
  async get(key) {
    const result = await prisma.cache.findUnique({
      where: {key},
      select: {metadata: true, value: true},
    })
    if (!result) return null
    return {
      metadata: result.metadata,
      value: JSON.parse(result.value),
    }
  },
  async set(key, {value, metadata}) {
    await prisma.cache.upsert({
      where: {key},
      create: {
        key,
        value: JSON.stringify(value),
        metadata: {create: metadata},
      },
      update: {
        key,
        value: JSON.stringify(value),
        metadata: {
          upsert: {
            update: metadata,
            create: metadata,
          },
        },
      },
    })
  },
  async delete(key) {
    await prisma.cache.delete({where: {key}})
  },
}

import type { CacheEntry } from 'cachified';
import LRUCache from 'lru-cache';
import { cachified, createBatch } from 'cachified';

type Entry = any;
const lru = new LRUCache<string, CacheEntry<string>>({ max: 1000 });

function getEntries(ids: number[]): Promise<Entry[]> {
  const batch = createBatch(getFreshValues);

  return Promise.all(
    ids.map((id) =>
      cachified({
        key: `entry-${id}`,
        cache: lru,
        getFreshValue: batch.add(id),
      }),
    ),
  );
}

async function getFreshValues(idsThatAreNotInCache: number[]): Entry[] {
  const res = await fetch(
    `https://example.org/api?ids=${idsThatAreNotInCache.join(',')}`,
  );
  const data = await res.json();

  return data as Entry[];
}

import { LRUCache } from "lru-cache";
import { cachified, CacheEntry } from "cachified";

const lru = new LRUCache<string, CacheEntry>({ max: 1000 });

function getUser() {
  return cachified({
    key: `user`,
    cache: lru,
    async getFreshValue() {
           //    ^? (property) CachifiedOptions<{ name: string; }>.getFreshValue: GetFreshValue<{ name: string }>
      return { name: 'Max' }
    },
  });
}

import { LRUCache } from "lru-cache";
import { cachified, CacheEntry, verboseReporter } from "cachified";

const lru = new LRUCache<string, CacheEntry>({ max: 1000 });

function getUser() {
  return cachified({
    key: `user`,
    cache: lru,
    reporter: verboseReporter(),
    async getFreshValue() {
           //    ^? (property) CachifiedOptions<unknown>.getFreshValue: GetFreshValue<unknown>
      return { name: 'Max' }
    },
  });
}

// This is a sample Cloudflare worker script

import { cachified, Cache, cloudflareKvCacheAdapter } from 'cachified';

export interface Env {
  KV: KVNamespace;
  CACHIFIED_KV_CACHE: Cache;
}

export async function getUserById(userId: number, env: Env): Promise<Record<string, unknown>> {
  return cachified({
    key: `user-${userId}`,
    cache: env.CACHIFIED_KV_CACHE,
    async getFreshValue() {
      const response = await fetch(`https://jsonplaceholder.typicode.com/users/${userId}`);
      return response.json();
    },
    ttl: 300_000,
  });
}

export default {
  async fetch(request: Request, env: Env, ctx: ExecutionContext): Promise<Response> {
    // It is a common pattern to pass around the env object to most functions when writing workers code
    // So it's convenient to inject the cache adapter into the env object
    env.CACHIFIED_KV_CACHE = cloudflareKvCacheAdapter({
      kv: env.KV,
      ctx: ctx,
      keyPrefix: 'mycache', // optional
    });
    const userId = Math.floor(Math.random() * 10) + 1;
    const user = await getUserById(userId, env);
    return new Response(`User data is ${JSON.stringify(user)}`);
  },
};

// default to false for enableRedisJson
export declare function redisCacheAdapter(redisCache: RedisLikeCache, options?: { enableRedisJson?: boolean }): Cache;

async function getEventAttendeeCount(eventId: string) {
	const event = await getEvent(eventId)
	return event.attendees.length
}

const attendeeCountCache = {}
type CacheOptions = { ttl?: number; swr?: number }
async function updateEventAttendeeCountCache(
	eventId: string,
	{ ttl = 1000 * 60 * 60 * 24, swr = 1000 * 60 * 60 },
) {
	attendeeCountCache[eventId] = {
		value: await getEventAttendeeCount(eventId),
		createdTime: Date.now(),
		ttl,
		swr,
	}
}

async function softPurgeEventAttendeeCountCache(eventId: string) {
	if (!attendeeCountCache[eventId]) return

	attendeeCountCache[eventId] = {
		...attendeeCountCache[eventId],
		ttl: 0,
		swr:
			attendeeCountCache[eventId].ttl +
			attendeeCountCache[eventId].createdTime,
	}
}

async function getEventAttendeeCountCached(
	eventId: string,
	{ forceFresh, ...cacheOptions }: CacheOptions & { forceFresh?: boolean } = {},
) {
	if (forceFresh) {
		await updateEventAttendeeCountCache(eventId, cacheOptions)
	}
	const cacheEntry = attendeeCountCache[eventId]
	if (!cacheEntry || cacheEntry.createdTime + cacheEntry.ttl < Date.now()) {
		const expiredTime = cacheEntry.createdTime + cacheEntry.ttl
		const serveStale = expiredTime + cacheEntry.swr > Date.now()
		if (serveStale) {
			// fire and forget (update in the background)
			void updateEventAttendeeCountCache(eventId, cacheOptions)
		} else {
			// wait for update
			await updateEventAttendeeCountCache(eventId, cacheOptions)
		}
	}

	return attendeeCountCache[eventId].value
}

function abortTimeoutSignal(timeMs: number) {
  const abortController = new AbortController()
  void new Promise(resolve => setTimeout(resolve, timeMs)).then(() => {
    abortController.abort()
  })
  return abortController.signal
}

async function gravatarExistsForEmail({
  email,
  request,
  timings,
  forceFresh,
}: {
  email: string
  request: Request
  timings?: Timings
  forceFresh?: boolean
}) {
  return cachified({
    key: `gravatar-exists-for:${email}`,
    cache: lruCache,
    request,
    timings,
    forceFresh,
    ttl: 1000 * 20,
    staleWhileRevalidate: 1000 * 60 * 60 * 24 * 365,
    checkValue: prevValue => typeof prevValue === 'boolean',
    getFreshValue: async () => {
      const gravatarUrl = getAvatar(email, {fallback: '404'})
      try {
        const avatarResponse = await fetch(gravatarUrl, {
          method: 'HEAD',
          signal: abortTimeoutSignal(1000 * 2),
        })
        return avatarResponse.status === 200
      } catch (error: unknown) {
        console.error(`Error getting gravatar for ${email}:`, error)
        return false
      }
    },
  })
}

export interface Cache {
    name?: string;
    get: (key: string) => Eventually<CacheEntry<unknown>>;
    set: (key: string, value: CacheEntry<unknown>) => unknown | Promise<unknown>;
    delete: (key: string) => unknown | Promise<unknown>;
    batch?: {
      get: (keys: string[]) => Eventually<CacheEntry<unknown>[]>;
      set: (entries: { key: string, value: CacheEntry<unknown> }[]) => unknown | Promise<unknown>;
      delete: (keys: string[]) => unknown | Promise<unknown>;
    }
}