@gscdump/engine 0.9.2 → 0.11.0

package/dist/source/index.d.mts

@@ -1,7 +1,7 @@
 import { F as TenantCtx, O as StorageEngine, T as Row } from "../_chunks/storage.mjs";
+import { o as ResolverAdapter } from "../_chunks/types.mjs";
 import { n as AnalysisResult, t as AnalysisParams } from "../_chunks/analysis-types.mjs";
-import { i as QueryRow, r as FileSet, s as SqlQuerySource, t as AnalysisQuerySource } from "../_chunks/source-types.mjs";
-import { t as AnalyzerRegistry } from "../_chunks/registry.mjs";
+import { C as ExecuteSqlOptions, E as SourceCapabilities, S as AnalysisSourceKind, T as QueryRow, t as AnalyzerRegistry, w as FileSet, x as AnalysisQuerySource } from "../_chunks/registry.mjs";
 import { PlannerCapabilities } from "gscdump/query/plan";
 import { BuilderState } from "gscdump/query";
 interface AttachedTableRunner {
@@ -28,6 +28,13 @@ interface AttachedTableSourceOptions {
    * paying the SQL execution cost. Omit to disable the check.
    */
   attachedTables?: readonly string[];
+  /**
+   * Dialect adapter surfaced on the source for analyzers that compose SQL
+   * from a `BuilderState` at plan-build time (e.g. `data-query`,
+   * `data-detail`). Attached-table sources execute pg-flavored DuckDB SQL,
+   * so callers should pass `pgResolverAdapter` here.
+   */
+  adapter?: ResolverAdapter<any>;
 }
 declare class AttachedTableMissingError extends Error {
   readonly missing: readonly string[];
@@ -39,6 +46,21 @@ declare class AttachedTableMissingError extends Error {
  */
 declare function rewriteForTableSource(sql: string, schema: string, fileSets: Record<string, FileSet>): string;
 declare function createAttachedTableSource(runner: AttachedTableRunner, options: AttachedTableSourceOptions): AnalysisQuerySource;
+interface CreateSqlQuerySourceOptions<TKey extends string> {
+  /** Debug-only identifier surfaced on the source for error messages. */
+  name: string;
+  /** Telemetry tag stamped onto analyzer result meta. */
+  kind?: AnalysisSourceKind;
+  /** Dialect-specific adapter; compiles `BuilderState` → `{ sql, params }`. */
+  adapter: ResolverAdapter<TKey>;
+  /** Drives the underlying DB. Called for both typed queries and raw SQL. */
+  execute: (sql: string, params: unknown[]) => Promise<QueryRow[]>;
+  /** Tenant id for multi-tenant dialects; forwarded to `resolveToSQL`. */
+  siteId?: string | number;
+  /** Additional capability flags merged on top of `adapter.capabilities`. */
+  extraCapabilities?: Partial<SourceCapabilities>;
+}
+declare function createSqlQuerySource<TKey extends string>(options: CreateSqlQuerySourceOptions<TKey>): AnalysisQuerySource;
 /**
  * Capabilities the engine query path honors. Matches what the DuckDB compiler
  * passes to `buildLogicalPlan`: regex pushes down; comparison joins and
@@ -51,12 +73,12 @@ interface EngineQuerySourceOptions {
   ctx: TenantCtx;
 }
 /**
- * Wraps a storage engine as a `SqlQuerySource`. `queryRows` runs typed
- * builder-state queries; `executeSql` delegates to `engine.runSQL` and
- * requires `opts.fileSets` (with a `FILES` entry so the target table can be
- * resolved for partition lookup).
+ * Wraps a storage engine as an `AnalysisQuerySource` with SQL execution.
+ * `queryRows` runs typed builder-state queries; `executeSql` delegates to
+ * `engine.runSQL` and requires `opts.fileSets` (with a `FILES` entry so the
+ * target table can be resolved for partition lookup).
  */
-declare function createEngineQuerySource(options: EngineQuerySourceOptions): SqlQuerySource;
+declare function createEngineQuerySource(options: EngineQuerySourceOptions): AnalysisQuerySource;
 /**
  * Convenience: wrap a storage engine + tenant ctx in a source and dispatch.
  * Equivalent to
@@ -75,4 +97,4 @@ declare function queryComparisonRows<TRow = QueryRow>(source: AnalysisQuerySourc
   current: TRow[];
   previous: TRow[];
 }>;
-export { AttachedTableMissingError, type AttachedTableRunner, type AttachedTableSourceOptions, ENGINE_QUERY_CAPABILITIES, EngineQuerySourceOptions, TypedQuery, createAttachedTableSource, createEngineQuerySource, queryComparisonRows, queryRows, rewriteForTableSource, runAnalyzerWithEngine, typedQuery };
+export { type AnalysisQuerySource, type AnalysisSourceKind, AttachedTableMissingError, type AttachedTableRunner, type AttachedTableSourceOptions, type CreateSqlQuerySourceOptions, ENGINE_QUERY_CAPABILITIES, EngineQuerySourceOptions, type ExecuteSqlOptions, type FileSet, type QueryRow, type SourceCapabilities, TypedQuery, createAttachedTableSource, createEngineQuerySource, createSqlQuerySource, queryComparisonRows, queryRows, rewriteForTableSource, runAnalyzerWithEngine, typedQuery };

package/dist/source/index.mjs

@@ -1,5 +1,5 @@
-import { l as assertDimensionsSupported } from "../_chunks/pg-adapter.mjs";
-import { a as getFilterDimensions } from "../_chunks/resolver.mjs";
+import { h as resolveToSQL, n as pgResolverAdapter, s as assertDimensionsSupported } from "../_chunks/pg-adapter.mjs";
+import { i as getFilterDimensions } from "../_chunks/resolver.mjs";
 import { n as runAnalyzerFromSource } from "../_chunks/dispatch.mjs";
 var AttachedTableMissingError = class extends Error {
 	constructor(missing) {
@@ -11,7 +11,12 @@ var AttachedTableMissingError = class extends Error {
 const ATTACHED_TABLE_CAPABILITIES = {
 	fileSets: true,
 	attachedTables: true,
-	regex: true
+	regex: true,
+	executeSql: true
+};
+const ATTACHED_TABLE_CAPABILITIES_WITH_ADAPTER = {
+	...ATTACHED_TABLE_CAPABILITIES,
+	adapter: true
 };
 function rewriteForTableSource(sql, schema, fileSets) {
 	let out = sql;
@@ -22,11 +27,13 @@ function rewriteForTableSource(sql, schema, fileSets) {
 	return out;
 }
 function createAttachedTableSource(runner, options) {
-	const { schema, signal, attachedTables } = options;
+	const { schema, signal, attachedTables, adapter } = options;
 	const attachedSet = attachedTables ? new Set(attachedTables) : null;
 	return {
 		name: "attached-table",
-		capabilities: ATTACHED_TABLE_CAPABILITIES,
+		kind: "browser",
+		capabilities: adapter ? ATTACHED_TABLE_CAPABILITIES_WITH_ADAPTER : ATTACHED_TABLE_CAPABILITIES,
+		adapter,
 		async queryRows() {
 			throw new Error("attached-table source: queryRows is not supported; use SQL analyzers");
 		},
@@ -43,6 +50,31 @@ function createAttachedTableSource(runner, options) {
 		}
 	};
 }
+function createSqlQuerySource(options) {
+	const { name, kind, adapter, execute, siteId, extraCapabilities } = options;
+	return {
+		name,
+		kind,
+		capabilities: {
+			...adapter.capabilities,
+			...extraCapabilities,
+			executeSql: true,
+			adapter: true
+		},
+		adapter,
+		siteId,
+		async queryRows(state) {
+			const resolved = resolveToSQL(state, {
+				adapter,
+				siteId
+			});
+			return execute(resolved.sql, resolved.params);
+		},
+		executeSql(sql, params) {
+			return execute(sql, params ?? []);
+		}
+	};
+}
 function isMetricDimension(dim) {
 	return [
 		"clicks",
@@ -60,13 +92,16 @@ const ENGINE_QUERY_CAPABILITIES = {
 const ENGINE_SOURCE_CAPABILITIES = {
 	...ENGINE_QUERY_CAPABILITIES,
 	fileSets: true,
-	localSource: true
+	executeSql: true,
+	adapter: true
 };
 function createEngineQuerySource(options) {
 	const { engine, ctx } = options;
 	return {
 		name: "engine",
+		kind: "local",
 		capabilities: ENGINE_SOURCE_CAPABILITIES,
+		adapter: pgResolverAdapter,
 		async queryRows(state) {
 			const filterDims = getFilterDimensions(state.filter, isMetricDimension);
 			assertDimensionsSupported([...state.dimensions, ...filterDims], "stored", "engine query source");
@@ -110,4 +145,4 @@ async function queryComparisonRows(source, current, previous) {
 		previous: previousRows
 	};
 }
-export { AttachedTableMissingError, ENGINE_QUERY_CAPABILITIES, createAttachedTableSource, createEngineQuerySource, queryComparisonRows, queryRows, rewriteForTableSource, runAnalyzerWithEngine, typedQuery };
+export { AttachedTableMissingError, ENGINE_QUERY_CAPABILITIES, createAttachedTableSource, createEngineQuerySource, createSqlQuerySource, queryComparisonRows, queryRows, rewriteForTableSource, runAnalyzerWithEngine, typedQuery };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@gscdump/engine",
   "type": "module",
-  "version": "0.9.2",
+  "version": "0.11.0",
   "description": "Append-only Parquet/DuckDB storage engine + planner + adapters for the gscdump pipeline. Node + edge runtimes; opt-in heavy peers.",
   "author": {
     "name": "Harlan Wilton",
@@ -61,15 +61,25 @@
       "import": "./dist/sql-fragments.mjs",
       "default": "./dist/sql-fragments.mjs"
     },
+    "./schedule": {
+      "types": "./dist/schedule.d.mts",
+      "import": "./dist/schedule.mjs",
+      "default": "./dist/schedule.mjs"
+    },
     "./entities": {
       "types": "./dist/entities.d.mts",
       "import": "./dist/entities.mjs",
       "default": "./dist/entities.mjs"
     },
+    "./rollups": {
+      "types": "./dist/rollups.d.mts",
+      "import": "./dist/rollups.mjs",
+      "default": "./dist/rollups.mjs"
+    },
     "./node": {
-      "types": "./dist/adapters/duckdb-node.d.mts",
-      "import": "./dist/adapters/duckdb-node.mjs",
-      "default": "./dist/adapters/duckdb-node.mjs"
+      "types": "./dist/adapters/node.d.mts",
+      "import": "./dist/adapters/node.mjs",
+      "default": "./dist/adapters/node.mjs"
     },
     "./filesystem": {
       "types": "./dist/adapters/filesystem.d.mts",
@@ -159,7 +169,7 @@
   "dependencies": {
     "drizzle-orm": "^0.45.2",
     "proper-lockfile": "^4.1.2",
-    "gscdump": "0.9.2"
+    "gscdump": "0.11.0"
   },
   "devDependencies": {
     "@duckdb/duckdb-wasm": "^1.32.0",

package/dist/_chunks/source-types.d.mts

@@ -1,31 +0,0 @@
-import { PlannerCapabilities } from "gscdump/query/plan";
-import { TableName } from "gscdump/contracts";
-import { BuilderState } from "gscdump/query";
-type QueryRow = Record<string, unknown>;
-interface FileSet {
-  table: TableName;
-  partitions: string[];
-}
-interface ExecuteSqlOptions {
-  fileSets?: Record<string, FileSet>;
-}
-interface SourceCapabilities extends PlannerCapabilities {
-  attachedTables?: boolean;
-  fileSets?: boolean;
-  localSource?: boolean;
-}
-interface RowQuerySource {
-  name?: string;
-  capabilities: SourceCapabilities;
-  queryRows: (state: BuilderState) => Promise<QueryRow[]>;
-  readonly executeSql?: undefined;
-}
-interface SqlQuerySource {
-  name?: string;
-  capabilities: SourceCapabilities;
-  queryRows: (state: BuilderState) => Promise<QueryRow[]>;
-  executeSql: (sql: string, params?: unknown[], opts?: ExecuteSqlOptions) => Promise<QueryRow[]>;
-}
-type AnalysisQuerySource = RowQuerySource | SqlQuerySource;
-declare function isSqlQuerySource(s: AnalysisQuerySource): s is SqlQuerySource;
-export { RowQuerySource as a, isSqlQuerySource as c, QueryRow as i, ExecuteSqlOptions as n, SourceCapabilities as o, FileSet as r, SqlQuerySource as s, AnalysisQuerySource as t };