@astrojs/db 0.10.6 → 0.11.0

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/login/index.js

@@ -9,7 +9,7 @@ import { SESSION_LOGIN_FILE } from "../../../tokens.js";
 import { getAstroStudioUrl } from "../../../utils.js";
 const isWebContainer = (
   // Stackblitz heuristic
-  process.versions?.webcontainer ?? // Github Codespaces heuristic
+  process.versions?.webcontainer ?? // GitHub Codespaces heuristic
   process.env.CODESPACE_NAME
 );
 async function cmd({

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";

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

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

package/dist/core/errors.d.ts

@@ -1,3 +1,4 @@
+export declare const MISSING_SESSION_ID_CI_ERROR: string;
 export declare const MISSING_SESSION_ID_ERROR: string;
 export declare const MISSING_PROJECT_ID_ERROR: string;
 export declare const MISSING_EXECUTE_PATH_ERROR: string;

package/dist/core/errors.js

@@ -1,4 +1,8 @@
 import { bold, cyan, red } from "kleur/colors";
+const MISSING_SESSION_ID_CI_ERROR = `${red("\u25B6 ASTRO_STUDIO_APP_TOKEN required")}
+
+	To authenticate with Astro Studio add the token to your CI's environment variables.
+`;
 const MISSING_SESSION_ID_ERROR = `${red("\u25B6 Login required!")}
 
   To authenticate with Astro Studio, run
@@ -53,6 +57,7 @@ export {
   INTEGRATION_TABLE_CONFLICT_ERROR,
   MISSING_EXECUTE_PATH_ERROR,
   MISSING_PROJECT_ID_ERROR,
+  MISSING_SESSION_ID_CI_ERROR,
   MISSING_SESSION_ID_ERROR,
   RENAME_COLUMN_ERROR,
   RENAME_TABLE_ERROR,

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 {
@@ -52,7 +68,8 @@ function astroDBIntegration() {
             tables,
             root: config.root,
             srcDir: config.srcDir,
-            output: config.output
+            output: config.output,
+            seedHandler
           });
         } else {
           dbPlugin = vitePluginDb({
@@ -61,7 +78,9 @@ function astroDBIntegration() {
             seedFiles,
             root: config.root,
             srcDir: config.srcDir,
-            output: config.output
+            output: config.output,
+            logger,
+            seedHandler
           });
         }
         updateConfig({
@@ -86,6 +105,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))
@@ -105,33 +127,9 @@ function astroDBIntegration() {
           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 +142,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 +162,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,21 +20,16 @@ function vitePluginDb(params) {
     configResolved(resolvedConfig) {
       command = resolvedConfig.command;
     },
-    async resolveId(id, rawImporter) {
+    async resolveId(id) {
       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;
+      if (params.seedHandler.inProgress) {
+        return resolved.importedFromSeedFile;
       }
-      return resolved.virtual;
+      return resolved.module;
     },
     async load(id) {
-      if (id !== resolved.virtual && id !== resolved.seedVirtual)
+      if (id !== resolved.module && id !== resolved.importedFromSeedFile)
         return;
       if (params.connectToStudio) {
         return getStudioVirtualModContents({
@@ -42,11 +39,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 +70,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 +121,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/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,
@@ -70,15 +70,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 +104,7 @@ async function bundleFile({
   root,
   virtualModContents
 }) {
+  const { ASTRO_DATABASE_FILE } = getAstroEnv();
   const result = await esbuild({
     absWorkingDir: process.cwd(),
     entryPoints: [fileURLToPath(fileUrl)],
@@ -116,7 +118,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 +168,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) {

package/dist/core/tokens.js

@@ -2,10 +2,15 @@ import { readFile } from "node:fs/promises";
 import { homedir } from "node:os";
 import { join } from "node:path";
 import { pathToFileURL } from "node:url";
+import ci from "ci-info";
 import { green } from "kleur/colors";
 import ora from "ora";
 import { safeFetch } from "../runtime/utils.js";
-import { MISSING_PROJECT_ID_ERROR, MISSING_SESSION_ID_ERROR } from "./errors.js";
+import {
+  MISSING_PROJECT_ID_ERROR,
+  MISSING_SESSION_ID_CI_ERROR,
+  MISSING_SESSION_ID_ERROR
+} from "./errors.js";
 import { getAstroStudioEnv, getAstroStudioUrl } from "./utils.js";
 const SESSION_LOGIN_FILE = pathToFileURL(join(homedir(), ".astro", "session-token"));
 const PROJECT_ID_FILE = pathToFileURL(join(process.cwd(), ".astro", "link"));
@@ -159,11 +164,15 @@ async function getManagedAppTokenOrExit(token) {
   }
   const sessionToken = await getSessionIdFromFile();
   if (!sessionToken) {
-    console.error(MISSING_SESSION_ID_ERROR);
+    if (ci.isCI) {
+      console.error(MISSING_SESSION_ID_CI_ERROR);
+    } else {
+      console.error(MISSING_SESSION_ID_ERROR);
+    }
     process.exit(1);
   }
   const projectId = await getProjectIdFromFile();
-  if (!sessionToken || !projectId) {
+  if (!projectId) {
     console.error(MISSING_PROJECT_ID_ERROR);
     process.exit(1);
   }

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/index.d.ts

@@ -1,8 +1,7 @@
 import { type ColumnDataType } from 'drizzle-orm';
-import { type DBColumn, type DBTable } from '../core/types.js';
+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

@@ -6,11 +6,9 @@ import {
   sqliteTable,
   text
 } from "drizzle-orm/sqlite-core";
-import {} from "../core/types.js";
 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;
 }
@@ -116,7 +114,7 @@ function normalizeDatabaseUrl(envDbUrl, defaultDbUrl) {
     if (envDbUrl.startsWith("file://")) {
       return envDbUrl;
     }
-    return new URL(envDbUrl, pathToFileURL(process.cwd())).toString();
+    return new URL(envDbUrl, pathToFileURL(process.cwd()) + "/").toString();
   } else {
     return defaultDbUrl;
   }
@@ -126,6 +124,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/dist/utils.d.ts

@@ -1,2 +1,4 @@
 export { defineDbIntegration } from './core/utils.js';
-export { asDrizzleTable } from './runtime/index.js';
+import type { ColumnsConfig, TableConfig } from './core/types.js';
+import { type Table } from './runtime/index.js';
+export declare function asDrizzleTable<TableName extends string = string, TColumns extends ColumnsConfig = ColumnsConfig>(name: TableName, tableConfig: TableConfig<TColumns>): Table<TableName, TColumns>;

package/dist/utils.js

@@ -1,5 +1,9 @@
 import { defineDbIntegration } from "./core/utils.js";
-import { asDrizzleTable } from "./runtime/index.js";
+import { tableSchema } from "./core/schemas.js";
+import { asDrizzleTable as internal_asDrizzleTable } from "./runtime/index.js";
+function asDrizzleTable(name, tableConfig) {
+  return internal_asDrizzleTable(name, tableSchema.parse(tableConfig));
+}
 export {
   asDrizzleTable,
   defineDbIntegration

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@astrojs/db",
-  "version": "0.10.6",
+  "version": "0.11.0",
   "description": "Add libSQL and Astro Studio support to your Astro site",
   "license": "MIT",
   "repository": {
@@ -64,6 +64,7 @@
   "dependencies": {
     "@libsql/client": "^0.6.0",
     "async-listen": "^3.0.1",
+    "ci-info": "^4.0.0",
     "deep-diff": "^1.0.2",
     "drizzle-orm": "^0.30.9",
     "github-slugger": "^2.0.0",
@@ -74,7 +75,7 @@
     "prompts": "^2.4.2",
     "strip-ansi": "^7.1.0",
     "yargs-parser": "^21.1.1",
-    "zod": "^3.23.0"
+    "zod": "^3.23.5"
   },
   "devDependencies": {
     "@types/chai": "^4.3.14",
@@ -88,7 +89,7 @@
     "mocha": "^10.4.0",
     "typescript": "^5.4.5",
     "vite": "^5.2.10",
-    "astro": "4.6.4",
+    "astro": "4.7.1",
     "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
-};