@gscdump/nuxt 0.22.1 → 0.22.4

package/app/composables/useGscSiteAnalyzer.ts

@@ -1,36 +1,31 @@
-// Per-site DuckDB-WASM analyzer over the Iceberg fact tables.
+// Per-site DuckDB-WASM analyzer over the hosted Iceberg fact tables.
 //
-// One analyzer instance per `(siteId, searchType, range)`, cached on the
-// NuxtApp so every subpage under `/sites/[id]/*` shares the same DuckDB boot
-// + attached parquet. The site overview pays the cold cost once; tabbing
-// across Queries / Pages / Countries / etc is essentially free — DuckDB has
-// the data resident in memory and each tab just runs a different SQL query.
-//
-// Tables are attached LAZILY: the first call that needs `queries` triggers
-// the parquet fetch for that table; sibling tabs reuse the attach. This
-// keeps cold-tab latency low and avoids attaching parquet for tables a
-// session never touches (`countries` if the user only looks at Queries).
-//
-// Iceberg fact tables follow the same shape:
-//   pages                          — url, date, clicks, impressions, sum_position
-//   queries                        — query, query_canonical, date, …metrics
-//   countries                      — country, date, …metrics
-//   dates                          — date, …metrics + anonymized_impressions_pct + 9-col device pivot
-//   page_queries                   — url, query, query_canonical, date, …metrics
-//   search_appearance              — searchAppearance, date, …metrics
-//   search_appearance_*            — searchAppearance plus page/query context
+// The module owns the browser runtime lifecycle: resolve analysis sources,
+// boot shared DuckDB-WASM, attach parquet tables on demand, mirror progress
+// into the layer-wide map, and materialise Arrow rows into plain objects.
+// Callers keep ownership of SQL, presentation, and page-specific state.
 
 import type { AsyncDuckDB, AsyncDuckDBConnection } from '@duckdb/duckdb-wasm'
-import type { AnalysisParams, AnalysisResult } from '@gscdump/analysis'
 import type { FileResolutionResponse } from '@gscdump/contracts'
 import type { OpfsAttachedHandle } from '@gscdump/engine-duckdb-wasm'
+import type { AnalysisParams, AnalysisResult } from '@gscdump/engine/analysis-types'
 import { defaultAnalyzerRegistry } from '@gscdump/analysis'
 import { runAnalyzerFromSource } from '@gscdump/engine/analyzer'
 import { createAttachedTableSource } from '@gscdump/engine/source'
-import { useGscFetch } from '#imports'
-import { attachParquetWithFallback } from '../utils/duckdb-wasm'
-
-export type GscFactTable = 'pages' | 'queries' | 'countries' | 'dates' | 'page_queries' | 'search_appearance' | 'search_appearance_pages' | 'search_appearance_queries' | 'search_appearance_page_queries'
+import { gscQueries } from '../queries/gsc'
+import { attachParquetWithFallback, sharedGscDuckDBWasm } from '../utils/duckdb-wasm'
+import { useGscRpc } from '../utils/gsc-rpc'
+
+export type GscFactTable
+  = | 'pages'
+    | 'queries'
+    | 'countries'
+    | 'dates'
+    | 'page_queries'
+    | 'search_appearance'
+    | 'search_appearance_pages'
+    | 'search_appearance_queries'
+    | 'search_appearance_page_queries'
 
 export type GscTableStage = 'idle' | 'resolving' | 'downloading' | 'attaching' | 'ready' | 'error' | 'unavailable'
 
