@astrojs/db 0.4.1 → 0.6.0

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

@@ -1,48 +1,50 @@
-import * as color from "kleur/colors";
 import deepDiff from "deep-diff";
-import {
-  columnSchema
-} from "../types.js";
 import { SQLiteAsyncDialect } from "drizzle-orm/sqlite-core";
+import * as color from "kleur/colors";
 import { customAlphabet } from "nanoid";
-import prompts from "prompts";
+import { hasPrimaryKey } from "../../runtime/index.js";
 import {
   getCreateIndexQueries,
   getCreateTableQuery,
+  getDropTableIfExistsQuery,
   getModifiers,
   getReferencesConfig,
   hasDefault,
   schemaTypeToSqlType
-} from "../queries.js";
-import { hasPrimaryKey } from "../../runtime/index.js";
+} from "../../runtime/queries.js";
 import { isSerializedSQL } from "../../runtime/types.js";
+import { RENAME_COLUMN_ERROR, RENAME_TABLE_ERROR } from "../errors.js";
+import {
+  columnSchema
+} from "../types.js";
+import { getRemoteDatabaseUrl } from "../utils.js";
 const sqlite = new SQLiteAsyncDialect();
 const genTempTableName = customAlphabet("abcdefghijklmnopqrstuvwxyz", 10);
 async function getMigrationQueries({
   oldSnapshot,
-  newSnapshot,
-  ambiguityResponses
+  newSnapshot
 }) {
   const queries = [];
   const confirmations = [];
-  let added = getAddedCollections(oldSnapshot, newSnapshot);
-  let dropped = getDroppedCollections(oldSnapshot, newSnapshot);
-  if (!isEmpty(added) && !isEmpty(dropped)) {
-    const resolved = await resolveCollectionRenames(added, dropped, ambiguityResponses);
-    added = resolved.added;
-    dropped = resolved.dropped;
-    for (const { from, to } of resolved.renamed) {
-      const renameQuery = `ALTER TABLE ${sqlite.escapeName(from)} RENAME TO ${sqlite.escapeName(
-        to
-      )}`;
-      queries.push(renameQuery);
-    }
+  const addedCollections = getAddedCollections(oldSnapshot, newSnapshot);
+  const droppedTables = getDroppedCollections(oldSnapshot, newSnapshot);
+  const notDeprecatedDroppedTables = Object.fromEntries(
+    Object.entries(droppedTables).filter(([, table]) => !table.deprecated)
+  );
+  if (!isEmpty(addedCollections) && !isEmpty(notDeprecatedDroppedTables)) {
+    throw new Error(
+      RENAME_TABLE_ERROR(
+        Object.keys(addedCollections)[0],
+        Object.keys(notDeprecatedDroppedTables)[0]
+      )
+    );
   }
-  for (const [collectionName, collection] of Object.entries(added)) {
+  for (const [collectionName, collection] of Object.entries(addedCollections)) {
+    queries.push(getDropTableIfExistsQuery(collectionName));
     queries.push(getCreateTableQuery(collectionName, collection));
     queries.push(...getCreateIndexQueries(collectionName, collection));
   }
-  for (const [collectionName] of Object.entries(dropped)) {
+  for (const [collectionName] of Object.entries(droppedTables)) {
     const dropQuery = `DROP TABLE ${sqlite.escapeName(collectionName)}`;
     queries.push(dropQuery);
   }
@@ -50,6 +52,19 @@ async function getMigrationQueries({
     const oldCollection = oldSnapshot.schema[collectionName];
     if (!oldCollection)
       continue;
+    const addedColumns = getAdded(oldCollection.columns, newCollection.columns);
+    const droppedColumns = getDropped(oldCollection.columns, newCollection.columns);
+    const notDeprecatedDroppedColumns = Object.fromEntries(
+      Object.entries(droppedColumns).filter(([key, col]) => !col.schema.deprecated)
+    );
+    if (!isEmpty(addedColumns) && !isEmpty(notDeprecatedDroppedColumns)) {
+      throw new Error(
+        RENAME_COLUMN_ERROR(
+          `${collectionName}.${Object.keys(addedColumns)[0]}`,
+          `${collectionName}.${Object.keys(notDeprecatedDroppedColumns)[0]}`
+        )
+      );
+    }
     const result = await getCollectionChangeQueries({
       collectionName,
       oldCollection,
@@ -63,14 +78,13 @@ async function getMigrationQueries({
 async function getCollectionChangeQueries({
   collectionName,
   oldCollection,
-  newCollection,
-  ambiguityResponses
+  newCollection
 }) {
   const queries = [];
   const confirmations = [];
   const updated = getUpdatedColumns(oldCollection.columns, newCollection.columns);
-  let added = getAdded(oldCollection.columns, newCollection.columns);
-  let dropped = getDropped(oldCollection.columns, newCollection.columns);
+  const added = getAdded(oldCollection.columns, newCollection.columns);
+  const dropped = getDropped(oldCollection.columns, newCollection.columns);
   const hasForeignKeyChanges = Boolean(
     deepDiff(oldCollection.foreignKeys, newCollection.foreignKeys)
   );
@@ -84,12 +98,6 @@ async function getCollectionChangeQueries({
       confirmations
     };
   }
-  if (!hasForeignKeyChanges && !isEmpty(added) && !isEmpty(dropped)) {
-    const resolved = await resolveColumnRenames(collectionName, added, dropped, ambiguityResponses);
-    added = resolved.added;
-    dropped = resolved.dropped;
-    queries.push(...getColumnRenameQueries(collectionName, resolved.renamed));
-  }
   if (!hasForeignKeyChanges && isEmpty(updated) && Object.values(dropped).every(canAlterTableDropColumn) && Object.values(added).every(canAlterTableAddColumn)) {
     queries.push(
       ...getAlterTableQueries(collectionName, added, dropped),
@@ -158,82 +166,6 @@ function getChangeIndexQueries({
   queries.push(...getCreateIndexQueries(collectionName, { indexes: added }));
   return queries;
 }
-async function resolveColumnRenames(collectionName, mightAdd, mightDrop, ambiguityResponses) {
-  const added = {};
-  const dropped = {};
-  const renamed = [];
-  for (const [columnName, column] of Object.entries(mightAdd)) {
-    let oldColumnName = ambiguityResponses ? ambiguityResponses.columnRenames[collectionName]?.[columnName] ?? "__NEW__" : void 0;
-    if (!oldColumnName) {
-      const res = await prompts(
-        {
-          type: "select",
-          name: "columnName",
-          message: "New column " + color.blue(color.bold(`${collectionName}.${columnName}`)) + " detected. Was this renamed from an existing column?",
-          choices: [
-            { title: "New column (not renamed from existing)", value: "__NEW__" },
-            ...Object.keys(mightDrop).filter((key) => !(key in renamed)).map((key) => ({ title: key, value: key }))
-          ]
-        },
-        {
-          onCancel: () => {
-            process.exit(1);
-          }
-        }
-      );
-      oldColumnName = res.columnName;
-    }
-    if (oldColumnName === "__NEW__") {
-      added[columnName] = column;
-    } else {
-      renamed.push({ from: oldColumnName, to: columnName });
-    }
-  }
-  for (const [droppedColumnName, droppedColumn] of Object.entries(mightDrop)) {
-    if (!renamed.find((r) => r.from === droppedColumnName)) {
-      dropped[droppedColumnName] = droppedColumn;
-    }
-  }
-  return { added, dropped, renamed };
-}
-async function resolveCollectionRenames(mightAdd, mightDrop, ambiguityResponses) {
-  const added = {};
-  const dropped = {};
-  const renamed = [];
-  for (const [collectionName, collection] of Object.entries(mightAdd)) {
-    let oldCollectionName = ambiguityResponses ? ambiguityResponses.collectionRenames[collectionName] ?? "__NEW__" : void 0;
-    if (!oldCollectionName) {
-      const res = await prompts(
-        {
-          type: "select",
-          name: "collectionName",
-          message: "New collection " + color.blue(color.bold(collectionName)) + " detected. Was this renamed from an existing collection?",
-          choices: [
-            { title: "New collection (not renamed from existing)", value: "__NEW__" },
-            ...Object.keys(mightDrop).filter((key) => !(key in renamed)).map((key) => ({ title: key, value: key }))
-          ]
-        },
-        {
-          onCancel: () => {
-            process.exit(1);
-          }
-        }
-      );
-      oldCollectionName = res.collectionName;
-    }
-    if (oldCollectionName === "__NEW__") {
-      added[collectionName] = collection;
-    } else {
-      renamed.push({ from: oldCollectionName, to: collectionName });
-    }
-  }
-  for (const [droppedCollectionName, droppedCollection] of Object.entries(mightDrop)) {
-    if (!renamed.find((r) => r.from === droppedCollectionName)) {
-      dropped[droppedCollectionName] = droppedCollection;
-    }
-  }
-  return { added, dropped, renamed };
-}
 function getAddedCollections(oldCollections, newCollections) {
   const added = {};
   for (const [key, newCollection] of Object.entries(newCollections.schema)) {
@@ -250,17 +182,6 @@ function getDroppedCollections(oldCollections, newCollections) {
   }
   return dropped;
 }
-function getColumnRenameQueries(unescapedCollectionName, renamed) {
-  const queries = [];
-  const collectionName = sqlite.escapeName(unescapedCollectionName);
-  for (const { from, to } of renamed) {
-    const q = `ALTER TABLE ${collectionName} RENAME COLUMN ${sqlite.escapeName(
-      from
-    )} TO ${sqlite.escapeName(to)}`;
-    queries.push(q);
-  }
-  return queries;
-}
 function getAlterTableQueries(unescapedCollectionName, added, dropped) {
   const queries = [];
   const collectionName = sqlite.escapeName(unescapedCollectionName);
@@ -412,7 +333,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());
+  const response = await fetch(url, {
+    method: "POST",
+    headers: new Headers({
+      Authorization: `Bearer ${appToken}`
+    })
+  });
+  const result = await response.json();
+  return result.data;
+}
+function createCurrentSnapshot({ tables = {} }) {
+  const schema = JSON.parse(JSON.stringify(tables));
+  return { experimentalVersion: 1, schema };
+}
+function createEmptySnapshot() {
+  return { experimentalVersion: 1, schema: {} };
+}
 export {
+  createCurrentSnapshot,
+  createEmptySnapshot,
   getCollectionChangeQueries,
-  getMigrationQueries
+  getMigrationQueries,
+  getProductionCurrentSnapshot
 };

package/dist/core/consts.d.ts

@@ -1,6 +1,8 @@
 export declare const PACKAGE_NAME: any;
 export declare const RUNTIME_IMPORT: string;
 export declare const RUNTIME_DRIZZLE_IMPORT: string;
+export declare const RUNTIME_CONFIG_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";
+export declare const CONFIG_FILE_NAMES: string[];

package/dist/core/consts.js

@@ -4,13 +4,17 @@ const PACKAGE_NAME = JSON.parse(
 ).name;
 const RUNTIME_IMPORT = JSON.stringify(`${PACKAGE_NAME}/runtime`);
 const RUNTIME_DRIZZLE_IMPORT = JSON.stringify(`${PACKAGE_NAME}/runtime/drizzle`);
+const RUNTIME_CONFIG_IMPORT = JSON.stringify(`${PACKAGE_NAME}/runtime/config`);
 const DB_TYPES_FILE = "db-types.d.ts";
 const VIRTUAL_MODULE_ID = "astro:db";
 const DB_PATH = ".astro/content.db";
+const CONFIG_FILE_NAMES = ["config.ts", "config.js", "config.mts", "config.mjs"];
 export {
+  CONFIG_FILE_NAMES,
   DB_PATH,
   DB_TYPES_FILE,
   PACKAGE_NAME,
+  RUNTIME_CONFIG_IMPORT,
   RUNTIME_DRIZZLE_IMPORT,
   RUNTIME_IMPORT,
   VIRTUAL_MODULE_ID

package/dist/core/errors.d.ts

@@ -1,9 +1,11 @@
 export declare const MISSING_SESSION_ID_ERROR: string;
 export declare const MISSING_PROJECT_ID_ERROR: string;
-export declare const STUDIO_CONFIG_MISSING_WRITABLE_TABLE_ERROR: (tableName: string) => string;
-export declare const UNSAFE_WRITABLE_WARNING: string;
-export declare const STUDIO_CONFIG_MISSING_CLI_ERROR: string;
-export declare const MIGRATIONS_NOT_INITIALIZED: string;
-export declare const SEED_WRITABLE_IN_PROD_ERROR: (tableName: string) => string;
-export declare const SEED_ERROR: (tableName: string, error: string) => string;
-export declare const SEED_EMPTY_ARRAY_ERROR: (tableName: string) => string;
+export declare const MISSING_EXECUTE_PATH_ERROR: string;
+export declare const RENAME_TABLE_ERROR: (oldTable: string, newTable: string) => string;
+export declare const RENAME_COLUMN_ERROR: (oldSelector: string, newSelector: string) => string;
+export declare const FILE_NOT_FOUND_ERROR: (path: string) => string;
+export declare const SEED_ERROR: (error: string) => string;
+export declare const REFERENCE_DNE_ERROR: (columnName: string) => string;
+export declare const FOREIGN_KEY_DNE_ERROR: (tableName: string) => string;
+export declare const FOREIGN_KEY_REFERENCES_LENGTH_ERROR: (tableName: string) => string;
+export declare const FOREIGN_KEY_REFERENCES_EMPTY_ERROR: (tableName: string) => string;

package/dist/core/errors.js

@@ -1,4 +1,4 @@
-import { cyan, bold, red, green, yellow } from "kleur/colors";
+import { bold, cyan, green, red, yellow } from "kleur/colors";
 const MISSING_SESSION_ID_ERROR = `${red("\u25B6 Login required!")}
 
   To authenticate with Astro Studio, run
@@ -9,56 +9,57 @@ const MISSING_PROJECT_ID_ERROR = `${red("\u25B6 Directory not linked.")}
   To link this directory to an Astro Studio project, run
   ${cyan("astro db link")}
 `;
-const STUDIO_CONFIG_MISSING_WRITABLE_TABLE_ERROR = (tableName) => `${red(
-  `\u25B6 Writable table ${bold(tableName)} requires Astro Studio or the ${yellow(
-    "unsafeWritable"
-  )} option.`
-)}
-
-  Visit ${cyan("https://astro.build/studio")} to create your account
-  and set ${green("studio: true")} in your astro.config.mjs file to enable Studio.
-`;
-const UNSAFE_WRITABLE_WARNING = `${yellow(
-  "unsafeWritable"
-)} option is enabled and you are using writable tables.
-  Redeploying your app may result in wiping away your database.
-	I hope you know what you are doing.
+const MISSING_EXECUTE_PATH_ERROR = `${red(
+  "\u25B6 No file path provided."
+)} Provide a path by running ${cyan("astro db execute <path>")}
 `;
-const STUDIO_CONFIG_MISSING_CLI_ERROR = `${red("\u25B6 This command requires Astro Studio.")}
-
-  Visit ${cyan("https://astro.build/studio")} to create your account
-  and set ${green("studio: true")} in your astro.config.mjs file to enable Studio.
+const RENAME_TABLE_ERROR = (oldTable, newTable) => {
+  return red("\u25B6 Potential table rename detected: " + oldTable + ", " + newTable) + `
+  You cannot add and remove tables in the same schema update batch.
+  To resolve, add a 'deprecated: true' flag to '${oldTable}' instead.`;
+};
+const RENAME_COLUMN_ERROR = (oldSelector, newSelector) => {
+  return red("\u25B6 Potential column rename detected: " + oldSelector + ", " + newSelector) + `
+  You cannot add and remove columns in the same table.
+  To resolve, add a 'deprecated: true' flag to '${oldSelector}' instead.`;
+};
+const FILE_NOT_FOUND_ERROR = (path) => `${red("\u25B6 File not found:")} ${bold(path)}
 `;
-const MIGRATIONS_NOT_INITIALIZED = `${yellow(
-  "\u25B6 No migrations found!"
-)}
+const SEED_ERROR = (error) => {
+  return `${red(`Error while seeding database:`)}
 
-  To scaffold your migrations folder, run
-  ${cyan("astro db sync")}
-`;
-const SEED_WRITABLE_IN_PROD_ERROR = (tableName) => {
-  return `${red(
-    `Writable tables should not be seeded in production with data().`
-  )} You can seed ${bold(
+${error}`;
+};
+const REFERENCE_DNE_ERROR = (columnName) => {
+  return `Column ${bold(
+    columnName
+  )} references a table that does not exist. Did you apply the referenced table to the \`tables\` object in your db config?`;
+};
+const FOREIGN_KEY_DNE_ERROR = (tableName) => {
+  return `Table ${bold(
     tableName
-  )} in development mode only using the "mode" flag. See the docs for more: https://www.notion.so/astroinc/astrojs-db-README-dcf6fa10de9a4f528be56cee96e8c054?pvs=4#278aed3fc37e4cec80240d1552ff6ac5`;
+  )} references a table that does not exist. Did you apply the referenced table to the \`tables\` object in your db config?`;
 };
-const SEED_ERROR = (tableName, error) => {
-  return `${red(`Error seeding table ${bold(tableName)}:`)}
-
-${error}`;
+const FOREIGN_KEY_REFERENCES_LENGTH_ERROR = (tableName) => {
+  return `Foreign key on ${bold(
+    tableName
+  )} is misconfigured. \`columns\` and \`references\` must be the same length.`;
 };
-const SEED_EMPTY_ARRAY_ERROR = (tableName) => {
-  return SEED_ERROR(tableName, `Empty array was passed. seed() must receive at least one value.`);
+const FOREIGN_KEY_REFERENCES_EMPTY_ERROR = (tableName) => {
+  return `Foreign key on ${bold(
+    tableName
+  )} is misconfigured. \`references\` array cannot be empty.`;
 };
 export {
-  MIGRATIONS_NOT_INITIALIZED,
+  FILE_NOT_FOUND_ERROR,
+  FOREIGN_KEY_DNE_ERROR,
+  FOREIGN_KEY_REFERENCES_EMPTY_ERROR,
+  FOREIGN_KEY_REFERENCES_LENGTH_ERROR,
+  MISSING_EXECUTE_PATH_ERROR,
   MISSING_PROJECT_ID_ERROR,
   MISSING_SESSION_ID_ERROR,
-  SEED_EMPTY_ARRAY_ERROR,
-  SEED_ERROR,
-  SEED_WRITABLE_IN_PROD_ERROR,
-  STUDIO_CONFIG_MISSING_CLI_ERROR,
-  STUDIO_CONFIG_MISSING_WRITABLE_TABLE_ERROR,
-  UNSAFE_WRITABLE_WARNING
+  REFERENCE_DNE_ERROR,
+  RENAME_COLUMN_ERROR,
+  RENAME_TABLE_ERROR,
+  SEED_ERROR
 };

package/dist/core/integration/file-url.js

@@ -1,6 +1,6 @@
 import fs from "node:fs";
-import { pathToFileURL } from "node:url";
 import path from "node:path";
+import { pathToFileURL } from "node:url";
 async function copyFile(toDir, fromUrl, toUrl) {
   await fs.promises.mkdir(toDir, { recursive: true });
   await fs.promises.rename(fromUrl, toUrl);
@@ -61,10 +61,7 @@ function fileURLIntegration() {
           }
           await Promise.all(unlinks);
           const assetDir = new URL(config.build.assets, config.outDir);
-          const assetFiles = await fs.promises.readdir(assetDir);
-          if (!assetFiles.length) {
-            await fs.promises.rmdir(assetDir);
-          }
+          await fs.promises.rmdir(assetDir).catch(() => []);
         } else {
           const moves = [];
           for (const fileName of fileNames) {

package/dist/core/integration/index.js

@@ -1,66 +1,27 @@
-var __knownSymbol = (name, symbol) => {
-  return (symbol = Symbol[name]) ? symbol : Symbol.for("Symbol." + name);
-};
-var __using = (stack, value, async) => {
-  if (value != null) {
-    if (typeof value !== "object" && typeof value !== "function")
-      throw TypeError("Object expected");
-    var dispose;
-    if (async)
-      dispose = value[__knownSymbol("asyncDispose")];
-    if (dispose === void 0)
-      dispose = value[__knownSymbol("dispose")];
-    if (typeof dispose !== "function")
-      throw TypeError("Object not disposable");
-    stack.push([async, dispose, value]);
-  } else if (async) {
-    stack.push([async]);
-  }
-  return value;
-};
-var __callDispose = (stack, error, hasError) => {
-  var E = typeof SuppressedError === "function" ? SuppressedError : function(e, s, m, _) {
-    return _ = Error(m), _.name = "SuppressedError", _.error = e, _.suppressed = s, _;
-  };
-  var fail = (e) => error = hasError ? new E(e, error, "An error was suppressed during disposal") : (hasError = true, e);
-  var next = (it) => {
-    while (it = stack.pop()) {
-      try {
-        var result = it[1] && it[1].call(it[2]);
-        if (it[0])
-          return Promise.resolve(result).then(next, (e) => (fail(e), next()));
-      } catch (e) {
-        fail(e);
-      }
-    }
-    if (hasError)
-      throw error;
-  };
-  return next();
-};
-import { vitePluginDb } from "./vite-plugin-db.js";
-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 { DB_PATH } from "../consts.js";
-import { createLocalDatabaseClient } from "../../runtime/db-client.js";
-import { astroConfigWithDbSchema } from "../types.js";
-import {} from "../utils.js";
-import { STUDIO_CONFIG_MISSING_WRITABLE_TABLE_ERROR, UNSAFE_WRITABLE_WARNING } from "../errors.js";
-import { errorMap } from "./error-map.js";
 import { dirname } from "path";
 import { fileURLToPath } from "url";
+import { mkdir, rm, writeFile } from "fs/promises";
 import { blue, yellow } from "kleur/colors";
-import { fileURLIntegration } from "./file-url.js";
-import { recreateTables, seedData } from "../queries.js";
+import { CONFIG_FILE_NAMES, DB_PATH } from "../consts.js";
+import { loadDbConfigFile } from "../load-file.js";
 import { getManagedAppTokenOrExit } from "../tokens.js";
+import { dbConfigSchema } from "../types.js";
+import { getDbDirectoryUrl } from "../utils.js";
+import { errorMap } from "./error-map.js";
+import { fileURLIntegration } from "./file-url.js";
+import { typegen } from "./typegen.js";
+import { vitePluginDb } from "./vite-plugin-db.js";
+import { vitePluginInjectEnvTs } from "./vite-plugin-inject-env-ts.js";
 function astroDBIntegration() {
-  let connectedToRemote = false;
+  let connectToStudio = false;
+  let configFileDependencies = [];
+  let root;
   let appToken;
-  let schemas = {
-    tables() {
-      throw new Error("tables not found");
+  let dbConfig;
+  let tables = {
+    get() {
+      throw new Error("[astro:db] INTERNAL Tables not loaded yet");
     }
   };
   let command;
@@ -69,24 +30,26 @@ function astroDBIntegration() {
     hooks: {
       "astro:config:setup": async ({ updateConfig, config, command: _command, logger }) => {
         command = _command;
-        if (_command === "preview")
+        root = config.root;
+        if (command === "preview")
           return;
         let dbPlugin = void 0;
-        const studio = config.db?.studio ?? false;
-        if (studio && command === "build" && process.env.ASTRO_DB_TEST_ENV !== "1") {
+        connectToStudio = command === "build";
+        if (connectToStudio) {
           appToken = await getManagedAppTokenOrExit();
-          connectedToRemote = true;
           dbPlugin = vitePluginDb({
-            connectToStudio: true,
+            connectToStudio,
             appToken: appToken.token,
-            schemas,
-            root: config.root
+            tables,
+            root: config.root,
+            srcDir: config.srcDir
           });
         } else {
           dbPlugin = vitePluginDb({
             connectToStudio: false,
-            schemas,
-            root: config.root
+            tables,
+            root: config.root,
+            srcDir: config.srcDir
           });
         }
         updateConfig({
@@ -96,63 +59,44 @@ function astroDBIntegration() {
           }
         });
       },
-      "astro:config:done": async ({ config, logger }) => {
-        const configWithDb = astroConfigWithDbSchema.parse(config, { errorMap });
-        const tables = configWithDb.db?.tables ?? {};
-        schemas.tables = () => tables;
-        const studio = configWithDb.db?.studio ?? false;
-        const unsafeWritable = Boolean(configWithDb.db?.unsafeWritable);
-        const foundWritableCollection = Object.entries(tables).find(([, c]) => c.writable);
-        const writableAllowed = studio || unsafeWritable;
-        if (!writableAllowed && foundWritableCollection) {
-          logger.error(STUDIO_CONFIG_MISSING_WRITABLE_TABLE_ERROR(foundWritableCollection[0]));
-          process.exit(1);
-        } else if (unsafeWritable && foundWritableCollection) {
-          logger.warn(UNSAFE_WRITABLE_WARNING);
-        }
-        if (!connectedToRemote) {
-          var _stack = [];
-          try {
-            const dbUrl = new URL(DB_PATH, config.root);
-            if (existsSync(dbUrl)) {
-              await rm(dbUrl);
-            }
-            await mkdir(dirname(fileURLToPath(dbUrl)), { recursive: true });
-            await writeFile(dbUrl, "");
-            const db = __using(_stack, await createLocalDatabaseClient({
-              tables,
-              dbUrl: dbUrl.toString(),
-              seeding: true
-            }));
-            await recreateTables({ db, tables });
-            if (configWithDb.db?.data) {
-              await seedData({
-                db,
-                data: configWithDb.db.data,
-                logger,
-                mode: command === "dev" ? "dev" : "build"
-              });
-            }
-            logger.debug("Database setup complete.");
-          } catch (_) {
-            var _error = _, _hasError = true;
-          } finally {
-            __callDispose(_stack, _error, _hasError);
+      "astro:config:done": async ({ config }) => {
+        const { mod, dependencies } = await loadDbConfigFile(config.root);
+        configFileDependencies = dependencies;
+        dbConfig = dbConfigSchema.parse(mod?.default ?? {}, {
+          errorMap
+        });
+        tables.get = () => dbConfig.tables ?? {};
+        if (!connectToStudio && !process.env.TEST_IN_MEMORY_DB) {
+          const dbUrl = new URL(DB_PATH, config.root);
+          if (existsSync(dbUrl)) {
+            await rm(dbUrl);
           }
+          await mkdir(dirname(fileURLToPath(dbUrl)), { recursive: true });
+          await writeFile(dbUrl, "");
         }
-        await typegen({ tables, root: config.root });
+        await typegen({ tables: tables.get() ?? {}, root: config.root });
       },
       "astro:server:start": async ({ logger }) => {
         setTimeout(() => {
           logger.info(
-            connectedToRemote ? "Connected to remote database." : "New local database created."
+            connectToStudio ? "Connected to remote database." : "New local database created."
           );
         }, 100);
       },
+      "astro:server:setup": async ({ server }) => {
+        const filesToWatch = [
+          ...CONFIG_FILE_NAMES.map((c) => new URL(c, getDbDirectoryUrl(root))),
+          ...configFileDependencies.map((c) => new URL(c, root))
+        ];
+        server.watcher.on("all", (event, relativeEntry) => {
+          const entry = new URL(relativeEntry, root);
+          if (filesToWatch.some((f) => entry.href === f.href)) {
+            server.restart();
+          }
+        });
+      },
       "astro:build:start": async ({ logger }) => {
-        logger.info(
-          "database: " + (connectedToRemote ? yellow("remote") : blue("local database."))
-        );
+        logger.info("database: " + (connectToStudio ? yellow("remote") : blue("local database.")));
       },
       "astro:build:done": async ({}) => {
         await appToken?.destroy();

package/dist/core/integration/typegen.js

@@ -18,21 +18,11 @@ ${Object.entries(tables).map(([name, collection]) => generateTableType(name, col
   await writeFile(new URL(DB_TYPES_FILE, dotAstroDir), content);
 }
 function generateTableType(name, collection) {
+  const sanitizedColumnsList = Object.entries(collection.columns).filter(([key, val]) => !val.schema.deprecated);
+  const sanitizedColumns = Object.fromEntries(sanitizedColumnsList);
   let tableType = `	export const ${name}: import(${RUNTIME_IMPORT}).Table<
 		${JSON.stringify(name)},
-		${JSON.stringify(
-    Object.fromEntries(
-      Object.entries(collection.columns).map(([columnName, column]) => [
-        columnName,
-        {
-          // Only select columns Drizzle needs for inference
-          type: column.type,
-          optional: column.schema.optional,
-          default: column.schema.default
-        }
-      ])
-    )
-  )}
+		${JSON.stringify(sanitizedColumns)}
 	>;`;
   return tableType;
 }