@astrojs/db 0.1.18 → 0.1.20

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

@@ -0,0 +1,6 @@
+import type { AstroConfig } from 'astro';
+import type { Arguments } from 'yargs-parser';
+export declare function cmd({ config, flags }: {
+    config: AstroConfig;
+    flags: Arguments;
+}): Promise<void>;

package/dist/{cli → core/cli}/commands/push/index.js

@@ -1,9 +1,7 @@
 import { createClient } from "@libsql/client";
 import deepDiff from "deep-diff";
-import { eq, sql } from "drizzle-orm";
-import { SQLiteAsyncDialect } from "drizzle-orm/sqlite-core";
-import { appTokenError } from "../../../errors.js";
 import { drizzle } from "drizzle-orm/sqlite-proxy";
+import { appTokenError } from "../../../errors.js";
 import {
   createCurrentSnapshot,
   createEmptySnapshot,
@@ -11,19 +9,11 @@ import {
   initializeFromMigrations,
   loadInitialSnapshot,
   loadMigration
-} from "../../../migrations.js";
-import {
-  STUDIO_ADMIN_TABLE_ROW_ID,
-  adminTable,
-  createRemoteDatabaseClient,
-  getAstroStudioEnv,
-  getRemoteDatabaseUrl,
-  migrationsTable
-} from "../../../utils.js";
-import { getMigrationQueries } from "../../queries.js";
-import { setupDbTables } from "../../../internal.js";
+} from "../../migrations.js";
+import { getAstroStudioEnv, getRemoteDatabaseUrl } from "../../../utils.js";
+import { getMigrationQueries } from "../../migration-queries.js";
+import { setupDbTables } from "../../../queries.js";
 const { diff } = deepDiff;
