ignore unresolved databases

Author: mbostock

src/javascript.ts

@@ -3,7 +3,7 @@ import type {Expression, Identifier, Node, Options, Program} from "acorn";
 import {fileReference} from "./files.js";
 import {findAssignments} from "./javascript/assignments.js";
 import {findAwaits} from "./javascript/awaits.js";
-import {resolveDatabase} from "./javascript/databases.js";
+import {resolveDatabases} from "./javascript/databases.js";
 import {findDeclarations} from "./javascript/declarations.js";
 import {findFeatures} from "./javascript/features.js";
 import {rewriteFetches} from "./javascript/fetches.js";
@@ -81,7 +81,7 @@ export function transpileJavaScript(input: string, options: ParseOptions): Trans
       ...(inputs.length ? {inputs} : null),
       ...(options.inline ? {inline: true} : null),
       ...(node.declarations?.length ? {outputs: node.declarations.map(({name}) => name)} : null),
-      ...(databases.length ? {databases: databases.map((d) => resolveDatabase(d))} : null),
+      ...(databases.length ? {databases: resolveDatabases(databases)} : null),
       ...(files.length ? {files} : null),
       body: `${node.async ? "async " : ""}(${inputs}) => {
 ${String(output)}${node.declarations?.length ? `\nreturn {${node.declarations.map(({name}) => name)}};` : ""}

src/javascript/databases.ts

@@ -35,16 +35,21 @@ function encodeToken(payload: {name: string; exp: number}, secret: string): stri
   return `${Buffer.from(data).toString("base64")}.${Buffer.from(hmac).toString("base64")}`;
 }
 
+export function resolveDatabases(
+  databases: DatabaseReference[],
+  {exp = Date.now() + DATABASE_TOKEN_DURATION, env = process.env} = {}
+): ResolvedDatabaseReference[] {
+  const options = {exp, env};
+  return databases.map((d) => resolveDatabase(d, options)).filter((d): d is ResolvedDatabaseReference => !!d);
+}
+
 export function resolveDatabase(
   database: DatabaseReference,
   {exp = Date.now() + DATABASE_TOKEN_DURATION, env = process.env} = {}
-): DatabaseReference | ResolvedDatabaseReference {
+): ResolvedDatabaseReference | undefined {
   const {name} = database;
   const config = getDatabaseProxyConfig(env, name);
-  if (!config) {
-    console.warn(`Unable to resolve database: ${name}`);
-    return database;
-  }
+  if (!config) return void console.warn(`Unable to resolve database: ${name}`);
   const url = new URL("http://localhost");
   url.protocol = config.ssl !== "disabled" ? "https:" : "http:";
   url.host = config.host;

test/javascript/databases-test.ts

@@ -1,22 +1,25 @@
 import assert from "node:assert";
 import {createHmac} from "node:crypto";
-import {type ResolvedDatabaseReference, resolveDatabase} from "../../src/javascript/databases.js";
+import {type ResolvedDatabaseReference, resolveDatabase, resolveDatabases} from "../../src/javascript/databases.js";
 import type {DatabaseReference} from "../../src/javascript.js";
 
+const exp = Date.UTC(2020, 0, 1);
+
+const snow2 = {
+  name: "snow2",
+  type: "snowflake",
+  host: "localhost",
+  port: "2899",
+  ssl: "disabled",
+  origin: "http://127.0.0.1:3000",
+  secret: "0249f7ba6fff3856cb9868d115dbcd6b2ef51f1e9a55fdc6f7484013b7c191c5"
+};
+
+const env = {
+  OBSERVABLEHQ_DB_SECRET_snow2: Buffer.from(JSON.stringify(snow2), "utf-8").toString("base64")
+};
+
 describe("resolveDatabase", () => {
-  const exp = Date.UTC(2020, 0, 1);
-  const snow2 = {
-    name: "snow2",
-    type: "snowflake",
-    host: "localhost",
-    port: "2899",
-    ssl: "disabled",
-    origin: "http://127.0.0.1:3000",
-    secret: "0249f7ba6fff3856cb9868d115dbcd6b2ef51f1e9a55fdc6f7484013b7c191c5"
-  };
-  const env = {
-    OBSERVABLEHQ_DB_SECRET_snow2: Buffer.from(JSON.stringify(snow2), "utf-8").toString("base64")
-  };
   it("returns a resolved database reference", async () => {
     const input: DatabaseReference = {name: "snow2"};
     const output = resolveDatabase(input, {env, exp});
@@ -37,9 +40,18 @@ describe("resolveDatabase", () => {
     resolveDatabase(input, {env});
     assert.deepStrictEqual(input, {name: "snow2"});
   });
-  it("returns an unresolved database reference when it can’t be resolved", async () => {
+  it("returns undefined when it can’t be resolved", async () => {
     const input = {name: "notthere"};
-    assert.strictEqual(resolveDatabase(input), input);
+    assert.strictEqual(resolveDatabase(input), undefined);
     assert.deepStrictEqual(input, {name: "notthere"});
   });
 });
+
+describe("resolveDatabases", () => {
+  it("returns only resolved database references", async () => {
+    const notthere: DatabaseReference = {name: "notthere"};
+    const snow2: DatabaseReference = {name: "snow2"};
+    const output = resolveDatabases([notthere, snow2], {env, exp});
+    assert.deepStrictEqual<ResolvedDatabaseReference[]>(output, [resolveDatabase(snow2, {env, exp})!]);
+  });
+});

test/output/databaseclient.json

@@ -23,11 +23,7 @@
       "outputs": [
         "db"
       ],
-      "databases": [
-        {
-          "name": "dwh-local-proxy"
-        }
-      ],
+      "databases": [],
       "body": "(DatabaseClient) => {\nconst db = DatabaseClient(\"dwh-local-proxy\");\nreturn {db};\n}"
     }
   ],