@wavehouse/sdk 0.0.0-dev.0f8826c → 0.0.0-dev.h04a85f20bb96

package/dist/index.js

@@ -35,29 +35,64 @@ function err(error) {
   return { ok: false, data: null, error };
 }
 
+// src/url.ts
+function resolveURL(base, path, params) {
+  const root = new URL(base);
+  root.search = "";
+  root.hash = "";
+  if (!root.pathname.endsWith("/")) root.pathname += "/";
+  const url = new URL(path.replace(/^\/+/, ""), root);
+  if (params) {
+    for (const [k, v] of Object.entries(params)) {
+      url.searchParams.set(k, v);
+    }
+  }
+  return url;
+}
+
 // src/http.ts
+function mergeHeaders(base, extra) {
+  if (!extra) return base;
+  const sdkNames = new Set(Object.keys(base).map((k) => k.toLowerCase()));
+  const merged = { ...base };
+  const configured = /* @__PURE__ */ new Map();
+  for (const [name, value] of Object.entries(extra)) {
+    const lower = name.toLowerCase();
+    if (sdkNames.has(lower)) continue;
+    const prior = configured.get(lower);
+    if (prior !== void 0) delete merged[prior];
+    merged[name] = value;
+    configured.set(lower, name);
+  }
+  return merged;
+}
 async function request(ctx, opts) {
-  const url = buildURL(ctx.baseURL, opts.path, opts.params);
+  const url = resolveURL(ctx.baseURL, opts.path, opts.params).toString();
   const headers = {
-    "Content-Type": "application/json",
+    "Content-Type": opts.contentType ?? "application/json",
     Accept: "application/json"
   };
+  const requestBody = opts.rawBody !== void 0 ? opts.rawBody : opts.body !== void 0 ? JSON.stringify(opts.body) : void 0;
   if (ctx.auth) {
     const token = await ctx.auth();
     if (token) {
       headers.Authorization = `Bearer ${token}`;
     }
   }
+  const finalHeaders = mergeHeaders(headers, ctx.options.headers);
   let lastError = null;
   const maxAttempts = ctx.options.maxRetries + 1;
   for (let attempt = 0; attempt < maxAttempts; attempt++) {
     try {
-      const res = await fetch(url, {
+      const init = {
+        ...ctx.options.fetchOptions,
         method: opts.method,
-        headers,
-        body: opts.body !== void 0 ? JSON.stringify(opts.body) : void 0,
+        headers: finalHeaders,
+        body: requestBody,
         signal: opts.signal
-      });
+      };
+      const doFetch = ctx.options.fetch;
+      const res = doFetch ? await doFetch(url, init) : await fetch(url, init);
       if (res.ok) {
         const text = await res.text();
         const data = text ? JSON.parse(text) : void 0;
@@ -95,15 +130,6 @@ async function request(ctx, opts) {
   }
   return { data: null, error: lastError, headers: new Headers() };
 }
-function buildURL(base, path, params) {
-  const url = new URL(path, base.endsWith("/") ? base : `${base}/`);
-  if (params) {
-    for (const [k, v] of Object.entries(params)) {
-      url.searchParams.set(k, v);
-    }
-  }
-  return url.toString();
-}
 function backoff(attempt) {
   return Math.min(1e3 * 2 ** attempt, 3e4);
 }
@@ -172,7 +198,14 @@ var PipeRef = class {
     this._params = params;
     this._createStream = createStream;
   }
-  /** Execute the pipe and return results. */
+  /**
+   * Execute the pipe and return results.
+   *
+   * Takes only `signal` — deliberately narrower than the `RequestOptions` the
+   * query builder accepts. The pipes endpoint binds the body as the pipe's
+   * parameters, so there is no row cap to forward; give the pipe a `{{limit}}`
+   * parameter in its SQL and pass it via `wh.pipe(name, { limit })`.
+   */
   async fetch(opts) {
     const { data, error } = await request(this._ctx, {
       method: "POST",
@@ -520,7 +553,7 @@ var SSETransport = class {
     this.onStatus?.("closed");
   }
   async _doConnect() {
-    const url = new URL("/v1/stream", this._opts.baseURL);
+    const url = resolveURL(this._opts.baseURL, "/v1/stream");
     url.searchParams.set("table", this._opts.table);
     if (this._opts.since) {
       url.searchParams.set("since", this._opts.since);
@@ -690,6 +723,15 @@ var QueryBuilder = class _QueryBuilder {
   select(...columns) {
     return this._clone({ columns: [...this._state.columns, ...columns] });
   }
+  /**
+   * Select every column the caller's role is allowed to read (the all-columns
+   * wildcard). Use this instead of `.select(...)` when you want a full-row read;
+   * a bare `.fetch()` with no `.select()` does this implicitly. Mutually
+   * exclusive with `.select(...)`.
+   */
+  selectAll() {
+    return this._clone({ selectAll: true });
+  }
   where(column, op, value) {
     const filter = { column, op: OP_MAP[op], value };
     return this._clone({ filters: [...this._state.filters, filter] });
@@ -731,7 +773,7 @@ var QueryBuilder = class _QueryBuilder {
     return this._clone({ cacheTTL: seconds });
   }
   // --- Execution ---
-  /** Default row limit when none is specified. Matches backend DefaultMaxRows. */
+  /** Default row limit when none is specified — deliberately tighter than the backend's DefaultMaxRows (10000) safety cap. */
   static DEFAULT_LIMIT = 1e3;
   async fetch(opts) {
     const effectiveLimit = opts?.limit ?? this._state.limit ?? _QueryBuilder.DEFAULT_LIMIT;
@@ -745,11 +787,11 @@ var QueryBuilder = class _QueryBuilder {
     if (error) return err(error);
     const rows = data;
     const hasMore = effectiveLimit != null && rows.length >= effectiveLimit;
-    if (hasMore) {
+    if (hasMore && this._state.orderBy.length > 0) {
       const nextFn = () => this._fetchNext(rows, effectiveLimit, opts);
       return okPage(rows, true, nextFn);
     }
-    return okPage(rows, false);
+    return okPage(rows, hasMore);
   }
   stream(opts) {
     const raw = this._createStream(this._state.table, opts);
@@ -788,31 +830,35 @@ var QueryBuilder = class _QueryBuilder {
   }
   _buildAST(effectiveLimit) {
     const ast = {};
-    if (this._state.columns.length > 0) ast.columns = this._state.columns;
-    if (this._state.aggregations.length > 0) ast.aggregations = this._state.aggregations;
+    const hasColumns = this._state.columns.length > 0;
+    const hasAggs = this._state.aggregations.length > 0;
+    if (this._state.selectAll) {
+      ast.select_all = true;
+    } else if (hasColumns) {
+      ast.columns = this._state.columns;
+    } else if (!hasAggs) {
+      ast.select_all = true;
+    }
+    if (hasAggs) ast.aggregations = this._state.aggregations;
     if (this._state.filters.length > 0) ast.filters = this._state.filters;
     if (this._state.groupBy.length > 0) ast.group_by = this._state.groupBy;
-    if (this._state.orderBy.length > 0) {
-      ast.order_by = this._state.orderBy;
-    } else if (effectiveLimit != null && this._state.aggregations.length === 0) {
-      ast.order_by = [{ column: "received_timestamp", dir: "desc" }];
-    }
+    if (this._state.orderBy.length > 0) ast.order_by = this._state.orderBy;
     if (effectiveLimit != null) ast.limit = effectiveLimit;
     if (this._state.timeRange) ast.time_range = this._state.timeRange;
     return ast;
   }
   async _fetchNext(prevRows, _limit, opts) {
-    const orderCol = this._state.orderBy[0]?.column ?? "received_timestamp";
-    const orderDir = this._state.orderBy[0]?.dir ?? "desc";
+    const cursor = this._state.orderBy[0];
+    if (cursor == null) return okPage([], false);
+    const { column: orderCol, dir: orderDir } = cursor;
     const lastRow = prevRows[prevRows.length - 1];
     const lastValue = lastRow?.[orderCol];
     if (lastValue === void 0) return okPage([], false);
     const cursorOp = orderDir === "desc" ? "lt" : "gt";
     const cursorFilter = { column: orderCol, op: cursorOp, value: lastValue };
-    const orderBy = this._state.orderBy.length > 0 ? this._state.orderBy : [{ column: orderCol, dir: orderDir }];
     const nextBuilder = this._clone({
       filters: [...this._state.filters, cursorFilter],
-      orderBy
+      orderBy: this._state.orderBy
     });
     return nextBuilder.fetch(opts);
   }
@@ -903,6 +949,12 @@ function projectColumns(row, columns) {
 }
 
 // src/table.ts
+var NDJSON_CONTENT_TYPE = "application/x-ndjson";
+async function ndjsonSourceToString(source) {
+  if (typeof source === "string") return source;
+  if (source instanceof Uint8Array) return new TextDecoder().decode(source);
+  return new Response(source).text();
+}
 var TableRef = class {
   _ctx;
   _table;
@@ -931,22 +983,34 @@ var TableRef = class {
       this._createStream
     );
   }
-  /** Insert one or more rows into this table. */
+  /**
+   * Start a query that selects every column the caller's role is allowed to read
+   * (the all-columns wildcard). Use instead of `.select(...)` for an explicit
+   * full-row read; `.fetch()` does this implicitly.
+   */
+  selectAll() {
+    return this.select().selectAll();
+  }
+  /**
+   * Insert one or more rows into this table.
+   *
+   * A single object is sent as a JSON `POST /v1/ingest`. An **array** is
+   * serialized to NDJSON (one record per line) and sent as a single
+   * `application/x-ndjson` request: a bad record no longer fails or hides the
+   * rest of the batch — per-record outcomes come back in the result
+   * (`failed` / `results`), and `ok` is true only when every record succeeded.
+   *
+   * The array path sends one request regardless of size; bounded-concurrency
+   * chunking of very large arrays is tracked separately (#196). For NDJSON you
+   * already have (a file or stream), use {@link insertNDJSON}.
+   */
   async insert(data, opts) {
     if (Array.isArray(data)) {
-      const promises = data.map(
-        (row) => request(this._ctx, {
-          method: "POST",
-          path: `/v1/ingest?table=${encodeURIComponent(this._table)}`,
-          body: row,
-          signal: opts?.signal
-        })
-      );
-      const results = await Promise.all(promises);
-      for (const res2 of results) {
-        if (res2.error) return err(res2.error);
+      if (data.length === 0) {
+        return ok({ ok: true, total: 0, succeeded: 0, failed: 0, duplicates: 0, results: [] });
       }
-      return ok({ ok: true });
+      const ndjson = data.map((row) => JSON.stringify(row)).join("\n");
+      return this._sendNDJSON(ndjson, opts);
     }
     const { data: res, error } = await request(this._ctx, {
       method: "POST",
@@ -959,6 +1023,46 @@ var TableRef = class {
     if (res?.duplicate != null) result.duplicate = res.duplicate;
     return ok(result);
   }
+  /**
+   * Insert pre-formatted NDJSON (newline-delimited JSON, one record per line)
+   * from a string, raw bytes, a Blob/File, or a byte stream — e.g. a `.ndjson`
+   * file or a stream produced by another system. For in-memory rows, prefer
+   * {@link insert}.
+   *
+   * Non-string sources are read fully into memory before sending (the server
+   * streams the parse). Returns the same per-record batch summary as an array
+   * `insert`.
+   */
+  async insertNDJSON(source, opts) {
+    const ndjson = await ndjsonSourceToString(source);
+    return this._sendNDJSON(ndjson, opts);
+  }
+  /**
+   * @internal Send an NDJSON body and map the server's batch response onto an
+   * {@link InsertResult}. A transport / whole-request failure surfaces as the
+   * Result error arm; a processed batch (even with rejected records) surfaces
+   * as the success arm with `ok = failed === 0`.
+   */
+  async _sendNDJSON(ndjson, opts) {
+    const { data, error } = await request(this._ctx, {
+      method: "POST",
+      path: `/v1/ingest?table=${encodeURIComponent(this._table)}`,
+      rawBody: ndjson,
+      contentType: NDJSON_CONTENT_TYPE,
+      signal: opts?.signal
+    });
+    if (error) return err(error);
+    const r = data ?? { total: 0, succeeded: 0, failed: 0, duplicates: 0 };
+    const result = {
+      ok: r.failed === 0,
+      total: r.total,
+      succeeded: r.succeeded,
+      failed: r.failed,
+      duplicates: r.duplicates
+    };
+    if (r.results && r.results.length > 0) result.results = r.results;
+    return ok(result);
+  }
   /** Fetch the schema for this table. */
   async schema(opts) {
     const { data, error } = await request(this._ctx, {
@@ -994,7 +1098,10 @@ var WaveHouseClient = class {
       baseURL: config.baseURL.replace(/\/+$/, ""),
       auth: config.auth,
       options: {
-        maxRetries: config.options?.maxRetries ?? 2
+        maxRetries: config.options?.maxRetries ?? 2,
+        fetch: config.options?.fetch,
+        headers: config.options?.headers,
+        fetchOptions: config.options?.fetchOptions
       }
     };
     this.schema = new SchemaNamespace(this._ctx);