@gscdump/engine-duckdb-wasm 0.9.2 → 0.10.0

package/dist/index.d.mts

@@ -1,6 +1,5 @@
 import { Assume, DrizzleConfig, entityKind } from "drizzle-orm";
 import { PgDatabase, PgDialect, PgPreparedQuery, PgQueryResultHKT, PgSession } from "drizzle-orm/pg-core";
-import { QueryRow, SqlQuerySource, pgResolverAdapter as browserResolverAdapter } from "@gscdump/engine/resolver";
 import { DrizzleSchema as Schema, countries, devices, drizzleSchema as schema, keywords, page_keywords, pages } from "@gscdump/engine/schema";
 import * as _$_gscdump_engine_scope0 from "@gscdump/engine/scope";
 import { ScopedRunnerOptions, TableScope } from "@gscdump/engine/scope";
@@ -26,13 +25,6 @@ interface DuckDBWasmDrizzleDatabase<TSchema extends Record<string, unknown> = Re
   $client: Promise<DuckDBWasmClient>;
 }
 declare function drizzle<TSchema extends Record<string, unknown> = Record<string, never>>(client: Promise<DuckDBWasmClient> | DuckDBWasmClient, config?: DrizzleConfig<TSchema>): DuckDBWasmDrizzleDatabase<TSchema>;
-interface BrowserQueryRunner {
-  query: (sql: string, params?: unknown[]) => Promise<QueryRow[]>;
-}
-interface EngineConfig {
-  runner: BrowserQueryRunner;
-}
-declare function createEngine(config: EngineConfig): SqlQuerySource;
 interface InsightRunnerOptions {
   db: AsyncDuckDB;
   conn: AsyncDuckDBConnection;
@@ -142,15 +134,6 @@ interface AttachParquetUrlTablesOptions {
     total: number;
   }) => void;
 }
-interface AttachSingleTableOptions {
-  db: AsyncDuckDB;
-  conn: AsyncDuckDBConnection;
-  table: string;
-  urls: string[];
-  fetch?: typeof fetch;
-  schema?: string;
-  fetchInit?: RequestInit;
-}
 /**
  * Handle returned from {@link attachParquetUrlTables}. Lets callers detach
  * the created views (for lazy re-attach on a new manifest version) or cheap-
@@ -188,37 +171,12 @@ interface BrowserAnalysisRuntime {
   setAttachedTables: (tables: readonly string[]) => void;
   close: () => Promise<void>;
 }
-/**
- * Build a `DuckDBBundles` map from a single base URL hosting the standard
- * DuckDB-WASM asset set (matches the names jsDelivr + `@duckdb/duckdb-wasm`
- * ship). Callers pointing at a Worker / R2 / self-hosted origin can pass
- * just the origin instead of duplicating the URL layout across apps.
- *
- * Omits `coi` (pthread) by default; most hosts don't serve the
- * cross-origin-isolation headers needed to use it and requesting a missing
- * asset fails bundle selection on Safari/Firefox.
- */
-declare function createDuckDBBundlesFromBase(baseUrl: string, options?: {
-  includeCoi?: boolean;
-}): DuckDBBundles;
 declare function bootDuckDBWasm(options?: BootDuckDBWasmOptions): Promise<DuckDBWasmBootResult>;
 declare function attachParquetTables(options: AttachParquetTablesOptions): Promise<void>;
 declare function attachParquetUrlTables(options: AttachParquetUrlTablesOptions): Promise<AttachedTablesHandle>;
-/**
- * Incremental attach — fetch + register a single table's URLs and create the
- * view, without touching any other table. Use this for lazy attach when a
- * page only needs one of several available tables.
- */
-declare function attachSingleTable(options: AttachSingleTableOptions): Promise<void>;
-/**
- * List the views currently attached under `schema` via DuckDB's
- * `information_schema`. Lets callers decide whether to call
- * `attachSingleTable` before each query without guessing at state.
- */
-declare function listAttachedTables(conn: AsyncDuckDBConnection, schema?: string): Promise<string[]>;
 declare function createBrowserAnalysisRuntime(boot: DuckDBWasmBootResult, options?: {
   schema?: string;
   version?: number | string;
   attachedTables?: readonly string[];
 }): BrowserAnalysisRuntime;
