@sixb/ducklake 0.2.1 → 0.2.2

package/README.md

@@ -65,6 +65,18 @@ const lakeStorage = new DuckLakeStorage({
 Use `close()` during service shutdown so DuckDB can close its runtime and release
 catalog connections cleanly.
 
+### Extensions
+
+On first use, the provider installs DuckLake and the extensions its catalog,
+data path and secrets need. A missing extension is downloaded over HTTPS from
+`https://extensions.duckdb.org` into DuckDB's extension directory
+(`duckdb.config.extension_directory`, `~/.duckdb/extensions` by default), so a
+host that allows only that HTTPS domain, such as a restricted Vercel sandbox,
+can open a lake. When that download fails, the provider logs a warning and
+DuckDB's own `INSTALL` downloads the extension over plain HTTP, as before.
+With `custom_extension_repository` set, DuckDB installs from that repository
+alone.
+
 ### Maintenance
 
 DuckLake keeps historical snapshots and deleted files until maintenance runs.

package/dist/index.js

@@ -871,13 +871,78 @@ function localCatalogCoordinationKey(options) {
 }
 
 // src/internal/duckdb-runtime.ts
-import { mkdir, mkdtemp, rm } from "fs/promises";
-import { join, resolve as resolve2 } from "path";
+import { mkdir, mkdtemp as mkdtemp2, rm as rm2 } from "fs/promises";
+import { join as join2, resolve as resolve2 } from "path";
 import {
   DuckDBInstance
 } from "@duckdb/node-api";
 import { LakeStorageError as LakeStorageError11 } from "@sixb/core/lake-storage";
 
+// src/internal/duckdb-extensions.ts
+import { mkdtemp, rm, writeFile } from "fs/promises";
+import { tmpdir } from "os";
+import { join } from "path";
+import { promisify } from "util";
+import { gunzip } from "zlib";
+var extensionsUrl = "https://extensions.duckdb.org";
+var downloadTimeoutMillis = 60000;
+var gunzipAsync = promisify(gunzip);
+async function prefetchDuckDbExtensions(runtime, extensions) {
+  await prefetch(runtime, extensions).catch((error) => warnFallback(extensions.join("', '"), error));
+}
+async function prefetch(runtime, extensions) {
+  const [target] = await runtime.query(`
+    SELECT
+      version() AS version,
+      (SELECT platform FROM pragma_platform()) AS platform,
+      current_setting('custom_extension_repository') AS repository
+  `);
+  if (target?.repository !== "")
+    return;
+  const missing = await missingExtensions(runtime, extensions);
+  if (missing.length === 0)
+    return;
+  const directory = await mkdtemp(join(tmpdir(), "sixb-duckdb-extensions-"));
+  try {
+    const downloads = await Promise.all(missing.map(async (name) => ({
+      name,
+      file: await download(`${target.version}/${target.platform}/${name}`, directory, name).catch((error) => warnFallback(name, error))
+    })));
+    for (const { name, file } of downloads) {
+      if (file === undefined)
+        continue;
+      await runtime.run(`INSTALL ${quoteSqlString(file)}`).catch((error) => warnFallback(name, error));
+    }
+  } finally {
+    await rm(directory, { recursive: true, force: true });
+  }
+}
+function warnFallback(name, error) {
+  const reason = error instanceof Error ? error.message : String(error);
+  console.warn(`[SixbDuckLake] Could not install DuckDB extension '${name}' over HTTPS (${reason}); falling back to DuckDB's INSTALL.`);
+  return;
+}
+async function missingExtensions(runtime, extensions) {
+  const requested = `[${quoteSqlStringList(extensions.map((extension) => extension.toLowerCase()))}]`;
+  const rows = await runtime.query(`
+    SELECT extension_name
+    FROM duckdb_extensions()
+    WHERE NOT installed
+      AND (list_contains(${requested}, extension_name) OR list_has_any(${requested}, aliases))
+  `);
+  return rows.map((row) => String(row.extension_name));
+}
+async function download(path, directory, name) {
+  const response = await fetch(`${extensionsUrl}/${path}.duckdb_extension.gz`, {
+    signal: AbortSignal.timeout(downloadTimeoutMillis)
+  });
+  if (!response.ok)
+    throw new Error(`HTTP ${response.status}`);
+  const file = join(directory, `${name}.duckdb_extension`);
+  await writeFile(file, await gunzipAsync(new Uint8Array(await response.arrayBuffer())));
+  return file;
+}
+
 // src/internal/duckdb-reader.ts
 import { LakeStorageError as LakeStorageError10 } from "@sixb/core/lake-storage";
 
@@ -1094,7 +1159,7 @@ class NodeDuckDbRuntime {
     this.connection.closeSync();
     this.instance.closeSync();
     if (this.temporaryDirectory)
-      await rm(this.temporaryDirectory, { recursive: true, force: true });
+      await rm2(this.temporaryDirectory, { recursive: true, force: true });
     const failed = results.find((result) => result.status === "rejected");
     if (failed?.status === "rejected")
       throw failed.reason;
@@ -1181,7 +1246,7 @@ async function createDuckDbRuntime(options = {}) {
   if (base !== "") {
     const directory = resolve2(base);
     await mkdir(directory, { recursive: true });
-    temporaryDirectory = await mkdtemp(join(directory, "sixb-"));
+    temporaryDirectory = await mkdtemp2(join2(directory, "sixb-"));
   }
   let instance;
   try {
@@ -1193,13 +1258,15 @@ async function createDuckDbRuntime(options = {}) {
   } catch (error) {
     instance?.closeSync();
     if (temporaryDirectory)
-      await rm(temporaryDirectory, { recursive: true, force: true });
+      await rm2(temporaryDirectory, { recursive: true, force: true });
     throw error;
   }
 }
 async function installDuckLakeExtensions(runtime, options) {
+  const extensions = requiredExtensions(options);
+  await prefetchDuckDbExtensions(runtime, ["ducklake", ...extensions]);
   await runtime.run("INSTALL ducklake");
-  for (const extension of requiredExtensions(options)) {
+  for (const extension of extensions) {
     await runtime.run(`INSTALL ${quoteIdentifier(extension)}`);
   }
 }
@@ -5812,4 +5879,4 @@ export {
   DuckLakeStorage
 };
 
-//# debugId=8FEE4C4A10B2BA3064756E2164756E21
+//# debugId=11CCDDEF58B2058164756E2164756E21