@@ -44,49 +39,36 @@ export interface GscTableStatus {
 }
 
 export interface UseGscSiteAnalyzerReturn {
-  /** Per-table stage + file counts. `<GscBootProgress />` reads from the layer-wide map (we mirror there); this is the local view for in-page hints. */
   tables: Readonly<Ref<Record<GscFactTable, GscTableStatus>>>
-  /** True once DuckDB-WASM has booted. Queries can dispatch as soon as the table they need is in `'ready'`. */
   ready: Readonly<Ref<boolean>>
-  /** First fatal error (boot or any table). Per-table errors land on `tables[<name>].error`. */
   error: Readonly<Ref<Error | null>>
-  /**
-   * Run SQL against the attached tables. Awaits the requested tables' attach,
-   * triggering on-demand attach if they haven't been started yet.
-   */
-  query: <T = Record<string, unknown>>(opts: { sql: string, needs: readonly GscFactTable[], params?: readonly unknown[] }) => Promise<T[]>
-  /**
-   * Positional-form `query` returning `{ rows, queryMs }`. Convenience for
-   * callers that want raw SQL access without naming `needs` themselves; the
-   * required tables are inferred from `FROM`/`JOIN` references.
-   */
+  query: <T = Record<string, unknown>>(opts: {
+    sql: string
+    needs: readonly GscFactTable[]
+    params?: readonly unknown[]
+  }) => Promise<T[]>
   runQuery: <T = Record<string, unknown>>(sql: string, params?: readonly unknown[]) => Promise<{ rows: T[], queryMs: number }>
-  /**
-   * Dispatch an analyzer from `defaultAnalyzerRegistry` against the attached
-   * tables. Builds an `attached-table` SQL source that proxies back through
-   * `query()`, so the per-site DuckDB-WASM boot and the on-demand attach
-   * lifecycle are reused.
-   */
   analyze: (params: AnalysisParams, opts?: { signal?: AbortSignal }) => Promise<AnalysisResult & { queryMs: number }>
 }
 
 interface BootedAnalyzer {
-  /** Inert proxy used until the real DuckDB-WASM boots. */
   bootPromise: Promise<{ db: AsyncDuckDB, conn: AsyncDuckDBConnection }>
-  /** Latched once attach has been started for a table; resolves when the table is queryable. */
   tablePromises: Map<GscFactTable, Promise<void>>
-  /** Reactive per-table status (mirrored to the layer-wide progress map). */
   tables: Ref<Record<GscFactTable, GscTableStatus>>
   ready: Ref<boolean>
   error: Ref<Error | null>
-  /** Held mutex around DuckDB DDL/query calls — WASM DuckDB is single-connection. */
   withDb: <T>(fn: (conn: AsyncDuckDBConnection) => Promise<T>) => Promise<T>
-  /** Per-instance refcount — bumped on every consumer hookup, decremented on dispose. */
   refs: number
-  /** Cleanup; called when refs hits 0. */
   dispose: () => Promise<void>
 }
 