-export { type AnalyzeResult, type AttachParquetTablesOptions, type AttachParquetUrlTablesOptions, type AttachSingleTableOptions, type AttachedTablesHandle, type BootDuckDBWasmOptions, type BrowserAnalysisRuntime, type BrowserParquetFile, type BrowserParquetTable, type BrowserParquetUrlTable, type BrowserQueryRunner, type ComparisonMode, type DuckDBWasmBootResult, type DuckDBWasmClient, DuckDBWasmDatabase, type DuckDBWasmDrizzleDatabase, type EngineConfig, type InsightRunner, type InsightRunnerOptions, type QueryResult, type ResolveWindowOptions, type ResolvedWindow, type Schema, type ScopedRunnerOptions, type StrikingMomentumOptions, type StrikingMomentumRow, type TableScope, type WindowPreset, attachParquetTables, attachParquetUrlTables, attachSingleTable, bootDuckDBWasm, browserResolverAdapter, countries, createBrowserAnalysisRuntime, createClient, createDuckDBBundlesFromBase, createEngine, createInsightRunner, devices, drizzle, keywords, listAttachedTables, mergeScope, page_keywords, pages, resolveWindow, schema, scopeFor, strikingMomentum };
+export { type AnalyzeResult, type AttachParquetTablesOptions, type AttachParquetUrlTablesOptions, type AttachedTablesHandle, type BootDuckDBWasmOptions, type BrowserAnalysisRuntime, type BrowserParquetFile, type BrowserParquetTable, type BrowserParquetUrlTable, type ComparisonMode, type DuckDBWasmBootResult, type DuckDBWasmClient, DuckDBWasmDatabase, type DuckDBWasmDrizzleDatabase, type InsightRunner, type InsightRunnerOptions, type QueryResult, type ResolveWindowOptions, type ResolvedWindow, type Schema, type ScopedRunnerOptions, type StrikingMomentumOptions, type StrikingMomentumRow, type TableScope, type WindowPreset, attachParquetTables, attachParquetUrlTables, bootDuckDBWasm, countries, createBrowserAnalysisRuntime, createClient, createInsightRunner, devices, drizzle, keywords, mergeScope, page_keywords, pages, resolveWindow, schema, scopeFor, strikingMomentum };

package/dist/index.mjs

@@ -1,11 +1,11 @@
 import { arrowToRows } from "@gscdump/engine/arrow";
 import { DefaultLogger, NoopLogger, createTableRelationsHelpers, entityKind, extractTablesRelationalConfig, fillPlaceholders, sql } from "drizzle-orm";
 import { PgDatabase, PgDialect, PgPreparedQuery, PgSession } from "drizzle-orm/pg-core";
-import { createSqlQuerySource, pgResolverAdapter as browserResolverAdapter } from "@gscdump/engine/resolver";
 import { toIsoDate } from "gscdump";
 import { countries, devices, drizzleSchema as schema, keywords, page_keywords, pages } from "@gscdump/engine/schema";
 import { createScopedHelpers } from "@gscdump/engine/scope";
 import { runAnalyzerFromSource } from "@gscdump/engine/analyzer";
+import { pgResolverAdapter } from "@gscdump/engine/resolver";
 import { createAttachedTableSource } from "@gscdump/engine/source";
 import { sqlEscape } from "@gscdump/engine/sql";
 import { resolveWindow } from "@gscdump/engine/period";
@@ -89,15 +89,6 @@ function drizzle(client, config = {}) {
 	db.$client = clientPromise;
 	return db;
 }
