@astrojs/db 0.4.1 → 0.6.0

package/dist/{core → runtime}/queries.js

@@ -1,127 +1,103 @@
-import {
-} from "../core/types.js";
-import { bold } from "kleur/colors";
-import { sql, getTableName } from "drizzle-orm";
+import { LibsqlError } from "@libsql/client";
+import { sql } from "drizzle-orm";
 import { SQLiteAsyncDialect } from "drizzle-orm/sqlite-core";
-import { hasPrimaryKey } from "../runtime/index.js";
-import { isSerializedSQL } from "../runtime/types.js";
-import { SEED_EMPTY_ARRAY_ERROR, SEED_ERROR, SEED_WRITABLE_IN_PROD_ERROR } from "./errors.js";
+import { bold } from "kleur/colors";
+import {
+  FOREIGN_KEY_DNE_ERROR,
+  FOREIGN_KEY_REFERENCES_EMPTY_ERROR,
+  FOREIGN_KEY_REFERENCES_LENGTH_ERROR,
+  REFERENCE_DNE_ERROR,
+  SEED_ERROR
+} from "../core/errors.js";
+import { hasPrimaryKey } from "./index.js";
+import { isSerializedSQL } from "./types.js";
 const sqlite = new SQLiteAsyncDialect();
-async function recreateTables({
-  db,
-  tables
-}) {
-  const setupQueries = [];
-  for (const [name, collection] of Object.entries(tables)) {
-    const dropQuery = sql.raw(`DROP TABLE IF EXISTS ${sqlite.escapeName(name)}`);
-    const createQuery = sql.raw(getCreateTableQuery(name, collection));
-    const indexQueries = getCreateIndexQueries(name, collection);
-    setupQueries.push(dropQuery, createQuery, ...indexQueries.map((s) => sql.raw(s)));
-  }
-  for (const q of setupQueries) {
-    await db.run(q);
-  }
-}
-async function seedData({
+const SEED_DEV_FILE_NAME = ["seed.ts", "seed.js", "seed.mjs", "seed.mts"];
+async function seedLocal({
   db,
-  data,
-  logger,
-  mode
+  tables,
+  // Glob all potential seed files to catch renames and deletions.
+  fileGlob
 }) {
-  const dataFns = Array.isArray(data) ? data : [data];
-  try {
-    for (const dataFn of dataFns) {
-      await dataFn({
-        seed: async (config, values) => {
-          seedErrorChecks(mode, config, values);
-          try {
-            await db.insert(config.table).values(values);
-          } catch (e) {
-            const msg = e instanceof Error ? e.message : String(e);
-            throw new Error(SEED_ERROR(getTableName(config.table), msg));
-          }
-        },
-        seedReturning: async (config, values) => {
-          seedErrorChecks(mode, config, values);
-          try {
-            let result = db.insert(config.table).values(values).returning();
-            if (!Array.isArray(values)) {
-              result = result.get();
-            }
-            return result;
-          } catch (e) {
-            const msg = e instanceof Error ? e.message : String(e);
-            throw new Error(SEED_ERROR(getTableName(config.table), msg));
-          }
-        },
-        db,
-        mode
+  await recreateTables({ db, tables });
+  for (const fileName of SEED_DEV_FILE_NAME) {
+    const key = Object.keys(fileGlob).find((f) => f.endsWith(fileName));
+    if (key) {
+      await fileGlob[key]().catch((e) => {
+        if (e instanceof LibsqlError) {
+          throw new Error(SEED_ERROR(e.message));
+        }
+        throw e;
       });
+      return;
     }
-  } catch (e) {
-    if (!(e instanceof Error))
-      throw e;
-    (logger ?? console).error(e.message);
   }
 }
-function seedErrorChecks(mode, { table, writable }, values) {
-  const tableName = getTableName(table);
-  if (writable && mode === "build" && process.env.ASTRO_DB_TEST_ENV !== "1") {
-    throw new Error(SEED_WRITABLE_IN_PROD_ERROR(tableName));
-  }
-  if (Array.isArray(values) && values.length === 0) {
-    throw new Error(SEED_EMPTY_ARRAY_ERROR(tableName));
+async function recreateTables({ db, tables }) {
+  const setupQueries = [];
+  for (const [name, table] of Object.entries(tables)) {
+    const dropQuery = sql.raw(`DROP TABLE IF EXISTS ${sqlite.escapeName(name)}`);
+    const createQuery = sql.raw(getCreateTableQuery(name, table));
+    const indexQueries = getCreateIndexQueries(name, table);
+    setupQueries.push(dropQuery, createQuery, ...indexQueries.map((s) => sql.raw(s)));
   }
+  await db.batch([
+    db.run(sql`pragma defer_foreign_keys=true;`),
+    ...setupQueries.map((q) => db.run(q))
+  ]);
 }
-function getCreateTableQuery(collectionName, collection) {
-  let query = `CREATE TABLE ${sqlite.escapeName(collectionName)} (`;
+function getDropTableIfExistsQuery(tableName) {
+  return `DROP TABLE IF EXISTS ${sqlite.escapeName(tableName)}`;
+}
+function getCreateTableQuery(tableName, table) {
+  let query = `CREATE TABLE ${sqlite.escapeName(tableName)} (`;
   const colQueries = [];
-  const colHasPrimaryKey = Object.entries(collection.columns).find(
+  const colHasPrimaryKey = Object.entries(table.columns).find(
     ([, column]) => hasPrimaryKey(column)
   );
   if (!colHasPrimaryKey) {
     colQueries.push("_id INTEGER PRIMARY KEY");
   }
-  for (const [columnName, column] of Object.entries(collection.columns)) {
+  for (const [columnName, column] of Object.entries(table.columns)) {
     const colQuery = `${sqlite.escapeName(columnName)} ${schemaTypeToSqlType(
       column.type
     )}${getModifiers(columnName, column)}`;
     colQueries.push(colQuery);
   }
-  colQueries.push(...getCreateForeignKeyQueries(collectionName, collection));
+  colQueries.push(...getCreateForeignKeyQueries(tableName, table));
   query += colQueries.join(", ") + ")";
   return query;
 }
-function getCreateIndexQueries(collectionName, collection) {
+function getCreateIndexQueries(tableName, table) {
   let queries = [];
-  for (const [indexName, indexProps] of Object.entries(collection.indexes ?? {})) {
+  for (const [indexName, indexProps] of Object.entries(table.indexes ?? {})) {
     const onColNames = asArray(indexProps.on);
     const onCols = onColNames.map((colName) => sqlite.escapeName(colName));
     const unique = indexProps.unique ? "UNIQUE " : "";
     const indexQuery = `CREATE ${unique}INDEX ${sqlite.escapeName(
       indexName
-    )} ON ${sqlite.escapeName(collectionName)} (${onCols.join(", ")})`;
+    )} ON ${sqlite.escapeName(tableName)} (${onCols.join(", ")})`;
     queries.push(indexQuery);
   }
   return queries;
 }
-function getCreateForeignKeyQueries(collectionName, collection) {
+function getCreateForeignKeyQueries(tableName, table) {
   let queries = [];
-  for (const foreignKey of collection.foreignKeys ?? []) {
+  for (const foreignKey of table.foreignKeys ?? []) {
     const columns = asArray(foreignKey.columns);
     const references = asArray(foreignKey.references);
     if (columns.length !== references.length) {
-      throw new Error(
-        `Foreign key on ${collectionName} is misconfigured. \`columns\` and \`references\` must be the same length.`
-      );
+      throw new Error(FOREIGN_KEY_REFERENCES_LENGTH_ERROR(tableName));
+    }
+    const firstReference = references[0];
+    if (!firstReference) {
+      throw new Error(FOREIGN_KEY_REFERENCES_EMPTY_ERROR(tableName));
     }
-    const referencedCollection = references[0]?.schema.collection;
-    if (!referencedCollection) {
-      throw new Error(
-        `Foreign key on ${collectionName} is misconfigured. \`references\` cannot be empty.`
-      );
+    const referencedTable = firstReference.schema.collection;
+    if (!referencedTable) {
+      throw new Error(FOREIGN_KEY_DNE_ERROR(tableName));
     }
-    const query = `FOREIGN KEY (${columns.map((f) => sqlite.escapeName(f)).join(", ")}) REFERENCES ${sqlite.escapeName(referencedCollection)}(${references.map((r) => sqlite.escapeName(r.schema.name)).join(", ")})`;
+    const query = `FOREIGN KEY (${columns.map((f) => sqlite.escapeName(f)).join(", ")}) REFERENCES ${sqlite.escapeName(referencedTable)}(${references.map((r) => sqlite.escapeName(r.schema.name)).join(", ")})`;
     queries.push(query);
   }
   return queries;
@@ -156,13 +132,11 @@ function getModifiers(columnName, column) {
   }
   const references = getReferencesConfig(column);
   if (references) {
-    const { collection, name } = references.schema;
-    if (!collection || !name) {
-      throw new Error(
-        `Column ${collection}.${name} references a collection that does not exist. Did you apply the referenced collection to the \`tables\` object in your Astro config?`
-      );
+    const { collection: tableName, name } = references.schema;
+    if (!tableName || !name) {
+      throw new Error(REFERENCE_DNE_ERROR(columnName));
     }
-    modifiers += ` REFERENCES ${sqlite.escapeName(collection)} (${sqlite.escapeName(name)})`;
+    modifiers += ` REFERENCES ${sqlite.escapeName(tableName)} (${sqlite.escapeName(name)})`;
   }
   return modifiers;
 }
@@ -218,13 +192,15 @@ function getDefaultValueSql(columnName, column) {
   }
 }
 export {
+  SEED_DEV_FILE_NAME,
   getCreateForeignKeyQueries,
   getCreateIndexQueries,
   getCreateTableQuery,
+  getDropTableIfExistsQuery,
   getModifiers,
   getReferencesConfig,
   hasDefault,
   recreateTables,
   schemaTypeToSqlType,
-  seedData
+  seedLocal
 };

package/dist/runtime/types.d.ts

@@ -1,6 +1,6 @@
-import type { ColumnDataType, ColumnBaseConfig } from 'drizzle-orm';
+import type { ColumnBaseConfig, ColumnDataType } from 'drizzle-orm';
 import type { SQLiteColumn, SQLiteTableWithColumns } from 'drizzle-orm/sqlite-core';
-import type { DBColumn, ColumnsConfig } from '../core/types.js';
+import type { ColumnsConfig, DBColumn, OutputColumnsConfig } from '../core/types.js';
 type GeneratedConfig<T extends ColumnDataType = ColumnDataType> = Pick<ColumnBaseConfig<T, string>, 'name' | 'tableName' | 'notNull' | 'hasDefault'>;
 export type AstroText<T extends GeneratedConfig<'string'>> = SQLiteColumn<T & {
     data: string;
@@ -43,7 +43,7 @@ export type AstroJson<T extends GeneratedConfig<'custom'>> = SQLiteColumn<T & {
     baseColumn: never;
 }>;
 export type Column<T extends DBColumn['type'], S extends GeneratedConfig> = T extends 'boolean' ? AstroBoolean<S> : T extends 'number' ? AstroNumber<S> : T extends 'text' ? AstroText<S> : T extends 'date' ? AstroDate<S> : T extends 'json' ? AstroJson<S> : never;
-export type Table<TTableName extends string, TColumns extends ColumnsConfig> = SQLiteTableWithColumns<{
+export type Table<TTableName extends string, TColumns extends OutputColumnsConfig | ColumnsConfig> = SQLiteTableWithColumns<{
     name: TTableName;
     schema: undefined;
     dialect: 'sqlite';

package/dist/utils.d.ts

@@ -0,0 +1 @@
+export { asDrizzleTable } from './runtime/index.js';

package/dist/utils.js

@@ -0,0 +1,4 @@
+import { asDrizzleTable } from "./runtime/index.js";
+export {
+  asDrizzleTable
+};

package/index.d.ts

@@ -1,3 +1,5 @@
-/// <reference types="./config-augment.d.ts" />
-export * from './dist/index.js';
-export { default } from './dist/index.js';
+export { default, cli } from './dist/index.js';
+
+declare module 'astro:db' {
+	export { defineTable, defineDB, column, sql, NOW, TRUE, FALSE } from './dist/index.js';
+}

package/package.json

@@ -1,17 +1,21 @@
 {
   "name": "@astrojs/db",
-  "version": "0.4.1",
+  "version": "0.6.0",
   "description": "",
   "license": "MIT",
   "type": "module",
-  "types": "./index.d.ts",
+  "types": "./dist/index.d.ts",
   "author": "withastro",
   "main": "./dist/index.js",
   "exports": {
     ".": {
-      "types": "./index.d.ts",
+      "types": "./dist/index.d.ts",
       "import": "./dist/index.js"
     },
+    "./utils": {
+      "types": "./dist/utils.d.ts",
+      "import": "./dist/utils.js"
+    },
     "./runtime": {
       "types": "./dist/runtime/index.d.ts",
       "import": "./dist/runtime/index.js"
@@ -20,6 +24,10 @@
       "types": "./dist/runtime/drizzle.d.ts",
       "import": "./dist/runtime/drizzle.js"
     },
+    "./runtime/config": {
+      "types": "./dist/runtime/config.d.ts",
+      "import": "./dist/runtime/config.js"
+    },
     "./package.json": "./package.json"
   },
   "typesVersions": {
@@ -27,11 +35,17 @@
       ".": [
         "./index.d.ts"
       ],
+      "utils": [
+        "./dist/utils.d.ts"
+      ],
       "runtime": [
         "./dist/runtime/index.d.ts"
       ],
       "runtime/drizzle": [
         "./dist/runtime/drizzle.d.ts"
+      ],
+      "runtime/config": [
+        "./dist/runtime/config.d.ts"
       ]
     }
   },
@@ -46,6 +60,7 @@
   ],
   "dependencies": {
     "@libsql/client": "^0.4.3",
+    "async-listen": "^3.0.1",
     "deep-diff": "^1.0.2",
     "drizzle-orm": "^0.28.6",
     "kleur": "^4.1.5",
@@ -67,8 +82,8 @@
     "cheerio": "1.0.0-rc.12",
     "mocha": "^10.2.0",
     "typescript": "^5.2.2",
-    "vite": "^4.4.11",
-    "astro": "4.4.5",
+    "vite": "^5.1.4",
+    "astro": "4.4.10",
     "astro-scripts": "0.0.14"
   },
   "scripts": {

package/config-augment.d.ts

@@ -1,4 +0,0 @@
-declare namespace Config {
-	type DBUserConfig = import('./dist/core/types.js').DBUserConfig;
-	export interface Database extends DBUserConfig {}
-}

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

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

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

@@ -1,39 +0,0 @@
-import { writeFile } from "node:fs/promises";
-import {
-  MIGRATIONS_CREATED,
-  MIGRATIONS_UP_TO_DATE,
-  getMigrationStatus,
-  initializeMigrationsDirectory
-} from "../../migrations.js";
-import { getMigrationQueries } from "../../migration-queries.js";
-import { bgRed, red, reset } from "kleur/colors";
-async function cmd({ config }) {
-  const migration = await getMigrationStatus(config);
-  if (migration.state === "no-migrations-found") {
-    await initializeMigrationsDirectory(migration.currentSnapshot);
-    console.log(MIGRATIONS_CREATED);
-    return;
-  } else if (migration.state === "up-to-date") {
-    console.log(MIGRATIONS_UP_TO_DATE);
-    return;
-  }
-  const { oldSnapshot, newSnapshot, newFilename, diff } = migration;
-  const { queries: migrationQueries, confirmations } = await getMigrationQueries({
-    oldSnapshot,
-    newSnapshot
-  });
-  confirmations.map((message) => console.log(bgRed(" !!! ") + " " + red(message)));
-  const migrationFileContent = {
-    diff,
-    db: migrationQueries,
-    // TODO(fks): Encode the relevant data, instead of the raw message.
-    // This will give `db push` more control over the formatting of the message.
-    confirm: confirmations.map((c) => reset(c))
-  };
-  const migrationFileName = `./migrations/${newFilename}`;
-  await writeFile(migrationFileName, JSON.stringify(migrationFileContent, void 0, 2));
-  console.log(migrationFileName + " created!");
-}
-export {
-  cmd
-};

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

@@ -1,34 +0,0 @@
-import deepDiff from 'deep-diff';
-import { type DBSnapshot } from '../types.js';
-import type { AstroConfig } from 'astro';
-export type MigrationStatus = {
-    state: 'no-migrations-found';
-    currentSnapshot: DBSnapshot;
-} | {
-    state: 'ahead';
-    oldSnapshot: DBSnapshot;
-    newSnapshot: DBSnapshot;
-    diff: deepDiff.Diff<DBSnapshot, DBSnapshot>[];
-    newFilename: string;
-    summary: string;
-    newFileContent?: string;
-} | {
-    state: 'up-to-date';
-    currentSnapshot: DBSnapshot;
-};
-export declare function getMigrationStatus(config: AstroConfig): Promise<MigrationStatus>;
-export declare const MIGRATIONS_CREATED: string;
-export declare const MIGRATIONS_UP_TO_DATE: string;
-export declare const MIGRATIONS_NOT_INITIALIZED: string;
-export declare const MIGRATION_NEEDED: string;
-export declare function getMigrations(): Promise<string[]>;
-export declare function loadMigration(migration: string): Promise<{
-    diff: any[];
-    db: string[];
-    confirm?: 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/cli/migrations.js

@@ -1,129 +0,0 @@
-import deepDiff from "deep-diff";
-import { mkdir, readFile, readdir, writeFile } from "fs/promises";
-import { tablesSchema } from "../types.js";
-import { cyan, green, yellow } from "kleur/colors";
-const { applyChange, diff: generateDiff } = deepDiff;
-async function getMigrationStatus(config) {
-  const currentSnapshot = createCurrentSnapshot(config);
-  const allMigrationFiles = await getMigrations();
-  if (allMigrationFiles.length === 0) {
-    return {
-      state: "no-migrations-found",
-      currentSnapshot
-    };
-  }
-  const previousSnapshot = await initializeFromMigrations(allMigrationFiles);
-  const diff = generateDiff(previousSnapshot, currentSnapshot);
-  if (diff) {
-    const n = getNewMigrationNumber(allMigrationFiles);
-    const newFilename = `${String(n + 1).padStart(4, "0")}_migration.json`;
-    return {
-      state: "ahead",
-      oldSnapshot: previousSnapshot,
-      newSnapshot: currentSnapshot,
-      diff,
-      newFilename,
-      summary: generateDiffSummary(diff)
-    };
-  }
-  return {
-    state: "up-to-date",
-    currentSnapshot
-  };
-}
-const MIGRATIONS_CREATED = `${green(
-  "\u25A0 Migrations initialized!"
-)}
-
-  To execute your migrations, run
-  ${cyan("astro db push")}`;
-const MIGRATIONS_UP_TO_DATE = `${green(
-  "\u25A0 No migrations needed!"
-)}
-
-  Your database is up to date.
-`;
-const MIGRATIONS_NOT_INITIALIZED = `${yellow(
-  "\u25B6 No migrations found!"
-)}
-
-  To scaffold your migrations folder, run
-  ${cyan("astro db sync")}
-`;
-const MIGRATION_NEEDED = `${yellow(
-  "\u25B6 Changes detected!"
-)}
-
-  To create the necessary migration file, run
-  ${cyan("astro db sync")}
-`;
-function generateDiffSummary(diff) {
-  return JSON.stringify(diff, null, 2);
-}
-function getNewMigrationNumber(allMigrationFiles) {
-  const len = allMigrationFiles.length - 1;
-  return allMigrationFiles.reduce((acc, curr) => {
-    const num = Number.parseInt(curr.split("_")[0] ?? len, 10);
-    return num > acc ? num : acc;
-  }, 0);
-}
-async function getMigrations() {
-  const migrationFiles = await readdir("./migrations").catch((err) => {
-    if (err.code === "ENOENT") {
-      return [];
-    }
-    throw err;
-  });
-  return migrationFiles;
-}
-async function loadMigration(migration) {
-  return JSON.parse(await readFile(`./migrations/${migration}`, "utf-8"));
-}
-async function loadInitialSnapshot() {
-  const snapshot = JSON.parse(await readFile("./migrations/0000_snapshot.json", "utf-8"));
-  if (snapshot.experimentalVersion === 1) {
-    return snapshot;
-  }
-  if (!snapshot.schema) {
-    return { experimentalVersion: 1, schema: snapshot };
-  }
-  throw new Error("Invalid snapshot format");
-}
-async function initializeMigrationsDirectory(currentSnapshot) {
-  await mkdir("./migrations", { recursive: true });
-  await writeFile("./migrations/0000_snapshot.json", JSON.stringify(currentSnapshot, void 0, 2));
-}
-async function initializeFromMigrations(allMigrationFiles) {
-  const prevSnapshot = await loadInitialSnapshot();
-  for (const migration of allMigrationFiles) {
-    if (migration === "0000_snapshot.json")
-      continue;
-    const migrationContent = await loadMigration(migration);
-    migrationContent.diff.forEach((change) => {
-      applyChange(prevSnapshot, {}, change);
-    });
-  }
-  return prevSnapshot;
-}
-function createCurrentSnapshot(config) {
-  const tablesConfig = tablesSchema.parse(config.db?.tables ?? {});
-  const schema = JSON.parse(JSON.stringify(tablesConfig));
-  return { experimentalVersion: 1, schema };
-}
-function createEmptySnapshot() {
-  return { experimentalVersion: 1, schema: {} };
-}
-export {
-  MIGRATIONS_CREATED,
-  MIGRATIONS_NOT_INITIALIZED,
-  MIGRATIONS_UP_TO_DATE,
-  MIGRATION_NEEDED,
-  createCurrentSnapshot,
-  createEmptySnapshot,
-  getMigrationStatus,
-  getMigrations,
-  initializeFromMigrations,
-  initializeMigrationsDirectory,
-  loadInitialSnapshot,
-  loadMigration
-};

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

@@ -1,6 +0,0 @@
-/**
- * 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/load-astro-config.js

@@ -1,79 +0,0 @@
-import fs from "node:fs";
-import path from "node:path";
-import { pathToFileURL } from "node:url";
-import { bold, red } from "kleur/colors";
-import { createServer } from "vite";
-async function loadAstroConfig(root) {
-  const configPath = search(root);
-  if (!configPath)
-    return {};
-  try {
-    return await loadConfigWithVite(configPath);
-  } catch (e) {
-    console.error(`${bold(red("[astro]"))} Unable to load Astro config.
-`);
-    throw e;
-  }
-}
-function search(root) {
-  const paths = [
-    "astro.config.mjs",
-    "astro.config.js",
-    "astro.config.ts",
-    "astro.config.mts",
-    "astro.config.cjs",
-    "astro.config.cts"
-  ].map((p) => path.join(root, p));
-  for (const file of paths) {
-    if (fs.existsSync(file)) {
-      return file;
-    }
-  }
-}
-async function loadConfigWithVite(configPath) {
-  if (/\.[cm]?js$/.test(configPath)) {
-    try {
-      const config = await import(
-        /* @vite-ignore */
-        pathToFileURL(configPath).toString() + "?t=" + Date.now()
-      );
-      return config.default ?? {};
-    } catch (e) {
-    }
-  }
-  let server;
-  try {
-    server = await createViteServer();
-    const mod = await server.ssrLoadModule(configPath, { fixStacktrace: true });
-    return mod.default ?? {};
-  } finally {
-    if (server) {
-      await server.close();
-    }
-  }
-}
-async function createViteServer() {
-  const viteServer = await createServer({
-    server: { middlewareMode: true, hmr: false, watch: { ignored: ["**"] } },
-    optimizeDeps: { disabled: true },
-    clearScreen: false,
-    appType: "custom",
-    ssr: {
-      // NOTE: Vite doesn't externalize linked packages by default. During testing locally,
-      // these dependencies trip up Vite's dev SSR transform. Awaiting upstream feature:
-      // https://github.com/vitejs/vite/pull/10939
-      external: [
-        "@astrojs/tailwind",
-        "@astrojs/mdx",
-        "@astrojs/react",
-        "@astrojs/preact",
-        "@astrojs/sitemap",
-        "@astrojs/markdoc"
-      ]
-    }
-  });
-  return viteServer;
-}
-export {
-  loadAstroConfig
-};