@gscdump/nuxt 0.22.1 → 1.5.1

package/app/composables/useGscRollup.ts

@@ -1,252 +0,0 @@
-// Rollup fetchers.
-//
-//   useGscRollup(site, id)             → { data, envelope, loading, refresh }
-//   useGscRollups(site, [id, ...])     → { get, payload, envelopes, loading, refresh }
-//   useGscRollupFanout(sites, id)      → { envelopes, loading, refresh }
-//
-// The single/multi-site overload on `useGscRollups` from the previous API was
-// split into three focused hooks so each has one return shape.
-//
-// Progress flows to the shared analytics map so <GscBootProgress> lights up.
-
-import type { RollupEnvelope } from '@gscdump/contracts'
-import type { SiteListItem } from './useGscAnalytics'
-import { useGscResource } from './_useGscResource'
-import { useGscAnalyticsContext } from './useGscAnalytics'
-import { useGscAnalyticsClient } from './useGscAnalyticsClient'
-
-type RollupsInput = MaybeRefOrGetter<string | readonly string[]>
-type SiteLike = string | { id: string } | SiteListItem
-
-export interface UseGscRollupReturn<T> {
-  data: Ref<T | null>
-  envelope: Ref<RollupEnvelope<T> | null>
-  loading: Readonly<Ref<boolean>>
-  refresh: () => Promise<void>
-}
-
-export interface UseGscRollupsReturn<T> {
-  get: (rollupId: string) => RollupEnvelope<T> | null
-  payload: (rollupId: string) => T | null
-  envelopes: Ref<Record<string, RollupEnvelope<T> | null>>
-  loading: Readonly<Ref<boolean>>
-  refresh: () => Promise<void>
-}
-
-export interface UseGscRollupFanoutReturn<T> {
-  /** `{ [siteId]: envelope | null }` — null for sites missing the rollup. */
-  envelopes: Ref<Record<string, RollupEnvelope<T> | null>>
-  loading: Readonly<Ref<boolean>>
-  /**
-   * How many fan-out fetches have resolved so far (incl. nulls). Useful for
-   *  showing "loaded X/Y" hints in tiers where each site is a live API call.
-   */
-  progress: Readonly<Ref<{ completed: number, total: number }>>
-  refresh: () => Promise<void>
-}
-
-export interface UseGscRollupOptions {
-  /**
-   * Optional reactive `{ start, end }` ISO-date window. When provided, the
-   * endpoint is free to synthesize the rollup for that window (how it does
-   * so is host-specific). Rollups that are range-agnostic (e.g. the
-   * client-sliced `daily_totals`) safely ignore these params.
-   */
-  range?: MaybeRefOrGetter<{ start: string, end: string } | null | undefined>
-}
-
-/** Fetch one rollup for one site. */
-export function useGscRollup<T = unknown>(
-  siteId: MaybeRefOrGetter<string | null | undefined>,
-  rollupId: MaybeRefOrGetter<string>,
-  opts: UseGscRollupOptions = {},
-): UseGscRollupReturn<T> {
-  const ctx = useGscAnalyticsContext()
-  const resource = useGscResource<[string, string], RollupEnvelope<T> | null>({
-    keys: [siteId, rollupId],
-    fetcher: (id, rid) => fetchOne<T>(id, rid, ctx, toValue(opts.range) ?? null),
-    watchSources: [() => toValue(opts.range)?.start, () => toValue(opts.range)?.end],
-    isEmpty: env => env == null,
-  })
-
-  return {
-    data: computed<T | null>(() => resource.data.value?.payload ?? null),
-    envelope: resource.data as unknown as Ref<RollupEnvelope<T> | null>,
-    loading: resource.loading as unknown as Readonly<Ref<boolean>>,
-    refresh: resource.refresh,
-  }
-}
-
-/** Fetch N rollups for one site. */
-export function useGscRollups<T = unknown>(
-  siteId: MaybeRefOrGetter<string | null | undefined>,
-  rollupIds: RollupsInput,
-  opts: UseGscRollupOptions = {},
-): UseGscRollupsReturn<T> {
-  const ctx = useGscAnalyticsContext()
-
-  const envelopes = ref<Record<string, RollupEnvelope<T> | null>>({})
-  const loading = ref(false)
-
-  async function refresh(): Promise<void> {
-    const sid = toValue(siteId)
-    const rids = normaliseRollups(toValue(rollupIds))
-    if (!sid || rids.length === 0) {
-      envelopes.value = {}
-      return
-    }
-    loading.value = true
-    const range = toValue(opts.range) ?? null
-    const next: Record<string, RollupEnvelope<T> | null> = {}
-    try {
-      await Promise.all(rids.map(async (rid) => {
-        next[rid] = await fetchOne<T>(sid, rid, ctx, range)
-      }))
-      envelopes.value = next
-    }
-    finally {
-      loading.value = false
-    }
-  }
-
-  watch(
-    () => [toValue(siteId), normaliseRollups(toValue(rollupIds)).join(','), toValue(opts.range)?.start, toValue(opts.range)?.end],
-    refresh,
-    { immediate: true },
-  )
-
-  return {
-    get: (rollupId: string) => envelopes.value[rollupId] ?? null,
-    payload: (rollupId: string) => envelopes.value[rollupId]?.payload ?? null,
-    envelopes,
-    loading: loading as Readonly<Ref<boolean>>,
-    refresh,
-  }
-}
-
-/**
- * Fan one rollup id across N sites — returns `{ [siteId]: envelope | null }`.
- * Used by the "all sites" overview page; composes without an overload.
- */
-export function useGscRollupFanout<T = unknown>(
-  sites: MaybeRefOrGetter<readonly SiteLike[] | null | undefined>,
-  rollupId: MaybeRefOrGetter<string>,
-  opts: UseGscRollupOptions = {},
-): UseGscRollupFanoutReturn<T> {
-  const ctx = useGscAnalyticsContext()
-  const envelopes = ref<Record<string, RollupEnvelope<T> | null>>({})
-  const loading = ref(false)
-  const progress = ref<{ completed: number, total: number }>({ completed: 0, total: 0 })
-  // Ensures late-arriving promises from a superseded run don't mutate state
-  // for the current run (e.g. when the range changes rapidly).
-  let runToken = 0
-
-  async function refresh(): Promise<void> {
-    const token = ++runToken
-    const siteIds = normaliseSites(toValue(sites))
-    const rid = toValue(rollupId)
-    if (siteIds.length === 0 || !rid) {
-      envelopes.value = {}
-      progress.value = { completed: 0, total: 0 }
-      return
-    }
-    loading.value = true
-    // Seed envelopes with nulls so the UI can render skeleton rows before any
-    // fetch resolves. Writes land incrementally as each site returns.
-    const seeded: Record<string, RollupEnvelope<T> | null> = {}
-    for (const sid of siteIds) seeded[sid] = null
-    envelopes.value = seeded
-    progress.value = { completed: 0, total: siteIds.length }
-    const range = toValue(opts.range) ?? null
-    try {
-      await Promise.all(siteIds.map(async (sid) => {
-        const env = await fetchOne<T>(sid, rid, ctx, range)
-        if (token !== runToken)
-          return
-        envelopes.value = { ...envelopes.value, [sid]: env }
-        progress.value = { completed: progress.value.completed + 1, total: siteIds.length }
-      }))
-    }
-    finally {
-      if (token === runToken)
-        loading.value = false
-    }
-  }
-
-  watch(
-    () => [normaliseSites(toValue(sites)).join(','), toValue(rollupId), toValue(opts.range)?.start, toValue(opts.range)?.end],
-    refresh,
-    { immediate: true },
-  )
-
-  return {
-    envelopes,
-    loading: loading as Readonly<Ref<boolean>>,
-    progress: progress as Readonly<Ref<{ completed: number, total: number }>>,
-    refresh,
-  }
-}
-
-function normaliseSites(input: unknown): string[] {
-  if (!input)
-    return []
-  const list = Array.isArray(input) ? input : [input]
-  const out: string[] = []
-  for (const s of list) {
-    if (typeof s === 'string') {
-      if (s)
-        out.push(s)
-    }
-    else if (s && typeof s === 'object' && 'id' in s && typeof s.id === 'string' && s.id) {
-      out.push(s.id)
-    }
-  }
-  return out
-}
-
-async function fetchOne<T>(
-  siteId: string,
-  rollupId: string,
-  ctx: ReturnType<typeof useGscAnalyticsContext>,
-  range: { start: string, end: string } | null = null,
-): Promise<RollupEnvelope<T> | null> {
-  ctx.patchProgress(siteId, {
-    source: 'rollup',
-    stage: 'manifest',
-    filesTotal: 1,
-    filesAttached: 0,
-    startedAt: Date.now(),
-    error: undefined,
-    endedAt: undefined,
-  })
-  try {
-    const env = await useGscAnalyticsClient().getRollup<T>(
-      siteId,
-      rollupId,
-      range ? { start: range.start, end: range.end } : undefined,
-    )
-    ctx.patchProgress(siteId, { stage: 'ready', filesAttached: 1, endedAt: Date.now() })
-    return env
-  }
-  catch (err: unknown) {
-    const status = (err as { statusCode?: number, status?: number })?.statusCode
-      ?? (err as { status?: number })?.status
-    if (status === 404) {
-      ctx.patchProgress(siteId, { stage: 'ready', filesAttached: 1, endedAt: Date.now() })
-      return null
-    }
-    const msg = err instanceof Error ? err.message : String(err)
-    ctx.patchProgress(siteId, { stage: 'error', error: msg, endedAt: Date.now() })
-    return null
-  }
-}
-
-function normaliseRollups(input: unknown): string[] {
-  if (!input)
-    return []
-  if (typeof input === 'string')
-    return input ? [input] : []
-  if (Array.isArray(input))
-    return input.filter((v): v is string => typeof v === 'string' && v.length > 0)
-  return []
-}

