@gscdump/nuxt 0.19.7 → 0.20.0

package/README.md

@@ -81,9 +81,10 @@ the data — e.g. nuxtseo.com pro consuming gscdump.com. Two pieces:
 2. **Hand the layer a per-viewer api key**: register a client plugin that
    trades the viewer's host session for an api key, then call
    `setGscFetchHeaders({ 'x-api-key': key })`. The layer's `useGscFetch`
-   attaches the header to every `/api/__gsc/*` call automatically. The same
-   header rides parquet GETs in `attachParquetUrlTables` (DuckDB-WASM
-   browser path), so R2 reads work cross-origin.
+   attaches the header to every `/api/__gsc/*` call automatically. Browser
+   parquet reads use exact-object URLs minted by the source endpoint; runtime
+   preflights can include this header, while DuckDB-WASM range reads are
+   authorized by the token embedded in each URL.
 
 The `setupGscFetchAuth` helper collapses the boilerplate:
 

package/app/composables/useGscAnalyticsSourceInfo.ts

@@ -5,11 +5,12 @@
 // Use this to render locked/ghost UI upfront without issuing a doomed
 // analyze() call for each panel.
 //
-// The reactive composable and the non-reactive `loadSourceInfoFor` (used by
-// `useGscAnalyzer.createInstance`) share one entry per site via the shared
-// site-resource seam, so they collapse to one network read per session.
+// The reactive composable and the non-reactive `loadSourceInfoFor` share one
+// entry per site/searchType/range via the shared site-resource seam, so they
+// collapse to one network read per session slice.
 
 import type { SourceCapabilities } from '@gscdump/analysis'
+import type { SourceInfoOptions } from '@gscdump/contracts'
 import { acquireSharedEntry, useGscSharedSiteResource } from './_useGscSharedSiteResource'
 import { useGscAnalyticsClient } from './useGscAnalyticsClient'
 
@@ -48,6 +49,7 @@ interface SourceInfoEntry {
 }
 
 const SOURCE_INFO_NAMESPACE = 'source-info'
