@gscdump/nuxt 0.21.3 → 0.22.4

package/app/composables/useGscResource.ts

@@ -1,114 +1,11 @@
-// Site-keyed async resource composable. Owns key-watch, stale-token discard,
-// status classification, refresh, and dispose for every read-only `/api/__gsc/*`
-// fetcher in the layer. Resource composables (useGscSitemaps,
-// useGscIndexingDiagnostics, …) are thin adapters that wire reactive keys to
-// `useGscAnalyticsClient().getX(...)` plus optional derived computeds.
-//
-// Stale-token (not AbortController) because `@gscdump/sdk`'s AnalyticsClient
-// doesn't accept a signal. Late-arriving promises from a superseded run are
-// dropped on `data`/`status` writes; the in-flight fetch still runs to
-// completion, which is acceptable for read-only GETs.
-
-import type { ComputedRef, Ref, WatchSource } from 'vue'
-import type { GscErrorStatus } from '../utils/gsc-error'
-import { classifyGscError } from '../utils/gsc-error'
-
-export type GscResourceStatus = 'idle' | 'pending' | 'success' | 'empty' | GscErrorStatus
-
-export interface UseGscResourceOptions<TArgs extends readonly unknown[], TData> {
-  /** Reactive args passed to the fetcher. Resource stays idle while any required key is null/undefined. */
-  keys: { [I in keyof TArgs]: MaybeRefOrGetter<TArgs[I] | null | undefined> }
-  /** Async fetcher invoked with the resolved keys. */
-  fetcher: (...args: TArgs) => Promise<TData | null>
-  /** Predicate for the `empty` status — defaults to checking `null`/`[]`/typical container fields. */
-  isEmpty?: (data: TData) => boolean
-  /** Extra reactive sources that should retrigger a fetch. */
-  watchSources?: WatchSource[]
-}
-
-export interface UseGscResourceReturn<TData> {
-  data: Ref<TData | null>
-  status: Ref<GscResourceStatus>
-  loading: ComputedRef<boolean>
-  error: Ref<Error | null>
-  refresh: () => Promise<void>
-}
-
-function defaultIsEmpty(v: unknown): boolean {
-  if (v == null)
-    return true
-  if (Array.isArray(v))
-    return v.length === 0
-  if (typeof v === 'object') {
-    const rec = v as Record<string, unknown>
-    for (const key of ['rows', 'records', 'snapshots', 'items', 'results']) {
-      const arr = rec[key]
-      if (Array.isArray(arr))
-        return arr.length === 0
-    }
-  }
-  return false
-}
-
-export function useGscResource<TArgs extends readonly unknown[], TData>(
-  opts: UseGscResourceOptions<TArgs, TData>,
-): UseGscResourceReturn<TData> {
-  const data = shallowRef<TData | null>(null)
-  const status = ref<GscResourceStatus>('idle')
-  const error = ref<Error | null>(null)
-  const loading = computed(() => status.value === 'pending')
-
-  let runToken = 0
-
-  function resolveKeys(): TArgs | null {
-    const out: unknown[] = []
-    for (const k of opts.keys) {
-      const v = toValue(k)
-      if (v == null || v === '')
-        return null
-      out.push(v)
-    }
-    return out as unknown as TArgs
-  }
-
-  async function refresh(): Promise<void> {
-    const args = resolveKeys()
-    const token = ++runToken
-    if (!args) {
-      data.value = null
-      status.value = 'idle'
-      error.value = null
-      return
-    }
-    status.value = 'pending'
-    error.value = null
-    try {
-      const out = await opts.fetcher(...args)
-      if (token !== runToken)
-        return
-      data.value = out
-      const empty = out == null || (opts.isEmpty ?? defaultIsEmpty)(out)
-      status.value = empty ? 'empty' : 'success'
-    }
-    catch (e) {
-      if (token !== runToken)
-        return
-      const classified = classifyGscError(e)
-      error.value = e instanceof Error ? e : new Error(String(e))
-      status.value = classified.status
-      data.value = null
-    }
-  }
-
-  watch(
-    [...opts.keys.map(k => () => toValue(k)), ...(opts.watchSources ?? [])],
-    refresh,
-    { immediate: true },
-  )
-
-  onScopeDispose(() => {
-    runToken++
-  })
-
-  return { data, status, loading, error, refresh }
-}
+// Public re-export. The implementation lives in `_useGscResource.ts`; the
+// module's `imports:extend` hook strips `_use*` from host auto-imports so
+// consumers see the wrapper at `useGscResource` and the layer's own
+// composables import the internal file directly. Named re-exports because
+// Nuxt's auto-import scanner doesn't traverse `export *`.
+export {
+  type GscResourceStatus,
+  useGscResource,
+  type UseGscResourceOptions,
+  type UseGscResourceReturn,
+} from './_useGscResource'