-const sqliteDialect = new SQLiteAsyncDialect();
 async function cmd({ config, flags }) {
   const isSeedData = flags.seed;
   const isDryRun = flags.dryRun;
@@ -45,20 +35,18 @@ async function cmd({ config, flags }) {
     console.error(appTokenError);
     process.exit(1);
   }
-  const db = createRemoteDatabaseClient(appToken);
-  await db.run(
-    sql`CREATE TABLE IF NOT EXISTS ReservedAstroStudioMigrations ( name TEXT PRIMARY KEY )`
-  );
-  const allRemoteMigrations = await db.select().from(migrationsTable);
   const allLocalMigrations = await getMigrations();
-  const missingMigrations = allLocalMigrations.filter((migration) => {
-    return !allRemoteMigrations.find((m) => m.name === migration);
+  const { data: missingMigrations } = await prepareMigrateQuery({
+    migrations: allLocalMigrations,
+    appToken
   });
   if (missingMigrations.length === 0) {
     console.info("No migrations to push! Your database is up to date!");
-  } else {
+    process.exit(0);
+  }
+  if (missingMigrations.length > 0) {
     console.log(`Pushing ${missingMigrations.length} migrations...`);
-    await pushSchema({ migrations: missingMigrations, appToken, isDryRun, db, currentSnapshot });
+    await pushSchema({ migrations: missingMigrations, appToken, isDryRun, currentSnapshot });
   }
   if (isSeedData) {
     console.info("Pushing data...");
@@ -70,7 +58,6 @@ async function pushSchema({
   migrations,
   appToken,
   isDryRun,
-  db,
   currentSnapshot
 }) {
   const initialSnapshot = migrations.find((m) => m === "0000_snapshot.json");
@@ -80,13 +67,10 @@ async function pushSchema({
     oldSnapshot: createEmptySnapshot(),
     newSnapshot: await loadInitialSnapshot()
   }) : [];
-  const missingMigrationBatch = missingMigrationContents.reduce((acc, curr) => {
+  const queries = missingMigrationContents.reduce((acc, curr) => {
     return [...acc, ...curr.db];
   }, initialMigrationBatch);
-  const queries = missingMigrationBatch.map((q) => sql.raw(q));
-  await runBatchQuery({ queries, appToken, isDryRun });
-  await db.insert(migrationsTable).values(migrations.map((m) => ({ name: m })));
-  await db.update(adminTable).set({ collections: JSON.stringify(currentSnapshot) }).where(eq(adminTable.id, STUDIO_ADMIN_TABLE_ROW_ID));
+  await runMigrateQuery({ queries, migrations, snapshot: currentSnapshot, appToken, isDryRun });
 }
 async function pushData({
   config,
@@ -131,21 +115,24 @@ async function pushData({
     body: JSON.stringify(queries)
   });
 }
-async function runBatchQuery({
-  queries: sqlQueries,
+async function runMigrateQuery({
+  queries,
+  migrations,
+  snapshot,
   appToken,
   isDryRun
 }) {
-  const queries = sqlQueries.map((q) => sqliteDialect.sqlToQuery(q));
-  const requestBody = queries.map((q) => ({
-    sql: q.sql,
-    args: q.params
-  }));
+  const requestBody = {
+    snapshot,
+    migrations,
+    sql: queries,
+    experimentalVersion: 1
+  };
   if (isDryRun) {
     console.info("[DRY RUN] Batch query:", JSON.stringify(requestBody, null, 2));
     return new Response(null, { status: 200 });
   }
-  const url = new URL("/db/query", getRemoteDatabaseUrl());
+  const url = new URL("/db/migrate/run", getRemoteDatabaseUrl());
   return await fetch(url, {
     method: "POST",
     headers: new Headers({
@@ -154,6 +141,24 @@ async function runBatchQuery({
     body: JSON.stringify(requestBody)
   });
 }
+async function prepareMigrateQuery({
+  migrations,
+  appToken
+}) {
+  const url = new URL("/db/migrate/prepare", getRemoteDatabaseUrl());
+  const requestBody = {
+    migrations,
+    experimentalVersion: 1
+  };
+  const result = await fetch(url, {
+    method: "POST",
+    headers: new Headers({
+      Authorization: `Bearer ${appToken}`
+    }),
+    body: JSON.stringify(requestBody)
+  });
+  return await result.json();
+}
 export {
   cmd
 };

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

@@ -0,0 +1,6 @@
+import type { AstroConfig } from 'astro';
+import type { Arguments } from 'yargs-parser';
+export declare function cmd({ flags }: {
+    config: AstroConfig;
+    flags: Arguments;
+}): Promise<void>;

package/dist/{cli → core/cli}/commands/shell/index.js

@@ -1,14 +1,15 @@
 import { sql } from "drizzle-orm";
 import { appTokenError } from "../../../errors.js";
-import { createRemoteDatabaseClient, getAstroStudioEnv } from "../../../utils.js";
-async function cmd({ config, flags }) {
+import { getAstroStudioEnv, getRemoteDatabaseUrl } from "../../../utils.js";
+import { createRemoteDatabaseClient } from "../../../../runtime/db-client.js";
+async function cmd({ flags }) {
   const query = flags.query;
   const appToken = flags.token ?? getAstroStudioEnv().ASTRO_STUDIO_APP_TOKEN;
   if (!appToken) {
     console.error(appTokenError);
     process.exit(1);
   }
-  const db = createRemoteDatabaseClient(appToken);
+  const db = createRemoteDatabaseClient(appToken, getRemoteDatabaseUrl());
   const result = await db.run(sql.raw(query));
   console.log(result);
 }

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

@@ -0,0 +1,6 @@
+import type { AstroConfig } from 'astro';
+import type { Arguments } from 'yargs-parser';
+export declare function cmd({ config }: {
+    config: AstroConfig;
+    flags: Arguments;
+}): Promise<void>;

package/dist/{cli → core/cli}/commands/sync/index.js

@@ -5,8 +5,8 @@ import {
   getMigrations,
   initializeFromMigrations,
   initializeMigrationsDirectory
-} from "../../../migrations.js";
-import { getMigrationQueries } from "../../queries.js";
+} from "../../migrations.js";
+import { getMigrationQueries } from "../../migration-queries.js";
 const { diff } = deepDiff;
 async function cmd({ config }) {
   const currentSnapshot = createCurrentSnapshot(config);

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

@@ -0,0 +1,6 @@
+import type { AstroConfig } from 'astro';
+import type { Arguments } from 'yargs-parser';
+export declare function cmd({ config }: {
+    config: AstroConfig;
+    flags: Arguments;
+}): Promise<void>;

package/dist/{cli → core/cli}/commands/verify/index.js

@@ -1,5 +1,5 @@
 import deepDiff from "deep-diff";
-import { getMigrations, initializeFromMigrations } from "../../../migrations.js";
+import { getMigrations, initializeFromMigrations } from "../../migrations.js";
 const { diff } = deepDiff;
 async function cmd({ config }) {
   const currentSnapshot = JSON.parse(JSON.stringify(config.db?.collections ?? {}));

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

@@ -0,0 +1,6 @@
+import type { AstroConfig } from 'astro';
+import type { Arguments } from 'yargs-parser';
+export declare function cli({ flags, config }: {
+    flags: Arguments;
+    config: AstroConfig;
+}): Promise<void>;

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

@@ -0,0 +1,18 @@
+import type { DBCollection, DBSnapshot } from '../types.js';
+interface PromptResponses {
+    allowDataLoss: boolean;
+    fieldRenames: Record<string, string | false>;
+    collectionRenames: Record<string, string | false>;
+}
+export declare function getMigrationQueries({ oldSnapshot, newSnapshot, promptResponses, }: {
+    oldSnapshot: DBSnapshot;
+    newSnapshot: DBSnapshot;
+    promptResponses?: PromptResponses;
+}): Promise<string[]>;
+export declare function getCollectionChangeQueries({ collectionName, oldCollection, newCollection, promptResponses, }: {
+    collectionName: string;
+    oldCollection: DBCollection;
+    newCollection: DBCollection;
+    promptResponses?: PromptResponses;
+}): Promise<string[]>;
+export {};

package/dist/{cli/queries.js → core/cli/migration-queries.js}

@@ -1,14 +1,16 @@
 import * as color from "kleur/colors";
+import deepDiff from "deep-diff";
 import { SQLiteAsyncDialect } from "drizzle-orm/sqlite-core";
 import { customAlphabet } from "nanoid";
 import prompts from "prompts";
 import {
+  getCreateIndexQueries,
   getCreateTableQuery,
   getModifiers,
   hasDefault,
-  hasPrimaryKey,
   schemaTypeToSqlType
-} from "../internal.js";
+} from "../queries.js";
+import { hasPrimaryKey } from "../../runtime/index.js";
 const sqlite = new SQLiteAsyncDialect();
 const genTempTableName = customAlphabet("abcdefghijklmnopqrstuvwxyz", 10);
 async function getMigrationQueries({
@@ -36,6 +38,7 @@ async function getMigrationQueries({
   }
   for (const [collectionName, collection] of Object.entries(added)) {
     queries.push(getCreateTableQuery(collectionName, collection));
+    queries.push(...getCreateIndexQueries(collectionName, collection));
   }
   for (const [collectionName] of Object.entries(dropped)) {
     const dropQuery = `DROP TABLE ${sqlite.escapeName(collectionName)}`;
@@ -63,10 +66,14 @@ async function getCollectionChangeQueries({
 }) {
   const queries = [];
   const updated = getUpdatedFields(oldCollection.fields, newCollection.fields);
-  let added = getAddedFields(oldCollection.fields, newCollection.fields);
-  let dropped = getDroppedFields(oldCollection.fields, newCollection.fields);
+  let added = getAdded(oldCollection.fields, newCollection.fields);
+  let dropped = getDropped(oldCollection.fields, newCollection.fields);
   if (isEmpty(updated) && isEmpty(added) && isEmpty(dropped)) {
-    return [];
+    return getChangeIndexQueries({
+      collectionName,
+      oldIndexes: oldCollection.indexes,
+      newIndexes: newCollection.indexes
+    });
   }
   if (!isEmpty(added) && !isEmpty(dropped)) {
     const resolved = await resolveFieldRenames(
@@ -80,7 +87,14 @@ async function getCollectionChangeQueries({
     queries.push(...getFieldRenameQueries(collectionName, resolved.renamed));
   }
   if (isEmpty(updated) && Object.values(dropped).every(canAlterTableDropColumn) && Object.values(added).every(canAlterTableAddColumn)) {
-    queries.push(...getAlterTableQueries(collectionName, added, dropped));
+    queries.push(
+      ...getAlterTableQueries(collectionName, added, dropped),
+      ...getChangeIndexQueries({
+        collectionName,
+        oldIndexes: oldCollection.indexes,
+        newIndexes: newCollection.indexes
+      })
+    );
     return queries;
   }
   const dataLossCheck = canRecreateTableWithoutDataLoss(added, updated);
@@ -117,7 +131,7 @@ async function getCollectionChangeQueries({
       allowDataLoss = !!res.allowDataLoss;
     }
     if (!allowDataLoss) {
-      console.log("Exiting without changes \u{1F44B}");
+      console.info("Exiting without changes \u{1F44B}");
       process.exit(0);
     }
   }
@@ -127,13 +141,31 @@ async function getCollectionChangeQueries({
     ([, field]) => hasPrimaryKey(field.old) || hasPrimaryKey(field.new)
   );
   const recreateTableQueries = getRecreateTableQueries({
-    unescapedCollectionName: collectionName,
+    collectionName,
     newCollection,
     added,
     hasDataLoss: dataLossCheck.dataLoss,
     migrateHiddenPrimaryKey: !addedPrimaryKey && !droppedPrimaryKey && !updatedPrimaryKey
   });
-  queries.push(...recreateTableQueries);
+  queries.push(...recreateTableQueries, ...getCreateIndexQueries(collectionName, newCollection));
+  return queries;
+}
+function getChangeIndexQueries({
+  collectionName,
+  oldIndexes = {},
+  newIndexes = {}
+}) {
+  const added = getAdded(oldIndexes, newIndexes);
+  const dropped = getDropped(oldIndexes, newIndexes);
+  const updated = getUpdated(oldIndexes, newIndexes);
+  Object.assign(dropped, updated);
+  Object.assign(added, updated);
+  const queries = [];
+  for (const indexName of Object.keys(dropped)) {
+    const dropQuery = `DROP INDEX ${sqlite.escapeName(indexName)}`;
+    queries.push(dropQuery);
+  }
+  queries.push(...getCreateIndexQueries(collectionName, { indexes: added }));
   return queries;
 }
 async function resolveFieldRenames(collectionName, mightAdd, mightDrop, renamePromptResponses) {
@@ -277,17 +309,20 @@ function getAlterTableQueries(unescapedCollectionName, added, dropped) {
   return queries;
 }
 function getRecreateTableQueries({
-  unescapedCollectionName,
+  collectionName: unescCollectionName,
   newCollection,
   added,
   hasDataLoss,
   migrateHiddenPrimaryKey
 }) {
-  const unescTempName = `${unescapedCollectionName}_${genTempTableName()}`;
+  const unescTempName = `${unescCollectionName}_${genTempTableName()}`;
   const tempName = sqlite.escapeName(unescTempName);
-  const collectionName = sqlite.escapeName(unescapedCollectionName);
+  const collectionName = sqlite.escapeName(unescCollectionName);
   if (hasDataLoss) {
-    return [`DROP TABLE ${collectionName}`, getCreateTableQuery(collectionName, newCollection)];
+    return [
+      `DROP TABLE ${collectionName}`,
+      getCreateTableQuery(unescCollectionName, newCollection)
+    ];
   }
   const newColumns = [...Object.keys(newCollection.fields)];
   if (migrateHiddenPrimaryKey) {
@@ -330,7 +365,7 @@ function canRecreateTableWithoutDataLoss(added, updated) {
     if (!a.optional && !hasDefault(a)) {
       return { dataLoss: true, fieldName, reason: "added-required" };
     }
-    if (a.unique) {
+    if (!a.optional && a.unique) {
       return { dataLoss: true, fieldName, reason: "added-unique" };
     }
   }
@@ -341,22 +376,33 @@ function canRecreateTableWithoutDataLoss(added, updated) {
   }
   return { dataLoss: false };
 }
-function getAddedFields(oldFields, newFields) {
+function getAdded(oldObj, newObj) {
   const added = {};
-  for (const [key, newField] of Object.entries(newFields)) {
-    if (!(key in oldFields))
-      added[key] = newField;
+  for (const [key, value] of Object.entries(newObj)) {
+    if (!(key in oldObj))
+      added[key] = value;
   }
   return added;
 }
-function getDroppedFields(oldFields, newFields) {
+function getDropped(oldObj, newObj) {
   const dropped = {};
-  for (const [key, oldField] of Object.entries(oldFields)) {
-    if (!(key in newFields))
-      dropped[key] = oldField;
+  for (const [key, value] of Object.entries(oldObj)) {
+    if (!(key in newObj))
+      dropped[key] = value;
   }
   return dropped;
 }
+function getUpdated(oldObj, newObj) {
+  const updated = {};
+  for (const [key, value] of Object.entries(newObj)) {
+    const oldValue = oldObj[key];
+    if (!oldValue)
+      continue;
+    if (deepDiff(oldValue, value))
+      updated[key] = value;
+  }
+  return updated;
+}
 function getUpdatedFields(oldFields, newFields) {
   const updated = {};
   for (const [key, newField] of Object.entries(newFields)) {

package/dist/core/cli/migrations.d.ts

@@ -0,0 +1,12 @@
+import type { DBSnapshot } from '../types.js';
+import type { AstroConfig } from 'astro';
+export declare function getMigrations(): Promise<string[]>;
+export declare function loadMigration(migration: string): Promise<{
+    diff: any[];
+    db: string[];
+}>;
+export declare function loadInitialSnapshot(): Promise<DBSnapshot>;
+export declare function initializeMigrationsDirectory(currentSnapshot: DBSnapshot): Promise<void>;
+export declare function initializeFromMigrations(allMigrationFiles: string[]): Promise<DBSnapshot>;
+export declare function createCurrentSnapshot(config: AstroConfig): DBSnapshot;
+export declare function createEmptySnapshot(): DBSnapshot;

package/dist/core/consts.d.ts

@@ -0,0 +1,6 @@
+export declare const PACKAGE_NAME: any;
+export declare const RUNTIME_IMPORT: string;
+export declare const RUNTIME_DRIZZLE_IMPORT: string;
+export declare const DB_TYPES_FILE = "db-types.d.ts";
+export declare const VIRTUAL_MODULE_ID = "astro:db";
+export declare const DB_PATH = ".astro/content.db";

package/dist/core/consts.js

@@ -0,0 +1,17 @@
+import { readFileSync } from "node:fs";
+const PACKAGE_NAME = JSON.parse(
+  readFileSync(new URL("../../package.json", import.meta.url), "utf8")
+).name;
+const RUNTIME_IMPORT = JSON.stringify(`${PACKAGE_NAME}/runtime`);
+const RUNTIME_DRIZZLE_IMPORT = JSON.stringify(`${PACKAGE_NAME}/runtime/drizzle`);
+const DB_TYPES_FILE = "db-types.d.ts";
+const VIRTUAL_MODULE_ID = "astro:db";
+const DB_PATH = ".astro/content.db";
+export {
+  DB_PATH,
+  DB_TYPES_FILE,
+  PACKAGE_NAME,
+  RUNTIME_DRIZZLE_IMPORT,
+  RUNTIME_IMPORT,
+  VIRTUAL_MODULE_ID
+};

package/dist/core/errors.d.ts

@@ -0,0 +1 @@
+export declare const appTokenError: string;

package/dist/core/errors.js

@@ -0,0 +1,7 @@
+import { red } from "kleur/colors";
+const appTokenError = `${red(
+  "\u26A0\uFE0F App token invalid or expired."
+)} Please generate a new one from your the Studio dashboard under project settings.`;
+export {
+  appTokenError
+};

package/dist/core/integration/error-map.d.ts

@@ -0,0 +1,6 @@
+/**
+ * This is a modified version of Astro's error map. source:
+ * https://github.com/withastro/astro/blob/main/packages/astro/src/content/error-map.ts
+ */
+import type { z } from 'astro/zod';
+export declare const errorMap: z.ZodErrorMap;

package/dist/core/integration/file-url.d.ts

@@ -0,0 +1,2 @@
+import type { AstroIntegration } from 'astro';
+export declare function fileURLIntegration(): AstroIntegration;

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

@@ -0,0 +1,2 @@
+import type { AstroIntegration } from 'astro';
+export declare function integration(): AstroIntegration[];

package/dist/{integration.js → core/integration/index.js}

@@ -3,16 +3,17 @@ import { vitePluginInjectEnvTs } from "./vite-plugin-inject-env-ts.js";
 import { typegen } from "./typegen.js";
 import { existsSync } from "fs";
 import { mkdir, rm, writeFile } from "fs/promises";
-import { getLocalDbUrl, DB_PATH } from "./consts.js";
-import { createLocalDatabaseClient, setupDbTables } from "./internal.js";
-import { astroConfigWithDbSchema } from "./config.js";
-import { getAstroStudioEnv } from "./utils.js";
-import { appTokenError } from "./errors.js";
+import { DB_PATH } from "../consts.js";
+import { createLocalDatabaseClient } from "../../runtime/db-client.js";
+import { astroConfigWithDbSchema } from "../types.js";
+import { getAstroStudioEnv } from "../utils.js";
+import { appTokenError } from "../errors.js";
 import { errorMap } from "./error-map.js";
 import { dirname } from "path";
 import { fileURLToPath } from "url";
 import { bold } from "kleur/colors";
-import { fileURLIntegration } from "./file-url-integration.js";
+import { fileURLIntegration } from "./file-url.js";
+import { setupDbTables } from "../queries.js";
 function astroDBIntegration() {
   return {
     name: "astro:db",
@@ -41,10 +42,10 @@ function astroDBIntegration() {
             connectToStudio: true,
             collections,
             appToken,
-            output: config.output
+            root: config.root
           });
         } else {
-          const dbUrl = getLocalDbUrl(config.root);
+          const dbUrl = new URL(DB_PATH, config.root);
           if (existsSync(dbUrl)) {
             await rm(dbUrl);
           }
@@ -52,7 +53,7 @@ function astroDBIntegration() {
           await writeFile(dbUrl, "");
           const db = await createLocalDatabaseClient({
             collections,
-            dbUrl: dbUrl.href,
+            dbUrl: dbUrl.toString(),
             seeding: true
           });
           await setupDbTables({
@@ -65,23 +66,28 @@ function astroDBIntegration() {
           logger.info("Collections set up \u{1F680}");
           dbPlugin = vitePluginDb({
             connectToStudio: false,
-            collections
+            collections,
+            root: config.root
           });
         }
         updateConfig({
           vite: {
             assetsInclude: [DB_PATH],
-            plugins: [dbPlugin, vitePluginInjectEnvTs(config), {
-              name: "my-plugin",
-              resolveId(id) {
-                if (id.endsWith("?server-path")) {
-                }
-              },
-              load(id) {
-                if (id.endsWith("?server-path")) {
+            plugins: [
+              dbPlugin,
+              vitePluginInjectEnvTs(config),
+              {
+                name: "my-plugin",
+                resolveId(id) {
+                  if (id.endsWith("?server-path")) {
+                  }
+                },
+                load(id) {
+                  if (id.endsWith("?server-path")) {
+                  }
                 }
               }
-            }]
+            ]
           }
         });
         await typegen({ collections, root: config.root });

package/dist/core/integration/load-astro-config.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Pulled from the mothership, Astro core ❤️
+ *
+ * @see https://github.com/withastro/astro/blob/main/packages/astro/src/core/config/config.ts#L121
+ */
+export declare function loadAstroConfig(root: string): Promise<Record<string, unknown>>;

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

@@ -0,0 +1,5 @@
+import type { DBCollections } from '../types.js';
+export declare function typegen({ collections, root }: {
+    collections: DBCollections;
+    root: URL;
+}): Promise<void>;

package/dist/{typegen.js → core/integration/typegen.js}

@@ -1,12 +1,12 @@
 import { existsSync } from "node:fs";
 import { mkdir, writeFile } from "node:fs/promises";
-import { DB_TYPES_FILE, DRIZZLE_MOD_IMPORT, INTERNAL_MOD_IMPORT } from "./consts.js";
+import { DB_TYPES_FILE, RUNTIME_DRIZZLE_IMPORT, RUNTIME_IMPORT } from "../consts.js";
 async function typegen({ collections, root }) {
   const content = `// This file is generated by \`studio sync\`
 declare module 'astro:db' {
-	export const db: import(${INTERNAL_MOD_IMPORT}).SqliteDB;
+	export const db: import(${RUNTIME_IMPORT}).SqliteDB;
 	export const dbUrl: string;
-	export * from ${DRIZZLE_MOD_IMPORT};
+	export * from ${RUNTIME_DRIZZLE_IMPORT};
 
 ${Object.entries(collections).map(([name, collection]) => generateTableType(name, collection)).join("\n")}
 }
@@ -18,7 +18,7 @@ ${Object.entries(collections).map(([name, collection]) => generateTableType(name
   await writeFile(new URL(DB_TYPES_FILE, dotAstroDir), content);
 }
 function generateTableType(name, collection) {
-  let tableType = `	export const ${name}: import(${INTERNAL_MOD_IMPORT}).Table<
+  let tableType = `	export const ${name}: import(${RUNTIME_IMPORT}).Table<
 		${JSON.stringify(name)},
 		${JSON.stringify(
     Object.fromEntries(

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

@@ -0,0 +1,20 @@
+import type { DBCollections } from '../types.js';
+import type { VitePlugin } from '../utils.js';
+export declare function vitePluginDb(params: {
+    connectToStudio: false;
+    collections: DBCollections;
+    root: URL;
+} | {
+    connectToStudio: true;
+    collections: DBCollections;
+    appToken: string;
+    root: URL;
+}): VitePlugin;
+export declare function getVirtualModContents({ collections, root }: {
+    collections: DBCollections;
+    root: URL;
+}): string;
+export declare function getStudioVirtualModContents({ collections, appToken, }: {
+    collections: DBCollections;
+    appToken: string;
+}): string;