@astrojs/db 0.13.2 → 0.14.0-beta.1

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

@@ -1,8 +1,14 @@
+import { type ManagedAppToken } from '@astrojs/studio';
 import type { AstroConfig, AstroIntegration } from 'astro';
 import './types.js';
 export type VitePlugin = Required<AstroConfig['vite']>['plugins'][number];
 export declare function getAstroEnv(envMode?: string): Record<`ASTRO_${string}`, string>;
-export declare function getRemoteDatabaseUrl(): string;
+export type RemoteDatabaseInfo = {
+    type: 'libsql' | 'studio';
+    url: string;
+};
+export declare function getRemoteDatabaseInfo(): RemoteDatabaseInfo;
+export declare function getManagedRemoteToken(token?: string, dbInfo?: RemoteDatabaseInfo): Promise<ManagedAppToken>;
 export declare function getDbDirectoryUrl(root: URL | string): URL;
 export declare function defineDbIntegration(integration: AstroIntegration): AstroIntegration;
 export type Result<T> = {

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

@@ -1,5 +1,4 @@
 import { existsSync } from "node:fs";
-import { getManagedAppTokenOrExit } from "@astrojs/studio";
 import { LibsqlError } from "@libsql/client";
 import { green } from "kleur/colors";
 import {
@@ -13,6 +12,7 @@ import {
   getStudioVirtualModContents
 } from "../../../integration/vite-plugin-db.js";
 import { bundleFile, importBundledFile } from "../../../load-file.js";
+import { getManagedRemoteToken } from "../../../utils.js";
 async function cmd({
   astroConfig,
   dbConfig,
@@ -30,7 +30,7 @@ async function cmd({
   }
   let virtualModContents;
   if (flags.remote) {
-    const appToken = await getManagedAppTokenOrExit(flags.token);
+    const appToken = await getManagedRemoteToken(flags.token);
     virtualModContents = getStudioVirtualModContents({
       tables: dbConfig.tables ?? {},
       appToken: appToken.token,

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

@@ -12,7 +12,6 @@ import { bgRed, cyan } from "kleur/colors";
 import ora from "ora";
 import prompts from "prompts";
 import { safeFetch } from "../../../../runtime/utils.js";
-import {} from "../../../utils.js";
 async function cmd() {
   const sessionToken = await getSessionIdFromFile();
   if (!sessionToken) {

package/dist/core/cli/commands/push/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({ dbConfig, flags, }: {
     astroConfig: AstroConfig;
     dbConfig: DBConfig;

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

@@ -1,9 +1,12 @@
-import { getManagedAppTokenOrExit } from "@astrojs/studio";
+import { sql } from "drizzle-orm";
 import prompts from "prompts";
+import { createRemoteDatabaseClient } from "../../../../runtime/index.js";
 import { safeFetch } from "../../../../runtime/utils.js";
 import { MIGRATION_VERSION } from "../../../consts.js";
-import {} from "../../../types.js";
-import { getRemoteDatabaseUrl } from "../../../utils.js";
+import {
+  getManagedRemoteToken,
+  getRemoteDatabaseInfo
+} from "../../../utils.js";
 import {
   createCurrentSnapshot,
   createEmptySnapshot,
@@ -17,8 +20,12 @@ async function cmd({
 }) {
   const isDryRun = flags.dryRun;
   const isForceReset = flags.forceReset;
-  const appToken = await getManagedAppTokenOrExit(flags.token);
-  const productionSnapshot = await getProductionCurrentSnapshot({ appToken: appToken.token });
+  const dbInfo = getRemoteDatabaseInfo();
+  const appToken = await getManagedRemoteToken(flags.token, dbInfo);
+  const productionSnapshot = await getProductionCurrentSnapshot({
+    dbInfo,
+    appToken: appToken.token
+  });
   const currentSnapshot = createCurrentSnapshot(dbConfig);
   const isFromScratch = !productionSnapshot;
   const { queries: migrationQueries, confirmations } = await getMigrationQueries({
@@ -53,6 +60,7 @@ async function cmd({
     console.log(`Pushing database schema updates...`);
     await pushSchema({
       statements: migrationQueries,
+      dbInfo,
       appToken: appToken.token,
       isDryRun,
       currentSnapshot
@@ -63,6 +71,7 @@ async function cmd({
 }
 async function pushSchema({
   statements,
+  dbInfo,
   appToken,
   isDryRun,
   currentSnapshot
@@ -76,7 +85,31 @@ async function pushSchema({
     console.info("[DRY RUN] Batch query:", JSON.stringify(requestBody, null, 2));
     return new Response(null, { status: 200 });
   }
-  const url = new URL("/db/push", getRemoteDatabaseUrl());
+  return dbInfo.type === "studio" ? pushToStudio(requestBody, appToken, dbInfo.url) : pushToDb(requestBody, appToken, dbInfo.url);
+}
+async function pushToDb(requestBody, appToken, remoteUrl) {
+  const client = createRemoteDatabaseClient({
+    dbType: "libsql",
+    appToken,
+    remoteUrl
+  });
+  await client.run(sql`create table if not exists _astro_db_snapshot (
+		id INTEGER PRIMARY KEY AUTOINCREMENT,
+		version TEXT,
+		snapshot BLOB
+	);`);
+  await client.transaction(async (tx) => {
+    for (const stmt of requestBody.sql) {
+      await tx.run(sql.raw(stmt));
+    }
+    await tx.run(sql`insert into _astro_db_snapshot (version, snapshot) values (
+			${requestBody.version},
+			${JSON.stringify(requestBody.snapshot)}
+		)`);
+  });
+}
+async function pushToStudio(requestBody, appToken, remoteUrl) {
+  const url = new URL("/db/push", remoteUrl);
   const response = await safeFetch(
     url,
     {

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

@@ -1,4 +1,3 @@
-import { getManagedAppTokenOrExit } from "@astrojs/studio";
 import { sql } from "drizzle-orm";
 import {
   createLocalDatabaseClient,
@@ -7,7 +6,7 @@ import {
 import { normalizeDatabaseUrl } from "../../../../runtime/index.js";
 import { DB_PATH } from "../../../consts.js";
 import { SHELL_QUERY_MISSING_ERROR } from "../../../errors.js";
-import { getAstroEnv, getRemoteDatabaseUrl } from "../../../utils.js";
+import { getAstroEnv, getManagedRemoteToken, getRemoteDatabaseInfo } from "../../../utils.js";
 async function cmd({
   flags,
   astroConfig
@@ -17,9 +16,14 @@ async function cmd({
     console.error(SHELL_QUERY_MISSING_ERROR);
     process.exit(1);
   }
+  const dbInfo = getRemoteDatabaseInfo();
   if (flags.remote) {
-    const appToken = await getManagedAppTokenOrExit(flags.token);
-    const db = createRemoteDatabaseClient(appToken.token, getRemoteDatabaseUrl());
+    const appToken = await getManagedRemoteToken(flags.token, dbInfo);
+    const db = createRemoteDatabaseClient({
+      dbType: dbInfo.type,
+      remoteUrl: dbInfo.url,
+      appToken: appToken.token
+    });
     const result = await db.run(sql.raw(query));
     await appToken.destroy();
     console.log(result);
@@ -29,7 +33,7 @@ async function cmd({
       ASTRO_DATABASE_FILE,
       new URL(DB_PATH, astroConfig.root).href
     );
-    const db = createLocalDatabaseClient({ dbUrl });
+    const db = createLocalDatabaseClient({ dbUrl, enableTransations: dbInfo.type === "libsql" });
     const result = await db.run(sql.raw(query));
     console.log(result);
   }

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

@@ -1,4 +1,4 @@
-import { getManagedAppTokenOrExit } from "@astrojs/studio";
+import { getManagedRemoteToken, getRemoteDatabaseInfo } from "../../../utils.js";
 import {
   createCurrentSnapshot,
   createEmptySnapshot,
@@ -11,8 +11,12 @@ async function cmd({
   flags
 }) {
   const isJson = flags.json;
-  const appToken = await getManagedAppTokenOrExit(flags.token);
-  const productionSnapshot = await getProductionCurrentSnapshot({ appToken: appToken.token });
+  const dbInfo = getRemoteDatabaseInfo();
+  const appToken = await getManagedRemoteToken(flags.token, dbInfo);
+  const productionSnapshot = await getProductionCurrentSnapshot({
+    dbInfo,
+    appToken: appToken.token
+  });
   const currentSnapshot = createCurrentSnapshot(dbConfig);
   const { queries: migrationQueries, confirmations } = await getMigrationQueries({
     oldSnapshot: productionSnapshot || createEmptySnapshot(),

package/dist/core/cli/migration-queries.d.ts

@@ -1,4 +1,5 @@
-import { type DBConfig, type DBSnapshot, type ResolvedDBTable } from '../types.js';
+import type { DBConfig, DBSnapshot, ResolvedDBTable } from '../types.js';
+import type { RemoteDatabaseInfo } from '../utils.js';
 export declare function getMigrationQueries({ oldSnapshot, newSnapshot, reset, }: {
     oldSnapshot: DBSnapshot;
     newSnapshot: DBSnapshot;
@@ -15,7 +16,8 @@ export declare function getTableChangeQueries({ tableName, oldTable, newTable, }
     queries: string[];
     confirmations: string[];
 }>;
-export declare function getProductionCurrentSnapshot({ appToken, }: {
+export declare function getProductionCurrentSnapshot(options: {
+    dbInfo: RemoteDatabaseInfo;
     appToken: string;
 }): Promise<DBSnapshot | undefined>;
 export declare function createCurrentSnapshot({ tables }: DBConfig): DBSnapshot;

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

@@ -1,9 +1,11 @@
 import deepDiff from "deep-diff";
+import { sql } from "drizzle-orm";
 import { SQLiteAsyncDialect } from "drizzle-orm/sqlite-core";
 import * as color from "kleur/colors";
 import { customAlphabet } from "nanoid";
 import stripAnsi from "strip-ansi";
 import { hasPrimaryKey } from "../../runtime/index.js";
+import { createRemoteDatabaseClient } from "../../runtime/index.js";
 import { isSerializedSQL } from "../../runtime/types.js";
 import { safeFetch } from "../../runtime/utils.js";
 import { MIGRATION_VERSION } from "../consts.js";
@@ -18,9 +20,6 @@ import {
   schemaTypeToSqlType
 } from "../queries.js";
 import { columnSchema } from "../schemas.js";
-import {
-} from "../types.js";
-import { getRemoteDatabaseUrl } from "../utils.js";
 const sqlite = new SQLiteAsyncDialect();
 const genTempTableName = customAlphabet("abcdefghijklmnopqrstuvwxyz", 10);
 async function getMigrationQueries({
@@ -304,10 +303,30 @@ function canChangeTypeWithoutQuery(oldColumn, newColumn) {
 function hasRuntimeDefault(column) {
   return !!(column.schema.default && isSerializedSQL(column.schema.default));
 }
-async function getProductionCurrentSnapshot({
-  appToken
-}) {
-  const url = new URL("/db/schema", getRemoteDatabaseUrl());
+function getProductionCurrentSnapshot(options) {
+  return options.dbInfo.type === "studio" ? getStudioCurrentSnapshot(options.appToken, options.dbInfo.url) : getDbCurrentSnapshot(options.appToken, options.dbInfo.url);
+}
+async function getDbCurrentSnapshot(appToken, remoteUrl) {
+  const client = createRemoteDatabaseClient({
+    dbType: "libsql",
+    appToken,
+    remoteUrl
+  });
+  try {
+    const res = await client.get(
+      // Latest snapshot
+      sql`select snapshot from _astro_db_snapshot order by id desc limit 1;`
+    );
+    return JSON.parse(res.snapshot);
+  } catch (error) {
+    if (error.code === "SQLITE_UNKNOWN") {
+      return;
+    }
+    throw error;
+  }
+}
+async function getStudioCurrentSnapshot(appToken, remoteUrl) {
+  const url = new URL("/db/schema", remoteUrl);
   const response = await safeFetch(
     url,
     {

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

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

package/dist/core/integration/index.js

@@ -2,7 +2,6 @@ import { existsSync } from "node:fs";
 import { mkdir, writeFile } from "node:fs/promises";
 import { dirname } from "node:path";
 import { fileURLToPath } from "node:url";
-import { getManagedAppTokenOrExit } from "@astrojs/studio";
 import { LibsqlError } from "@libsql/client";
 import { blue, yellow } from "kleur/colors";
 import {
@@ -16,7 +15,7 @@ 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 { getDbDirectoryUrl } from "../utils.js";
+import { getDbDirectoryUrl, getManagedRemoteToken } from "../utils.js";
 import { fileURLIntegration } from "./file-url.js";
 import { getDtsContent } from "./typegen.js";
 import {
@@ -24,7 +23,7 @@ import {
   vitePluginDb
 } from "./vite-plugin-db.js";
 function astroDBIntegration() {
-  let connectToStudio = false;
+  let connectToRemote = false;
   let configFileDependencies = [];
   let root;
   let appToken;
@@ -46,22 +45,21 @@ function astroDBIntegration() {
     inProgress: false
   };
   let command;
-  let output = "server";
+  let finalBuildOutput;
   return {
     name: "astro:db",
     hooks: {
       "astro:config:setup": async ({ updateConfig, config, command: _command, logger }) => {
         command = _command;
         root = config.root;
-        output = config.output;
         if (command === "preview") return;
         let dbPlugin = void 0;
         const args = parseArgs(process.argv.slice(3));
-        connectToStudio = process.env.ASTRO_INTERNAL_TEST_REMOTE || args["remote"];
-        if (connectToStudio) {
-          appToken = await getManagedAppTokenOrExit();
+        connectToRemote = process.env.ASTRO_INTERNAL_TEST_REMOTE || args["remote"];
+        if (connectToRemote) {
+          appToken = await getManagedRemoteToken();
           dbPlugin = vitePluginDb({
-            connectToStudio,
+            connectToStudio: connectToRemote,
             appToken: appToken.token,
             tables,
             root: config.root,
@@ -88,14 +86,15 @@ function astroDBIntegration() {
           }
         });
       },
-      "astro:config:done": async ({ config, injectTypes }) => {
+      "astro:config:done": async ({ config, injectTypes, buildOutput }) => {
         if (command === "preview") return;
+        finalBuildOutput = buildOutput;
         const { dbConfig, dependencies, integrationSeedPaths } = await resolveDbConfig(config);
         tables.get = () => dbConfig.tables;
         seedFiles.get = () => integrationSeedPaths;
         configFileDependencies = dependencies;
         const localDbUrl = new URL(DB_PATH, config.root);
-        if (!connectToStudio && !existsSync(localDbUrl)) {
+        if (!connectToRemote && !existsSync(localDbUrl)) {
           await mkdir(dirname(fileURLToPath(localDbUrl)), { recursive: true });
           await writeFile(localDbUrl, "");
         }
@@ -120,9 +119,9 @@ function astroDBIntegration() {
         });
         setTimeout(() => {
           logger.info(
-            connectToStudio ? "Connected to remote database." : "New local database created."
+            connectToRemote ? "Connected to remote database." : "New local database created."
           );
-          if (connectToStudio) return;
+          if (connectToRemote) return;
           const localSeedPaths = SEED_DEV_FILE_NAME.map(
             (name) => new URL(name, getDbDirectoryUrl(root))
           );
@@ -134,12 +133,12 @@ function astroDBIntegration() {
         }, 100);
       },
       "astro:build:start": async ({ logger }) => {
-        if (!connectToStudio && !databaseFileEnvDefined() && (output === "server" || output === "hybrid")) {
+        if (!connectToRemote && !databaseFileEnvDefined() && finalBuildOutput === "server") {
           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 AstroDbError(message, hint);
         }
-        logger.info("database: " + (connectToStudio ? yellow("remote") : blue("local database.")));
+        logger.info("database: " + (connectToRemote ? yellow("remote") : blue("local database.")));
       },
       "astro:build:setup": async ({ vite }) => {
         tempViteServer = await getTempViteServer({ viteConfig: vite });

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

@@ -7,7 +7,11 @@ import { normalizeDatabaseUrl } from "../../runtime/index.js";
 import { DB_PATH, RUNTIME_IMPORT, RUNTIME_VIRTUAL_IMPORT, VIRTUAL_MODULE_ID } from "../consts.js";
 import { getResolvedFileUrl } from "../load-file.js";
 import { SEED_DEV_FILE_NAME, getCreateIndexQueries, getCreateTableQuery } from "../queries.js";
-import { getAstroEnv, getDbDirectoryUrl, getRemoteDatabaseUrl } from "../utils.js";
+import {
+  getAstroEnv,
+  getDbDirectoryUrl,
+  getRemoteDatabaseInfo
+} from "../utils.js";
 const resolved = {
   module: "\0" + VIRTUAL_MODULE_ID,
   importedFromSeedFile: "\0" + VIRTUAL_MODULE_ID + ":seed"
@@ -70,12 +74,13 @@ function getLocalVirtualModContents({
   tables,
   root
 }) {
+  const dbInfo = getRemoteDatabaseInfo();
   const dbUrl = new URL(DB_PATH, root);
   return `
 import { asDrizzleTable, createLocalDatabaseClient, normalizeDatabaseUrl } from ${RUNTIME_IMPORT};
 
 const dbUrl = normalizeDatabaseUrl(import.meta.env.ASTRO_DATABASE_FILE, ${JSON.stringify(dbUrl)});
-export const db = createLocalDatabaseClient({ dbUrl });
+export const db = createLocalDatabaseClient({ dbUrl, enableTransactions: ${dbInfo.url === "libsql"} });
 
 export * from ${RUNTIME_VIRTUAL_IMPORT};
 
@@ -87,25 +92,31 @@ function getStudioVirtualModContents({
   isBuild,
   output
 }) {
+  const dbInfo = getRemoteDatabaseInfo();
   function appTokenArg() {
     if (isBuild) {
+      const envPrefix = dbInfo.type === "studio" ? "ASTRO_STUDIO" : "ASTRO_DB";
       if (output === "server") {
-        return "process.env.ASTRO_STUDIO_APP_TOKEN";
+        return `process.env.${envPrefix}_APP_TOKEN`;
       } else {
-        return `process.env.ASTRO_STUDIO_APP_TOKEN ?? ${JSON.stringify(appToken)}`;
+        return `process.env.${envPrefix}_APP_TOKEN ?? ${JSON.stringify(appToken)}`;
       }
     } else {
       return JSON.stringify(appToken);
     }
   }
   function dbUrlArg() {
-    const dbStr = JSON.stringify(getRemoteDatabaseUrl());
-    return `import.meta.env.ASTRO_STUDIO_REMOTE_DB_URL ?? ${dbStr}`;
+    const dbStr = JSON.stringify(dbInfo.url);
+    return dbInfo.type === "studio" ? `import.meta.env.ASTRO_STUDIO_REMOTE_DB_URL ?? ${dbStr}` : `import.meta.env.ASTRO_DB_REMOTE_URL ?? ${dbStr}`;
   }
   return `
 import {asDrizzleTable, createRemoteDatabaseClient} from ${RUNTIME_IMPORT};
 
-export const db = await createRemoteDatabaseClient(${appTokenArg()}, ${dbUrlArg()});
+export const db = await createRemoteDatabaseClient({
+  dbType: ${JSON.stringify(dbInfo.type)},
+  remoteUrl: ${dbUrlArg()},
+  appToken: ${appTokenArg()},
+});
 
 export * from ${RUNTIME_VIRTUAL_IMPORT};
 
@@ -121,9 +132,10 @@ function getStringifiedTableExports(tables) {
 }
 const sqlite = new SQLiteAsyncDialect();
 async function recreateTables({ tables, root }) {
+  const dbInfo = getRemoteDatabaseInfo();
   const { ASTRO_DATABASE_FILE } = getAstroEnv();
   const dbUrl = normalizeDatabaseUrl(ASTRO_DATABASE_FILE, new URL(DB_PATH, root).href);
-  const db = createLocalDatabaseClient({ dbUrl });
+  const db = createLocalDatabaseClient({ dbUrl, enableTransations: dbInfo.type === "libsql" });
   const setupQueries = [];
   for (const [name, table] of Object.entries(tables.get() ?? {})) {
     const dropQuery = sql.raw(`DROP TABLE IF EXISTS ${sqlite.escapeName(name)}`);

package/dist/core/load-file.js

@@ -116,6 +116,7 @@ async function bundleFile({
     metafile: true,
     define: {
       "import.meta.env.ASTRO_STUDIO_REMOTE_DB_URL": "undefined",
+      "import.meta.env.ASTRO_DB_REMOTE_DB_URL": "undefined",
       "import.meta.env.ASTRO_DATABASE_FILE": JSON.stringify(ASTRO_DATABASE_FILE ?? "")
     },
     plugins: [

package/dist/core/queries.js

@@ -1,4 +1,3 @@
-import {} from "drizzle-orm";
 import { SQLiteAsyncDialect } from "drizzle-orm/sqlite-core";
 import { bold } from "kleur/colors";
 import {

package/dist/core/utils.d.ts

@@ -1,8 +1,14 @@
+import { type ManagedAppToken } from '@astrojs/studio';
 import type { AstroConfig, AstroIntegration } from 'astro';
 import './types.js';
 export type VitePlugin = Required<AstroConfig['vite']>['plugins'][number];
 export declare function getAstroEnv(envMode?: string): Record<`ASTRO_${string}`, string>;
-export declare function getRemoteDatabaseUrl(): string;
+export type RemoteDatabaseInfo = {
+    type: 'libsql' | 'studio';
+    url: string;
+};
+export declare function getRemoteDatabaseInfo(): RemoteDatabaseInfo;
+export declare function getManagedRemoteToken(token?: string, dbInfo?: RemoteDatabaseInfo): Promise<ManagedAppToken>;
 export declare function getDbDirectoryUrl(root: URL | string): URL;
 export declare function defineDbIntegration(integration: AstroIntegration): AstroIntegration;
 export type Result<T> = {

package/dist/core/utils.js

@@ -1,13 +1,39 @@
-import { getAstroStudioEnv } from "@astrojs/studio";
+import { getAstroStudioEnv, getManagedAppTokenOrExit } from "@astrojs/studio";
 import { loadEnv } from "vite";
 import "./types.js";
 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";
+function getRemoteDatabaseInfo() {
+  const astroEnv = getAstroEnv();
+  const studioEnv = getAstroStudioEnv();
+  if (studioEnv.ASTRO_STUDIO_REMOTE_DB_URL)
+    return {
+      type: "studio",
+      url: studioEnv.ASTRO_STUDIO_REMOTE_DB_URL
+    };
+  if (astroEnv.ASTRO_DB_REMOTE_URL)
+    return {
+      type: "libsql",
+      url: astroEnv.ASTRO_DB_REMOTE_URL
+    };
+  return {
+    type: "studio",
+    url: "https://db.services.astro.build"
+  };
+}
+function getManagedRemoteToken(token, dbInfo) {
+  dbInfo ??= getRemoteDatabaseInfo();
+  if (dbInfo.type === "studio") {
+    return getManagedAppTokenOrExit(token);
+  }
+  const astroEnv = getAstroEnv();
+  return Promise.resolve({
+    token: token ?? astroEnv.ASTRO_DB_APP_TOKEN,
+    renew: () => Promise.resolve(),
+    destroy: () => Promise.resolve()
+  });
 }
 function getDbDirectoryUrl(root) {
   return new URL("db/", root);
@@ -24,6 +50,7 @@ export {
   defineDbIntegration,
   getAstroEnv,
   getDbDirectoryUrl,
-  getRemoteDatabaseUrl,
+  getManagedRemoteToken,
+  getRemoteDatabaseInfo,
   mapObject
 };

package/dist/runtime/db-client.d.ts

@@ -1,6 +1,14 @@
 import type { LibSQLDatabase } from 'drizzle-orm/libsql';
 import { type SqliteRemoteDatabase } from 'drizzle-orm/sqlite-proxy';
-export declare function createLocalDatabaseClient({ dbUrl }: {
+type LocalDbClientOptions = {
     dbUrl: string;
-}): LibSQLDatabase;
-export declare function createRemoteDatabaseClient(appToken: string, remoteDbURL: string): SqliteRemoteDatabase<Record<string, never>>;
+    enableTransations: boolean;
+};
+export declare function createLocalDatabaseClient(options: LocalDbClientOptions): LibSQLDatabase;
+type RemoteDbClientOptions = {
+    dbType: 'studio' | 'libsql';
+    appToken: string;
+    remoteUrl: string | URL;
+};
+export declare function createRemoteDatabaseClient(options: RemoteDbClientOptions): SqliteRemoteDatabase<Record<string, never>> | LibSQLDatabase<Record<string, never>>;
+export {};

package/dist/runtime/db-client.js

@@ -13,11 +13,13 @@ function applyTransactionNotSupported(db) {
     }
   });
 }
-function createLocalDatabaseClient({ dbUrl }) {
-  const url = isWebContainer ? "file:content.db" : dbUrl;
+function createLocalDatabaseClient(options) {
+  const url = isWebContainer ? "file:content.db" : options.dbUrl;
   const client = createClient({ url });
   const db = drizzleLibsql(client);
-  applyTransactionNotSupported(db);
+  if (!options.enableTransations) {
+    applyTransactionNotSupported(db);
+  }
   return db;
 }
 const remoteResultSchema = z.object({
@@ -27,7 +29,21 @@ const remoteResultSchema = z.object({
   rowsAffected: z.number(),
   lastInsertRowid: z.unknown().optional()
 });
-function createRemoteDatabaseClient(appToken, remoteDbURL) {
+function createRemoteDatabaseClient(options) {
+  const remoteUrl = new URL(options.remoteUrl);
+  return options.dbType === "studio" ? createStudioDatabaseClient(options.appToken, remoteUrl) : createRemoteLibSQLClient(options.appToken, remoteUrl);
+}
+function createRemoteLibSQLClient(appToken, remoteDbURL) {
+  const options = Object.fromEntries(remoteDbURL.searchParams.entries());
+  remoteDbURL.search = "";
+  const client = createClient({
+    ...options,
+    authToken: appToken,
+    url: remoteDbURL.protocol === "memory:" ? ":memory:" : remoteDbURL.toString()
+  });
+  return drizzleLibsql(client);
+}
+function createStudioDatabaseClient(appToken, remoteDbURL) {
   if (appToken == null) {
     throw new Error(`Cannot create a remote client: missing app token.`);
   }

package/dist/runtime/index.d.ts

@@ -1,5 +1,5 @@
 import { type ColumnDataType } from 'drizzle-orm';
-import { type LibSQLDatabase } from 'drizzle-orm/libsql';
+import type { LibSQLDatabase } from 'drizzle-orm/libsql';
 import type { DBColumn, DBTable } from '../core/types.js';
 export type Database = Omit<LibSQLDatabase, 'transaction'>;
 export type { Table } from './types.js';

package/dist/runtime/index.js

@@ -1,5 +1,4 @@
 import { sql } from "drizzle-orm";
-import {} from "drizzle-orm/libsql";
 import {
   customType,
   index,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@astrojs/db",
-  "version": "0.13.2",
+  "version": "0.14.0-beta.1",
   "description": "Add libSQL and Astro Studio support to your Astro site",
   "license": "MIT",
   "repository": {
@@ -62,7 +62,7 @@
     "astro-integration"
   ],
   "dependencies": {
-    "@libsql/client": "^0.9.0",
+    "@libsql/client": "^0.10.0",
     "async-listen": "^3.0.1",
     "deep-diff": "^1.0.2",
     "drizzle-orm": "^0.31.2",
@@ -70,7 +70,7 @@
     "kleur": "^4.1.5",
     "nanoid": "^5.0.7",
     "open": "^10.1.0",
-    "ora": "^8.0.1",
+    "ora": "^8.1.0",
     "prompts": "^2.4.2",
     "strip-ansi": "^7.1.0",
     "yargs-parser": "^21.1.1",
@@ -83,8 +83,8 @@
     "@types/yargs-parser": "^21.0.3",
     "cheerio": "1.0.0",
     "typescript": "^5.5.4",
-    "vite": "^5.4.1",
-    "astro": "4.14.3",
+    "vite": "^5.4.3",
+    "astro": "5.0.0-beta.1",
     "astro-scripts": "0.0.14"
   },
   "scripts": {