package/app/composables/useGscRollup.ts

@@ -11,9 +11,10 @@
 
 import type { RollupEnvelope } from '@gscdump/contracts'
 import type { SiteListItem } from './useGscAnalytics'
+import { gscQueries } from '../queries/gsc'
+import { useGscRpc } from '../utils/gsc-rpc'
 import { useGscResource } from './_useGscResource'
 import { useGscAnalyticsContext } from './useGscAnalytics'
-import { useGscAnalyticsClient } from './useGscAnalyticsClient'
 
 type RollupsInput = MaybeRefOrGetter<string | readonly string[]>
 type SiteLike = string | { id: string } | SiteListItem
@@ -62,9 +63,11 @@ export function useGscRollup<T = unknown>(
   opts: UseGscRollupOptions = {},
 ): UseGscRollupReturn<T> {
   const ctx = useGscAnalyticsContext()
+  const rpc = useGscRpc()
   const resource = useGscResource<[string, string], RollupEnvelope<T> | null>({
+    namespace: 'gsc-rollup',
     keys: [siteId, rollupId],
-    fetcher: (id, rid) => fetchOne<T>(id, rid, ctx, toValue(opts.range) ?? null),
+    fetcher: (id, rid) => fetchOne<T>(rpc, id, rid, ctx, toValue(opts.range) ?? null),
     watchSources: [() => toValue(opts.range)?.start, () => toValue(opts.range)?.end],
     isEmpty: env => env == null,
   })
@@ -84,43 +87,31 @@ export function useGscRollups<T = unknown>(
   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 {
+  const rpc = useGscRpc()
+  const rollupKey = computed(() => encodeStringList(normaliseRollups(toValue(rollupIds))))
+  const resource = useGscResource<[string, string], Record<string, RollupEnvelope<T> | null>>({
+    namespace: 'gsc-rollups',
+    keys: [siteId, rollupKey],
+    fetcher: async (sid, encoded) => {
+      const rids = decodeStringList(encoded)
+      const next: Record<string, RollupEnvelope<T> | null> = {}
+      const range = toValue(opts.range) ?? null
       await Promise.all(rids.map(async (rid) => {
-        next[rid] = await fetchOne<T>(sid, rid, ctx, range)
+        next[rid] = await fetchOne<T>(rpc, 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 next
+    },
+    watchSources: [() => toValue(opts.range)?.start, () => toValue(opts.range)?.end],
+    isEmpty: value => Object.keys(value).length === 0,
+  })
+  const envelopes = computed<Record<string, RollupEnvelope<T> | null>>(() => resource.data.value ?? {})
 
   return {
     get: (rollupId: string) => envelopes.value[rollupId] ?? null,
     payload: (rollupId: string) => envelopes.value[rollupId]?.payload ?? null,
-    envelopes,
-    loading: loading as Readonly<Ref<boolean>>,
-    refresh,
+    envelopes: envelopes as unknown as Ref<Record<string, RollupEnvelope<T> | null>>,
+    loading: resource.loading as unknown as Readonly<Ref<boolean>>,
+    refresh: resource.refresh,
   }
 }
 
@@ -134,56 +125,39 @@ export function useGscRollupFanout<T = unknown>(
   opts: UseGscRollupOptions = {},
 ): UseGscRollupFanoutReturn<T> {
   const ctx = useGscAnalyticsContext()
-  const envelopes = ref<Record<string, RollupEnvelope<T> | null>>({})
-  const loading = ref(false)
+  const rpc = useGscRpc()
   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 {
+  const siteKey = computed(() => encodeStringList(normaliseSites(toValue(sites))))
+  const resource = useGscResource<[string, string], Record<string, RollupEnvelope<T> | null>>({
+    namespace: 'gsc-rollup-fanout',
+    keys: [siteKey, rollupId],
+    fetcher: async (encoded, rid) => {
+      const siteIds = decodeStringList(encoded)
+      progress.value = { completed: 0, total: siteIds.length }
+      const range = toValue(opts.range) ?? null
+      const next: Record<string, RollupEnvelope<T> | null> = {}
       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 }
+        next[sid] = await fetchOne<T>(rpc, sid, rid, ctx, range)
         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 next
+    },
+    watchSources: [() => toValue(opts.range)?.start, () => toValue(opts.range)?.end],
+    isEmpty: value => Object.keys(value).length === 0,
+  })
+  const envelopes = computed<Record<string, RollupEnvelope<T> | null>>(() => resource.data.value ?? {})
+  watch(resource.loading, (loading) => {
+    if (loading)
+      return
+    if (!resource.data.value)
+      progress.value = { completed: 0, total: 0 }
+  }, { immediate: true })
 
   return {
-    envelopes,
-    loading: loading as Readonly<Ref<boolean>>,
+    envelopes: envelopes as unknown as Ref<Record<string, RollupEnvelope<T> | null>>,
+    loading: resource.loading as unknown as Readonly<Ref<boolean>>,
     progress: progress as Readonly<Ref<{ completed: number, total: number }>>,
-    refresh,
+    refresh: resource.refresh,
   }
 }
 
@@ -204,7 +178,19 @@ function normaliseSites(input: unknown): string[] {
   return out
 }
 
+function encodeStringList(values: string[]): string {
+  return values.length > 0 ? JSON.stringify(values) : ''
+}
+
+function decodeStringList(encoded: string): string[] {
+  const parsed = JSON.parse(encoded) as unknown
+  return Array.isArray(parsed)
+    ? parsed.filter((v): v is string => typeof v === 'string' && v.length > 0)
+    : []
+}
+
 async function fetchOne<T>(
+  rpc: ReturnType<typeof useGscRpc>,
   siteId: string,
   rollupId: string,
   ctx: ReturnType<typeof useGscAnalyticsContext>,
@@ -220,11 +206,10 @@ async function fetchOne<T>(
     endedAt: undefined,
   })
   try {
-    const env = await useGscAnalyticsClient().getRollup<T>(
-      siteId,
-      rollupId,
-      range ? { start: range.start, end: range.end } : undefined,
-    )
+    const env = await rpc.query(
+      gscQueries.rollup(siteId, rollupId, range ?? undefined),
+      { silent: true },
+    ) as RollupEnvelope<T>
     ctx.patchProgress(siteId, { stage: 'ready', filesAttached: 1, endedAt: Date.now() })
     return env
   }

package/app/composables/useGscSearchAppearance.ts

@@ -5,8 +5,8 @@
 import type { GscApiRange, SearchAppearanceResponse, SearchAppearanceRow } from '@gscdump/contracts'
 import type { ComputedRef, Ref } from '@vue/runtime-core'
 import type { GscResourceStatus } from './_useGscResource'
+import { gscQueries } from '../queries/gsc'
 import { useGscResource } from './_useGscResource'
-import { useGscAnalyticsClient } from './useGscAnalyticsClient'
 
 export interface UseGscSearchAppearanceReturn {
   response: Readonly<Ref<SearchAppearanceResponse | null>>
@@ -14,8 +14,8 @@ export interface UseGscSearchAppearanceReturn {
   range: ComputedRef<GscApiRange | null>
   source: ComputedRef<SearchAppearanceResponse['source'] | null>
   loading: ComputedRef<boolean>
-  status: Ref<GscResourceStatus>
-  error: Ref<Error | null>
+  status: Readonly<Ref<GscResourceStatus>>
+  error: Readonly<Ref<Error | null>>
   refresh: () => Promise<void>
 }
 
@@ -23,14 +23,13 @@ export function useGscSearchAppearance(
   siteId: MaybeRefOrGetter<string | null | undefined>,
   range: MaybeRefOrGetter<{ start: string, end: string } | null | undefined>,
 ): UseGscSearchAppearanceReturn {
-  const { data, status, loading, error, refresh } = useGscResource({
+  const { data, status, loading, error, refresh } = useGscResource<[string, string, string], SearchAppearanceResponse>({
     keys: [
       siteId,
       () => toValue(range)?.start,
       () => toValue(range)?.end,
     ] as const,
-    fetcher: (id: string, start: string, end: string) =>
-      useGscAnalyticsClient().getSearchAppearance(id, { start, end }),
+    operation: (id, start, end) => gscQueries.searchAppearance(id, { start, end }),
     isEmpty: r => r.rows.length === 0,
   })