+interface AnalyzerArgs {
+  siteId: string
+  searchType: string
+  range: { start: string, end: string }
+  useOpfsCache: boolean
+}
+
 const ALL_TABLES: readonly GscFactTable[] = [
   'pages',
   'queries',
@@ -101,6 +83,7 @@ const ALL_TABLES: readonly GscFactTable[] = [
 
 const FACT_TABLE_NAMES = ALL_TABLES.join('|')
 const TABLE_RE = new RegExp(`\\b(?:FROM|JOIN)\\s+(?:main\\.)?(${FACT_TABLE_NAMES})\\b`, 'gi')
+const instanceCaches = new WeakMap<object, Map<string, BootedAnalyzer>>()
 
 function tablesFromSql(sql: string): readonly GscFactTable[] {
   const out = new Set<GscFactTable>()
@@ -121,11 +104,6 @@ function emptyTables(): Record<GscFactTable, GscTableStatus> {
   return Object.fromEntries(ALL_TABLES.map(t => [t, emptyStatus()])) as Record<GscFactTable, GscTableStatus>
 }
 
-// Per-NuxtApp instance cache keyed by `siteId|searchType|start|end`. WeakMap
-// against the NuxtApp so SSR isolation holds (each request gets its own cache)
-// and client-side instances live as long as the app does.
-const instanceCaches = new WeakMap<object, Map<string, BootedAnalyzer>>()
-
 function getCache(): Map<string, BootedAnalyzer> {
   const app = useNuxtApp()
   let bag = instanceCaches.get(app)
@@ -143,46 +121,47 @@ function instanceKey(siteId: string, searchType: string, range: { start: string,
 export function useGscSiteAnalyzer(
   siteId: MaybeRefOrGetter<string | null | undefined>,
   range: MaybeRefOrGetter<{ start: string, end: string } | null | undefined>,
-  options: { searchType?: 'web' | 'image' | 'video' | 'news' | 'discover' | 'googleNews', useOpfsCache?: boolean } = {},
+  options: {
+    searchType?: 'web' | 'image' | 'video' | 'news' | 'discover' | 'googleNews'
+    useOpfsCache?: boolean
+  } = {},
 ): UseGscSiteAnalyzerReturn {
   const searchType = options.searchType ?? 'web'
   const useOpfsCache = options.useOpfsCache ?? true
-
-  // The reactive return shape — proxies the currently-selected instance.
-  // We rebind every time the key changes (e.g. range moves outside the
-  // cached attach window).
   const tables = ref<Record<GscFactTable, GscTableStatus>>(emptyTables())
   const ready = ref(false)
   const error = ref<Error | null>(null)
   let active: BootedAnalyzer | null = null
+  let stopEffects: (() => void) | null = null
 
   function bind(instance: BootedAnalyzer | null): void {
-    // Release the previous instance's refcount; pick up the new one. Skipping
-    // shutdown on rebind means tab navigation never tears DuckDB down — the
-    // instance lives until every consumer unmounts and the cache drops it.
     const prev = active
+    stopEffects?.()
+    stopEffects = null
     active = instance
+
     if (instance) {
       instance.refs++
-      tables.value = instance.tables.value
-      ready.value = instance.ready.value
-      error.value = instance.error.value
-      // Re-link reactive refs to the live instance.
-      watchEffect(() => {
-        tables.value = instance.tables.value
-      })
-      watchEffect(() => {
-        ready.value = instance.ready.value
-      })
-      watchEffect(() => {
-        error.value = instance.error.value
+      const scope = effectScope()
+      scope.run(() => {
+        watchEffect(() => {
+          tables.value = instance.tables.value
+        })
+        watchEffect(() => {
+          ready.value = instance.ready.value
+        })
+        watchEffect(() => {
+          error.value = instance.error.value
+        })
       })
+      stopEffects = () => scope.stop()
     }
     else {
       tables.value = emptyTables()
       ready.value = false
       error.value = null
     }
+
     if (prev) {
       prev.refs--
       if (prev.refs <= 0)
@@ -219,12 +198,15 @@ export function useGscSiteAnalyzer(
 
   onScopeDispose(() => bind(null))
 
-  async function query<T = Record<string, unknown>>(opts: { sql: string, needs: readonly GscFactTable[], params?: readonly unknown[] }): Promise<T[]> {
+  async function query<T = Record<string, unknown>>(opts: {
+    sql: string
+    needs: readonly GscFactTable[]
+    params?: readonly unknown[]
+  }): Promise<T[]> {
     if (!active)
       throw new Error('useGscSiteAnalyzer: no active instance (site/range not set)')
     const instance = active
     await instance.bootPromise
-    // Kick off (or join) per-table attaches for every table the query needs.
     await Promise.all(opts.needs.map(t => ensureTable(instance, t)))
     return instance.withDb(async (conn) => {
       const result = opts.params && opts.params.length > 0
@@ -238,11 +220,6 @@ export function useGscSiteAnalyzer(
             }
           })()
         : await conn.query(opts.sql)
-      // Apache Arrow returns `Proxy(StructRow)` rows — Vue's reactivity
-      // can't make those reactive (the Arrow proxy's `isExtensible` trap
-      // throws a TypeError when the reactive proxy probes it). Materialise
-      // into plain objects at the seam so every consumer is free to assign
-      // results directly into a `ref`/`reactive` without surprise.
       const arr = result.toArray() as unknown as Array<Record<string, unknown>>
       return arr.map(row => ({ ...row })) as unknown as T[]
     })
@@ -286,15 +263,6 @@ export function useGscSiteAnalyzer(
   }
 }
 
-// ── implementation ──────────────────────────────────────────────────────────
-
-interface AnalyzerArgs {
-  siteId: string
-  searchType: string
-  range: { start: string, end: string }
-  useOpfsCache: boolean
-}
-
 function createAnalyzer(args: AnalyzerArgs): BootedAnalyzer {
   const tables = ref<Record<GscFactTable, GscTableStatus>>(emptyTables())
   const ready = ref(false)
@@ -302,38 +270,32 @@ function createAnalyzer(args: AnalyzerArgs): BootedAnalyzer {
   const tablePromises = new Map<GscFactTable, Promise<void>>()
   const opfsHandles = new Map<GscFactTable, OpfsAttachedHandle>()
 
-  // Pin the configured fetcher + analytics config at construction — these
-  // need a NuxtApp context, which is available here (the composable's
-  // setup) but not inside the async work spawned below.
-  const $gscFetch = useGscFetch()
+  const rpc = useGscRpc()
   const analyticsConfig = useGscAnalyticsConfig()
   const analyticsCtx = useGscAnalyticsContext()
-  const apiBase = (analyticsConfig.apiBase ?? '').replace(/\/+$/, '')
 
-  // Single resolve call — `analysis-sources` already returns all 5 tables
-  // for a given site+range, so we hit it once and demux per-table later.
   let resolvePromise: Promise<FileResolutionResponse | null> | null = null
   function getResolution(): Promise<FileResolutionResponse | null> {
     if (resolvePromise)
       return resolvePromise
-    const qs = `searchType=${args.searchType}&start=${args.range.start}&end=${args.range.end}`
-    resolvePromise = $gscFetch<FileResolutionResponse | { canUseBrowser?: false }>(
-      `${apiBase}/api/__gsc/sites/${args.siteId}/analysis-sources?${qs}`,
+    resolvePromise = rpc.query(
+      gscQueries.analysisSources(args.siteId, undefined, {
+        searchType: args.searchType as 'web' | 'image' | 'video' | 'news' | 'discover' | 'googleNews',
+        start: args.range.start,
+        end: args.range.end,
+      }),
+      { silent: true },
     )
       .then((res) => {
         if (!res || (res as { canUseBrowser?: boolean }).canUseBrowser === false)
           return null
-        return res as FileResolutionResponse
+        return res as unknown as FileResolutionResponse
       })
       .catch(() => null)
     return resolvePromise
   }
 
-  // Boot DuckDB-WASM up front — the resolve and the WASM bundle download in
-  // parallel, so by the time a query asks for a table, the DB is ready.
   const bootPromise: Promise<{ db: AsyncDuckDB, conn: AsyncDuckDBConnection }> = (async () => {
-    // Shared boot: navigating home → site detail (or between sites) reuses
-    // the same DuckDB-WASM instance instead of paying ~800ms cold-boot again.
     const bundleBase = (analyticsConfig as { duckdbBundleBase?: string }).duckdbBundleBase
     const boot = await sharedGscDuckDBWasm(bundleBase)
     ready.value = true
@@ -343,8 +305,6 @@ function createAnalyzer(args: AnalyzerArgs): BootedAnalyzer {
     error.value = err instanceof Error ? err : new Error(String(err))
   })
 
-  // DuckDB-WASM single-connection mutex — DDL and queries serialise; downloads
-  // run free in parallel outside the lock.
   let dbLock: Promise<unknown> = Promise.resolve()
   function withDb<T>(fn: (conn: AsyncDuckDBConnection) => Promise<T>): Promise<T> {
     const next = dbLock.then(async () => {
@@ -355,20 +315,23 @@ function createAnalyzer(args: AnalyzerArgs): BootedAnalyzer {
     return next
   }
 
-  // Per-table attach kicker. Stores its promise so concurrent callers join
-  // the same in-flight work; the layer-wide `patchProgress` map is updated
-  // as each phase advances so `<GscBootProgress />` shows the site's table
-  // load alongside other sites.
   function patchSelf(table: GscFactTable, patch: Partial<GscTableStatus>): void {
     tables.value = { ...tables.value, [table]: { ...tables.value[table], ...patch } }
   }
+
   function patchLayer(table: GscFactTable, stage: GscTableStage, extras: Partial<GscTableStatus> = {}): void {
-    // Reuse the layer's SiteLoadProgress shape, namespacing by table so
-    // multiple tables for the same site don't collide on the boot bar.
     const siteSlot = `${args.siteId}#${table}`
-    const layerStage = stage === 'unavailable' ? 'ready' : stage === 'downloading' || stage === 'attaching' ? 'attach' : stage === 'resolving' ? 'manifest' : stage === 'ready' ? 'ready' : stage === 'error' ? 'error' : 'idle'
+    const layerStage = stage === 'unavailable'
+      ? 'ready'
+      : stage === 'downloading' || stage === 'attaching'
+        ? 'attach'
+        : stage === 'resolving'
+          ? 'manifest'
+          : stage === 'ready'
+            ? 'ready'
+            : stage === 'error' ? 'error' : 'idle'
     analyticsCtx.patchProgress(siteSlot, {
-      stage: layerStage as never,
+      stage: layerStage,
       source: 'duckdb',
       filesAttached: extras.filesAttached ?? tables.value[table].filesAttached,
       filesTotal: extras.filesTotal ?? tables.value[table].filesTotal,
@@ -385,15 +348,18 @@ function createAnalyzer(args: AnalyzerArgs): BootedAnalyzer {
 
     const full = await getResolution()
     if (!full) {
-      patchSelf(table, { stage: 'unavailable', endedAt: Date.now() })
-      patchLayer(table, 'unavailable', { endedAt: Date.now() })
+      const endedAt = Date.now()
+      patchSelf(table, { stage: 'unavailable', endedAt })
+      patchLayer(table, 'unavailable', { endedAt })
       return
     }
+
     const tableEntry = full.tables.find(t => t.table === table)
     const browserFiles = tableEntry?.mode === 'browser' ? tableEntry.files : []
     if (browserFiles.length === 0) {
-      patchSelf(table, { stage: 'unavailable', endedAt: Date.now() })
-      patchLayer(table, 'unavailable', { endedAt: Date.now() })
+      const endedAt = Date.now()
+      patchSelf(table, { stage: 'unavailable', endedAt })
+      patchLayer(table, 'unavailable', { endedAt })
       return
     }
 
@@ -402,10 +368,7 @@ function createAnalyzer(args: AnalyzerArgs): BootedAnalyzer {
 
     const sid = sqlIdent(args.siteId)
     const tableIdent = sqlIdent(table)
-    // Per-(site,table) view name keeps OPFS file names unique across sites
-    // sharing this DuckDB instance.
     const viewName = `${tableIdent}_${sid}`
-
     let filesAttached = 0
     const { db, conn } = await bootPromise
     const opfsHandle = await attachParquetWithFallback({
@@ -423,14 +386,12 @@ function createAnalyzer(args: AnalyzerArgs): BootedAnalyzer {
       },
     }).catch((err) => {
       const msg = err instanceof Error ? err.message : String(err)
-      patchSelf(table, { stage: 'error', error: msg, endedAt: Date.now() })
-      patchLayer(table, 'error', { error: msg, endedAt: Date.now() })
+      const endedAt = Date.now()
+      patchSelf(table, { stage: 'error', error: msg, endedAt })
+      patchLayer(table, 'error', { error: msg, endedAt })
       throw err
     })
 
-    // Query SQL references the canonical table name (`pages`, etc.); the
-    // underlying view is per-(site,table) so OPFS file names don't collide
-    // across sites that may share a DuckDB instance in future.
     if (viewName !== tableIdent) {
       await withDb(async (conn) => {
         await conn.query(`CREATE OR REPLACE VIEW ${tableIdent} AS SELECT * FROM ${viewName}`)
@@ -440,8 +401,9 @@ function createAnalyzer(args: AnalyzerArgs): BootedAnalyzer {
     if (opfsHandle)
       opfsHandles.set(table, opfsHandle)
 
-    patchSelf(table, { stage: 'ready', endedAt: Date.now() })
-    patchLayer(table, 'ready', { endedAt: Date.now() })
+    const endedAt = Date.now()
+    patchSelf(table, { stage: 'ready', endedAt })
+    patchLayer(table, 'ready', { endedAt })
   }
 
   function ensureTableInner(table: GscFactTable): Promise<void> {
@@ -462,8 +424,6 @@ function createAnalyzer(args: AnalyzerArgs): BootedAnalyzer {
     withDb,
     refs: 0,
     dispose: async () => {
-      // Pull the cache entry first so subsequent obtains create a fresh one
-      // (we can't dispose mid-attach without leaking promises).
       const cache = instanceCaches.get(useNuxtApp())
       if (cache) {
         for (const [k, v] of cache.entries()) {
@@ -477,19 +437,15 @@ function createAnalyzer(args: AnalyzerArgs): BootedAnalyzer {
         for (const h of opfsHandles.values())
           await h.detach().catch(() => {})
         opfsHandles.clear()
-        // Drop the per-site views we created so a re-attach is clean. Do NOT
-        // terminate the DB — it's shared via `sharedGscDuckDBWasm`.
         const { conn } = await bootPromise
         for (const t of ALL_TABLES)
           await conn.query(`DROP VIEW IF EXISTS ${sqlIdent(t)}`).catch(() => {})
       }
       catch {
-        // Boot failed — nothing to tear down.
+        // Boot failed; nothing to tear down.
       }
     },
   }
-  // Attach the ensureTable closure to the instance so the outer composable
-  // can reach it without a globalThis hack.
   ;(instance as BootedAnalyzer & { ensureTable: typeof ensureTableInner }).ensureTable = ensureTableInner
   return instance
 }

package/app/composables/useGscSitemapHistory.ts

@@ -4,16 +4,16 @@
 import type { SitemapHistoryRecord, SitemapHistoryResponse } 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 UseGscSitemapHistoryReturn {
   response: Readonly<Ref<SitemapHistoryResponse | null>>
   snapshots: ComputedRef<SitemapHistoryRecord[]>
   path: ComputedRef<string | null>
   loading: ComputedRef<boolean>
-  status: Ref<GscResourceStatus>
-  error: Ref<Error | null>
+  status: Readonly<Ref<GscResourceStatus>>
+  error: Readonly<Ref<Error | null>>
   refresh: () => Promise<void>
 }
 
@@ -21,9 +21,9 @@ export function useGscSitemapHistory(
   siteId: MaybeRefOrGetter<string | null | undefined>,
   feedpathHash: MaybeRefOrGetter<string | null | undefined>,
 ): UseGscSitemapHistoryReturn {
-  const { data, status, loading, error, refresh } = useGscResource({
+  const { data, status, loading, error, refresh } = useGscResource<[string, string], SitemapHistoryResponse>({
     keys: [siteId, feedpathHash] as const,
-    fetcher: (id: string, hash: string) => useGscAnalyticsClient().getSitemapHistory(id, hash),
+    operation: (id, hash) => gscQueries.sitemapHistory(id, hash),
   })
 
   const snapshots = computed(() => data.value?.snapshots ?? [])

package/app/composables/useGscSitemaps.ts

@@ -5,22 +5,22 @@
 import type { SitemapHistoryRecord, SitemapIndex } 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 UseGscSitemapsReturn {
   index: Readonly<Ref<SitemapIndex | null>>
   records: ComputedRef<SitemapHistoryRecord[]>
   loading: ComputedRef<boolean>
-  status: Ref<GscResourceStatus>
-  error: Ref<Error | null>
+  status: Readonly<Ref<GscResourceStatus>>
+  error: Readonly<Ref<Error | null>>
   refresh: () => Promise<void>
 }
 
 export function useGscSitemaps(siteId: MaybeRefOrGetter<string | null | undefined>): UseGscSitemapsReturn {
-  const { data, status, loading, error, refresh } = useGscResource({
+  const { data, status, loading, error, refresh } = useGscResource<[string], SitemapIndex>({
     keys: [siteId] as const,
-    fetcher: (id: string) => useGscAnalyticsClient().getSitemaps(id),
+    operation: (id: string) => gscQueries.sitemaps(id),
   })
 
   const records = computed<SitemapHistoryRecord[]>(() => {

package/app/queries/gsc.ts

@@ -0,0 +1,163 @@
+import type { AnalysisSourcesOptions, BackfillRange, GscApiRange, GscdumpTopAssociationParams, IndexingInspectRequest, SourceInfoOptions } from '@gscdump/contracts'
+import type { AnalysisParams } from '@gscdump/engine/analysis-types'
+import { analyticsRoutes, gscdumpAnalysisParamsSchema, gscdumpAnalysisResponseSchema, partnerEndpointSchemas } from '@gscdump/contracts'
+import { defineNuxtQueryGroup, defineNuxtRpcMutation, defineNuxtRpcQuery } from 'nuxt-use-query/rpc'
+
+const DEFAULT_SEARCH_TYPE = 'web'
+
+type SearchType = NonNullable<SourceInfoOptions['searchType']>
+
+function searchTypeQuery(searchType?: SearchType): Record<string, string> {
+  return { searchType: searchType ?? DEFAULT_SEARCH_TYPE }
+}
+
+function dateRangeQuery(options: { start?: string, end?: string, startDate?: string, endDate?: string } | undefined): Record<string, string> {
+  const query: Record<string, string> = {}
+  const start = options?.start ?? options?.startDate
+  const end = options?.end ?? options?.endDate
+  if (start)
+    query.start = start
+  if (end)
+    query.end = end
+  return query
+}
+
+function sourceInfoQuery(options: SourceInfoOptions | undefined): Record<string, string> {
+  return {
+    ...searchTypeQuery(options?.searchType),
+    ...dateRangeQuery(options),
+  }
+}
+
+function tablesQuery(
+  tablesOrOptions: string[] | string | AnalysisSourcesOptions | undefined,
+  options?: { searchType?: SearchType, start?: string, end?: string, startDate?: string, endDate?: string },
+): Record<string, string> {
+  const isOptions = !!tablesOrOptions && typeof tablesOrOptions === 'object' && !Array.isArray(tablesOrOptions)
+  const source = isOptions ? tablesOrOptions : options
+  const tables = isOptions ? tablesOrOptions.tables : tablesOrOptions
+  const query = {
+    ...searchTypeQuery(source?.searchType),
+    ...dateRangeQuery(source),
+  }
+  if (tables)
+    query.tables = Array.isArray(tables) ? tables.join(',') : tables
+  return query
+}
+
+function withDefaultSearchType<T>(value: T): T {
+  if (!value || typeof value !== 'object' || Array.isArray(value))
+    return value
+  return {
+    ...(value as Record<string, unknown>),
+    searchType: (value as { searchType?: SearchType }).searchType ?? DEFAULT_SEARCH_TYPE,
+  } as T
+}
+
+export const gscQueries = defineNuxtQueryGroup('gsc', {
+  whoami: () => defineNuxtRpcQuery({
+    key: ['gsc', 'whoami'],
+    path: analyticsRoutes.whoami,
+    response: partnerEndpointSchemas.analyticsWhoami.response,
+  }),
+  sites: () => defineNuxtRpcQuery({
+    key: ['gsc', 'sites'],
+    path: analyticsRoutes.sites,
+    response: partnerEndpointSchemas.analyticsSites.response,
+  }),
+  sourceInfo: (siteId: string, options?: SourceInfoOptions) => defineNuxtRpcQuery({
+    key: ['gsc', 'source-info', siteId, options?.searchType ?? DEFAULT_SEARCH_TYPE, options?.start ?? options?.startDate ?? '', options?.end ?? options?.endDate ?? ''],
+    path: analyticsRoutes.site.sourceInfo(siteId),
+    query: sourceInfoQuery(options),
+    response: partnerEndpointSchemas.analyticsSourceInfo.response,
+  }),
+  analysisSources: (
+    siteId: string,
+    tables?: string[] | string | AnalysisSourcesOptions,
+    options?: { searchType?: SearchType, start?: string, end?: string, startDate?: string, endDate?: string },
+  ) => {
+    const source = tables && typeof tables === 'object' && !Array.isArray(tables) ? tables : options
+    const tableList = tables && typeof tables === 'object' && !Array.isArray(tables) ? tables.tables : tables
+    const tablesCsv = Array.isArray(tableList) ? tableList.join(',') : (tableList ?? '')
+    return defineNuxtRpcQuery({
+      key: ['gsc', 'analysis-sources', siteId, source?.searchType ?? DEFAULT_SEARCH_TYPE, source?.start ?? source?.startDate ?? '', source?.end ?? source?.endDate ?? '', tablesCsv],
+      path: analyticsRoutes.site.analysisSources(siteId),
+      query: tablesQuery(tables, options),
+      response: partnerEndpointSchemas.analyticsAnalysisSources.response,
+    })
+  },
+  analyze: (siteId: string) => defineNuxtRpcMutation({
+    body: gscdumpAnalysisParamsSchema,
+    method: 'POST',
+    path: analyticsRoutes.site.analyze(siteId),
+    response: gscdumpAnalysisResponseSchema,
+  }),
+  backfill: (siteId: string) => defineNuxtRpcMutation({
+    body: partnerEndpointSchemas.analyticsBackfill.body,
+    method: 'POST',
+    path: analyticsRoutes.site.backfill(siteId),
+    response: partnerEndpointSchemas.analyticsBackfill.response,
+  }),
+  sitemaps: (siteId: string) => defineNuxtRpcQuery({
+    key: ['gsc', 'sitemaps', siteId],
+    path: analyticsRoutes.site.sitemaps(siteId),
+    response: partnerEndpointSchemas.analyticsSitemaps.response,
+  }),
+  sitemapHistory: (siteId: string, hash: string) => defineNuxtRpcQuery({
+    key: ['gsc', 'sitemap-history', siteId, hash],
+    path: analyticsRoutes.site.sitemapHistory(siteId, hash),
+    response: partnerEndpointSchemas.analyticsSitemapHistory.response,
+  }),
+  inspections: (siteId: string) => defineNuxtRpcQuery({
+    key: ['gsc', 'inspections', siteId],
+    path: analyticsRoutes.site.inspections(siteId),
+    response: partnerEndpointSchemas.analyticsInspections.response,
+  }),
+  inspectionHistory: (siteId: string, hash: string) => defineNuxtRpcQuery({
+    key: ['gsc', 'inspection-history', siteId, hash],
+    path: analyticsRoutes.site.inspectionHistory(siteId, hash),
+    response: partnerEndpointSchemas.analyticsInspectionHistory.response,
+  }),
+  indexingInspect: (siteId: string) => defineNuxtRpcMutation({
+    body: partnerEndpointSchemas.analyticsIndexingInspect.body,
+    method: 'POST',
+    path: analyticsRoutes.site.indexingInspect(siteId),
+    response: partnerEndpointSchemas.analyticsIndexingInspect.response,
+  }),
+  countries: (siteId: string, range: GscApiRange) => defineNuxtRpcQuery({
+    key: ['gsc', 'countries', siteId, range.start, range.end],
+    path: analyticsRoutes.site.countries(siteId),
+    query: range,
+    response: partnerEndpointSchemas.analyticsCountries.response,
+  }),
+  searchAppearance: (siteId: string, range: GscApiRange) => defineNuxtRpcQuery({
+    key: ['gsc', 'search-appearance', siteId, range.start, range.end],
+    path: analyticsRoutes.site.searchAppearance(siteId),
+    query: range,
+    response: partnerEndpointSchemas.analyticsSearchAppearance.response,
+  }),
+  rollup: (siteId: string, rollupId: string, range?: Partial<GscApiRange>) => defineNuxtRpcQuery({
+    key: ['gsc', 'rollup', siteId, rollupId, range?.start ?? '', range?.end ?? ''],
+    path: analyticsRoutes.site.rollup(siteId, rollupId),
+    query: range,
+    response: partnerEndpointSchemas.analyticsRollup.response,
+  }),
+  topAssociation: (siteId: string, query: GscdumpTopAssociationParams) => defineNuxtRpcQuery({
+    key: ['gsc', 'top-association', siteId, query.type, query.identifier, query.startDate, query.endDate],
+    path: analyticsRoutes.site.topAssociation(siteId),
+    query,
+    response: partnerEndpointSchemas.getTopAssociation.response,
+  }),
+  syncProgress: () => defineNuxtRpcQuery({
+    key: ['gsc', 'sync-progress'],
+    path: analyticsRoutes.syncProgress,
+    response: partnerEndpointSchemas.appSyncProgress.response,
+  }),
+})
+
+export function withDefaultGscSearchType(params: AnalysisParams): AnalysisParams {
+  return withDefaultSearchType(params)
+}
+
+export type GscIndexingInspectBody = IndexingInspectRequest
+export type GscBackfillBody = BackfillRange