@j0hanz/superfetch 1.2.5 → 2.0.1

package/dist/services/cache.d.ts

@@ -1,20 +1,15 @@
 import type { CacheEntry } from '../config/types/content.js';
-interface CacheKeyParts {
+export interface CacheUpdateEvent {
+    cacheKey: string;
     namespace: string;
     urlHash: string;
 }
-interface CacheUpdateEvent extends CacheKeyParts {
-    cacheKey: string;
-}
+type CacheUpdateListener = (event: CacheUpdateEvent) => void;
+export declare function onCacheUpdate(listener: CacheUpdateListener): () => void;
 interface CacheEntryMetadata {
     url: string;
     title?: string;
 }
-type CacheUpdateListener = (event: CacheUpdateEvent) => void;
-export declare function createCacheKey(namespace: string, url: string, vary?: Record<string, unknown> | string): string | null;
-export declare function parseCacheKey(cacheKey: string): CacheKeyParts | null;
-export declare function toResourceUri(cacheKey: string): string | null;
-export declare function onCacheUpdate(listener: CacheUpdateListener): () => void;
 export declare function get(cacheKey: string | null): CacheEntry | undefined;
 export declare function set(cacheKey: string | null, content: string, metadata: CacheEntryMetadata): void;
 export declare function keys(): readonly string[];

package/dist/services/cache.js

@@ -1,11 +1,28 @@
 import { setInterval as setIntervalPromise } from 'node:timers/promises';
-import { CACHE_HASH } from '../config/constants.js';
 import { config } from '../config/index.js';
-import { sha256Hex } from '../utils/crypto.js';
-import { getErrorMessage } from '../utils/error-utils.js';
+import { getErrorMessage } from '../utils/error-details.js';
+import { parseCacheKey } from './cache-keys.js';
 import { logWarn } from './logger.js';
 const contentCache = new Map();
 let cleanupController = null;
+const updateListeners = new Set();
+export function onCacheUpdate(listener) {
+    updateListeners.add(listener);
+    return () => {
+        updateListeners.delete(listener);
+    };
+}
+function notifyCacheUpdate(cacheKey) {
+    if (updateListeners.size === 0)
+        return;
+    const parts = parseCacheKey(cacheKey);
+    if (!parts)
+        return;
+    const event = { cacheKey, ...parts };
+    for (const listener of updateListeners) {
+        listener(event);
+    }
+}
 function startCleanupLoop() {
     if (cleanupController)
         return;
@@ -18,156 +35,73 @@ function startCleanupLoop() {
 }
 async function runCleanupLoop(signal) {
     const intervalMs = Math.floor(config.cache.ttl * 1000);
-    for await (const _ of setIntervalPromise(intervalMs, undefined, {
+    for await (const getNow of setIntervalPromise(intervalMs, Date.now, {
         signal,
         ref: false,
     })) {
-        evictEntries();
+        enforceCacheLimits(getNow());
     }
 }
-function evictEntries() {
-    const now = Date.now();
+function enforceCacheLimits(now) {
     for (const [key, item] of contentCache.entries()) {
         if (now > item.expiresAt) {
             contentCache.delete(key);
         }
     }
-    if (contentCache.size <= config.cache.maxKeys)
-        return;
-    const keysToRemove = contentCache.size - config.cache.maxKeys;
-    const iterator = contentCache.keys();
-    for (let i = 0; i < keysToRemove; i++) {
-        const { value, done } = iterator.next();
-        if (done)
-            break;
-        contentCache.delete(value);
-    }
+    trimCacheToMaxKeys();
 }
-const updateListeners = new Set();
-function stableStringify(value) {
-    if (value === null || value === undefined) {
-        return '';
-    }
-    if (typeof value !== 'object') {
-        return JSON.stringify(value);
-    }
-    if (Array.isArray(value)) {
-        return `[${value.map((item) => stableStringify(item)).join(',')}]`;
-    }
-    const entries = Object.entries(value)
-        .filter(([, entryValue]) => entryValue !== undefined)
-        .sort(([a], [b]) => a.localeCompare(b))
-        .map(([key, entryValue]) => `${JSON.stringify(key)}:${stableStringify(entryValue)}`);
-    return `{${entries.join(',')}}`;
-}
-function createHashFragment(input, length) {
-    return sha256Hex(input).substring(0, length);
-}
-/**
- * Constructs a cache key from namespace, URL hash, and optional vary hash.
- * Format: "namespace:urlHash" or "namespace:urlHash.varyHash" if vary params exist.
- * @param namespace - Cache namespace (e.g., "fetch-markdown")
- * @param urlHash - SHA-256 hash of the URL (truncated to 16 chars)
- * @param varyHash - Optional hash of vary parameters (e.g., headers, options)
- * @returns Complete cache key string
- */
-function buildCacheKey(namespace, urlHash, varyHash) {
-    return varyHash
-        ? `${namespace}:${urlHash}.${varyHash}`
-        : `${namespace}:${urlHash}`;
-}
-function getVaryHash(vary) {
-    if (!vary)
-        return undefined;
-    const varyString = typeof vary === 'string' ? vary : stableStringify(vary);
-    if (!varyString)
+export function get(cacheKey) {
+    if (!isCacheReadable(cacheKey))
         return undefined;
-    return createHashFragment(varyString, CACHE_HASH.VARY_HASH_LENGTH);
-}
-export function createCacheKey(namespace, url, vary) {
-    if (!namespace || !url)
-        return null;
-    const urlHash = createHashFragment(url, CACHE_HASH.URL_HASH_LENGTH);
-    const varyHash = getVaryHash(vary);
-    return buildCacheKey(namespace, urlHash, varyHash);
-}
-export function parseCacheKey(cacheKey) {
-    if (!cacheKey)
-        return null;
-    const [namespace, ...rest] = cacheKey.split(':');
-    const urlHash = rest.join(':');
-    if (!namespace || !urlHash)
-        return null;
-    return { namespace, urlHash };
-}
-export function toResourceUri(cacheKey) {
-    const parts = parseCacheKey(cacheKey);
-    if (!parts)
-        return null;
-    return `superfetch://cache/${parts.namespace}/${parts.urlHash}`;
+    return runCacheOperation(cacheKey, 'Cache get error', () => readCacheEntry(cacheKey));
 }
-export function onCacheUpdate(listener) {
-    updateListeners.add(listener);
-    return () => {
-        updateListeners.delete(listener);
-    };
+function isCacheReadable(cacheKey) {
+    return config.cache.enabled && Boolean(cacheKey);
 }
-function emitCacheUpdate(cacheKey) {
-    const parts = parseCacheKey(cacheKey);
-    if (!parts)
-        return;
-    for (const listener of updateListeners) {
-        listener({ cacheKey, ...parts });
-    }
+function isCacheWritable(cacheKey, content) {
+    return config.cache.enabled && Boolean(cacheKey) && Boolean(content);
 }
-export function get(cacheKey) {
-    if (!isCacheReadable(cacheKey))
-        return undefined;
+function runCacheOperation(cacheKey, message, operation) {
     try {
-        return readCacheEntry(cacheKey);
+        return operation();
     }
     catch (error) {
-        logWarn('Cache get error', {
-            key: cacheKey.substring(0, 100),
-            error: getErrorMessage(error),
-        });
+        logCacheError(message, cacheKey, error);
         return undefined;
     }
 }
-function isCacheReadable(cacheKey) {
-    return config.cache.enabled && Boolean(cacheKey);
-}
 function readCacheEntry(cacheKey) {
+    const now = Date.now();
+    return readCacheItem(cacheKey, now)?.entry;
+}
+function isExpired(item, now) {
+    return now > item.expiresAt;
+}
+function readCacheItem(cacheKey, now) {
     const item = contentCache.get(cacheKey);
     if (!item)
         return undefined;
-    if (isExpired(item)) {
+    if (isExpired(item, now)) {
         contentCache.delete(cacheKey);
         return undefined;
     }
-    return item.entry;
-}
-function isExpired(item) {
-    return Date.now() > item.expiresAt;
+    return item;
 }
 export function set(cacheKey, content, metadata) {
-    if (!config.cache.enabled)
+    if (!isCacheWritable(cacheKey, content))
         return;
-    if (!cacheKey)
-        return;
-    if (!content)
-        return;
-    try {
+    runCacheOperation(cacheKey, 'Cache set error', () => {
         startCleanupLoop();
-        const entry = buildCacheEntry(cacheKey, content, metadata);
-        persistCacheEntry(cacheKey, entry);
-    }
-    catch (error) {
-        logWarn('Cache set error', {
-            key: cacheKey.substring(0, 100),
-            error: getErrorMessage(error),
+        const now = Date.now();
+        const expiresAtMs = now + config.cache.ttl * 1000;
+        const entry = buildCacheEntry({
+            content,
+            metadata,
+            fetchedAtMs: now,
+            expiresAtMs,
         });
-    }
+        persistCacheEntry(cacheKey, entry, expiresAtMs);
+    });
 }
 export function keys() {
     return Array.from(contentCache.keys());
@@ -175,33 +109,37 @@ export function keys() {
 export function isEnabled() {
     return config.cache.enabled;
 }
-function buildCacheEntry(cacheKey, content, metadata) {
-    const entry = {
+function buildCacheEntry({ content, metadata, fetchedAtMs, expiresAtMs, }) {
+    return {
         url: metadata.url,
         content,
-        fetchedAt: new Date().toISOString(),
-        expiresAt: new Date(Date.now() + config.cache.ttl * 1000).toISOString(),
+        fetchedAt: new Date(fetchedAtMs).toISOString(),
+        expiresAt: new Date(expiresAtMs).toISOString(),
+        ...(metadata.title === undefined ? {} : { title: metadata.title }),
     };
-    if (metadata.title !== undefined) {
-        entry.title = metadata.title;
-    }
-    return entry;
 }
-function persistCacheEntry(cacheKey, entry) {
-    const expiresAt = Date.now() + config.cache.ttl * 1000;
-    contentCache.set(cacheKey, { entry, expiresAt });
-    enforceMaxKeysLimit();
-    emitCacheUpdate(cacheKey);
+function persistCacheEntry(cacheKey, entry, expiresAtMs) {
+    contentCache.set(cacheKey, { entry, expiresAt: expiresAtMs });
+    trimCacheToMaxKeys();
+    notifyCacheUpdate(cacheKey);
 }
-function enforceMaxKeysLimit() {
+function trimCacheToMaxKeys() {
     if (contentCache.size <= config.cache.maxKeys)
         return;
-    const keysToRemove = contentCache.size - config.cache.maxKeys;
+    removeOldestEntries(contentCache.size - config.cache.maxKeys);
+}
+function removeOldestEntries(count) {
     const iterator = contentCache.keys();
-    for (let i = 0; i < keysToRemove; i++) {
-        const { value, done } = iterator.next();
-        if (done)
+    for (let removed = 0; removed < count; removed += 1) {
+        const next = iterator.next();
+        if (next.done)
             break;
-        contentCache.delete(value);
+        contentCache.delete(next.value);
     }
 }
+function logCacheError(message, cacheKey, error) {
+    logWarn(message, {
+        key: cacheKey.length > 100 ? cacheKey.slice(0, 100) : cacheKey,
+        error: getErrorMessage(error),
+    });
+}

package/dist/services/context.d.ts

@@ -3,7 +3,6 @@ interface RequestContext {
     readonly sessionId?: string;
 }
 export declare function runWithRequestContext<T>(context: RequestContext, fn: () => T): T;
-export declare function bindToRequestContext<T extends (...args: unknown[]) => unknown>(fn: T): T;
 export declare function getRequestId(): string | undefined;
 export declare function getSessionId(): string | undefined;
 export {};

package/dist/services/context.js

@@ -3,13 +3,6 @@ const requestContext = new AsyncLocalStorage();
 export function runWithRequestContext(context, fn) {
     return requestContext.run(context, fn);
 }
-export function bindToRequestContext(fn) {
-    const store = requestContext.getStore();
-    if (!store) {
-        return fn;
-    }
-    return ((...args) => requestContext.run(store, () => fn(...args)));
-}
 export function getRequestId() {
     return requestContext.getStore()?.requestId;
 }

package/dist/services/extractor.js

@@ -1,101 +1,28 @@
 import { parseHTML } from 'linkedom';
 import { Readability } from '@mozilla/readability';
-import { getErrorMessage } from '../utils/error-utils.js';
+import { getErrorMessage } from '../utils/error-details.js';
+import { isRecord } from '../utils/guards.js';
 import { truncateHtml } from '../utils/html-truncator.js';
 import { logError, logInfo, logWarn } from './logger.js';
-import { createMetaCollectorState, resolveMetaField, } from './metadata-collector.js';
-function collectMetaTag(state, tag) {
-    const content = getMetaContent(tag);
-    if (!content)
-        return;
-    if (collectOpenGraphMeta(state, tag, content))
-        return;
-    if (collectTwitterMeta(state, tag, content))
-        return;
-    collectStandardMeta(state, tag, content);
-}
-function getMetaContent(tag) {
-    return tag.getAttribute('content')?.trim() ?? null;
-}
-function collectOpenGraphMeta(state, tag, content) {
-    const property = tag.getAttribute('property');
-    if (!property?.startsWith('og:'))
-        return false;
-    const key = property.replace('og:', '');
-    if (key === 'title')
-        state.title.og = content;
-    if (key === 'description')
-        state.description.og = content;
-    return true;
-}
-function collectTwitterMeta(state, tag, content) {
-    const name = tag.getAttribute('name');
-    if (!name?.startsWith('twitter:'))
+import { extractMetadata } from './metadata-collector.js';
+function isReadabilityCompatible(doc) {
+    if (!isRecord(doc))
         return false;
-    const key = name.replace('twitter:', '');
-    if (key === 'title')
-        state.title.twitter = content;
-    if (key === 'description')
-        state.description.twitter = content;
-    return true;
-}
-function collectStandardMeta(state, tag, content) {
-    const name = tag.getAttribute('name');
-    if (name === 'description') {
-        state.description.standard = content;
-    }
-    if (name === 'author') {
-        state.author.standard = content;
-    }
+    return hasDocumentElement(doc) && hasQuerySelectors(doc);
 }
-function scanMetaTags(document, state) {
-    const metaTags = document.querySelectorAll('meta');
-    for (const tag of metaTags) {
-        collectMetaTag(state, tag);
-    }
-}
-function ensureTitleFallback(document, state) {
-    if (state.title.standard)
-        return;
-    const titleEl = document.querySelector('title');
-    if (titleEl?.textContent) {
-        state.title.standard = titleEl.textContent.trim();
-    }
+function hasDocumentElement(record) {
+    return 'documentElement' in record;
 }
-function extractMetadata(document) {
-    const state = createMetaCollectorState();
-    scanMetaTags(document, state);
-    ensureTitleFallback(document, state);
-    const metadata = {};
-    const title = resolveMetaField(state, 'title');
-    const description = resolveMetaField(state, 'description');
-    const author = resolveMetaField(state, 'author');
-    if (title !== undefined)
-        metadata.title = title;
-    if (description !== undefined)
-        metadata.description = description;
-    if (author !== undefined)
-        metadata.author = author;
-    return metadata;
-}
-function isReadabilityCompatible(doc) {
-    if (!doc || typeof doc !== 'object')
-        return false;
-    if (!('documentElement' in doc))
-        return false;
-    if (!('querySelectorAll' in doc))
-        return false;
-    if (!('querySelector' in doc))
-        return false;
-    return true;
+function hasQuerySelectors(record) {
+    return (typeof record.querySelectorAll === 'function' &&
+        typeof record.querySelector === 'function');
 }
 function extractArticle(document) {
     if (!isReadabilityCompatible(document)) {
         logWarn('Document not compatible with Readability');
         return null;
     }
-    const parsed = parseReadabilityArticle(document);
-    return parsed ? mapReadabilityResult(parsed) : null;
+    return mapParsedArticle(parseReadabilityArticle(document));
 }
 function parseReadabilityArticle(document) {
     try {
@@ -104,31 +31,38 @@ function parseReadabilityArticle(document) {
         return reader.parse();
     }
     catch (error) {
-        logError('Failed to extract article with Readability', error instanceof Error ? error : undefined);
+        logError('Failed to extract article with Readability', asError(error));
         return null;
     }
 }
+function asError(error) {
+    if (error instanceof Error) {
+        return error;
+    }
+    return undefined;
+}
+function mapParsedArticle(parsed) {
+    return parsed ? mapReadabilityResult(parsed) : null;
+}
 function mapReadabilityResult(parsed) {
-    const article = {
+    return {
         content: parsed.content ?? '',
         textContent: parsed.textContent ?? '',
+        ...buildOptionalArticleFields(parsed),
     };
-    const title = toOptional(parsed.title);
-    if (title !== undefined)
-        article.title = title;
-    const byline = toOptional(parsed.byline);
-    if (byline !== undefined)
-        article.byline = byline;
-    const excerpt = toOptional(parsed.excerpt);
-    if (excerpt !== undefined)
-        article.excerpt = excerpt;
-    const siteName = toOptional(parsed.siteName);
-    if (siteName !== undefined)
-        article.siteName = siteName;
-    return article;
-}
-function toOptional(value) {
-    return value ?? undefined;
+}
+function buildOptionalArticleFields(parsed) {
+    const optional = {};
+    addOptionalField(optional, 'title', parsed.title);
+    addOptionalField(optional, 'byline', parsed.byline);
+    addOptionalField(optional, 'excerpt', parsed.excerpt);
+    addOptionalField(optional, 'siteName', parsed.siteName);
+    return optional;
+}
+function addOptionalField(target, key, value) {
+    if (value == null)
+        return;
+    target[key] = value;
 }
 export function extractContent(html, url, options = { extractArticle: true }) {
     if (!isValidInput(html, url)) {
@@ -138,12 +72,13 @@ export function extractContent(html, url, options = { extractArticle: true }) {
 }
 function tryExtractContent(html, url, options) {
     try {
-        const processedHtml = truncateHtml(html);
-        const { document } = parseHTML(processedHtml);
+        const { document } = parseHTML(truncateHtml(html));
         applyBaseUri(document, url);
         const metadata = extractMetadata(document);
-        const article = options.extractArticle ? extractArticle(document) : null;
-        return { article, metadata };
+        return {
+            article: resolveArticleExtraction(document, options.extractArticle),
+            metadata,
+        };
     }
     catch (error) {
         logError('Failed to extract content', error instanceof Error ? error : undefined);
@@ -151,15 +86,19 @@ function tryExtractContent(html, url, options) {
     }
 }
 function isValidInput(html, url) {
-    if (!html || typeof html !== 'string') {
-        logWarn('extractContent called with invalid HTML input');
-        return false;
-    }
-    if (!url || typeof url !== 'string') {
-        logWarn('extractContent called with invalid URL');
-        return false;
-    }
-    return true;
+    return (validateRequiredString(html, 'extractContent called with invalid HTML input') && validateRequiredString(url, 'extractContent called with invalid URL'));
+}
+function validateRequiredString(value, message) {
+    if (isNonEmptyString(value))
+        return true;
+    logWarn(message);
+    return false;
+}
+function isNonEmptyString(value) {
+    return typeof value === 'string' && value.length > 0;
+}
+function resolveArticleExtraction(document, shouldExtract) {
+    return shouldExtract ? extractArticle(document) : null;
 }
 function applyBaseUri(document, url) {
     try {

package/dist/services/fetcher/agents.d.ts

@@ -1,3 +1,3 @@
-import { Agent } from 'undici';
-export declare const dispatcher: Agent;
+import { type Dispatcher } from 'undici';
+export declare const dispatcher: Dispatcher;
 export declare function destroyAgents(): void;