@astrojs/db 0.15.0 → 0.16.0

package/dist/core/schemas.js

@@ -65,7 +65,7 @@ const textColumnBaseSchema = baseColumnSchema.omit({ optional: true }).extend({
     z.object({
       // text primary key allows NULL values.
       // NULL values bypass unique checks, which could
-      // lead to duplicate URLs per record in Astro Studio.
+      // lead to duplicate URLs per record.
       // disable `optional` for primary keys.
       primaryKey: z.literal(true),
       optional: z.literal(false).optional()

package/dist/core/types.d.ts

@@ -1,5 +1,5 @@
 import type { z } from 'zod';
-import type { MaybeArray, booleanColumnSchema, columnSchema, columnsSchema, dateColumnSchema, dbConfigSchema, indexSchema, jsonColumnSchema, numberColumnOptsSchema, numberColumnSchema, referenceableColumnSchema, resolvedIndexSchema, tableSchema, textColumnOptsSchema, textColumnSchema } from './schemas.js';
+import type { booleanColumnSchema, columnSchema, columnsSchema, dateColumnSchema, dbConfigSchema, indexSchema, jsonColumnSchema, MaybeArray, numberColumnOptsSchema, numberColumnSchema, referenceableColumnSchema, resolvedIndexSchema, tableSchema, textColumnOptsSchema, textColumnSchema } from './schemas.js';
 export type ResolvedIndexes = z.output<typeof dbConfigSchema>['tables'][string]['indexes'];
 export type BooleanColumn = z.infer<typeof booleanColumnSchema>;
 export type BooleanColumnInput = z.input<typeof booleanColumnSchema>;

package/dist/core/utils.d.ts

@@ -1,23 +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 type RemoteDatabaseInfo = {
-    type: 'libsql' | 'studio';
     url: string;
+    token: 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> = {
-    success: true;
-    data: T;
-} | {
-    success: false;
-    data: unknown;
-};
 /**
  * Map an object's values to a new set of values
  * while preserving types.

package/dist/core/utils.js

@@ -1,4 +1,3 @@
-import { getAstroStudioEnv, getManagedAppTokenOrExit } from "@astrojs/studio";
 import { loadEnv } from "vite";
 import "./types.js";
 function getAstroEnv(envMode = "") {
@@ -7,34 +6,11 @@ function getAstroEnv(envMode = "") {
 }
 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"
+    url: astroEnv.ASTRO_DB_REMOTE_URL,
+    token: astroEnv.ASTRO_DB_APP_TOKEN
   };
 }
-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);
 }
@@ -50,7 +26,6 @@ export {
   defineDbIntegration,
   getAstroEnv,
   getDbDirectoryUrl,
-  getManagedRemoteToken,
   getRemoteDatabaseInfo,
   mapObject
 };

package/dist/index.d.ts

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

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

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

package/dist/runtime/db-client.js

@@ -1,37 +1,15 @@
 import { createClient } from "@libsql/client";
 import { drizzle as drizzleLibsql } from "drizzle-orm/libsql";
-import { drizzle as drizzleProxy } from "drizzle-orm/sqlite-proxy";
-import { z } from "zod";
-import { DetailedLibsqlError, safeFetch } from "./utils.js";
 const isWebContainer = !!process.versions?.webcontainer;
-function applyTransactionNotSupported(db) {
-  Object.assign(db, {
-    transaction() {
-      throw new Error(
-        "`db.transaction()` is not currently supported. We recommend `db.batch()` for automatic error rollbacks across multiple queries."
-      );
-    }
-  });
-}
 function createLocalDatabaseClient(options) {
   const url = isWebContainer ? "file:content.db" : options.dbUrl;
   const client = createClient({ url });
   const db = drizzleLibsql(client);
-  if (!options.enableTransactions) {
-    applyTransactionNotSupported(db);
-  }
   return db;
 }
-const remoteResultSchema = z.object({
-  columns: z.array(z.string()),
-  columnTypes: z.array(z.string()),
-  rows: z.array(z.array(z.unknown())),
-  rowsAffected: z.number(),
-  lastInsertRowid: z.unknown().optional()
-});
 function createRemoteDatabaseClient(options) {
-  const remoteUrl = new URL(options.remoteUrl);
-  return options.dbType === "studio" ? createStudioDatabaseClient(options.appToken, remoteUrl) : createRemoteLibSQLClient(options.appToken, remoteUrl, options.remoteUrl.toString());
+  const url = new URL(options.url);
+  return createRemoteLibSQLClient(options.token, url, options.url.toString());
 }
 function parseOpts(config) {
   return {
@@ -43,153 +21,18 @@ function parseOpts(config) {
     ...config.concurrency ? { concurrency: parseInt(config.concurrency) } : {}
   };
 }
-function createRemoteLibSQLClient(appToken, remoteDbURL, rawUrl) {
-  const options = Object.fromEntries(remoteDbURL.searchParams.entries());
-  remoteDbURL.search = "";
-  let url = remoteDbURL.toString();
-  if (remoteDbURL.protocol === "memory:") {
+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 (remoteDbURL.protocol === "file:" && remoteDbURL.pathname.startsWith("/") && !rawUrl.startsWith("file:/")) {
-    url = "file:" + remoteDbURL.pathname.substring(1);
+  } else if (dbURL.protocol === "file:" && dbURL.pathname.startsWith("/") && !rawUrl.startsWith("file:/")) {
+    url = "file:" + dbURL.pathname.substring(1);
   }
-  const client = createClient({ ...parseOpts(options), url, authToken: appToken });
+  const client = createClient({ ...parseOpts(options), url, authToken });
   return drizzleLibsql(client);
 }
-function createStudioDatabaseClient(appToken, remoteDbURL) {
-  if (appToken == null) {
-    throw new Error(`Cannot create a remote client: missing app token.`);
-  }
-  const url = new URL("/db/query", remoteDbURL);
-  const db = drizzleProxy(
-    async (sql, parameters, method) => {
-      const requestBody = { sql, args: parameters };
-      const res = await safeFetch(
-        url,
-        {
-          method: "POST",
-          headers: {
-            Authorization: `Bearer ${appToken}`,
-            "Content-Type": "application/json"
-          },
-          body: JSON.stringify(requestBody)
-        },
-        async (response) => {
-          throw await parseRemoteError(response);
-        }
-      );
-      let remoteResult;
-      try {
-        const json = await res.json();
-        remoteResult = remoteResultSchema.parse(json);
-      } catch {
-        throw new DetailedLibsqlError({
-          message: await getUnexpectedResponseMessage(res),
-          code: KNOWN_ERROR_CODES.SQL_QUERY_FAILED
-        });
-      }
-      if (method === "run") {
-        const rawRows = Array.from(remoteResult.rows);
-        remoteResult.rows.toJSON = () => rawRows;
-        for (let i = 0; i < remoteResult.rows.length; i++) {
-          let row = remoteResult.rows[i];
-          let item = {};
-          remoteResult.columns.forEach((col, index) => {
-            item[col] = row[index];
-          });
-          remoteResult.rows[i] = item;
-        }
-        return remoteResult;
-      }
-      const rowValues = [];
-      for (const row of remoteResult.rows) {
-        if (row != null && typeof row === "object") {
-          rowValues.push(Object.values(row));
-        }
-      }
-      if (method === "get") {
-        return { rows: rowValues[0] };
-      }
-      return { rows: rowValues };
-    },
-    async (queries) => {
-      const stmts = queries.map(({ sql, params }) => ({ sql, args: params }));
-      const res = await safeFetch(
-        url,
-        {
-          method: "POST",
-          headers: {
-            Authorization: `Bearer ${appToken}`,
-            "Content-Type": "application/json"
-          },
-          body: JSON.stringify(stmts)
-        },
-        async (response) => {
-          throw await parseRemoteError(response);
-        }
-      );
-      let remoteResults;
-      try {
-        const json = await res.json();
-        remoteResults = z.array(remoteResultSchema).parse(json);
-      } catch {
-        throw new DetailedLibsqlError({
-          message: await getUnexpectedResponseMessage(res),
-          code: KNOWN_ERROR_CODES.SQL_QUERY_FAILED
-        });
-      }
-      let results = [];
-      for (const [idx, rawResult] of remoteResults.entries()) {
-        if (queries[idx]?.method === "run") {
-          results.push(rawResult);
-          continue;
-        }
-        const rowValues = [];
-        for (const row of rawResult.rows) {
-          if (row != null && typeof row === "object") {
-            rowValues.push(Object.values(row));
-          }
-        }
-        if (queries[idx]?.method === "get") {
-          results.push({ rows: rowValues[0] });
-        }
-        results.push({ rows: rowValues });
-      }
-      return results;
-    }
-  );
-  applyTransactionNotSupported(db);
-  return db;
-}
-const errorSchema = z.object({
-  success: z.boolean(),
-  error: z.object({
-    code: z.string(),
-    details: z.string().optional()
-  })
-});
-const KNOWN_ERROR_CODES = {
-  SQL_QUERY_FAILED: "SQL_QUERY_FAILED"
-};
-const getUnexpectedResponseMessage = async (response) => `Unexpected response from remote database:
-(Status ${response.status}) ${await response.clone().text()}`;
-async function parseRemoteError(response) {
-  let error;
-  try {
-    error = errorSchema.parse(await response.clone().json()).error;
-  } catch {
-    return new DetailedLibsqlError({
-      message: await getUnexpectedResponseMessage(response),
-      code: KNOWN_ERROR_CODES.SQL_QUERY_FAILED
-    });
-  }
-  let baseDetails = error.details?.replace(/.*SQLite error: /, "") ?? "Error querying remote database.";
-  const details = baseDetails.slice(baseDetails.indexOf(":") + 1).trim();
-  let hint = `See the Astro DB guide for query and push instructions: https://docs.astro.build/en/guides/astro-db/#query-your-database`;
-  if (error.code === KNOWN_ERROR_CODES.SQL_QUERY_FAILED && details.includes("no such table")) {
-    hint = `Did you run \`astro db push\` to push your latest table schemas?`;
-  }
-  return new DetailedLibsqlError({ message: details, code: error.code, hint });
-}
 export {
   createLocalDatabaseClient,
   createRemoteDatabaseClient,

package/dist/runtime/index.d.ts

@@ -2,8 +2,8 @@ import { type ColumnDataType } from 'drizzle-orm';
 import type { LibSQLDatabase } from 'drizzle-orm/libsql';
 import type { DBColumn, DBTable } from '../core/types.js';
 export type Database = LibSQLDatabase;
+export { createLocalDatabaseClient, createRemoteDatabaseClient } from './db-client.js';
 export type { Table } from './types.js';
-export { createRemoteDatabaseClient, createLocalDatabaseClient } from './db-client.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

@@ -8,7 +8,7 @@ import {
 } from "drizzle-orm/sqlite-core";
 import { isSerializedSQL } from "./types.js";
 import { pathToFileURL } from "./utils.js";
-import { createRemoteDatabaseClient, createLocalDatabaseClient } from "./db-client.js";
+import { createLocalDatabaseClient, createRemoteDatabaseClient } from "./db-client.js";
 function hasPrimaryKey(column) {
   return "primaryKey" in column.schema && !!column.schema.primaryKey;
 }

package/dist/runtime/utils.d.ts

@@ -1,22 +1,7 @@
 import { LibsqlError } from '@libsql/client';
 import { AstroError } from 'astro/errors';
-/**
- * Small wrapper around fetch that throws an error if the response is not OK. Allows for custom error handling as well through the onNotOK callback.
- */
-export declare function safeFetch(url: Parameters<typeof fetch>[0], options?: Parameters<typeof fetch>[1], onNotOK?: (response: Response) => void | Promise<void>): Promise<Response>;
 export declare class AstroDbError extends AstroError {
     name: string;
 }
-export declare class DetailedLibsqlError extends LibsqlError {
-    name: string;
-    hint?: string;
-    constructor({ message, code, hint, rawCode, cause, }: {
-        message: string;
-        code: string;
-        hint?: string;
-        rawCode?: number;
-        cause?: Error;
-    });
-}
 export declare function isDbError(err: unknown): err is LibsqlError;
 export declare function pathToFileURL(path: string): URL;

package/dist/runtime/utils.js

@@ -1,32 +1,9 @@
 import { LibsqlError } from "@libsql/client";
 import { AstroError } from "astro/errors";
 const isWindows = process?.platform === "win32";
-async function safeFetch(url, options = {}, onNotOK = () => {
-  throw new Error(`Request to ${url} returned a non-OK status code.`);
-}) {
-  const response = await fetch(url, options);
-  if (!response.ok) {
-    await onNotOK(response);
-  }
-  return response;
-}
 class AstroDbError extends AstroError {
   name = "Astro DB Error";
 }
-class DetailedLibsqlError extends LibsqlError {
-  name = "Astro DB Error";
-  hint;
-  constructor({
-    message,
-    code,
-    hint,
-    rawCode,
-    cause
-  }) {
-    super(message, code, rawCode, cause);
-    this.hint = hint;
-  }
-}
 function isDbError(err) {
   return err instanceof LibsqlError || err instanceof Error && err.libsqlError === true;
 }
@@ -49,8 +26,6 @@ function pathToFileURL(path) {
 }
 export {
   AstroDbError,
-  DetailedLibsqlError,
   isDbError,
-  pathToFileURL,
-  safeFetch
+  pathToFileURL
 };

package/dist/runtime/virtual.js

@@ -35,37 +35,37 @@ const NOW = _sql`CURRENT_TIMESTAMP`;
 const TRUE = _sql`TRUE`;
 const FALSE = _sql`FALSE`;
 import {
-  sql,
+  and,
+  asc,
+  avg,
+  avgDistinct,
+  between,
+  count,
+  countDistinct,
+  desc,
   eq,
+  exists,
   gt,
   gte,
+  ilike,
+  inArray,
+  isNotNull,
+  isNull,
+  like,
   lt,
   lte,
+  max,
+  min,
   ne,
-  isNull,
-  isNotNull,
-  inArray,
-  notInArray,
-  exists,
-  notExists,
-  between,
+  not,
   notBetween,
-  like,
-  ilike,
+  notExists,
   notIlike,
-  not,
-  asc,
-  desc,
-  and,
+  notInArray,
   or,
-  count,
-  countDistinct,
-  avg,
-  avgDistinct,
+  sql,
   sum,
-  sumDistinct,
-  max,
-  min
+  sumDistinct
 } from "drizzle-orm";
 import { alias } from "drizzle-orm/sqlite-core";
 import { isDbError } from "./utils.js";

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@astrojs/db",
-  "version": "0.15.0",
-  "description": "Add libSQL and Astro Studio support to your Astro site",
+  "version": "0.16.0",
+  "description": "Add libSQL support to your Astro site",
   "license": "MIT",
   "repository": {
     "type": "git",
@@ -63,18 +63,13 @@
   ],
   "dependencies": {
     "@libsql/client": "^0.15.2",
-    "async-listen": "^3.1.0",
     "deep-diff": "^1.0.2",
     "drizzle-orm": "^0.42.0",
-    "github-slugger": "^2.0.0",
     "kleur": "^4.1.5",
     "nanoid": "^5.1.5",
-    "open": "^10.1.0",
     "prompts": "^2.4.2",
     "yargs-parser": "^21.1.1",
-    "yocto-spinner": "^0.2.1",
-    "zod": "^3.24.2",
-    "@astrojs/studio": "0.1.9"
+    "zod": "^3.24.4"
   },
   "devDependencies": {
     "@types/deep-diff": "^1.0.5",
@@ -83,7 +78,7 @@
     "cheerio": "1.0.0",
     "typescript": "^5.8.3",
     "vite": "^6.3.4",
-    "astro": "5.8.1",
+    "astro": "5.12.8",
     "astro-scripts": "0.0.14"
   },
   "scripts": {

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

@@ -1 +0,0 @@
-export declare function cmd(): Promise<void>;