@observablehq/notebook-kit 1.1.0-rc.8 → 1.1.0

package/dist/bin/notebooks.js

@@ -16,12 +16,18 @@ switch (command) {
         await run(process.argv.slice(3));
         break;
     }
+    case "query": {
+        const { default: run } = await import("./query.js");
+        await run(process.argv.slice(3));
+        break;
+    }
     default: {
         console.log(`usage: notebooks <command>
 
   preview      start the preview server
   build        generate a static site
   download     download an Observable Notebook as HTML
+  query        run a database query
   help         print usage information
   version      print the version
 `);

package/dist/bin/query.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export default function run(args?: string[]): Promise<void>;

package/dist/bin/query.js

@@ -0,0 +1,59 @@
+#!/usr/bin/env node
+import { parseArgs } from "node:util";
+import { getDatabase, getDatabaseConfig, getQueryCachePath } from "../src/databases/index.js";
+import { dirname } from "node:path/win32";
+import { mkdir, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+if (process.argv[1] === import.meta.filename)
+    run();
+export default async function run(args) {
+    const { values, positionals } = parseArgs({
+        args,
+        allowPositionals: true,
+        allowNegative: true,
+        options: {
+            root: {
+                type: "string",
+                default: "."
+            },
+            database: {
+                type: "string"
+            },
+            help: {
+                type: "boolean",
+                short: "h"
+            }
+        }
+    });
+    if (values.help || !values.database) {
+        console.log(`usage: notebooks query <...query>
+
+  --database <name>        name of the database
+  --root <dir>             path to the root directory; defaults to cwd
+  -h, --help               show this message
+`);
+        return;
+    }
+    // Parse positionals into query template arguments.
+    const strings = [];
+    const params = [];
+    for (let i = 0; i < positionals.length; ++i) {
+        if (i & 1)
+            params.push(JSON.parse(positionals[i]));
+        else
+            strings.push(positionals[i]);
+    }
+    process.chdir(values.root);
+    const config = await getDatabaseConfig(".", values.database);
+    const database = await getDatabase(config);
+    const results = await database.call(null, strings, ...params);
+    const cachePath = await getQueryCachePath(".", values.database, strings, ...params);
+    await mkdir(dirname(cachePath), { recursive: true });
+    await writeFile(cachePath, JSON.stringify(results, replace));
+    console.log(join(values.root, cachePath));
+}
+// Force dates to be serialized as ISO 8601 UTC, undoing this:
+// https://github.com/snowflakedb/snowflake-connector-nodejs/blob/a9174fb7/lib/connection/result/sf_timestamp.js#L177-L179
+function replace(key, value) {
+    return this[key] instanceof Date ? Date.prototype.toJSON.call(this[key]) : value;
+}

package/dist/package.json

@@ -5,7 +5,7 @@
         "type": "git",
         "url": "git+https://github.com/observablehq/notebook-kit.git"
     },
-    "version": "1.1.0-rc.8",
+    "version": "1.1.0",
     "type": "module",
     "scripts": {
         "test": "vitest",
@@ -67,6 +67,7 @@
         "@eslint/js": "^9.29.0",
         "@types/jsdom": "^21.1.7",
         "@types/markdown-it": "^14.1.2",
+        "bun-types": "^1.2.20",
         "eslint": "^9.29.0",
         "globals": "^16.2.0",
         "htl": "^0.3.1",

package/dist/src/databases/duckdb.d.ts

@@ -1,2 +1,2 @@
-import type { DatabaseContext, DuckDBConfig, QueryTemplateFunction } from "./index.js";
-export default function duckdb({ path, options }: DuckDBConfig, context: DatabaseContext): QueryTemplateFunction;
+import type { DuckDBConfig, QueryTemplateFunction } from "./index.js";
+export default function duckdb({ path, options }: DuckDBConfig): QueryTemplateFunction;

package/dist/src/databases/duckdb.js

@@ -1,13 +1,9 @@
 import { DuckDBConnection, DuckDBInstance } from "@duckdb/node-api";
 import { BIGINT, BIT, BLOB, BOOLEAN, DATE, DOUBLE, FLOAT, HUGEINT, INTEGER, INTERVAL, SMALLINT, TIME, TIMESTAMP, TIMESTAMP_MS, TIMESTAMP_NS, TIMESTAMP_S, TIMESTAMPTZ, TINYINT, UBIGINT, UHUGEINT, UINTEGER, USMALLINT, UTINYINT, UUID, VARCHAR, VARINT } from "@duckdb/node-api"; // prettier-ignore
-import { join } from "node:path";
-export default function duckdb({ path, options }, context) {
-    if (path !== undefined)
-        path = join(context.cwd, path);
+export default function duckdb({ path, options }) {
     return async (strings, ...params) => {
         const instance = await DuckDBInstance.create(path, options);
         const connection = await DuckDBConnection.create(instance);
-        await connection.run(`SET file_search_path=$0`, [context.cwd]);
         const date = new Date();
         let result;
         let rows;

package/dist/src/databases/index.d.ts

@@ -1,6 +1,5 @@
 import type { ColumnSchema, QueryParam } from "../runtime/index.js";
-export { hash as getQueryHash, nameHash as getNameHash } from "../lib/hash.js";
-export type DatabaseConfig = DuckDBConfig | SnowflakeConfig | PostgresConfig;
+export type DatabaseConfig = DuckDBConfig | SQLiteConfig | SnowflakeConfig | PostgresConfig;
 export type DuckDBConfig = {
     type: "duckdb";
     path?: string;
@@ -8,6 +7,10 @@ export type DuckDBConfig = {
         [key: string]: string;
     };
 };
+export type SQLiteConfig = {
+    type: "sqlite";
+    path?: string;
+};
 export type SnowflakeConfig = {
     type: "snowflake";
     account: string;
@@ -27,9 +30,6 @@ export type PostgresConfig = {
     database?: string;
     ssl?: boolean;
 };
-export type DatabaseContext = {
-    cwd: string;
-};
 export type QueryTemplateFunction = (strings: readonly string[], ...params: QueryParam[]) => Promise<SerializableQueryResult>;
 export type SerializableQueryResult = {
     rows: Record<string, unknown>[];
@@ -38,5 +38,5 @@ export type SerializableQueryResult = {
     date: Date;
 };
 export declare function getDatabaseConfig(sourcePath: string, databaseName: string): Promise<DatabaseConfig>;
-export declare function getDatabase(config: DatabaseConfig, context: DatabaseContext): Promise<QueryTemplateFunction>;
+export declare function getDatabase(config: DatabaseConfig): Promise<QueryTemplateFunction>;
 export declare function getQueryCachePath(sourcePath: string, databaseName: string, strings: readonly string[], ...params: unknown[]): Promise<string>;

package/dist/src/databases/index.js

@@ -3,7 +3,6 @@ import { dirname, join } from "node:path";
 import { json } from "node:stream/consumers";
 import { isEnoent } from "../lib/error.js";
 import { hash as getQueryHash, nameHash as getNameHash } from "../lib/hash.js";
-export { hash as getQueryHash, nameHash as getNameHash } from "../lib/hash.js";
 export async function getDatabaseConfig(sourcePath, databaseName) {
     const sourceDir = dirname(sourcePath);
     const configPath = join(sourceDir, ".observable", "databases.json");
@@ -22,17 +21,23 @@ export async function getDatabaseConfig(sourcePath, databaseName) {
             config = { type: "postgres" };
         else if (databaseName === "duckdb")
             config = { type: "duckdb" };
-        else if (/\.(duck)?db$/i.test(databaseName))
+        else if (databaseName === "sqlite")
+            config = { type: "sqlite" };
+        else if (/\.duckdb$/i.test(databaseName))
             config = { type: "duckdb", path: databaseName };
+        else if (/\.db$/i.test(databaseName))
+            config = { type: "sqlite", path: databaseName }; // TODO disambiguate
         else
             throw new Error(`database not found: ${databaseName}`);
     }
     return config;
 }
-export async function getDatabase(config, context) {
+export async function getDatabase(config) {
     switch (config.type) {
         case "duckdb":
-            return (await import("./duckdb.js")).default(config, context);
+            return (await import("./duckdb.js")).default(config);
+        case "sqlite":
+            return (await import(process.versions.bun ? "./sqlite-bun.js" : "./sqlite-node.js")).default(config);
         case "snowflake":
             return (await import("./snowflake.js")).default(config);
         case "postgres":

package/dist/src/databases/sqlite-bun.d.ts

@@ -0,0 +1,2 @@
+import type { SQLiteConfig, QueryTemplateFunction } from "./index.js";
+export default function sqlite({ path }: SQLiteConfig): QueryTemplateFunction;

package/dist/src/databases/sqlite-bun.js

@@ -0,0 +1,27 @@
+import { Database } from "bun:sqlite";
+import { getColumnType } from "./sqlite.js";
+export default function sqlite({ path = ":memory:" }) {
+    return async (strings, ...params) => {
+        const date = new Date();
+        const database = new Database(path);
+        try {
+            const statement = database.prepare(strings.join("?"));
+            const rows = statement.all(...params);
+            return {
+                rows,
+                schema: getStatementSchema(statement),
+                duration: Date.now() - +date,
+                date
+            };
+        }
+        finally {
+            database.close();
+        }
+    };
+}
+function getStatementSchema(statement) {
+    return statement.columnNames.map((name, i) => ({
+        name,
+        type: getColumnType(statement.columnTypes[i])
+    }));
+}

package/dist/src/databases/sqlite-node.d.ts

@@ -0,0 +1,2 @@
+import type { SQLiteConfig, QueryTemplateFunction } from "./index.js";
+export default function sqlite({ path }: SQLiteConfig): QueryTemplateFunction;

package/dist/src/databases/sqlite-node.js

@@ -0,0 +1,26 @@
+import { DatabaseSync } from "node:sqlite";
+import { getColumnType } from "./sqlite.js";
+export default function sqlite({ path = ":memory:" }) {
+    return async (strings, ...params) => {
+        const date = new Date();
+        const database = new DatabaseSync(path);
+        try {
+            const statement = database.prepare(strings.join("?"));
+            const rows = statement.all(...params);
+            return {
+                rows,
+                schema: getStatementSchema(statement),
+                duration: Date.now() - +date,
+                date
+            };
+        }
+        finally {
+            database.close();
+        }
+    };
+}
+function getStatementSchema(statement) {
+    return statement
+        .columns()
+        .map((column) => ({ name: column.name, type: getColumnType(column.type) }));
+}

package/dist/src/databases/sqlite.d.ts

@@ -0,0 +1,2 @@
+import type { ColumnSchema } from "../runtime/index.js";
+export declare function getColumnType(type: string | null): ColumnSchema["type"];

package/dist/src/databases/sqlite.js

@@ -0,0 +1,36 @@
+export function getColumnType(type) {
+    switch (type) {
+        case "INT":
+        case "INTEGER":
+        case "TINYINT":
+        case "SMALLINT":
+        case "MEDIUMINT":
+        case "BIGINT":
+        case "UNSIGNED BIG INT":
+        case "INT2":
+        case "INT8":
+            return "integer";
+        case "TEXT":
+        case "CLOB":
+            return "string";
+        case "REAL":
+        case "DOUBLE":
+        case "DOUBLE PRECISION":
+        case "FLOAT":
+        case "NUMERIC":
+            return "number";
+        case "BLOB":
+            return "buffer";
+        case "DATE":
+        case "DATETIME":
+            return "string"; // TODO convert strings to Date instances in sql.js
+        case null:
+            return "other";
+        default:
+            return /^(?:(?:(?:VARYING|NATIVE) )?CHARACTER|(?:N|VAR|NVAR)CHAR)\(/.test(type)
+                ? "string"
+                : /^(?:DECIMAL|NUMERIC)\(/.test(type)
+                    ? "number"
+                    : "other";
+    }
+}

package/dist/src/runtime/index.d.ts

@@ -58,12 +58,12 @@ export declare class NotebookRuntime {
         width: () => AsyncGenerator<number, void, unknown>;
         DatabaseClient: () => {
             (name: string, options?: import("./stdlib/databaseClient.js").QueryOptionsSpec): import("./stdlib/databaseClient.js").DatabaseClient;
-            hash: typeof import("../lib/hash.js").hash;
             revive: ({ rows, schema, date, ...meta }: import("../databases/index.js").SerializableQueryResult) => import("./stdlib/databaseClient.js").QueryResult;
             prototype: {
                 readonly name: string;
                 readonly options: import("./stdlib/databaseClient.js").QueryOptions;
                 sql(strings: readonly string[], ...params: import("./stdlib/databaseClient.js").QueryParam[]): Promise<import("./stdlib/databaseClient.js").QueryResult>;
+                cachePath(strings: readonly string[], ...params: import("./stdlib/databaseClient.js").QueryParam[]): Promise<string>;
             };
         };
         FileAttachment: () => {

package/dist/src/runtime/stdlib/databaseClient.d.ts

@@ -1,5 +1,4 @@
 import type { SerializableQueryResult } from "../../databases/index.js";
-import { hash } from "../../lib/hash.js";
 /** A serializable value that can be interpolated into a query. */
 export type QueryParam = any;
 /** @see https://observablehq.com/@observablehq/database-client-specification#%C2%A71 */
@@ -32,7 +31,6 @@ export interface DatabaseClient {
 }
 export declare const DatabaseClient: {
     (name: string, options?: QueryOptionsSpec): DatabaseClient;
-    hash: typeof hash;
     revive: typeof revive;
     prototype: DatabaseClientImpl;
 };
@@ -41,6 +39,7 @@ declare class DatabaseClientImpl implements DatabaseClient {
     readonly options: QueryOptions;
     constructor(name: string, options: QueryOptions);
     sql(strings: readonly string[], ...params: QueryParam[]): Promise<QueryResult>;
+    cachePath(strings: readonly string[], ...params: QueryParam[]): Promise<string>;
 }
 declare function revive({ rows, schema, date, ...meta }: SerializableQueryResult): QueryResult;
 export {};

package/dist/src/runtime/stdlib/databaseClient.js

@@ -30,12 +30,15 @@ class DatabaseClientImpl {
         });
     }
     async sql(strings, ...params) {
-        const path = `.observable/cache/${await nameHash(this.name)}-${await hash(strings, ...params)}.json`;
+        const path = await this.cachePath(strings, ...params);
         const response = await fetch(path);
         if (!response.ok)
             throw new Error(`failed to fetch: ${path}`);
         return await response.json().then(revive);
     }
+    async cachePath(strings, ...params) {
+        return `.observable/cache/${await nameHash(this.name)}-${await hash(strings, ...params)}.json`;
+    }
 }
 function revive({ rows, schema, date, ...meta }) {
     for (const column of schema) {
@@ -69,7 +72,6 @@ function revive({ rows, schema, date, ...meta }) {
 function asDate(value) {
     return new Date(/^\d{4}-\d{2}-\d{2} \d{2}:\d{2}(?::\d{2})?$/.test(value) ? value + "Z" : value);
 }
-DatabaseClient.hash = hash;
 DatabaseClient.revive = revive;
 DatabaseClient.prototype = DatabaseClientImpl.prototype; // instanceof
 Object.defineProperty(DatabaseClientImpl, "name", { value: "DatabaseClient" }); // prevent mangling

package/dist/src/runtime/stdlib/index.d.ts

@@ -48,12 +48,12 @@ export declare const library: {
     width: () => AsyncGenerator<number, void, unknown>;
     DatabaseClient: () => {
         (name: string, options?: import("./databaseClient.js").QueryOptionsSpec): DatabaseClient;
-        hash: typeof import("../../lib/hash.js").hash;
         revive: ({ rows, schema, date, ...meta }: import("../../databases/index.js").SerializableQueryResult) => import("./databaseClient.js").QueryResult;
         prototype: {
             readonly name: string;
             readonly options: import("./databaseClient.js").QueryOptions;
             sql(strings: readonly string[], ...params: import("./databaseClient.js").QueryParam[]): Promise<import("./databaseClient.js").QueryResult>;
+            cachePath(strings: readonly string[], ...params: import("./databaseClient.js").QueryParam[]): Promise<string>;
         };
     };
     FileAttachment: () => {

package/dist/src/vite/observable.js

@@ -1,10 +1,11 @@
+import { fork } from "node:child_process";
 import { existsSync } from "node:fs";
-import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { readFile } from "node:fs/promises";
 import { dirname, join, resolve } from "node:path";
 import { relative } from "node:path/posix";
 import { fileURLToPath } from "node:url";
 import { JSDOM } from "jsdom";
-import { getDatabase, getDatabaseConfig, getQueryCachePath } from "../databases/index.js";
+import { getQueryCachePath } from "../databases/index.js";
 import { deserialize } from "../lib/serialize.js";
 import { Sourcemap } from "../javascript/sourcemap.js";
 import { transpile } from "../javascript/transpile.js";
@@ -69,16 +70,12 @@ export function observable({ window = new JSDOM().window, parser = new window.DO
                             const dir = dirname(context.filename);
                             const cachePath = await getQueryCachePath(context.filename, cell.database, [value]);
                             if (!existsSync(cachePath)) {
-                                const config = await getDatabaseConfig(context.filename, cell.database);
-                                try {
-                                    const database = await getDatabase(config, { cwd: dir });
-                                    const results = await database.call(null, [value]);
-                                    await mkdir(dirname(cachePath), { recursive: true });
-                                    await writeFile(cachePath, JSON.stringify(results));
-                                }
-                                catch (error) {
-                                    console.error(error);
-                                }
+                                const args = ["--root", dir, "--database", cell.database, value];
+                                const child = fork(fileURLToPath(import.meta.resolve("../../bin/query.js")), args);
+                                await new Promise((resolve, reject) => {
+                                    child.on("error", reject);
+                                    child.on("exit", resolve);
+                                });
                             }
                             cell.mode = "js";
                             cell.value = `FileAttachment(${JSON.stringify(relative(dir, cachePath))}).json().then(DatabaseClient.revive)${hidden ? "" : `.then(Inputs.table)${cell.output ? ".then(view)" : ""}`}`;

package/package.json

@@ -5,7 +5,7 @@
     "type": "git",
     "url": "git+https://github.com/observablehq/notebook-kit.git"
   },
-  "version": "1.1.0-rc.8",
+  "version": "1.1.0",
   "type": "module",
   "scripts": {
     "test": "vitest",
@@ -67,6 +67,7 @@
     "@eslint/js": "^9.29.0",
     "@types/jsdom": "^21.1.7",
     "@types/markdown-it": "^14.1.2",
+    "bun-types": "^1.2.20",
     "eslint": "^9.29.0",
     "globals": "^16.2.0",
     "htl": "^0.3.1",