@astrojs/db 0.10.7 → 0.11.1

package/dist/_internal/core/utils.d.ts

@@ -2,6 +2,7 @@ import type { AstroConfig, AstroIntegration } from 'astro';
 import type { AstroDbIntegration } from './types.js';
 export type VitePlugin = Required<AstroConfig['vite']>['plugins'][number];
 export declare function getAstroStudioEnv(envMode?: string): Record<`ASTRO_STUDIO_${string}`, string>;
+export declare function getAstroEnv(envMode?: string): Record<`ASTRO_${string}`, string>;
 export declare function getRemoteDatabaseUrl(): string;
 export declare function getAstroStudioUrl(): string;
 export declare function getDbDirectoryUrl(root: URL | string): URL;

package/dist/core/cli/commands/execute/index.d.ts

@@ -1,6 +1,6 @@
 import type { AstroConfig } from 'astro';
 import type { Arguments } from 'yargs-parser';
-import { type DBConfig } from '../../../types.js';
+import type { DBConfig } from '../../../types.js';
 export declare function cmd({ astroConfig, dbConfig, flags, }: {
     astroConfig: AstroConfig;
     dbConfig: DBConfig;

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

@@ -13,7 +13,6 @@ import {
 } from "../../../integration/vite-plugin-db.js";
 import { bundleFile, importBundledFile } from "../../../load-file.js";
 import { getManagedAppTokenOrExit } from "../../../tokens.js";
-import {} from "../../../types.js";
 async function cmd({
   astroConfig,
   dbConfig,
@@ -41,9 +40,7 @@ async function cmd({
   } else {
     virtualModContents = getLocalVirtualModContents({
       tables: dbConfig.tables ?? {},
-      root: astroConfig.root,
-      shouldSeed: false,
-      seedFiles: []
+      root: astroConfig.root
     });
   }
   const { code } = await bundleFile({ virtualModContents, root: astroConfig.root, fileUrl });

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

@@ -3,10 +3,11 @@ import {
   createLocalDatabaseClient,
   createRemoteDatabaseClient
 } from "../../../../runtime/db-client.js";
+import { normalizeDatabaseUrl } from "../../../../runtime/index.js";
 import { DB_PATH } from "../../../consts.js";
 import { SHELL_QUERY_MISSING_ERROR } from "../../../errors.js";
 import { getManagedAppTokenOrExit } from "../../../tokens.js";
-import { getRemoteDatabaseUrl } from "../../../utils.js";
+import { getAstroEnv, getRemoteDatabaseUrl } from "../../../utils.js";
 async function cmd({
   flags,
   astroConfig
@@ -23,7 +24,12 @@ async function cmd({
     await appToken.destroy();
     console.log(result);
   } else {
-    const db = createLocalDatabaseClient({ dbUrl: new URL(DB_PATH, astroConfig.root).href });
+    const { ASTRO_DATABASE_FILE } = getAstroEnv();
+    const dbUrl = normalizeDatabaseUrl(
+      ASTRO_DATABASE_FILE,
+      new URL(DB_PATH, astroConfig.root).href
+    );
+    const db = createLocalDatabaseClient({ dbUrl });
     const result = await db.run(sql.raw(query));
     console.log(result);
   }

package/dist/core/cli/migration-queries.js

@@ -4,6 +4,10 @@ import * as color from "kleur/colors";
 import { customAlphabet } from "nanoid";
 import stripAnsi from "strip-ansi";
 import { hasPrimaryKey } from "../../runtime/index.js";
+import { isSerializedSQL } from "../../runtime/types.js";
+import { safeFetch } from "../../runtime/utils.js";
+import { MIGRATION_VERSION } from "../consts.js";
+import { RENAME_COLUMN_ERROR, RENAME_TABLE_ERROR } from "../errors.js";
 import {
   getCreateIndexQueries,
   getCreateTableQuery,
@@ -12,11 +16,7 @@ import {
   getReferencesConfig,
   hasDefault,
   schemaTypeToSqlType
-} from "../../runtime/queries.js";
-import { isSerializedSQL } from "../../runtime/types.js";
-import { safeFetch } from "../../runtime/utils.js";
-import { MIGRATION_VERSION } from "../consts.js";
-import { RENAME_COLUMN_ERROR, RENAME_TABLE_ERROR } from "../errors.js";
+} from "../queries.js";
 import { columnSchema } from "../schemas.js";
 import {
 } from "../types.js";
@@ -55,8 +55,7 @@ async function getMigrationQueries({
   }
   for (const [tableName, newTable] of Object.entries(newSnapshot.schema)) {
     const oldTable = oldSnapshot.schema[tableName];
-    if (!oldTable)
-      continue;
+    if (!oldTable) continue;
     const addedColumns = getAdded(oldTable.columns, newTable.columns);
     const droppedColumns = getDropped(oldTable.columns, newTable.columns);
     const notDeprecatedDroppedColumns = Object.fromEntries(
@@ -161,16 +160,14 @@ function getChangeIndexQueries({
 function getAddedTables(oldTables, newTables) {
   const added = {};
   for (const [key, newTable] of Object.entries(newTables.schema)) {
-    if (!(key in oldTables.schema))
-      added[key] = newTable;
+    if (!(key in oldTables.schema)) added[key] = newTable;
   }
   return added;
 }
 function getDroppedTables(oldTables, newTables) {
   const dropped = {};
   for (const [key, oldTable] of Object.entries(oldTables.schema)) {
-    if (!(key in newTables.schema))
-      dropped[key] = oldTable;
+    if (!(key in newTables.schema)) dropped[key] = oldTable;
   }
   return dropped;
 }
@@ -222,23 +219,16 @@ function isEmpty(obj) {
   return Object.keys(obj).length === 0;
 }
 function canAlterTableAddColumn(column) {
-  if (column.schema.unique)
-    return false;
-  if (hasRuntimeDefault(column))
-    return false;
-  if (!column.schema.optional && !hasDefault(column))
-    return false;
-  if (hasPrimaryKey(column))
-    return false;
-  if (getReferencesConfig(column))
-    return false;
+  if (column.schema.unique) return false;
+  if (hasRuntimeDefault(column)) return false;
+  if (!column.schema.optional && !hasDefault(column)) return false;
+  if (hasPrimaryKey(column)) return false;
+  if (getReferencesConfig(column)) return false;
   return true;
 }
 function canAlterTableDropColumn(column) {
-  if (column.schema.unique)
-    return false;
-  if (hasPrimaryKey(column))
-    return false;
+  if (column.schema.unique) return false;
+  if (hasPrimaryKey(column)) return false;
   return true;
 }
 function canRecreateTableWithoutDataLoss(added, updated) {
@@ -260,16 +250,14 @@ function canRecreateTableWithoutDataLoss(added, updated) {
 function getAdded(oldObj, newObj) {
   const added = {};
   for (const [key, value] of Object.entries(newObj)) {
-    if (!(key in oldObj))
-      added[key] = value;
+    if (!(key in oldObj)) added[key] = value;
   }
   return added;
 }
 function getDropped(oldObj, newObj) {
   const dropped = {};
   for (const [key, value] of Object.entries(oldObj)) {
-    if (!(key in newObj))
-      dropped[key] = value;
+    if (!(key in newObj)) dropped[key] = value;
   }
   return dropped;
 }
@@ -277,10 +265,8 @@ function getUpdated(oldObj, newObj) {
   const updated = {};
   for (const [key, value] of Object.entries(newObj)) {
     const oldValue = oldObj[key];
-    if (!oldValue)
-      continue;
-    if (deepDiff(oldValue, value))
-      updated[key] = value;
+    if (!oldValue) continue;
+    if (deepDiff(oldValue, value)) updated[key] = value;
   }
   return updated;
 }
@@ -288,8 +274,7 @@ function getUpdatedColumns(oldColumns, newColumns) {
   const updated = {};
   for (const [key, newColumn] of Object.entries(newColumns)) {
     let oldColumn = oldColumns[key];
-    if (!oldColumn)
-      continue;
+    if (!oldColumn) continue;
     if (oldColumn.type !== newColumn.type && canChangeTypeWithoutQuery(oldColumn, newColumn)) {
       const asNewColumn = columnSchema.safeParse({
         type: newColumn.type,

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

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

package/dist/core/integration/error-map.js

@@ -52,8 +52,7 @@ const errorMap = (baseError, ctx) => {
   }
 };
 const getTypeOrLiteralMsg = (error) => {
-  if (error.received === "undefined")
-    return "Required";
+  if (error.received === "undefined") return "Required";
   const expectedDeduped = new Set(error.expected);
   switch (error.code) {
     case "invalid_type":
@@ -68,8 +67,7 @@ const getTypeOrLiteralMsg = (error) => {
 };
 const prefix = (key, msg) => key.length ? `**${key}**: ${msg}` : msg;
 const unionExpectedVals = (expectedVals) => [...expectedVals].map((expectedVal, idx) => {
-  if (idx === 0)
-    return JSON.stringify(expectedVal);
+  if (idx === 0) return JSON.stringify(expectedVal);
   const sep = " | ";
   return `${sep}${JSON.stringify(expectedVal)}`;
 }).join("");

package/dist/core/integration/index.js

@@ -1,25 +1,35 @@
 import { existsSync } from "fs";
 import { dirname } from "path";
 import { fileURLToPath } from "url";
+import { LibsqlError } from "@libsql/client";
 import { mkdir, writeFile } from "fs/promises";
 import { blue, yellow } from "kleur/colors";
-import { loadEnv } from "vite";
+import {
+  createServer,
+  loadEnv,
+  mergeConfig
+} 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 { EXEC_DEFAULT_EXPORT_ERROR, EXEC_ERROR } from "../errors.js";
 import { resolveDbConfig } from "../load-file.js";
+import { SEED_DEV_FILE_NAME } from "../queries.js";
 import { getManagedAppTokenOrExit } from "../tokens.js";
 import { getDbDirectoryUrl } from "../utils.js";
 import { fileURLIntegration } from "./file-url.js";
 import { typegenInternal } from "./typegen.js";
-import { resolved, 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;
   let configFileDependencies = [];
   let root;
   let appToken;
+  let tempViteServer;
   let tables = {
     get() {
       throw new Error("[astro:db] INTERNAL Tables not loaded yet");
@@ -30,6 +40,12 @@ function astroDBIntegration() {
       throw new Error("[astro:db] INTERNAL Seed files not loaded yet");
     }
   };
+  let seedHandler = {
+    execute: () => {
+      throw new Error("[astro:db] INTERNAL Seed handler not loaded yet");
+    },
+    inProgress: false
+  };
   let command;
   let output = "server";
   return {
@@ -39,8 +55,7 @@ function astroDBIntegration() {
         command = _command;
         root = config.root;
         output = config.output;
-        if (command === "preview")
-          return;
+        if (command === "preview") return;
         let dbPlugin = void 0;
         const args = parseArgs(process.argv.slice(3));
         connectToStudio = process.env.ASTRO_INTERNAL_TEST_REMOTE || args["remote"];
@@ -52,7 +67,8 @@ function astroDBIntegration() {
             tables,
             root: config.root,
             srcDir: config.srcDir,
-            output: config.output
+            output: config.output,
+            seedHandler
           });
         } else {
           dbPlugin = vitePluginDb({
@@ -61,7 +77,9 @@ function astroDBIntegration() {
             seedFiles,
             root: config.root,
             srcDir: config.srcDir,
-            output: config.output
+            output: config.output,
+            logger,
+            seedHandler
           });
         }
         updateConfig({
@@ -72,8 +90,7 @@ function astroDBIntegration() {
         });
       },
       "astro:config:done": async ({ config }) => {
-        if (command === "preview")
-          return;
+        if (command === "preview") return;
         const { dbConfig, dependencies, integrationSeedPaths } = await resolveDbConfig(config);
         tables.get = () => dbConfig.tables;
         seedFiles.get = () => integrationSeedPaths;
@@ -86,6 +103,9 @@ function astroDBIntegration() {
         await typegenInternal({ tables: tables.get() ?? {}, root: config.root });
       },
       "astro:server:setup": async ({ server, logger }) => {
+        seedHandler.execute = async (fileUrl) => {
+          await executeSeedFile({ fileUrl, viteServer: server });
+        };
         const filesToWatch = [
           ...CONFIG_FILE_NAMES.map((c) => new URL(c, getDbDirectoryUrl(root))),
           ...configFileDependencies.map((c) => new URL(c, root))
@@ -100,38 +120,13 @@ function astroDBIntegration() {
           logger.info(
             connectToStudio ? "Connected to remote database." : "New local database created."
           );
-          if (connectToStudio)
-            return;
+          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) => {
+            server.ssrLoadModule(resolved.module).catch((e) => {
               logger.error(e instanceof Error ? e.message : String(e));
-            }).finally(() => {
-              seedInFlight = false;
             });
           }
         }, 100);
@@ -144,8 +139,15 @@ function astroDBIntegration() {
         }
         logger.info("database: " + (connectToStudio ? yellow("remote") : blue("local database.")));
       },
+      "astro:build:setup": async ({ vite }) => {
+        tempViteServer = await getTempViteServer({ viteConfig: vite });
+        seedHandler.execute = async (fileUrl) => {
+          await executeSeedFile({ fileUrl, viteServer: tempViteServer });
+        };
+      },
       "astro:build:done": async ({}) => {
         await appToken?.destroy();
+        await tempViteServer?.close();
       }
     }
   };
@@ -157,6 +159,41 @@ function databaseFileEnvDefined() {
 function integration() {
   return [astroDBIntegration(), fileURLIntegration()];
 }
+async function executeSeedFile({
+  fileUrl,
+  viteServer
+}) {
+  const mod = await viteServer.ssrLoadModule(fileUrl.pathname);
+  if (typeof mod.default !== "function") {
+    throw new AstroDbError(EXEC_DEFAULT_EXPORT_ERROR(fileURLToPath(fileUrl)));
+  }
+  try {
+    await mod.default();
+  } catch (e) {
+    if (e instanceof LibsqlError) {
+      throw new AstroDbError(EXEC_ERROR(e.message));
+    }
+    throw e;
+  }
+}
+async function getTempViteServer({ viteConfig }) {
+  const tempViteServer = await createServer(
+    mergeConfig(viteConfig, {
+      server: { middlewareMode: true, hmr: false, watch: null },
+      optimizeDeps: { noDiscovery: true },
+      ssr: { external: [] },
+      logLevel: "silent"
+    })
+  );
+  const hotSend = tempViteServer.hot.send;
+  tempViteServer.hot.send = (payload) => {
+    if (payload.type === "error") {
+      throw payload.err;
+    }
+    return hotSend(payload);
+  };
+  return tempViteServer;
+}
 export {
   integration
 };

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

@@ -1,9 +1,9 @@
-import type { AstroConfig } from 'astro';
+import type { AstroConfig, AstroIntegrationLogger } from 'astro';
 import type { DBTables } from '../types.js';
 import { type VitePlugin } from '../utils.js';
 export declare const resolved: {
-    virtual: string;
-    seedVirtual: string;
+    module: string;
+    importedFromSeedFile: string;
 };
 export type LateTables = {
     get: () => DBTables;
@@ -11,13 +11,19 @@ export type LateTables = {
 export type LateSeedFiles = {
     get: () => Array<string | URL>;
 };
+export type SeedHandler = {
+    inProgress: boolean;
+    execute: (fileUrl: URL) => Promise<void>;
+};
 type VitePluginDBParams = {
     connectToStudio: false;
     tables: LateTables;
     seedFiles: LateSeedFiles;
     srcDir: URL;
     root: URL;
+    logger?: AstroIntegrationLogger;
     output: AstroConfig['output'];
+    seedHandler: SeedHandler;
 } | {
     connectToStudio: true;
     tables: LateTables;
@@ -25,14 +31,13 @@ type VitePluginDBParams = {
     srcDir: URL;
     root: URL;
     output: AstroConfig['output'];
+    seedHandler: SeedHandler;
 };
 export declare function vitePluginDb(params: VitePluginDBParams): VitePlugin;
 export declare function getConfigVirtualModContents(): string;
-export declare function getLocalVirtualModContents({ tables, root, seedFiles, shouldSeed, }: {
+export declare function getLocalVirtualModContents({ tables, root, }: {
     tables: DBTables;
-    seedFiles: Array<string | URL>;
     root: URL;
-    shouldSeed: boolean;
 }): string;
 export declare function getStudioVirtualModContents({ tables, appToken, isBuild, output, }: {
     tables: DBTables;

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

@@ -1,16 +1,18 @@
+import { existsSync } from "node:fs";
 import { fileURLToPath } from "node:url";
-import { normalizePath } from "vite";
-import { SEED_DEV_FILE_NAME } from "../../runtime/queries.js";
+import { sql } from "drizzle-orm";
+import { SQLiteAsyncDialect } from "drizzle-orm/sqlite-core";
+import { createLocalDatabaseClient } from "../../runtime/db-client.js";
+import { normalizeDatabaseUrl } from "../../runtime/index.js";
 import { DB_PATH, RUNTIME_IMPORT, RUNTIME_VIRTUAL_IMPORT, VIRTUAL_MODULE_ID } from "../consts.js";
-import { getDbDirectoryUrl, getRemoteDatabaseUrl } from "../utils.js";
-const WITH_SEED_VIRTUAL_MODULE_ID = "astro:db:seed";
+import { getResolvedFileUrl } from "../load-file.js";
+import { SEED_DEV_FILE_NAME, getCreateIndexQueries, getCreateTableQuery } from "../queries.js";
+import { getAstroEnv, getDbDirectoryUrl, getRemoteDatabaseUrl } from "../utils.js";
 const resolved = {
-  virtual: "\0" + VIRTUAL_MODULE_ID,
-  seedVirtual: "\0" + WITH_SEED_VIRTUAL_MODULE_ID
+  module: "\0" + VIRTUAL_MODULE_ID,
+  importedFromSeedFile: "\0" + VIRTUAL_MODULE_ID + ":seed"
 };
 function vitePluginDb(params) {
-  const srcDirPath = normalizePath(fileURLToPath(params.srcDir));
-  const dbDirPath = normalizePath(fileURLToPath(getDbDirectoryUrl(params.root)));
   let command = "build";
   return {
     name: "astro:db",
@@ -18,22 +20,15 @@ function vitePluginDb(params) {
     configResolved(resolvedConfig) {
       command = resolvedConfig.command;
     },
-    async resolveId(id, rawImporter) {
-      if (id !== VIRTUAL_MODULE_ID)
-        return;
-      if (params.connectToStudio)
-        return resolved.virtual;
-      const importer = rawImporter ? await this.resolve(rawImporter) : null;
-      if (!importer)
-        return resolved.virtual;
-      if (importer.id.startsWith(srcDirPath) && !importer.id.startsWith(dbDirPath)) {
-        return resolved.seedVirtual;
+    async resolveId(id) {
+      if (id !== VIRTUAL_MODULE_ID) return;
+      if (params.seedHandler.inProgress) {
+        return resolved.importedFromSeedFile;
       }
-      return resolved.virtual;
+      return resolved.module;
     },
     async load(id) {
-      if (id !== resolved.virtual && id !== resolved.seedVirtual)
-        return;
+      if (id !== resolved.module && id !== resolved.importedFromSeedFile) return;
       if (params.connectToStudio) {
         return getStudioVirtualModContents({
           appToken: params.appToken,
@@ -42,11 +37,28 @@ function vitePluginDb(params) {
           output: params.output
         });
       }
+      if (id === resolved.importedFromSeedFile) {
+        return getLocalVirtualModContents({
+          root: params.root,
+          tables: params.tables.get()
+        });
+      }
+      await recreateTables(params);
+      const seedFiles = getResolvedSeedFiles(params);
+      for await (const seedFile of seedFiles) {
+        this.addWatchFile(fileURLToPath(seedFile));
+        if (existsSync(seedFile)) {
+          params.seedHandler.inProgress = true;
+          await params.seedHandler.execute(seedFile);
+        }
+      }
+      if (params.seedHandler.inProgress) {
+        (params.logger ?? console).info("Seeded database.");
+        params.seedHandler.inProgress = false;
+      }
       return getLocalVirtualModContents({
         root: params.root,
-        tables: params.tables.get(),
-        seedFiles: params.seedFiles.get(),
-        shouldSeed: id === resolved.seedVirtual
+        tables: params.tables.get()
       });
     }
   };
@@ -56,40 +68,15 @@ function getConfigVirtualModContents() {
 }
 function getLocalVirtualModContents({
   tables,
-  root,
-  seedFiles,
-  shouldSeed
+  root
 }) {
-  const userSeedFilePaths = SEED_DEV_FILE_NAME.map(
-    // Format as /db/[name].ts
-    // for Vite import.meta.glob
-    (name) => new URL(name, getDbDirectoryUrl("file:///")).pathname
-  );
-  const resolveId = (id) => id.startsWith(".") ? normalizePath(fileURLToPath(new URL(id, root))) : id;
-  const integrationSeedImportStatements = [];
-  const integrationSeedImportNames = [];
-  seedFiles.forEach((pathOrUrl, index) => {
-    const path = typeof pathOrUrl === "string" ? resolveId(pathOrUrl) : pathOrUrl.pathname;
-    const importName = "integration_seed_" + index;
-    integrationSeedImportStatements.push(`import ${importName} from ${JSON.stringify(path)};`);
-    integrationSeedImportNames.push(importName);
-  });
   const dbUrl = new URL(DB_PATH, root);
   return `
 import { asDrizzleTable, createLocalDatabaseClient, normalizeDatabaseUrl } from ${RUNTIME_IMPORT};
-${shouldSeed ? `import { seedLocal } from ${RUNTIME_IMPORT};` : ""}
-${shouldSeed ? integrationSeedImportStatements.join("\n") : ""}
 
 const dbUrl = normalizeDatabaseUrl(import.meta.env.ASTRO_DATABASE_FILE, ${JSON.stringify(dbUrl)});
 export const db = createLocalDatabaseClient({ dbUrl });
 
-${shouldSeed ? `await seedLocal({
-	db,
-	tables: ${JSON.stringify(tables)},
-	userSeedGlob: import.meta.glob(${JSON.stringify(userSeedFilePaths)}, { eager: true }),
-	integrationSeedFunctions: [${integrationSeedImportNames.join(",")}],
-});` : ""}
-
 export * from ${RUNTIME_VIRTUAL_IMPORT};
 
 ${getStringifiedTableExports(tables)}`;
@@ -132,6 +119,31 @@ function getStringifiedTableExports(tables) {
     )}, false)`
   ).join("\n");
 }
+const sqlite = new SQLiteAsyncDialect();
+async function recreateTables({ tables, root }) {
+  const { ASTRO_DATABASE_FILE } = getAstroEnv();
+  const dbUrl = normalizeDatabaseUrl(ASTRO_DATABASE_FILE, new URL(DB_PATH, root).href);
+  const db = createLocalDatabaseClient({ dbUrl });
+  const setupQueries = [];
+  for (const [name, table] of Object.entries(tables.get() ?? {})) {
+    const dropQuery = sql.raw(`DROP TABLE IF EXISTS ${sqlite.escapeName(name)}`);
+    const createQuery = sql.raw(getCreateTableQuery(name, table));
+    const indexQueries = getCreateIndexQueries(name, table);
+    setupQueries.push(dropQuery, createQuery, ...indexQueries.map((s) => sql.raw(s)));
+  }
+  await db.batch([
+    db.run(sql`pragma defer_foreign_keys=true;`),
+    ...setupQueries.map((q) => db.run(q))
+  ]);
+}
+function getResolvedSeedFiles({
+  root,
+  seedFiles
+}) {
+  const localSeedFiles = SEED_DEV_FILE_NAME.map((name) => new URL(name, getDbDirectoryUrl(root)));
+  const integrationSeedFiles = seedFiles.get().map((s) => getResolvedFileUrl(root, s));
+  return [...integrationSeedFiles, ...localSeedFiles];
+}
 export {
   getConfigVirtualModContents,
   getLocalVirtualModContents,

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

@@ -26,8 +26,7 @@ async function setUpEnvTs({
   if (existsSync(envTsPath)) {
     let typesEnvContents = await readFile(envTsPath, "utf-8");
     const dotAstroDir = new URL(".astro/", root);
-    if (!existsSync(dotAstroDir))
-      return;
+    if (!existsSync(dotAstroDir)) return;
     const dbTypeReference = getDBTypeReference({ srcDir, dotAstroDir });
     if (!typesEnvContents.includes(dbTypeReference)) {
       typesEnvContents = `${dbTypeReference}

package/dist/core/load-file.d.ts

@@ -172,6 +172,7 @@ export declare function resolveDbConfig({ root, integrations, }: Pick<AstroConfi
     /** Additional `astro:db` seed file paths provided by integrations. */
     integrationSeedPaths: (string | URL)[];
 }>;
+export declare function getResolvedFileUrl(root: URL, filePathOrUrl: string | URL): URL;
 /**
  * Bundle arbitrary `mjs` or `ts` file.
  * Simplified fork from Vite's `bundleConfigFile` function.

package/dist/core/load-file.js

@@ -9,7 +9,7 @@ import { errorMap } from "./integration/error-map.js";
 import { getConfigVirtualModContents } from "./integration/vite-plugin-db.js";
 import { dbConfigSchema } from "./schemas.js";
 import {} from "./types.js";
-import { getDbDirectoryUrl } from "./utils.js";
+import { getAstroEnv, getDbDirectoryUrl } from "./utils.js";
 const isDbIntegration = (integration) => "astro:db:setup" in integration.hooks;
 async function resolveDbConfig({
   root,
@@ -21,8 +21,7 @@ async function resolveDbConfig({
   const integrationDbConfigPaths = [];
   const integrationSeedPaths = [];
   for (const integration of integrations) {
-    if (!isDbIntegration(integration))
-      continue;
+    if (!isDbIntegration(integration)) continue;
     const { name, hooks } = integration;
     if (hooks["astro:db:setup"]) {
       hooks["astro:db:setup"]({
@@ -70,15 +69,16 @@ async function loadUserConfigFile(root) {
   }
   return await loadAndBundleDbConfigFile({ root, fileUrl: configFileUrl });
 }
-async function loadIntegrationConfigFile(root, filePathOrUrl) {
-  let fileUrl;
+function getResolvedFileUrl(root, filePathOrUrl) {
   if (typeof filePathOrUrl === "string") {
     const { resolve } = createRequire(root);
     const resolvedFilePath = resolve(filePathOrUrl);
-    fileUrl = pathToFileURL(resolvedFilePath);
-  } else {
-    fileUrl = filePathOrUrl;
+    return pathToFileURL(resolvedFilePath);
   }
+  return filePathOrUrl;
+}
+async function loadIntegrationConfigFile(root, filePathOrUrl) {
+  const fileUrl = getResolvedFileUrl(root, filePathOrUrl);
   return await loadAndBundleDbConfigFile({ root, fileUrl });
 }
 async function loadAndBundleDbConfigFile({
@@ -103,6 +103,7 @@ async function bundleFile({
   root,
   virtualModContents
 }) {
+  const { ASTRO_DATABASE_FILE } = getAstroEnv();
   const result = await esbuild({
     absWorkingDir: process.cwd(),
     entryPoints: [fileURLToPath(fileUrl)],
@@ -116,7 +117,8 @@ async function bundleFile({
     sourcemap: "inline",
     metafile: true,
     define: {
-      "import.meta.env.ASTRO_STUDIO_REMOTE_DB_URL": "undefined"
+      "import.meta.env.ASTRO_STUDIO_REMOTE_DB_URL": "undefined",
+      "import.meta.env.ASTRO_DATABASE_FILE": JSON.stringify(ASTRO_DATABASE_FILE ?? "")
     },
     plugins: [
       {
@@ -165,6 +167,7 @@ async function importBundledFile({
 }
 export {
   bundleFile,
+  getResolvedFileUrl,
   importBundledFile,
   resolveDbConfig
 };

package/dist/{runtime → core}/queries.d.ts

@@ -1,4 +1,4 @@
-import type { BooleanColumn, ColumnType, DBColumn, DBTable, DateColumn, JsonColumn, NumberColumn, TextColumn } from '../core/types.js';
+import type { BooleanColumn, ColumnType, DBColumn, DBTable, DateColumn, JsonColumn, NumberColumn, TextColumn } from './types.js';
 export declare const SEED_DEV_FILE_NAME: string[];
 export declare function getDropTableIfExistsQuery(tableName: string): string;
 export declare function getCreateTableQuery(tableName: string, table: DBTable): string;
@@ -17,7 +17,7 @@ export declare function getReferencesConfig(column: DBColumn): {
     } & ({
         optional: boolean;
         primaryKey: false;
-        default?: number | import("./types.js").SerializedSQL | undefined;
+        default?: number | import("../runtime/types.js").SerializedSQL | undefined;
     } | {
         primaryKey: true;
         optional?: false | undefined;
@@ -33,7 +33,7 @@ export declare function getReferencesConfig(column: DBColumn): {
         name?: string | undefined;
         label?: string | undefined;
         collection?: string | undefined;
-        default?: string | import("./types.js").SerializedSQL | undefined;
+        default?: string | import("../runtime/types.js").SerializedSQL | undefined;
         multiline?: boolean | undefined;
     } & ({
         optional: boolean;

package/dist/{runtime → core}/queries.js

@@ -6,9 +6,9 @@ import {
   FOREIGN_KEY_REFERENCES_EMPTY_ERROR,
   FOREIGN_KEY_REFERENCES_LENGTH_ERROR,
   REFERENCE_DNE_ERROR
-} from "./errors.js";
-import { hasPrimaryKey } from "./index.js";
-import { isSerializedSQL } from "./types.js";
+} from "../runtime/errors.js";
+import { hasPrimaryKey } from "../runtime/index.js";
+import { isSerializedSQL } from "../runtime/types.js";
 const sqlite = new SQLiteAsyncDialect();
 const SEED_DEV_FILE_NAME = ["seed.ts", "seed.js", "seed.mjs", "seed.mts"];
 function getDropTableIfExistsQuery(tableName) {
@@ -107,8 +107,7 @@ function getModifiers(columnName, column) {
 }
 function getReferencesConfig(column) {
   const canHaveReferences = column.type === "number" || column.type === "text";
-  if (!canHaveReferences)
-    return void 0;
+  if (!canHaveReferences) return void 0;
   return column.schema.references;
 }
 function hasDefault(column) {

package/dist/core/utils.d.ts

@@ -2,6 +2,7 @@ import type { AstroConfig, AstroIntegration } from 'astro';
 import type { AstroDbIntegration } from './types.js';
 export type VitePlugin = Required<AstroConfig['vite']>['plugins'][number];
 export declare function getAstroStudioEnv(envMode?: string): Record<`ASTRO_STUDIO_${string}`, string>;
+export declare function getAstroEnv(envMode?: string): Record<`ASTRO_${string}`, string>;
 export declare function getRemoteDatabaseUrl(): string;
 export declare function getAstroStudioUrl(): string;
 export declare function getDbDirectoryUrl(root: URL | string): URL;

package/dist/core/utils.js

@@ -3,6 +3,10 @@ function getAstroStudioEnv(envMode = "") {
   const env = loadEnv(envMode, process.cwd(), "ASTRO_STUDIO_");
   return env;
 }
+function getAstroEnv(envMode = "") {
+  const env = loadEnv(envMode, process.cwd(), "ASTRO_");
+  return env;
+}
 function getRemoteDatabaseUrl() {
   const env = getAstroStudioEnv();
   return env.ASTRO_STUDIO_REMOTE_DB_URL || "https://db.services.astro.build";
@@ -24,6 +28,7 @@ function mapObject(item, callback) {
 }
 export {
   defineDbIntegration,
+  getAstroEnv,
   getAstroStudioEnv,
   getAstroStudioUrl,
   getDbDirectoryUrl,

package/dist/runtime/db-client.js

@@ -56,8 +56,7 @@ function createRemoteDatabaseClient(appToken, remoteDbURL) {
       } catch (e) {
         throw new AstroDbError(await getUnexpectedResponseMessage(res));
       }
-      if (method === "run")
-        return remoteResult;
+      if (method === "run") return remoteResult;
       const rowValues = [];
       for (const row of remoteResult.rows) {
         if (row != null && typeof row === "object") {

package/dist/runtime/index.d.ts

@@ -2,7 +2,6 @@ import { type ColumnDataType } from 'drizzle-orm';
 import type { DBColumn, DBTable } from '../core/types.js';
 export type { Table } from './types.js';
 export { createRemoteDatabaseClient, createLocalDatabaseClient } from './db-client.js';
-export { seedLocal } from './seed-local.js';
 export declare function hasPrimaryKey(column: DBColumn): boolean;
 export declare function asDrizzleTable(name: string, table: DBTable): import("drizzle-orm/sqlite-core").SQLiteTableWithColumns<{
     name: string;

package/dist/runtime/index.js

@@ -9,10 +9,10 @@ import {
 import { isSerializedSQL } from "./types.js";
 import { pathToFileURL } from "./utils.js";
 import { createRemoteDatabaseClient, createLocalDatabaseClient } from "./db-client.js";
-import { seedLocal } from "./seed-local.js";
 function hasPrimaryKey(column) {
   return "primaryKey" in column.schema && !!column.schema.primaryKey;
 }
+const isISODateString = (str) => /\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}.\d{3}Z/.test(str);
 const dateType = customType({
   dataType() {
     return "text";
@@ -21,6 +21,9 @@ const dateType = customType({
     return value.toISOString();
   },
   fromDriver(value) {
+    if (!isISODateString(value)) {
+      value += "Z";
+    }
     return new Date(value);
   }
 });
@@ -48,8 +51,7 @@ function asDrizzleTable(name, table) {
     for (const [indexName, indexProps] of Object.entries(table.indexes ?? {})) {
       const onColNames = Array.isArray(indexProps.on) ? indexProps.on : [indexProps.on];
       const onCols = onColNames.map((colName) => ormTable[colName]);
-      if (!atLeastOne(onCols))
-        continue;
+      if (!atLeastOne(onCols)) continue;
       indexes[indexName] = index(indexName).on(...onCols);
     }
     return indexes;
@@ -66,16 +68,14 @@ function columnMapper(columnName, column) {
       c = text(columnName);
       if (column.schema.default !== void 0)
         c = c.default(handleSerializedSQL(column.schema.default));
-      if (column.schema.primaryKey === true)
-        c = c.primaryKey();
+      if (column.schema.primaryKey === true) c = c.primaryKey();
       break;
     }
     case "number": {
       c = integer(columnName);
       if (column.schema.default !== void 0)
         c = c.default(handleSerializedSQL(column.schema.default));
-      if (column.schema.primaryKey === true)
-        c = c.primaryKey();
+      if (column.schema.primaryKey === true) c = c.primaryKey();
       break;
     }
     case "boolean": {
@@ -86,8 +86,7 @@ function columnMapper(columnName, column) {
     }
     case "json":
       c = jsonType(columnName);
-      if (column.schema.default !== void 0)
-        c = c.default(column.schema.default);
+      if (column.schema.default !== void 0) c = c.default(column.schema.default);
       break;
     case "date": {
       c = dateType(columnName);
@@ -98,10 +97,8 @@ function columnMapper(columnName, column) {
       break;
     }
   }
-  if (!column.schema.optional)
-    c = c.notNull();
-  if (column.schema.unique)
-    c = c.unique();
+  if (!column.schema.optional) c = c.notNull();
+  if (column.schema.unique) c = c.unique();
   return c;
 }
 function handleSerializedSQL(def) {
@@ -125,6 +122,5 @@ export {
   createLocalDatabaseClient,
   createRemoteDatabaseClient,
   hasPrimaryKey,
-  normalizeDatabaseUrl,
-  seedLocal
+  normalizeDatabaseUrl
 };

package/dist/runtime/utils.d.ts

@@ -6,5 +6,4 @@ export declare function safeFetch(url: Parameters<typeof fetch>[0], options?: Pa
 export declare class AstroDbError extends AstroError {
     name: string;
 }
-export default function slash(path: string): string;
 export declare function pathToFileURL(path: string): URL;

package/dist/runtime/utils.js

@@ -31,7 +31,6 @@ function pathToFileURL(path) {
 }
 export {
   AstroDbError,
-  slash as default,
   pathToFileURL,
   safeFetch
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@astrojs/db",
-  "version": "0.10.7",
+  "version": "0.11.1",
   "description": "Add libSQL and Astro Studio support to your Astro site",
   "license": "MIT",
   "repository": {
@@ -66,7 +66,7 @@
     "async-listen": "^3.0.1",
     "ci-info": "^4.0.0",
     "deep-diff": "^1.0.2",
-    "drizzle-orm": "^0.30.9",
+    "drizzle-orm": "^0.30.10",
     "github-slugger": "^2.0.0",
     "kleur": "^4.1.5",
     "nanoid": "^5.0.7",
@@ -75,12 +75,12 @@
     "prompts": "^2.4.2",
     "strip-ansi": "^7.1.0",
     "yargs-parser": "^21.1.1",
-    "zod": "^3.23.5"
+    "zod": "^3.23.8"
   },
   "devDependencies": {
-    "@types/chai": "^4.3.14",
+    "@types/chai": "^4.3.16",
     "@types/deep-diff": "^1.0.5",
-    "@types/diff": "^5.2.0",
+    "@types/diff": "^5.2.1",
     "@types/mocha": "^10.0.6",
     "@types/prompts": "^2.4.9",
     "@types/yargs-parser": "^21.0.3",
@@ -88,8 +88,8 @@
     "cheerio": "1.0.0-rc.12",
     "mocha": "^10.4.0",
     "typescript": "^5.4.5",
-    "vite": "^5.2.10",
-    "astro": "4.7.1",
+    "vite": "^5.2.11",
+    "astro": "4.8.0",
     "astro-scripts": "0.0.14"
   },
   "scripts": {

package/dist/runtime/seed-local.d.ts

@@ -1,10 +0,0 @@
-import type { LibSQLDatabase } from 'drizzle-orm/libsql';
-import { type DBTables } from '../core/types.js';
-export declare function seedLocal({ db, tables, userSeedGlob, integrationSeedFunctions, }: {
-    db: LibSQLDatabase;
-    tables: DBTables;
-    userSeedGlob: Record<string, {
-        default?: () => Promise<void>;
-    }>;
-    integrationSeedFunctions: Array<() => Promise<void>>;
-}): Promise<void>;

package/dist/runtime/seed-local.js

@@ -1,55 +0,0 @@
-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 } from "./errors.js";
-import { getCreateIndexQueries, getCreateTableQuery } from "./queries.js";
-import { AstroDbError } from "./utils.js";
-const sqlite = new SQLiteAsyncDialect();
-async function seedLocal({
-  db,
-  tables,
-  // Glob all potential seed files to catch renames and deletions.
-  userSeedGlob,
-  integrationSeedFunctions
-}) {
-  await recreateTables({ db, tables });
-  const seedFunctions = [];
-  const seedFilePath = Object.keys(userSeedGlob)[0];
-  if (seedFilePath) {
-    const mod = userSeedGlob[seedFilePath];
-    if (!mod.default)
-      throw new AstroDbError(SEED_DEFAULT_EXPORT_ERROR(seedFilePath));
-    seedFunctions.push(mod.default);
-  }
-  for (const seedFn of integrationSeedFunctions) {
-    seedFunctions.push(seedFn);
-  }
-  for (const seed of seedFunctions) {
-    try {
-      await seed();
-    } catch (e) {
-      if (e instanceof LibsqlError) {
-        throw new AstroDbError(`Failed to seed database:
-${e.message}`);
-      }
-      throw e;
-    }
-  }
-}
-async function recreateTables({ db, tables }) {
-  const setupQueries = [];
-  for (const [name, table] of Object.entries(tables)) {
-    const dropQuery = sql.raw(`DROP TABLE IF EXISTS ${sqlite.escapeName(name)}`);
-    const createQuery = sql.raw(getCreateTableQuery(name, table));
-    const indexQueries = getCreateIndexQueries(name, table);
-    setupQueries.push(dropQuery, createQuery, ...indexQueries.map((s) => sql.raw(s)));
-  }
-  await db.batch([
-    db.run(sql`pragma defer_foreign_keys=true;`),
-    ...setupQueries.map((q) => db.run(q))
-  ]);
-}
-export {
-  seedLocal
-};