+const DEFAULT_SEARCH_TYPE = 'web'
 
 function createEntry(): SourceInfoEntry {
   return {
@@ -58,12 +60,21 @@ function createEntry(): SourceInfoEntry {
   }
 }
 
-function fetchInto(entry: SourceInfoEntry, siteId: string): Promise<void> {
+function sourceInfoKey(siteId: string, options?: SourceInfoOptions): string {
+  return JSON.stringify([
+    siteId,
+    options?.searchType ?? DEFAULT_SEARCH_TYPE,
+    options?.start ?? options?.startDate ?? null,
+    options?.end ?? options?.endDate ?? null,
+  ])
+}
+
+function fetchInto(entry: SourceInfoEntry, siteId: string, options?: SourceInfoOptions): Promise<void> {
   if (entry.pending.value)
     return entry.pending.value
   entry.loading.value = true
   entry.error.value = null
-  const p = (useGscAnalyticsClient().getSourceInfo(siteId) as Promise<GscAnalyticsSourceInfo>)
+  const p = (useGscAnalyticsClient().getSourceInfo(siteId, options) as Promise<GscAnalyticsSourceInfo>)
     .then((data) => {
       entry.info.value = data
     })
@@ -85,11 +96,11 @@ function fetchInto(entry: SourceInfoEntry, siteId: string): Promise<void> {
  * site-resource seam, so gating UI and the analyzer mode probe collapse to
  * one network read per site per session.
  */
-export async function loadSourceInfoFor(siteId: string): Promise<GscAnalyticsSourceInfo> {
-  const entry = acquireSharedEntry(SOURCE_INFO_NAMESPACE, siteId, createEntry)
+export async function loadSourceInfoFor(siteId: string, options?: SourceInfoOptions): Promise<GscAnalyticsSourceInfo> {
+  const entry = acquireSharedEntry(SOURCE_INFO_NAMESPACE, sourceInfoKey(siteId, options), createEntry)
   if (entry.info.value)
     return entry.info.value
-  await fetchInto(entry, siteId)
+  await fetchInto(entry, siteId, options)
   if (entry.error.value)
     throw entry.error.value
   if (!entry.info.value)
@@ -99,8 +110,13 @@ export async function loadSourceInfoFor(siteId: string): Promise<GscAnalyticsSou
 
 export function useGscAnalyticsSourceInfo(
   siteId: MaybeRefOrGetter<string | null | undefined>,
+  options: MaybeRefOrGetter<SourceInfoOptions | null | undefined> = null,
 ): GscAnalyticsSourceInfoState {
-  const { bound } = useGscSharedSiteResource<SourceInfoEntry>(SOURCE_INFO_NAMESPACE, siteId, {
+  const cacheKey = computed(() => {
+    const id = toValue(siteId)
+    return id ? sourceInfoKey(id, toValue(options) ?? undefined) : null
+  })
+  const { bound } = useGscSharedSiteResource<SourceInfoEntry>(SOURCE_INFO_NAMESPACE, cacheKey, {
     factory: () => createEntry(),
     // No onDispose: source-info is cheap and persistent across the session.
   })
@@ -113,7 +129,7 @@ export function useGscAnalyticsSourceInfo(
       if (!id)
         return
       if (entry.info.value == null && entry.pending.value == null && entry.error.value == null)
-        void fetchInto(entry, id)
+        void fetchInto(entry, id, toValue(options) ?? undefined)
     }, { immediate: true })
   }
 
@@ -127,7 +143,7 @@ export function useGscAnalyticsSourceInfo(
     if (!entry || !id)
       return
     entry.info.value = null
-    await fetchInto(entry, id)
+    await fetchInto(entry, id, toValue(options) ?? undefined)
   }
 
   function supports(analyzerId: MaybeRefOrGetter<string>): ComputedRef<boolean> {

package/app/composables/useGscAnalyzer.ts

@@ -21,7 +21,6 @@ import { useGscSharedSiteResource } from './_useGscSharedSiteResource'
 import { useGscAnalyticsContext } from './useGscAnalytics'
 import { useGscAnalyticsClient } from './useGscAnalyticsClient'
 import { useGscAnalyticsConfig } from './useGscAnalyticsConfig'
-import { loadSourceInfoFor } from './useGscAnalyticsSourceInfo'
 import { resolveGscAuthHeaders } from './useGscAuth'
 
 export interface GscAnalyzerTimings {
@@ -51,6 +50,58 @@ export interface GscAnalyzerInstance {
 }
 
 const EMPTY_TABLES: readonly string[] = Object.freeze([])
+const DEFAULT_SEARCH_TYPE: NonNullable<AnalysisParams['searchType']> = 'web'
+const DEFAULT_ATTACH_FETCH_CONCURRENCY = 2
+const DEFAULT_ATTACH_MAX_FILES = 32
+const DEFAULT_ATTACH_MAX_BYTES = 16 * 1024 * 1024
+
+interface AnalyzerRange {
+  start: string
+  end: string
+}
+
+interface AnalysisSourcesClient {
+  getAnalysisSources: (
+    siteId: string,
+    tables?: string[] | string | { tables?: string[] | string, searchType?: NonNullable<AnalysisParams['searchType']>, start?: string, end?: string },
+    options?: { searchType?: NonNullable<AnalysisParams['searchType']>, start?: string, end?: string },
+  ) => Promise<AnalysisSourcesResponse>
+  getSourceInfo: (
+    siteId: string,
+    options?: { searchType?: NonNullable<AnalysisParams['searchType']>, start?: string, end?: string },
+  ) => Promise<SourceInfoResponse>
+}
+
+function normalizeSearchType(searchType: AnalysisParams['searchType']): NonNullable<AnalysisParams['searchType']> {
+  return searchType ?? DEFAULT_SEARCH_TYPE
+}
+
+function analyzerCacheKey(siteId: string, searchType: NonNullable<AnalysisParams['searchType']>, range: AnalyzerRange | null): string {
+  return JSON.stringify([siteId, searchType, range?.start ?? null, range?.end ?? null])
+}
+
+function parseAnalyzerCacheKey(key: string): { siteId: string, searchType: NonNullable<AnalysisParams['searchType']>, range: AnalyzerRange | null } {
+  const [siteId, searchType, start, end] = JSON.parse(key) as [string, NonNullable<AnalysisParams['searchType']>, string | null, string | null]
+  return { siteId, searchType, range: start && end ? { start, end } : null }
+}
+
+function normalizeRange(range: AnalyzerRange | null | undefined): AnalyzerRange | null {
+  return range?.start && range?.end ? range : null
+}
+
+function loadSourceInfo(siteId: string, searchType: NonNullable<AnalysisParams['searchType']>, range: AnalyzerRange | null): Promise<SourceInfoResponse> {
+  return (useGscAnalyticsClient() as unknown as AnalysisSourcesClient).getSourceInfo(siteId, {
+    searchType,
+    ...(range ? { start: range.start, end: range.end } : {}),
+  })
+}
+
+function loadAnalysisSources(siteId: string, searchType: NonNullable<AnalysisParams['searchType']>, range: AnalyzerRange | null): Promise<AnalysisSourcesResponse> {
+  return (useGscAnalyticsClient() as unknown as AnalysisSourcesClient).getAnalysisSources(siteId, undefined, {
+    searchType,
+    ...(range ? { start: range.start, end: range.end } : {}),
+  })
+}
 
 /**
  * Get (or create) an analyzer for a site. Per-site cached across the app so
@@ -59,10 +110,21 @@ const EMPTY_TABLES: readonly string[] = Object.freeze([])
  * bound cached instance; switching `siteId` rebinds and the computeds track
  * the new instance with no manual mirroring.
  */
-export function useGscAnalyzer(siteId: MaybeRefOrGetter<string | null | undefined>): GscAnalyzerInstance & { currentSiteId: Ref<string | null> } {
+export function useGscAnalyzer(
+  siteId: MaybeRefOrGetter<string | null | undefined>,
+  searchType: MaybeRefOrGetter<AnalysisParams['searchType']> = DEFAULT_SEARCH_TYPE,
+  range: MaybeRefOrGetter<AnalyzerRange | null | undefined> = null,
+): GscAnalyzerInstance & { currentSiteId: Ref<string | null> } {
   const ctx = useGscAnalyticsContext()
-  const { bound, currentSiteId } = useGscSharedSiteResource<GscAnalyzerInstance>('analyzer', siteId, {
-    factory: id => createInstance(id, ctx.patchProgress, () => loadSourceInfoFor(id) as Promise<SourceInfoResponse>),
+  const cacheKey = computed(() => {
+    const id = toValue(siteId)
+    return id ? analyzerCacheKey(id, normalizeSearchType(toValue(searchType)), normalizeRange(toValue(range))) : null
+  })
+  const { bound, currentSiteId: currentCacheKey } = useGscSharedSiteResource<GscAnalyzerInstance>('analyzer', cacheKey, {
+    factory: (key) => {
+      const parsed = parseAnalyzerCacheKey(key)
+      return createInstance(parsed.siteId, parsed.searchType, parsed.range, ctx.patchProgress)
+    },
     onDispose: inst => inst.dispose(),
   })
 
@@ -74,6 +136,10 @@ export function useGscAnalyzer(siteId: MaybeRefOrGetter<string | null | undefine
   const attachedTables = computed(() => bound.value?.attachedTables.value ?? (EMPTY_TABLES as string[])) as unknown as Ref<string[]>
   const timings = computed(() => bound.value?.timings.value ?? null) as unknown as Ref<GscAnalyzerTimings | null>
   const manifestVersion = computed(() => bound.value?.manifestVersion.value) as unknown as Ref<string | undefined>
+  const currentSiteId = computed(() => {
+    const key = currentCacheKey.value
+    return key ? parseAnalyzerCacheKey(key).siteId : null
+  }) as unknown as Ref<string | null>
 
   async function query(sql: string, params?: unknown[]): Promise<QueryResult> {
     const inst = bound.value
@@ -115,8 +181,9 @@ export function useGscAnalyzer(siteId: MaybeRefOrGetter<string | null | undefine
 
 function createInstance(
   siteId: string,
+  searchType: NonNullable<AnalysisParams['searchType']>,
+  range: AnalyzerRange | null,
   patchProgress: (id: string, p: Partial<SiteLoadProgress>) => void,
-  sourceInfoLoader: () => Promise<SourceInfoResponse>,
 ): GscAnalyzerInstance {
   const ready = ref(false)
   const initializing = ref(true)
@@ -133,6 +200,7 @@ function createInstance(
   let bootedDb: DuckDBWasmBootResult | null = null
   let attachedHandle: AttachedTablesHandle | null = null
   let mode: 'browser-attached' | 'server' = 'server'
+  const lifetimeController = new AbortController()
   const inFlight = new Map<string, Promise<AnalysisResult & { queryMs: number }>>()
 
   // Cross-origin: if the host returns relative parquet URLs (`/api/r2-data/…`)
@@ -146,9 +214,11 @@ function createInstance(
     return `${apiBase.replace(/\/+$/, '')}${url}`
   }
 
-  async function attachFromSources(sources: AnalysisSourcesResponse): Promise<{ attached: number, total: number }> {
+  async function attachFromSources(sources: AnalysisSourcesResponse, signal?: AbortSignal): Promise<{ attached: number, total: number }> {
     if (!bootedDb)
       throw new Error('useGscAnalyzer: attachFromSources called before DuckDB boot')
+    if (sources.canUseBrowser === false)
+      throw new Error(`useGscAnalyzer: browser attach unavailable: ${sources.reason ?? sources.fallback ?? 'coverage plan rejected'}`)
 
     const tables = Object.entries(sources.tables)
       .filter(([, urls]) => Array.isArray(urls) && urls.length > 0)
@@ -157,11 +227,10 @@ function createInstance(
     const total = tables.reduce((n, t) => n + t.urls.length, 0)
     patch({ stage: 'attach', filesTotal: total, filesAttached: 0 })
 
-    // Cross-origin parquet GETs need the host-supplied auth header (same one
-    // useGscFetch attaches to /api/__gsc/* calls). DuckDB-WASM runs raw fetch
-    // under the hood, so we pass the header through fetchInit. Cookies aren't
-    // useful here — the parquet origin (gscdump.com) and the host page sit in
-    // different session realms when the consumer mode is active.
+    // URL preflights can use the same host-supplied auth header as /api/__gsc/*.
+    // The actual DuckDB range reads are authorized by the exact-key token
+    // embedded in each analysis-sources URL, because registerFileURL cannot
+    // carry custom fetch headers into DuckDB-WASM's internal HTTP reader.
     const extraHeaders = resolveGscAuthHeaders()
     const hasExtra = Object.keys(extraHeaders).length > 0
     let attached = 0
@@ -174,6 +243,10 @@ function createInstance(
       fetchInit: hasExtra
         ? { credentials: 'omit', headers: extraHeaders }
         : { credentials: 'same-origin' },
+      fetchConcurrency: DEFAULT_ATTACH_FETCH_CONCURRENCY,
+      maxFiles: DEFAULT_ATTACH_MAX_FILES,
+      maxBytes: DEFAULT_ATTACH_MAX_BYTES,
+      signal,
       onFileAttached: () => {
         attached++
         patch({ filesAttached: attached })
@@ -193,7 +266,7 @@ function createInstance(
     patch({ stage: 'manifest', startedAt: Date.now(), filesAttached: 0, filesTotal: 0, error: undefined, endedAt: undefined })
     // Probe the server-resolved source first. Its kind + attachedTables bit
     // decides whether we boot DuckDB-WASM (expensive) or proxy to the server.
-    const info = await sourceInfoLoader()
+    const info = await loadSourceInfo(siteId, searchType, range)
     mode = info.browserAttachEligible ? 'browser-attached' : 'server'
 
     if (mode === 'server') {
@@ -224,11 +297,11 @@ function createInstance(
 
     patch({ stage: 'manifest' })
     const t1 = performance.now()
-    const sources = await useGscAnalyticsClient().getAnalysisSources(siteId) as AnalysisSourcesResponse
+    const sources = await loadAnalysisSources(siteId, searchType, range)
     const manifestMs = performance.now() - t1
 
     const t2 = performance.now()
-    const { total } = await attachFromSources(sources)
+    const { total } = await attachFromSources(sources, lifetimeController.signal)
     const attachMs = performance.now() - t2
 
     runtime = createBrowserAnalysisRuntime(bootedDb, { schema: 'main', attachedTables: attachedTables.value })
@@ -259,7 +332,7 @@ function createInstance(
   }
 
   async function runServerAnalyze(params: AnalysisParams, _signal?: AbortSignal): Promise<AnalysisResult & { queryMs: number }> {
-    const out = await useGscAnalyticsClient().analyze<AnalysisResult & { queryMs?: number }>(siteId, params)
+    const out = await useGscAnalyticsClient().analyze<AnalysisResult & { queryMs?: number }>(siteId, { ...params, searchType: params.searchType ?? searchType })
     return {
       results: coerceResults(out.results) as AnalysisResult['results'],
       meta: out.meta as AnalysisResult['meta'],
@@ -268,18 +341,19 @@ function createInstance(
   }
 
   async function analyze(params: AnalysisParams, opts?: { signal?: AbortSignal }): Promise<AnalysisResult & { queryMs: number }> {
-    const rt = await boot
+    const rt = opts?.signal ? await raceSignal(boot, opts.signal) : await boot
     opts?.signal?.throwIfAborted?.()
 
-    const key = JSON.stringify(params)
+    const scopedParams = { ...params, searchType: params.searchType ?? searchType }
+    const key = JSON.stringify({ manifestVersion: manifestVersion.value, params: scopedParams, searchType, siteId })
     const existing = inFlight.get(key)
     if (existing)
       return opts?.signal ? raceSignal(existing, opts.signal) : existing
 
     const p = (async () => {
       if (!rt)
-        return runServerAnalyze(params, opts?.signal)
-      const out = await rt.analyze(params as never, defaultAnalyzerRegistry)
+        return runServerAnalyze(scopedParams, opts?.signal)
+      const out = await rt.analyze(scopedParams as never, defaultAnalyzerRegistry, { signal: opts?.signal })
       opts?.signal?.throwIfAborted?.()
       return {
         results: coerceResults(out.results) as AnalysisResult['results'],
@@ -287,19 +361,22 @@ function createInstance(
         queryMs: out.queryMs,
       }
     })()
+    if (opts?.signal) {
+      return raceSignal(p, opts.signal)
+    }
     inFlight.set(key, p)
     p.finally(() => {
       if (inFlight.get(key) === p)
         inFlight.delete(key)
     })
-    return opts?.signal ? raceSignal(p, opts.signal) : p
+    return p
   }
 
   async function refresh(): Promise<boolean> {
     await boot
     if (mode !== 'browser-attached' || !runtime || !bootedDb)
       return false
-    const sources = await useGscAnalyticsClient().getAnalysisSources(siteId) as AnalysisSourcesResponse
+    const sources = await loadAnalysisSources(siteId, searchType, range)
     if (!runtime.isStale(sources.manifestVersion))
       return false
     // Drop the stale views before swapping in the new partitions. The runtime
@@ -315,6 +392,7 @@ function createInstance(
   }
 
   async function dispose(): Promise<void> {
+    lifetimeController.abort()
     await runtime?.close().catch((e) => {
       console.error('[analyzer] runtime.close failed', e)
     })

package/app/composables/useGscQuery.ts

@@ -132,8 +132,21 @@ async function defaultServerFallback<T>(siteId: string, params: AnalysisParams):
   return await useGscAnalyticsClient().analyze<T>(siteId, params)
 }
 
+const DEFAULT_SEARCH_TYPE: NonNullable<AnalysisParams['searchType']> = 'web'
+
+function withDefaultSearchType(params: AnalysisParams): AnalysisParams {
+  return { ...params, searchType: params.searchType ?? DEFAULT_SEARCH_TYPE }
+}
+
 export function useGscQuery<T = AnalysisResult>(opts: UseGscQueryOptions<T>): UseGscQueryReturn<T> {
-  const analyzer = useGscAnalyzer(opts.site)
+  const querySearchType = computed(() => toValue(opts.params).searchType ?? DEFAULT_SEARCH_TYPE)
+  const queryRange = computed(() => {
+    const params = toValue(opts.params)
+    return typeof params.startDate === 'string' && typeof params.endDate === 'string'
+      ? { start: params.startDate, end: params.endDate }
+      : null
+  })
+  const analyzer = useGscAnalyzer(opts.site, querySearchType, queryRange)
   const dispatcher = useGscQueryDispatcher()
 
   const data = shallowRef<T | null>(null)
@@ -164,7 +177,7 @@ export function useGscQuery<T = AnalysisResult>(opts: UseGscQueryOptions<T>): Us
   async function runServer(siteId: string): Promise<void> {
     const t0 = performance.now()
     const fn = opts.serverFallback ?? defaultServerFallback
-    const out = await fn(siteId, toValue(opts.params)) as T
+    const out = await fn(siteId, withDefaultSearchType(toValue(opts.params))) as T
     data.value = out
     engine.value = 'server'
     elapsedMs.value = performance.now() - t0
@@ -172,7 +185,7 @@ export function useGscQuery<T = AnalysisResult>(opts: UseGscQueryOptions<T>): Us
   }
 
   async function runBrowser(signal: AbortSignal): Promise<void> {
-    const out = await analyzer.analyze(toValue(opts.params), { signal })
+    const out = await analyzer.analyze(withDefaultSearchType(toValue(opts.params)), { signal })
     signal.throwIfAborted()
     const shaped = opts.reshape ? opts.reshape(out) : (out as unknown as T)
     data.value = shaped

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@gscdump/nuxt",
   "type": "module",
-  "version": "0.19.7",
+  "version": "0.20.0",
   "description": "Nuxt layer: GSC analytics UI + DuckDB-WASM integration. Frontend-only; server primitives live in @gscdump/analysis, @gscdump/engine-sqlite, @gscdump/cloudflare, and host apps.",
   "author": {
     "name": "Harlan Wilton",
@@ -55,12 +55,12 @@
     "defu": "^6.1.7",
     "ofetch": "^1.5.1",
     "tailwindcss": "^4.3.0",
-    "@gscdump/contracts": "0.19.7",
-    "@gscdump/engine": "0.19.7",
-    "@gscdump/engine-duckdb-wasm": "0.19.7",
-    "@gscdump/sdk": "0.19.7",
-    "gscdump": "0.19.7",
-    "@gscdump/analysis": "0.19.7"
+    "@gscdump/engine": "0.20.0",
+    "@gscdump/engine-duckdb-wasm": "0.20.0",
+    "@gscdump/sdk": "0.20.0",
+    "gscdump": "0.20.0",
+    "@gscdump/analysis": "0.20.0",
+    "@gscdump/contracts": "0.20.0"
   },
   "devDependencies": {
     "@nuxt/kit": "^4.4.6",