@astrojs/db 0.9.8 → 0.9.10

package/dist/core/cli/commands/execute/index.js

@@ -48,7 +48,7 @@ async function cmd({
   const { code } = await bundleFile({ virtualModContents, root: astroConfig.root, fileUrl });
   const mod = await importBundledFile({ code, root: astroConfig.root });
   if (typeof mod.default !== "function") {
-    console.error(EXEC_DEFAULT_EXPORT_ERROR);
+    console.error(EXEC_DEFAULT_EXPORT_ERROR(filePath));
     process.exit(1);
   }
   try {

package/dist/core/cli/print-help.js

@@ -27,7 +27,7 @@ function printHelp({
     message.push(
       linebreak(),
       `  ${bgGreen(black(` ${commandName} `))} ${green(
-        `v${"0.9.8"}`
+        `v${"0.9.10"}`
       )} ${headline}`
     );
   }

package/dist/core/integration/index.js

@@ -1,18 +1,19 @@
 import { existsSync } from "fs";
 import { dirname } from "path";
 import { fileURLToPath } from "url";
-import { AstroError } from "astro/errors";
 import { mkdir, writeFile } from "fs/promises";
 import { blue, yellow } from "kleur/colors";
 import { loadEnv } from "vite";
 import parseArgs from "yargs-parser";
+import { SEED_DEV_FILE_NAME } from "../../runtime/queries.js";
+import { AstroDbError } from "../../runtime/utils.js";
 import { CONFIG_FILE_NAMES, DB_PATH } from "../consts.js";
 import { resolveDbConfig } from "../load-file.js";
 import { getManagedAppTokenOrExit } from "../tokens.js";
 import { getDbDirectoryUrl } from "../utils.js";
 import { fileURLIntegration } from "./file-url.js";
 import { typegenInternal } from "./typegen.js";
-import { vitePluginDb } from "./vite-plugin-db.js";
+import { resolved, vitePluginDb } from "./vite-plugin-db.js";
 import { vitePluginInjectEnvTs } from "./vite-plugin-inject-env-ts.js";
 function astroDBIntegration() {
   let connectToStudio = false;
@@ -82,14 +83,7 @@ function astroDBIntegration() {
         }
         await typegenInternal({ tables: tables.get() ?? {}, root: config.root });
       },
-      "astro:server:start": async ({ logger }) => {
-        setTimeout(() => {
-          logger.info(
-            connectToStudio ? "Connected to remote database." : "New local database created."
-          );
-        }, 100);
-      },
-      "astro:server:setup": async ({ server }) => {
+      "astro:server:setup": async ({ server, logger }) => {
         const filesToWatch = [
           ...CONFIG_FILE_NAMES.map((c) => new URL(c, getDbDirectoryUrl(root))),
           ...configFileDependencies.map((c) => new URL(c, root))
@@ -100,12 +94,51 @@ function astroDBIntegration() {
             server.restart();
           }
         });
+        setTimeout(() => {
+          logger.info(
+            connectToStudio ? "Connected to remote database." : "New local database created."
+          );
+          if (connectToStudio)
+            return;
+          const localSeedPaths = SEED_DEV_FILE_NAME.map(
+            (name) => new URL(name, getDbDirectoryUrl(root))
+          );
+          let seedInFlight = false;
+          if (seedFiles.get().length || localSeedPaths.find((path) => existsSync(path))) {
+            loadSeedModule();
+          }
+          const eagerReloadIntegrationSeedPaths = seedFiles.get().map((s) => typeof s === "string" && s.startsWith(".") ? new URL(s, root) : s).filter((s) => s instanceof URL);
+          const eagerReloadSeedPaths = [...eagerReloadIntegrationSeedPaths, ...localSeedPaths];
+          server.watcher.on("all", (event, relativeEntry) => {
+            if (event === "unlink" || event === "unlinkDir")
+              return;
+            const entry = new URL(relativeEntry, root);
+            if (eagerReloadSeedPaths.find((path) => entry.href === path.href)) {
+              loadSeedModule();
+            }
+          });
+          function loadSeedModule() {
+            if (seedInFlight)
+              return;
+            seedInFlight = true;
+            const mod = server.moduleGraph.getModuleById(resolved.seedVirtual);
+            if (mod)
+              server.moduleGraph.invalidateModule(mod);
+            server.ssrLoadModule(resolved.seedVirtual).then(() => {
+              logger.info("Seeded database.");
+            }).catch((e) => {
+              logger.error(e instanceof Error ? e.message : String(e));
+            }).finally(() => {
+              seedInFlight = false;
+            });
+          }
+        }, 100);
       },
       "astro:build:start": async ({ logger }) => {
         if (!connectToStudio && !databaseFileEnvDefined() && (output === "server" || output === "hybrid")) {
           const message = `Attempting to build without the --remote flag or the ASTRO_DATABASE_FILE environment variable defined. You probably want to pass --remote to astro build.`;
           const hint = "Learn more connecting to Studio: https://docs.astro.build/en/guides/astro-db/#connect-to-astro-studio";
-          throw new AstroError(message, hint);
+          throw new AstroDbError(message, hint);
         }
         logger.info("database: " + (connectToStudio ? yellow("remote") : blue("local database.")));
       },

package/dist/core/integration/vite-plugin-db.d.ts

@@ -1,5 +1,9 @@
 import type { DBTables } from '../types.js';
 import { type VitePlugin } from '../utils.js';
+export declare const resolved: {
+    virtual: string;
+    seedVirtual: string;
+};
 export type LateTables = {
     get: () => DBTables;
 };

package/dist/core/integration/vite-plugin-db.js

@@ -74,12 +74,11 @@ function getLocalVirtualModContents({
   });
   const dbUrl = new URL(DB_PATH, root);
   return `
-import { asDrizzleTable, createLocalDatabaseClient } from ${RUNTIME_IMPORT};
+import { asDrizzleTable, createLocalDatabaseClient, normalizeDatabaseUrl } from ${RUNTIME_IMPORT};
 ${shouldSeed ? `import { seedLocal } from ${RUNTIME_IMPORT};` : ""}
 ${shouldSeed ? integrationSeedImportStatements.join("\n") : ""}
 
-const dbUrl = import.meta.env.ASTRO_DATABASE_FILE ?? ${JSON.stringify(dbUrl)};
-
+const dbUrl = normalizeDatabaseUrl(import.meta.env.ASTRO_DATABASE_FILE, ${JSON.stringify(dbUrl)});
 export const db = createLocalDatabaseClient({ dbUrl });
 
 ${shouldSeed ? `await seedLocal({
@@ -130,5 +129,6 @@ export {
   getConfigVirtualModContents,
   getLocalVirtualModContents,
   getStudioVirtualModContents,
+  resolved,
   vitePluginDb
 };

package/dist/core/integration/vite-plugin-inject-env-ts.js

@@ -2,7 +2,7 @@ import { existsSync } from "node:fs";
 import { readFile, writeFile } from "node:fs/promises";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
-import { bold, cyan } from "kleur/colors";
+import { bold } from "kleur/colors";
 import { normalizePath } from "vite";
 import { DB_TYPES_FILE } from "../consts.js";
 function vitePluginInjectEnvTs({ srcDir, root }, logger) {

package/dist/runtime/db-client.js

@@ -2,7 +2,7 @@ import { createClient } from "@libsql/client";
 import { drizzle as drizzleLibsql } from "drizzle-orm/libsql";
 import { drizzle as drizzleProxy } from "drizzle-orm/sqlite-proxy";
 import { z } from "zod";
-import { safeFetch } from "./utils.js";
+import { AstroDbError, safeFetch } from "./utils.js";
 const isWebContainer = !!process.versions?.webcontainer;
 function applyTransactionNotSupported(db) {
   Object.assign(db, {
@@ -45,12 +45,8 @@ function createRemoteDatabaseClient(appToken, remoteDbURL) {
           },
           body: JSON.stringify(requestBody)
         },
-        (response) => {
-          throw new Error(
-            `Failed to execute query.
-Query: ${sql}
-Full error: ${response.status} ${response.statusText}`
-          );
+        async (response) => {
+          throw await parseRemoteError(response);
         }
       );
       let remoteResult;
@@ -58,11 +54,7 @@ Full error: ${response.status} ${response.statusText}`
         const json = await res.json();
         remoteResult = remoteResultSchema.parse(json);
       } catch (e) {
-        throw new Error(
-          `Failed to execute query.
-Query: ${sql}
-Full error: Unexpected JSON response. ${e instanceof Error ? e.message : String(e)}`
-        );
+        throw new AstroDbError(await getUnexpectedResponseMessage(res));
       }
       if (method === "run")
         return remoteResult;
@@ -89,11 +81,8 @@ Full error: Unexpected JSON response. ${e instanceof Error ? e.message : String(
           },
           body: JSON.stringify(stmts)
         },
-        (response) => {
-          throw new Error(
-            `Failed to execute batch queries.
-Full error: ${response.status} ${response.statusText}}`
-          );
+        async (response) => {
+          throw await parseRemoteError(response);
         }
       );
       let remoteResults;
@@ -101,10 +90,7 @@ Full error: ${response.status} ${response.statusText}}`
         const json = await res.json();
         remoteResults = z.array(remoteResultSchema).parse(json);
       } catch (e) {
-        throw new Error(
-          `Failed to execute batch queries.
-Full error: Unexpected JSON response. ${e instanceof Error ? e.message : String(e)}`
-        );
+        throw new AstroDbError(await getUnexpectedResponseMessage(res));
       }
       let results = [];
       for (const [idx, rawResult] of remoteResults.entries()) {
@@ -129,6 +115,33 @@ Full error: Unexpected JSON response. ${e instanceof Error ? e.message : String(
   applyTransactionNotSupported(db);
   return db;
 }
+const errorSchema = z.object({
+  success: z.boolean(),
+  error: z.object({
+    code: z.string(),
+    details: z.string().optional()
+  })
+});
+const KNOWN_ERROR_CODES = {
+  SQL_QUERY_FAILED: "SQL_QUERY_FAILED"
+};
+const getUnexpectedResponseMessage = async (response) => `Unexpected response from remote database:
+(Status ${response.status}) ${await response.text()}`;
+async function parseRemoteError(response) {
+  let error;
+  try {
+    error = errorSchema.parse(await response.json()).error;
+  } catch (e) {
+    return new AstroDbError(await getUnexpectedResponseMessage(response));
+  }
+  let details = error.details?.replace(/.*SQLite error: /, "") ?? `(Code ${error.code}) 
+Error querying remote database.`;
+  let hint = `See the Astro DB guide for query and push instructions: https://docs.astro.build/en/guides/astro-db/#query-your-database`;
+  if (error.code === KNOWN_ERROR_CODES.SQL_QUERY_FAILED && details.includes("no such table")) {
+    hint = `Did you run \`astro db push\` to push your latest table schemas?`;
+  }
+  return new AstroDbError(details, hint);
+}
 export {
   createLocalDatabaseClient,
   createRemoteDatabaseClient

package/dist/runtime/errors.d.ts

@@ -2,5 +2,4 @@ export declare const FOREIGN_KEY_DNE_ERROR: (tableName: string) => string;
 export declare const FOREIGN_KEY_REFERENCES_LENGTH_ERROR: (tableName: string) => string;
 export declare const FOREIGN_KEY_REFERENCES_EMPTY_ERROR: (tableName: string) => string;
 export declare const REFERENCE_DNE_ERROR: (columnName: string) => string;
-export declare const SEED_ERROR: (error: string) => string;
 export declare const SEED_DEFAULT_EXPORT_ERROR: (fileName: string) => string;

package/dist/runtime/errors.js

@@ -19,19 +19,13 @@ const REFERENCE_DNE_ERROR = (columnName) => {
     columnName
   )} references a table that does not exist. Did you apply the referenced table to the \`tables\` object in your db config?`;
 };
-const SEED_ERROR = (error) => {
-  return `${red(`Error while seeding database:`)}
-
-${error}`;
-};
 const SEED_DEFAULT_EXPORT_ERROR = (fileName) => {
-  return SEED_ERROR(`Missing default function export in ${bold(fileName)}`);
+  return `Missing default function export in ${bold(fileName)}`;
 };
 export {
   FOREIGN_KEY_DNE_ERROR,
   FOREIGN_KEY_REFERENCES_EMPTY_ERROR,
   FOREIGN_KEY_REFERENCES_LENGTH_ERROR,
   REFERENCE_DNE_ERROR,
-  SEED_DEFAULT_EXPORT_ERROR,
-  SEED_ERROR
+  SEED_DEFAULT_EXPORT_ERROR
 };

package/dist/runtime/index.d.ts

@@ -23,3 +23,4 @@ export declare function asDrizzleTable(name: string, table: DBTable): import("dr
     };
     dialect: "sqlite";
 }>;
+export declare function normalizeDatabaseUrl(envDbUrl: string | undefined, defaultDbUrl: string): string;

package/dist/runtime/index.js

@@ -1,3 +1,4 @@
+import { pathToFileURL } from "url";
 import { sql } from "drizzle-orm";
 import {
   customType,
@@ -110,10 +111,21 @@ function handleSerializedSQL(def) {
   }
   return def;
 }
+function normalizeDatabaseUrl(envDbUrl, defaultDbUrl) {
+  if (envDbUrl) {
+    if (envDbUrl.startsWith("file://")) {
+      return envDbUrl;
+    }
+    return new URL(envDbUrl, pathToFileURL(process.cwd())).toString();
+  } else {
+    return defaultDbUrl;
+  }
+}
 export {
   asDrizzleTable,
   createLocalDatabaseClient,
   createRemoteDatabaseClient,
   hasPrimaryKey,
+  normalizeDatabaseUrl,
   seedLocal
 };

package/dist/runtime/seed-local.js

@@ -2,8 +2,9 @@ import { LibsqlError } from "@libsql/client";
 import { sql } from "drizzle-orm";
 import { SQLiteAsyncDialect } from "drizzle-orm/sqlite-core";
 import {} from "../core/types.js";
-import { SEED_DEFAULT_EXPORT_ERROR, SEED_ERROR } from "./errors.js";
+import { SEED_DEFAULT_EXPORT_ERROR } from "./errors.js";
 import { getCreateIndexQueries, getCreateTableQuery } from "./queries.js";
+import { AstroDbError } from "./utils.js";
 const sqlite = new SQLiteAsyncDialect();
 async function seedLocal({
   db,
@@ -18,7 +19,7 @@ async function seedLocal({
   if (seedFilePath) {
     const mod = userSeedGlob[seedFilePath];
     if (!mod.default)
-      throw new Error(SEED_DEFAULT_EXPORT_ERROR(seedFilePath));
+      throw new AstroDbError(SEED_DEFAULT_EXPORT_ERROR(seedFilePath));
     seedFunctions.push(mod.default);
   }
   for (const seedFn of integrationSeedFunctions) {
@@ -29,7 +30,8 @@ async function seedLocal({
       await seed();
     } catch (e) {
       if (e instanceof LibsqlError) {
-        throw new Error(SEED_ERROR(e.message));
+        throw new AstroDbError(`Failed to seed database:
+${e.message}`);
       }
       throw e;
     }

package/dist/runtime/utils.d.ts

@@ -1,4 +1,8 @@
+import { AstroError } from 'astro/errors';
 /**
  * Small wrapper around fetch that throws an error if the response is not OK. Allows for custom error handling as well through the onNotOK callback.
  */
 export declare function safeFetch(url: Parameters<typeof fetch>[0], options?: Parameters<typeof fetch>[1], onNotOK?: (response: Response) => void | Promise<void>): Promise<Response>;
+export declare class AstroDbError extends AstroError {
+    name: string;
+}

package/dist/runtime/utils.js

@@ -1,3 +1,4 @@
+import { AstroError } from "astro/errors";
 async function safeFetch(url, options = {}, onNotOK = () => {
   throw new Error(`Request to ${url} returned a non-OK status code.`);
 }) {
@@ -7,6 +8,10 @@ async function safeFetch(url, options = {}, onNotOK = () => {
   }
   return response;
 }
+class AstroDbError extends AstroError {
+  name = "Astro DB Error";
+}
 export {
+  AstroDbError,
   safeFetch
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@astrojs/db",
-  "version": "0.9.8",
+  "version": "0.9.10",
   "description": "",
   "license": "MIT",
   "type": "module",
@@ -81,7 +81,7 @@
     "mocha": "^10.2.0",
     "typescript": "^5.2.2",
     "vite": "^5.1.4",
-    "astro": "4.5.12",
+    "astro": "4.5.13",
     "astro-scripts": "0.0.14"
   },
   "scripts": {