package/app/composables/useGscSearchAppearance.ts

@@ -1,47 +0,0 @@
-// Fetches per-search-appearance facet performance (AMP, rich results, videos, …)
-// for a site over a date window. Server dispatches tier-aware: free → GSC API
-// live, pro → engine parquet. Uniform row shape regardless of backend.
-
-import type { GscApiRange, SearchAppearanceResponse, SearchAppearanceRow } from '@gscdump/contracts'
-import type { ComputedRef, Ref } from '@vue/runtime-core'
-import type { GscResourceStatus } from './_useGscResource'
-import { useGscResource } from './_useGscResource'
-import { useGscAnalyticsClient } from './useGscAnalyticsClient'
-
-export interface UseGscSearchAppearanceReturn {
-  response: Readonly<Ref<SearchAppearanceResponse | null>>
-  rows: ComputedRef<SearchAppearanceRow[]>
-  range: ComputedRef<GscApiRange | null>
-  source: ComputedRef<SearchAppearanceResponse['source'] | null>
-  loading: ComputedRef<boolean>
-  status: Ref<GscResourceStatus>
-  error: Ref<Error | null>
-  refresh: () => Promise<void>
-}
-
-export function useGscSearchAppearance(
-  siteId: MaybeRefOrGetter<string | null | undefined>,
-  range: MaybeRefOrGetter<{ start: string, end: string } | null | undefined>,
-): UseGscSearchAppearanceReturn {
-  const { data, status, loading, error, refresh } = useGscResource({
-    keys: [
-      siteId,
-      () => toValue(range)?.start,
-      () => toValue(range)?.end,
-    ] as const,
-    fetcher: (id: string, start: string, end: string) =>
-      useGscAnalyticsClient().getSearchAppearance(id, { start, end }),
-    isEmpty: r => r.rows.length === 0,
-  })
-
-  return {
-    response: data as Readonly<Ref<SearchAppearanceResponse | null>>,
-    rows: computed(() => data.value?.rows ?? []),
-    range: computed(() => data.value?.range ?? null),
-    source: computed(() => data.value?.source ?? null),
-    loading,
-    status,
-    error,
-    refresh,
-  }
-}