-function createEngine(config) {
-	const { runner } = config;
-	return createSqlQuerySource({
-		name: "browser",
-		adapter: browserResolverAdapter,
-		execute: (sql, params) => runner.query(sql, params),
-		extraCapabilities: { attachedTables: true }
-	});
-}
 async function strikingMomentum(runner, opts = {}) {
 	const windowDays = opts.windowDays ?? 90;
 	const anchor = opts.anchor ?? toIsoDate(/* @__PURE__ */ new Date());
@@ -178,25 +169,6 @@ function fileName(table, index, provided) {
 function readParquetViewSql(schema, table, files) {
 	return `CREATE OR REPLACE VIEW ${schema}.${table} AS SELECT * FROM read_parquet([${files.map((name) => `'${sqlEscape(name)}'`).join(", ")}], union_by_name = true)`;
 }
-function createDuckDBBundlesFromBase(baseUrl, options = {}) {
-	const base = baseUrl.replace(/\/+$/, "");
-	const bundles = {
-		mvp: {
-			mainModule: `${base}/duckdb-mvp.wasm`,
-			mainWorker: `${base}/duckdb-browser-mvp.worker.js`
-		},
-		eh: {
-			mainModule: `${base}/duckdb-eh.wasm`,
-			mainWorker: `${base}/duckdb-browser-eh.worker.js`
-		}
-	};
-	if (options.includeCoi) bundles.coi = {
-		mainModule: `${base}/duckdb-coi.wasm`,
-		mainWorker: `${base}/duckdb-browser-coi.worker.js`,
-		pthreadWorker: `${base}/duckdb-browser-coi.pthread.worker.js`
-	};
-	return bundles;
-}
 async function bootDuckDBWasm(options = {}) {
 	const { getJsDelivrBundles, selectBundle, AsyncDuckDB, ConsoleLogger } = await import("@duckdb/duckdb-wasm");
 	const bundle = await selectBundle(options.bundles ?? getJsDelivrBundles());
@@ -271,21 +243,6 @@ async function attachParquetUrlTables(options) {
 		}
 	};
 }
-async function attachSingleTable(options) {
-	const { db, conn, table, urls, fetch: fetchImpl = globalThis.fetch.bind(globalThis), schema = "main", fetchInit } = options;
-	if (urls.length === 0) return;
-	await Promise.all(urls.map(async (url, index) => {
-		const response = await fetchImpl(url, fetchInit);
-		if (!response.ok) throw new Error(`fetch ${url} failed: ${response.status}`);
-		const bytes = new Uint8Array(await response.arrayBuffer());
-		await db.registerFileBuffer(fileName(table, index), bytes);
-	}));
-	const names = urls.map((_, i) => fileName(table, i));
-	await conn.query(readParquetViewSql(schema, table, names));
-}
-async function listAttachedTables(conn, schema = "main") {
-	return arrowToRows(await conn.query(`SELECT table_name FROM information_schema.tables WHERE table_schema = '${sqlEscape(schema)}'`)).map((r) => String(r.table_name));
-}
 function createBrowserAnalysisRuntime(boot, options = {}) {
 	const { db, conn } = boot;
 	const schema = options.schema ?? "main";
@@ -340,7 +297,8 @@ function createBrowserAnalysisRuntime(boot, options = {}) {
 				} }, {
 					schema,
 					signal,
-					attachedTables
+					attachedTables,
+					adapter: pgResolverAdapter
 				}), params, registry);
 				return {
 					results: result.results,
@@ -367,4 +325,4 @@ function createBrowserAnalysisRuntime(boot, options = {}) {
 		}
 	};
 }
-export { DuckDBWasmDatabase, attachParquetTables, attachParquetUrlTables, attachSingleTable, bootDuckDBWasm, browserResolverAdapter, countries, createBrowserAnalysisRuntime, createClient, createDuckDBBundlesFromBase, createEngine, createInsightRunner, devices, drizzle, keywords, listAttachedTables, mergeScope, page_keywords, pages, resolveWindow, schema, scopeFor, strikingMomentum };
+export { DuckDBWasmDatabase, attachParquetTables, attachParquetUrlTables, bootDuckDBWasm, countries, createBrowserAnalysisRuntime, createClient, createInsightRunner, devices, drizzle, keywords, mergeScope, page_keywords, pages, resolveWindow, schema, scopeFor, strikingMomentum };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@gscdump/engine-duckdb-wasm",
   "type": "module",
-  "version": "0.9.2",
+  "version": "0.10.0",
   "description": "DuckDB-WASM engine adapter for @gscdump/analysis — typed browser analytics against parquet via R2.",
   "author": {
     "name": "Harlan Wilton",
@@ -45,8 +45,8 @@
   },
   "dependencies": {
     "drizzle-orm": "^0.45.2",
-    "@gscdump/engine": "0.9.2",
-    "gscdump": "0.9.2"
+    "gscdump": "0.10.0",
+    "@gscdump/engine": "0.10.0"
   },
   "devDependencies": {
     "@duckdb/duckdb-wasm": "^1.32.0",