@astrojs/db 0.17.2 → 0.18.0

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

@@ -1,5 +1,7 @@
 import { LibsqlError } from '@libsql/client';
 import { AstroError } from 'astro/errors';
+import type { DBColumn } from '../core/types.js';
+export declare function hasPrimaryKey(column: DBColumn): boolean;
 export declare class AstroDbError extends AstroError {
     name: string;
 }

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

@@ -35,12 +35,14 @@ async function cmd({
       tables: dbConfig.tables ?? {},
       appToken: flags.token ?? dbInfo.token,
       isBuild: false,
-      output: "server"
+      output: "server",
+      localExecution: true
     });
   } else {
     virtualModContents = getLocalVirtualModContents({
       tables: dbConfig.tables ?? {},
-      root: astroConfig.root
+      root: astroConfig.root,
+      localExecution: true
     });
   }
   const { code } = await bundleFile({ virtualModContents, root: astroConfig.root, fileUrl });

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

@@ -1,7 +1,7 @@
 import { sql } from "drizzle-orm";
 import prompts from "prompts";
-import { createRemoteDatabaseClient } from "../../../../runtime/index.js";
 import { MIGRATION_VERSION } from "../../../consts.js";
+import { createClient } from "../../../db-client/libsql-node.js";
 import { getRemoteDatabaseInfo } from "../../../utils.js";
 import {
   createCurrentSnapshot,
@@ -79,7 +79,7 @@ async function pushSchema({
   return pushToDb(requestBody, appToken, dbInfo.url);
 }
 async function pushToDb(requestBody, appToken, remoteUrl) {
-  const client = createRemoteDatabaseClient({
+  const client = createClient({
     token: appToken,
     url: remoteUrl
   });

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

@@ -1,10 +1,8 @@
 import { sql } from "drizzle-orm";
-import {
-  createLocalDatabaseClient,
-  createRemoteDatabaseClient
-} from "../../../../runtime/db-client.js";
 import { normalizeDatabaseUrl } from "../../../../runtime/index.js";
 import { DB_PATH } from "../../../consts.js";
+import { createClient as createLocalDatabaseClient } from "../../../db-client/libsql-local.js";
+import { createClient as createRemoteDatabaseClient } from "../../../db-client/libsql-node.js";
 import { SHELL_QUERY_MISSING_ERROR } from "../../../errors.js";
 import { getAstroEnv, getRemoteDatabaseInfo } from "../../../utils.js";
 async function cmd({
@@ -27,7 +25,7 @@ async function cmd({
       ASTRO_DATABASE_FILE,
       new URL(DB_PATH, astroConfig.root).href
     );
-    const db = createLocalDatabaseClient({ dbUrl });
+    const db = createLocalDatabaseClient({ url: dbUrl });
     const result = await db.run(sql.raw(query));
     console.log(result);
   }

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

@@ -4,10 +4,10 @@ import { sql } from "drizzle-orm";
 import { SQLiteAsyncDialect } from "drizzle-orm/sqlite-core";
 import * as color from "kleur/colors";
 import { customAlphabet } from "nanoid";
-import { createRemoteDatabaseClient, hasPrimaryKey } from "../../runtime/index.js";
 import { isSerializedSQL } from "../../runtime/types.js";
-import { isDbError } from "../../runtime/utils.js";
+import { hasPrimaryKey, isDbError } from "../../runtime/utils.js";
 import { MIGRATION_VERSION } from "../consts.js";
+import { createClient } from "../db-client/libsql-node.js";
 import { RENAME_COLUMN_ERROR, RENAME_TABLE_ERROR } from "../errors.js";
 import {
   getCreateIndexQueries,
@@ -309,7 +309,7 @@ function getProductionCurrentSnapshot({
   return getDbCurrentSnapshot(token, url);
 }
 async function getDbCurrentSnapshot(appToken, remoteUrl) {
-  const client = createRemoteDatabaseClient({
+  const client = createClient({
     token: appToken,
     url: remoteUrl
   });

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

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

package/dist/core/consts.d.ts

@@ -4,3 +4,9 @@ export declare const VIRTUAL_MODULE_ID = "astro:db";
 export declare const DB_PATH = ".astro/content.db";
 export declare const CONFIG_FILE_NAMES: string[];
 export declare const MIGRATION_VERSION = "2024-03-12";
+export declare const VIRTUAL_CLIENT_MODULE_ID = "virtual:astro:db-client";
+export declare const DB_CLIENTS: {
+    node: string;
+    web: string;
+    local: string;
+};

package/dist/core/consts.js

@@ -8,11 +8,19 @@ const VIRTUAL_MODULE_ID = "astro:db";
 const DB_PATH = ".astro/content.db";
 const CONFIG_FILE_NAMES = ["config.ts", "config.js", "config.mts", "config.mjs"];
 const MIGRATION_VERSION = "2024-03-12";
+const VIRTUAL_CLIENT_MODULE_ID = "virtual:astro:db-client";
+const DB_CLIENTS = {
+  node: `${PACKAGE_NAME}/db-client/libsql-node.js`,
+  web: `${PACKAGE_NAME}/db-client/libsql-web.js`,
+  local: `${PACKAGE_NAME}/db-client/libsql-local.js`
+};
 export {
   CONFIG_FILE_NAMES,
+  DB_CLIENTS,
   DB_PATH,
   MIGRATION_VERSION,
   RUNTIME_IMPORT,
   RUNTIME_VIRTUAL_IMPORT,
+  VIRTUAL_CLIENT_MODULE_ID,
   VIRTUAL_MODULE_ID
 };

package/dist/core/db-client/libsql-local.d.ts

@@ -0,0 +1,6 @@
+import { type LibSQLDatabase } from 'drizzle-orm/libsql';
+type LocalDbClientOptions = {
+    url: string;
+};
+export declare function createClient(options: LocalDbClientOptions): LibSQLDatabase;
+export {};

package/dist/core/db-client/libsql-local.js

@@ -0,0 +1,12 @@
+import { createClient as createLibsqlClient } from "@libsql/client";
+import { drizzle as drizzleLibsql } from "drizzle-orm/libsql";
+const isWebContainer = !!process.versions?.webcontainer;
+function createClient(options) {
+  const url = isWebContainer ? "file:content.db" : options.url;
+  const client = createLibsqlClient({ url });
+  const db = drizzleLibsql(client);
+  return db;
+}
+export {
+  createClient
+};

package/dist/core/db-client/libsql-node.d.ts

@@ -0,0 +1,8 @@
+type RemoteDbClientOptions = {
+    token: string;
+    url: string;
+};
+export declare function createClient(opts: RemoteDbClientOptions): import("drizzle-orm/libsql").LibSQLDatabase<Record<string, never>> & {
+    $client: import("@libsql/client").Client;
+};
+export {};

package/dist/core/db-client/libsql-node.js

@@ -0,0 +1,21 @@
+import { createClient as createLibsqlClient } from "@libsql/client";
+import { drizzle as drizzleLibsql } from "drizzle-orm/libsql";
+import { parseLibSQLConfig } from "./utils.js";
+function createClient(opts) {
+  const { token, url: rawUrl } = opts;
+  let parsedUrl = new URL(rawUrl);
+  const options = Object.fromEntries(parsedUrl.searchParams.entries());
+  parsedUrl.search = "";
+  let url = parsedUrl.toString();
+  if (parsedUrl.protocol === "memory:") {
+    url = ":memory:";
+  } else if (parsedUrl.protocol === "file:" && parsedUrl.pathname.startsWith("/") && !rawUrl.startsWith("file:/")) {
+    url = "file:" + parsedUrl.pathname.substring(1);
+  }
+  const libSQLOptions = parseLibSQLConfig(options);
+  const client = createLibsqlClient({ ...libSQLOptions, url, authToken: token });
+  return drizzleLibsql(client);
+}
+export {
+  createClient
+};

package/dist/core/db-client/libsql-web.d.ts

@@ -0,0 +1,8 @@
+type RemoteDbClientOptions = {
+    token: string;
+    url: string;
+};
+export declare function createClient(opts: RemoteDbClientOptions): import("drizzle-orm/libsql").LibSQLDatabase<Record<string, never>> & {
+    $client: import("@libsql/client/web").Client;
+};
+export {};

package/dist/core/db-client/libsql-web.js

@@ -0,0 +1,22 @@
+import { createClient as createLibsqlClient } from "@libsql/client/web";
+import { drizzle as drizzleLibsql } from "drizzle-orm/libsql/web";
+import { parseLibSQLConfig } from "./utils.js";
+function createClient(opts) {
+  const { token, url: rawUrl } = opts;
+  let parsedUrl = new URL(rawUrl);
+  const options = Object.fromEntries(parsedUrl.searchParams.entries());
+  parsedUrl.search = "";
+  let url = parsedUrl.toString();
+  const supportedProtocols = ["http:", "https:", "libsql:"];
+  if (!supportedProtocols.includes(parsedUrl.protocol)) {
+    throw new Error(
+      `Unsupported protocol "${parsedUrl.protocol}" for libSQL web client. Supported protocols are: ${supportedProtocols.join(", ")}.`
+    );
+  }
+  const libSQLOptions = parseLibSQLConfig(options);
+  const client = createLibsqlClient({ ...libSQLOptions, url, authToken: token });
+  return drizzleLibsql(client);
+}
+export {
+  createClient
+};

package/dist/core/db-client/utils.d.ts

@@ -0,0 +1,2 @@
+import type { Config as LibSQLConfig } from '@libsql/client';
+export declare const parseLibSQLConfig: (config: Record<string, string>) => Partial<LibSQLConfig>;

package/dist/core/db-client/utils.js

@@ -0,0 +1,46 @@
+import z from "zod";
+const rawLibSQLOptions = z.record(z.string());
+const parseNumber = (value) => z.coerce.number().parse(value);
+const parseBoolean = (value) => z.coerce.boolean().parse(value);
+const booleanValues = ["true", "false"];
+const parseOptionalBoolean = (value) => {
+  if (booleanValues.includes(value)) {
+    return parseBoolean(value);
+  }
+  return true;
+};
+const libSQLConfigTransformed = rawLibSQLOptions.transform((raw) => {
+  const parsed = {};
+  for (const [key, value] of Object.entries(raw)) {
+    switch (key) {
+      case "syncInterval":
+      case "concurrency":
+        parsed[key] = parseNumber(value);
+        break;
+      case "readYourWrites":
+      case "offline":
+      case "tls":
+        parsed[key] = parseOptionalBoolean(value);
+        break;
+      case "authToken":
+      case "encryptionKey":
+      case "syncUrl":
+        parsed[key] = value;
+        break;
+    }
+  }
+  return parsed;
+});
+const parseLibSQLConfig = (config) => {
+  try {
+    return libSQLConfigTransformed.parse(config);
+  } catch (error) {
+    if (error instanceof z.ZodError) {
+      throw new Error(`Invalid LibSQL config: ${error.errors.map((e) => e.message).join(", ")}`);
+    }
+    throw error;
+  }
+};
+export {
+  parseLibSQLConfig
+};

package/dist/core/integration/index.d.ts

@@ -1,2 +1,19 @@
 import type { AstroIntegration } from 'astro';
-export declare function integration(): AstroIntegration[];
+import { z } from 'zod';
+declare const astroDBConfigSchema: z.ZodDefault<z.ZodOptional<z.ZodObject<{
+    /**
+     * Sets the mode of the underlying `@libsql/client` connection.
+     *
+     * In most cases, the default 'node' mode is sufficient. On platforms like Cloudflare, or Deno, you may need to set this to 'web'.
+     *
+     * @default 'node'
+     */
+    mode: z.ZodDefault<z.ZodOptional<z.ZodUnion<[z.ZodLiteral<"node">, z.ZodLiteral<"web">]>>>;
+}, "strip", z.ZodTypeAny, {
+    mode: "node" | "web";
+}, {
+    mode?: "node" | "web" | undefined;
+}>>>;
+export type AstroDBConfig = z.infer<typeof astroDBConfigSchema>;
+export declare function integration(options?: AstroDBConfig): AstroIntegration[];
+export {};

package/dist/core/integration/index.js

@@ -9,6 +9,7 @@ import {
   mergeConfig
 } from "vite";
 import parseArgs from "yargs-parser";
+import { z } from "zod";
 import { AstroDbError, isDbError } from "../../runtime/utils.js";
 import { CONFIG_FILE_NAMES, DB_PATH, VIRTUAL_MODULE_ID } from "../consts.js";
 import { EXEC_DEFAULT_EXPORT_ERROR, EXEC_ERROR } from "../errors.js";
@@ -20,7 +21,19 @@ import { getDtsContent } from "./typegen.js";
 import {
   vitePluginDb
 } from "./vite-plugin-db.js";
-function astroDBIntegration() {
+import { vitePluginDbClient } from "./vite-plugin-db-client.js";
+const astroDBConfigSchema = z.object({
+  /**
+   * Sets the mode of the underlying `@libsql/client` connection.
+   *
+   * In most cases, the default 'node' mode is sufficient. On platforms like Cloudflare, or Deno, you may need to set this to 'web'.
+   *
+   * @default 'node'
+   */
+  mode: z.union([z.literal("node"), z.literal("web")]).optional().default("node")
+}).optional().default({});
+function astroDBIntegration(options) {
+  const resolvedConfig = astroDBConfigSchema.parse(options);
   let connectToRemote = false;
   let configFileDependencies = [];
   let root;
@@ -53,6 +66,10 @@ function astroDBIntegration() {
         let dbPlugin = void 0;
         const args = parseArgs(process.argv.slice(3));
         connectToRemote = process.env.ASTRO_INTERNAL_TEST_REMOTE || args["remote"];
+        const dbClientPlugin = vitePluginDbClient({
+          connectToRemote,
+          mode: resolvedConfig.mode
+        });
         if (connectToRemote) {
           dbPlugin = vitePluginDb({
             connectToRemote,
@@ -78,7 +95,7 @@ function astroDBIntegration() {
         updateConfig({
           vite: {
             assetsInclude: [DB_PATH],
-            plugins: [dbPlugin]
+            plugins: [dbClientPlugin, dbPlugin]
           }
         });
       },
@@ -152,8 +169,8 @@ function databaseFileEnvDefined() {
   const env = loadEnv("", process.cwd());
   return env.ASTRO_DATABASE_FILE != null || process.env.ASTRO_DATABASE_FILE != null;
 }
-function integration() {
-  return [astroDBIntegration(), fileURLIntegration()];
+function integration(options) {
+  return [astroDBIntegration(options), fileURLIntegration()];
 }
 async function executeSeedFile({
   fileUrl,

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

@@ -0,0 +1,7 @@
+import type { VitePlugin } from '../utils.js';
+type VitePluginDBClientParams = {
+    connectToRemote: boolean;
+    mode: 'node' | 'web';
+};
+export declare function vitePluginDbClient(params: VitePluginDBClientParams): VitePlugin;
+export {};

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

@@ -0,0 +1,42 @@
+import { DB_CLIENTS, VIRTUAL_CLIENT_MODULE_ID } from "../consts.js";
+function getRemoteClientModule(mode) {
+  switch (mode) {
+    case "web":
+      return `export { createClient } from '${DB_CLIENTS.web}';`;
+    case "node":
+    default:
+      return `export { createClient } from '${DB_CLIENTS.node}';`;
+  }
+}
+function getLocalClientModule(mode) {
+  switch (mode) {
+    case "node":
+    case "web":
+    default:
+      return `export { createClient } from '${DB_CLIENTS.local}';`;
+  }
+}
+const resolved = "\0" + VIRTUAL_CLIENT_MODULE_ID;
+function vitePluginDbClient(params) {
+  return {
+    name: "virtual:astro:db-client",
+    enforce: "pre",
+    async resolveId(id) {
+      if (id !== VIRTUAL_CLIENT_MODULE_ID) return;
+      return resolved;
+    },
+    async load(id) {
+      if (id !== resolved) return;
+      switch (params.connectToRemote) {
+        case true:
+          return getRemoteClientModule(params.mode);
+        case false:
+        default:
+          return getLocalClientModule(params.mode);
+      }
+    }
+  };
+}
+export {
+  vitePluginDbClient
+};

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

@@ -31,14 +31,30 @@ type VitePluginDBParams = {
 };
 export declare function vitePluginDb(params: VitePluginDBParams): VitePlugin;
 export declare function getConfigVirtualModContents(): string;
-export declare function getLocalVirtualModContents({ tables, root }: {
+export declare function getLocalVirtualModContents({ tables, root, localExecution, }: {
     tables: DBTables;
     root: URL;
+    /**
+     * Used for the execute command to import the client directly.
+     * In other cases, we use the runtime only vite virtual module.
+     *
+     * This is used to ensure that the client is imported correctly
+     * when executing commands like `astro db execute`.
+     */
+    localExecution: boolean;
 }): string;
-export declare function getRemoteVirtualModContents({ tables, appToken, isBuild, output, }: {
+export declare function getRemoteVirtualModContents({ tables, appToken, isBuild, output, localExecution, }: {
     tables: DBTables;
     appToken: string;
     isBuild: boolean;
     output: AstroConfig['output'];
+    /**
+     * Used for the execute command to import the client directly.
+     * In other cases, we use the runtime only vite virtual module.
+     *
+     * This is used to ensure that the client is imported correctly
+     * when executing commands like `astro db execute`.
+     */
+    localExecution: boolean;
 }): string;
 export {};

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

@@ -2,9 +2,16 @@ import { existsSync } from "node:fs";
 import { fileURLToPath } from "node:url";
 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 {
+  DB_CLIENTS,
+  DB_PATH,
+  RUNTIME_IMPORT,
+  RUNTIME_VIRTUAL_IMPORT,
+  VIRTUAL_CLIENT_MODULE_ID,
+  VIRTUAL_MODULE_ID
+} from "../consts.js";
+import { createClient } from "../db-client/libsql-local.js";
 import { getResolvedFileUrl } from "../load-file.js";
 import { getCreateIndexQueries, getCreateTableQuery, SEED_DEV_FILE_NAME } from "../queries.js";
 import {
@@ -38,13 +45,15 @@ function vitePluginDb(params) {
           appToken: params.appToken,
           tables: params.tables.get(),
           isBuild: command === "build",
-          output: params.output
+          output: params.output,
+          localExecution: false
         });
       }
       if (id === resolved.importedFromSeedFile) {
         return getLocalVirtualModContents({
           root: params.root,
-          tables: params.tables.get()
+          tables: params.tables.get(),
+          localExecution: false
         });
       }
       await recreateTables(params);
@@ -62,7 +71,8 @@ function vitePluginDb(params) {
       }
       return getLocalVirtualModContents({
         root: params.root,
-        tables: params.tables.get()
+        tables: params.tables.get(),
+        localExecution: false
       });
     }
   };
@@ -70,15 +80,24 @@ function vitePluginDb(params) {
 function getConfigVirtualModContents() {
   return `export * from ${RUNTIME_VIRTUAL_IMPORT}`;
 }
-function getLocalVirtualModContents({ tables, root }) {
+function getDBModule(localExecution) {
+  return localExecution ? `import { createClient } from '${DB_CLIENTS.node}';` : `import { createClient } from '${VIRTUAL_CLIENT_MODULE_ID}';`;
+}
+function getLocalVirtualModContents({
+  tables,
+  root,
+  localExecution
+}) {
   const { ASTRO_DATABASE_FILE } = getAstroEnv();
-  const dbInfo = getRemoteDatabaseInfo();
   const dbUrl = new URL(DB_PATH, root);
+  const clientImport = getDBModule(localExecution);
   return `
-import { asDrizzleTable, createLocalDatabaseClient, normalizeDatabaseUrl } from ${RUNTIME_IMPORT};
+import { asDrizzleTable, normalizeDatabaseUrl } from ${RUNTIME_IMPORT};
+
+${clientImport}
 
 const dbUrl = normalizeDatabaseUrl(${JSON.stringify(ASTRO_DATABASE_FILE)}, ${JSON.stringify(dbUrl)});
-export const db = createLocalDatabaseClient({ dbUrl, enableTransactions: ${dbInfo.url === "libsql"} });
+export const db = createClient({ url: dbUrl });
 
 export * from ${RUNTIME_VIRTUAL_IMPORT};
 
@@ -88,7 +107,8 @@ function getRemoteVirtualModContents({
   tables,
   appToken,
   isBuild,
-  output
+  output,
+  localExecution
 }) {
   const dbInfo = getRemoteDatabaseInfo();
   function appTokenArg() {
@@ -110,10 +130,13 @@ function getRemoteVirtualModContents({
       return dbStr;
     }
   }
+  const clientImport = getDBModule(localExecution);
   return `
-import {asDrizzleTable, createRemoteDatabaseClient} from ${RUNTIME_IMPORT};
+import {asDrizzleTable} from ${RUNTIME_IMPORT};
+
+${clientImport}
 
-export const db = await createRemoteDatabaseClient({
+export const db = await createClient({
   url: ${dbUrlArg()},
   token: ${appTokenArg()},
 });
@@ -134,7 +157,7 @@ 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 db = createClient({ url: dbUrl });
   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/queries.js

@@ -6,8 +6,8 @@ import {
   FOREIGN_KEY_REFERENCES_LENGTH_ERROR,
   REFERENCE_DNE_ERROR
 } from "../runtime/errors.js";
-import { hasPrimaryKey } from "../runtime/index.js";
 import { isSerializedSQL } from "../runtime/types.js";
+import { hasPrimaryKey } from "../runtime/utils.js";
 const sqlite = new SQLiteAsyncDialect();
 const SEED_DEV_FILE_NAME = ["seed.ts", "seed.js", "seed.mjs", "seed.mts"];
 function getDropTableIfExistsQuery(tableName) {

package/dist/index.d.ts

@@ -1,3 +1,3 @@
 export { cli } from './core/cli/index.js';
-export { integration as default } from './core/integration/index.js';
+export { type AstroDBConfig, integration as default } from './core/integration/index.js';
 export type { TableConfig } from './core/types.js';

package/dist/runtime/index.d.ts

@@ -1,10 +1,9 @@
 import { type ColumnDataType } from 'drizzle-orm';
 import type { LibSQLDatabase } from 'drizzle-orm/libsql';
-import type { DBColumn, DBTable } from '../core/types.js';
+import type { DBTable } from '../core/types.js';
 export type Database = LibSQLDatabase;
-export { createLocalDatabaseClient, createRemoteDatabaseClient } from './db-client.js';
 export type { Table } from './types.js';
-export declare function hasPrimaryKey(column: DBColumn): boolean;
+export { hasPrimaryKey } from './utils.js';
 export declare function asDrizzleTable(name: string, table: DBTable): import("drizzle-orm/sqlite-core").SQLiteTableWithColumns<{
     name: string;
     schema: undefined;

package/dist/runtime/index.js

@@ -7,11 +7,8 @@ import {
   text
 } from "drizzle-orm/sqlite-core";
 import { isSerializedSQL } from "./types.js";
-import { pathToFileURL } from "./utils.js";
-import { createLocalDatabaseClient, createRemoteDatabaseClient } from "./db-client.js";
-function hasPrimaryKey(column) {
-  return "primaryKey" in column.schema && !!column.schema.primaryKey;
-}
+import { hasPrimaryKey, pathToFileURL } from "./utils.js";
+import { hasPrimaryKey as hasPrimaryKey2 } from "./utils.js";
 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() {
@@ -119,8 +116,6 @@ function normalizeDatabaseUrl(envDbUrl, defaultDbUrl) {
 }
 export {
   asDrizzleTable,
-  createLocalDatabaseClient,
-  createRemoteDatabaseClient,
-  hasPrimaryKey,
+  hasPrimaryKey2 as hasPrimaryKey,
   normalizeDatabaseUrl
 };

package/dist/runtime/utils.d.ts

@@ -1,5 +1,7 @@
 import { LibsqlError } from '@libsql/client';
 import { AstroError } from 'astro/errors';
+import type { DBColumn } from '../core/types.js';
+export declare function hasPrimaryKey(column: DBColumn): boolean;
 export declare class AstroDbError extends AstroError {
     name: string;
 }

package/dist/runtime/utils.js

@@ -1,5 +1,8 @@
 import { LibsqlError } from "@libsql/client";
 import { AstroError } from "astro/errors";
+function hasPrimaryKey(column) {
+  return "primaryKey" in column.schema && !!column.schema.primaryKey;
+}
 const isWindows = process?.platform === "win32";
 class AstroDbError extends AstroError {
   name = "Astro DB Error";
@@ -26,6 +29,7 @@ function pathToFileURL(path) {
 }
 export {
   AstroDbError,
+  hasPrimaryKey,
   isDbError,
   pathToFileURL
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@astrojs/db",
-  "version": "0.17.2",
+  "version": "0.18.0",
   "description": "Add libSQL support to your Astro site",
   "license": "MIT",
   "repository": {
@@ -27,6 +27,7 @@
       "types": "./dist/runtime/index.d.ts",
       "default": "./dist/runtime/index.js"
     },
+    "./db-client/*": "./dist/core/db-client/*",
     "./dist/runtime/virtual.js": {
       "default": "./dist/runtime/virtual.js"
     },
@@ -62,7 +63,7 @@
     "astro-integration"
   ],
   "dependencies": {
-    "@libsql/client": "^0.15.14",
+    "@libsql/client": "^0.15.15",
     "deep-diff": "^1.0.2",
     "drizzle-orm": "^0.42.0",
     "kleur": "^4.1.5",
@@ -79,8 +80,8 @@
     "expect-type": "^1.2.2",
     "typescript": "^5.9.2",
     "vite": "^6.3.6",
-    "astro": "5.13.6",
-    "astro-scripts": "0.0.14"
+    "astro-scripts": "0.0.14",
+    "astro": "5.13.8"
   },
   "scripts": {
     "types:virtual": "tsc -p ./tsconfig.virtual.json",

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

@@ -1,15 +0,0 @@
-import { type Config as LibSQLConfig } from '@libsql/client';
-import type { LibSQLDatabase } from 'drizzle-orm/libsql';
-type LocalDbClientOptions = {
-    dbUrl: string;
-};
-export declare function createLocalDatabaseClient(options: LocalDbClientOptions): LibSQLDatabase;
-type RemoteDbClientOptions = {
-    token: string;
-    url: string | URL;
-};
-export declare function createRemoteDatabaseClient(options: RemoteDbClientOptions): LibSQLDatabase<Record<string, never>> & {
-    $client: import("@libsql/client").Client;
-};
-export declare function parseOpts(config: Record<string, string>): Partial<LibSQLConfig>;
-export {};

package/dist/runtime/db-client.js

@@ -1,40 +0,0 @@
-import { createClient } from "@libsql/client";
-import { drizzle as drizzleLibsql } from "drizzle-orm/libsql";
-const isWebContainer = !!process.versions?.webcontainer;
-function createLocalDatabaseClient(options) {
-  const url = isWebContainer ? "file:content.db" : options.dbUrl;
-  const client = createClient({ url });
-  const db = drizzleLibsql(client);
-  return db;
-}
-function createRemoteDatabaseClient(options) {
-  const url = new URL(options.url);
-  return createRemoteLibSQLClient(options.token, url, options.url.toString());
-}
-function parseOpts(config) {
-  return {
-    ...config,
-    ...config.syncInterval ? { syncInterval: parseInt(config.syncInterval) } : {},
-    ..."readYourWrites" in config ? { readYourWrites: config.readYourWrites !== "false" } : {},
-    ..."offline" in config ? { offline: config.offline !== "false" } : {},
-    ..."tls" in config ? { tls: config.tls !== "false" } : {},
-    ...config.concurrency ? { concurrency: parseInt(config.concurrency) } : {}
-  };
-}
-function createRemoteLibSQLClient(authToken, dbURL, rawUrl) {
-  const options = Object.fromEntries(dbURL.searchParams.entries());
-  dbURL.search = "";
-  let url = dbURL.toString();
-  if (dbURL.protocol === "memory:") {
-    url = ":memory:";
-  } else if (dbURL.protocol === "file:" && dbURL.pathname.startsWith("/") && !rawUrl.startsWith("file:/")) {
-    url = "file:" + dbURL.pathname.substring(1);
-  }
-  const client = createClient({ ...parseOpts(options), url, authToken });
-  return drizzleLibsql(client);
-}
-export {
-  createLocalDatabaseClient,
-  createRemoteDatabaseClient,
-  parseOpts
-};