@astrojs/db 0.3.5 → 0.4.0

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

@@ -27,12 +27,16 @@ async function cmd({ flags }) {
   });
   if (!response.ok) {
     if (response.status === 401) {
-      console.error(`${bgRed("Unauthorized")}
+      console.error(
+        `${bgRed("Unauthorized")}
 
   Are you logged in?
-  Run ${cyan("astro db login")} to authenticate and then try linking again.
+  Run ${cyan(
+          "astro db login"
+        )} to authenticate and then try linking again.
 
-`);
+`
+      );
       process.exit(1);
     }
     console.error(`Failed to link project: ${response.status} ${response.statusText}`);

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

@@ -6,7 +6,7 @@ import { red } from "kleur/colors";
 import prompts from "prompts";
 import { recreateTables, seedData } from "../../../queries.js";
 import { getManagedAppTokenOrExit } from "../../../tokens.js";
-import { collectionsSchema } from "../../../types.js";
+import { tablesSchema } from "../../../types.js";
 import { getRemoteDatabaseUrl } from "../../../utils.js";
 import { getMigrationQueries } from "../../migration-queries.js";
 import {
@@ -112,9 +112,9 @@ async function pushData({
     const libsqlClient = createClient({ url: ":memory:" });
     await recreateTables({
       db: drizzleLibsql(libsqlClient),
-      collections: collectionsSchema.parse(config.db.collections ?? {})
+      tables: tablesSchema.parse(config.db.tables ?? {})
     });
-    for (const [collectionName, { writable }] of Object.entries(config.db.collections ?? {})) {
+    for (const [collectionName, { writable }] of Object.entries(config.db.tables ?? {})) {
       if (!writable) {
         queries.push({
           sql: `DELETE FROM ${sqlite.escapeName(collectionName)}`,

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

@@ -1,8 +1,8 @@
-import { type DBCollection, type DBSnapshot } from '../types.js';
+import { type DBTable, type DBSnapshot } from '../types.js';
 /** Dependency injected for unit testing */
 type AmbiguityResponses = {
     collectionRenames: Record<string, string>;
-    fieldRenames: {
+    columnRenames: {
         [collectionName: string]: Record<string, string>;
     };
 };
@@ -16,8 +16,8 @@ export declare function getMigrationQueries({ oldSnapshot, newSnapshot, ambiguit
 }>;
 export declare function getCollectionChangeQueries({ collectionName, oldCollection, newCollection, ambiguityResponses, }: {
     collectionName: string;
-    oldCollection: DBCollection;
-    newCollection: DBCollection;
+    oldCollection: DBTable;
+    newCollection: DBTable;
     ambiguityResponses?: AmbiguityResponses;
 }): Promise<{
     queries: string[];

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

@@ -1,7 +1,7 @@
 import * as color from "kleur/colors";
 import deepDiff from "deep-diff";
 import {
-  fieldSchema
+  columnSchema
 } from "../types.js";
 import { SQLiteAsyncDialect } from "drizzle-orm/sqlite-core";
 import { customAlphabet } from "nanoid";
@@ -68,9 +68,9 @@ async function getCollectionChangeQueries({
 }) {
   const queries = [];
   const confirmations = [];
-  const updated = getUpdatedFields(oldCollection.fields, newCollection.fields);
-  let added = getAdded(oldCollection.fields, newCollection.fields);
-  let dropped = getDropped(oldCollection.fields, newCollection.fields);
+  const updated = getUpdatedColumns(oldCollection.columns, newCollection.columns);
+  let added = getAdded(oldCollection.columns, newCollection.columns);
+  let dropped = getDropped(oldCollection.columns, newCollection.columns);
   const hasForeignKeyChanges = Boolean(
     deepDiff(oldCollection.foreignKeys, newCollection.foreignKeys)
   );
@@ -85,10 +85,10 @@ async function getCollectionChangeQueries({
     };
   }
   if (!hasForeignKeyChanges && !isEmpty(added) && !isEmpty(dropped)) {
-    const resolved = await resolveFieldRenames(collectionName, added, dropped, ambiguityResponses);
+    const resolved = await resolveColumnRenames(collectionName, added, dropped, ambiguityResponses);
     added = resolved.added;
     dropped = resolved.dropped;
-    queries.push(...getFieldRenameQueries(collectionName, resolved.renamed));
+    queries.push(...getColumnRenameQueries(collectionName, resolved.renamed));
   }
   if (!hasForeignKeyChanges && isEmpty(updated) && Object.values(dropped).every(canAlterTableDropColumn) && Object.values(added).every(canAlterTableAddColumn)) {
     queries.push(
@@ -103,33 +103,33 @@ async function getCollectionChangeQueries({
   }
   const dataLossCheck = canRecreateTableWithoutDataLoss(added, updated);
   if (dataLossCheck.dataLoss) {
-    const { reason, fieldName } = dataLossCheck;
+    const { reason, columnName } = dataLossCheck;
     const reasonMsgs = {
-      "added-required": `New field ${color.bold(
-        collectionName + "." + fieldName
+      "added-required": `New column ${color.bold(
+        collectionName + "." + columnName
       )} is required with no default value.
 This requires deleting existing data in the ${color.bold(
         collectionName
       )} collection.`,
-      "added-unique": `New field ${color.bold(
-        collectionName + "." + fieldName
+      "added-unique": `New column ${color.bold(
+        collectionName + "." + columnName
       )} is marked as unique.
 This requires deleting existing data in the ${color.bold(
         collectionName
       )} collection.`,
-      "updated-type": `Updated field ${color.bold(
-        collectionName + "." + fieldName
-      )} cannot convert data to new field data type.
+      "updated-type": `Updated column ${color.bold(
+        collectionName + "." + columnName
+      )} cannot convert data to new column data type.
 This requires deleting existing data in the ${color.bold(
         collectionName
       )} collection.`
     };
     confirmations.push(reasonMsgs[reason]);
   }
-  const primaryKeyExists = Object.entries(newCollection.fields).find(
-    ([, field]) => hasPrimaryKey(field)
+  const primaryKeyExists = Object.entries(newCollection.columns).find(
+    ([, column]) => hasPrimaryKey(column)
   );
-  const droppedPrimaryKey = Object.entries(dropped).find(([, field]) => hasPrimaryKey(field));
+  const droppedPrimaryKey = Object.entries(dropped).find(([, column]) => hasPrimaryKey(column));
   const recreateTableQueries = getRecreateTableQueries({
     collectionName,
     newCollection,
@@ -158,20 +158,20 @@ function getChangeIndexQueries({
   queries.push(...getCreateIndexQueries(collectionName, { indexes: added }));
   return queries;
 }
-async function resolveFieldRenames(collectionName, mightAdd, mightDrop, ambiguityResponses) {
+async function resolveColumnRenames(collectionName, mightAdd, mightDrop, ambiguityResponses) {
   const added = {};
   const dropped = {};
   const renamed = [];
-  for (const [fieldName, field] of Object.entries(mightAdd)) {
-    let oldFieldName = ambiguityResponses ? ambiguityResponses.fieldRenames[collectionName]?.[fieldName] ?? "__NEW__" : void 0;
-    if (!oldFieldName) {
+  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: "fieldName",
-          message: "New field " + color.blue(color.bold(`${collectionName}.${fieldName}`)) + " detected. Was this renamed from an existing field?",
+          name: "columnName",
+          message: "New column " + color.blue(color.bold(`${collectionName}.${columnName}`)) + " detected. Was this renamed from an existing column?",
           choices: [
-            { title: "New field (not renamed from existing)", value: "__NEW__" },
+            { title: "New column (not renamed from existing)", value: "__NEW__" },
             ...Object.keys(mightDrop).filter((key) => !(key in renamed)).map((key) => ({ title: key, value: key }))
           ]
         },
@@ -181,17 +181,17 @@ async function resolveFieldRenames(collectionName, mightAdd, mightDrop, ambiguit
           }
         }
       );
-      oldFieldName = res.fieldName;
+      oldColumnName = res.columnName;
     }
-    if (oldFieldName === "__NEW__") {
-      added[fieldName] = field;
+    if (oldColumnName === "__NEW__") {
+      added[columnName] = column;
     } else {
-      renamed.push({ from: oldFieldName, to: fieldName });
+      renamed.push({ from: oldColumnName, to: columnName });
     }
   }
-  for (const [droppedFieldName, droppedField] of Object.entries(mightDrop)) {
-    if (!renamed.find((r) => r.from === droppedFieldName)) {
-      dropped[droppedFieldName] = droppedField;
+  for (const [droppedColumnName, droppedColumn] of Object.entries(mightDrop)) {
+    if (!renamed.find((r) => r.from === droppedColumnName)) {
+      dropped[droppedColumnName] = droppedColumn;
     }
   }
   return { added, dropped, renamed };
@@ -250,7 +250,7 @@ function getDroppedCollections(oldCollections, newCollections) {
   }
   return dropped;
 }
-function getFieldRenameQueries(unescapedCollectionName, renamed) {
+function getColumnRenameQueries(unescapedCollectionName, renamed) {
   const queries = [];
   const collectionName = sqlite.escapeName(unescapedCollectionName);
   for (const { from, to } of renamed) {
@@ -264,18 +264,18 @@ function getFieldRenameQueries(unescapedCollectionName, renamed) {
 function getAlterTableQueries(unescapedCollectionName, added, dropped) {
   const queries = [];
   const collectionName = sqlite.escapeName(unescapedCollectionName);
-  for (const [unescFieldName, field] of Object.entries(added)) {
-    const fieldName = sqlite.escapeName(unescFieldName);
-    const type = schemaTypeToSqlType(field.type);
-    const q = `ALTER TABLE ${collectionName} ADD COLUMN ${fieldName} ${type}${getModifiers(
-      fieldName,
-      field
+  for (const [unescColumnName, column] of Object.entries(added)) {
+    const columnName = sqlite.escapeName(unescColumnName);
+    const type = schemaTypeToSqlType(column.type);
+    const q = `ALTER TABLE ${collectionName} ADD COLUMN ${columnName} ${type}${getModifiers(
+      columnName,
+      column
     )}`;
     queries.push(q);
   }
-  for (const unescFieldName of Object.keys(dropped)) {
-    const fieldName = sqlite.escapeName(unescFieldName);
-    const q = `ALTER TABLE ${collectionName} DROP COLUMN ${fieldName}`;
+  for (const unescColumnName of Object.keys(dropped)) {
+    const columnName = sqlite.escapeName(unescColumnName);
+    const q = `ALTER TABLE ${collectionName} DROP COLUMN ${columnName}`;
     queries.push(q);
   }
   return queries;
@@ -296,7 +296,7 @@ function getRecreateTableQueries({
       getCreateTableQuery(unescCollectionName, newCollection)
     ];
   }
-  const newColumns = [...Object.keys(newCollection.fields)];
+  const newColumns = [...Object.keys(newCollection.columns)];
   if (migrateHiddenPrimaryKey) {
     newColumns.unshift("_id");
   }
@@ -311,41 +311,41 @@ function getRecreateTableQueries({
 function isEmpty(obj) {
   return Object.keys(obj).length === 0;
 }
-function canAlterTableAddColumn(field) {
-  if (field.schema.unique)
+function canAlterTableAddColumn(column) {
+  if (column.schema.unique)
     return false;
-  if (hasRuntimeDefault(field))
+  if (hasRuntimeDefault(column))
     return false;
-  if (!field.schema.optional && !hasDefault(field))
+  if (!column.schema.optional && !hasDefault(column))
     return false;
-  if (hasPrimaryKey(field))
+  if (hasPrimaryKey(column))
     return false;
-  if (getReferencesConfig(field))
+  if (getReferencesConfig(column))
     return false;
   return true;
 }
-function canAlterTableDropColumn(field) {
-  if (field.schema.unique)
+function canAlterTableDropColumn(column) {
+  if (column.schema.unique)
     return false;
-  if (hasPrimaryKey(field))
+  if (hasPrimaryKey(column))
     return false;
   return true;
 }
 function canRecreateTableWithoutDataLoss(added, updated) {
-  for (const [fieldName, a] of Object.entries(added)) {
+  for (const [columnName, a] of Object.entries(added)) {
     if (hasPrimaryKey(a) && a.type !== "number" && !hasDefault(a)) {
-      return { dataLoss: true, fieldName, reason: "added-required" };
+      return { dataLoss: true, columnName, reason: "added-required" };
     }
     if (!a.schema.optional && !hasDefault(a)) {
-      return { dataLoss: true, fieldName, reason: "added-required" };
+      return { dataLoss: true, columnName, reason: "added-required" };
     }
     if (!a.schema.optional && a.schema.unique) {
-      return { dataLoss: true, fieldName, reason: "added-unique" };
+      return { dataLoss: true, columnName, reason: "added-unique" };
     }
   }
-  for (const [fieldName, u] of Object.entries(updated)) {
+  for (const [columnName, u] of Object.entries(updated)) {
     if (u.old.type !== u.new.type && !canChangeTypeWithoutQuery(u.old, u.new)) {
-      return { dataLoss: true, fieldName, reason: "updated-type" };
+      return { dataLoss: true, columnName, reason: "updated-type" };
     }
   }
   return { dataLoss: false };
@@ -377,24 +377,24 @@ function getUpdated(oldObj, newObj) {
   }
   return updated;
 }
-function getUpdatedFields(oldFields, newFields) {
+function getUpdatedColumns(oldColumns, newColumns) {
   const updated = {};
-  for (const [key, newField] of Object.entries(newFields)) {
-    let oldField = oldFields[key];
-    if (!oldField)
+  for (const [key, newColumn] of Object.entries(newColumns)) {
+    let oldColumn = oldColumns[key];
+    if (!oldColumn)
       continue;
-    if (oldField.type !== newField.type && canChangeTypeWithoutQuery(oldField, newField)) {
-      const asNewField = fieldSchema.safeParse({
-        type: newField.type,
-        schema: oldField.schema
+    if (oldColumn.type !== newColumn.type && canChangeTypeWithoutQuery(oldColumn, newColumn)) {
+      const asNewColumn = columnSchema.safeParse({
+        type: newColumn.type,
+        schema: oldColumn.schema
       });
-      if (asNewField.success) {
-        oldField = asNewField.data;
+      if (asNewColumn.success) {
+        oldColumn = asNewColumn.data;
       }
     }
-    const diff = deepDiff(oldField, newField);
+    const diff = deepDiff(oldColumn, newColumn);
     if (diff) {
-      updated[key] = { old: oldField, new: newField };
+      updated[key] = { old: oldColumn, new: newColumn };
     }
   }
   return updated;
@@ -404,13 +404,13 @@ const typeChangesWithoutQuery = [
   { from: "date", to: "text" },
   { from: "json", to: "text" }
 ];
-function canChangeTypeWithoutQuery(oldField, newField) {
+function canChangeTypeWithoutQuery(oldColumn, newColumn) {
   return typeChangesWithoutQuery.some(
-    ({ from, to }) => oldField.type === from && newField.type === to
+    ({ from, to }) => oldColumn.type === from && newColumn.type === to
   );
 }
-function hasRuntimeDefault(field) {
-  return !!(field.schema.default && isSerializedSQL(field.schema.default));
+function hasRuntimeDefault(column) {
+  return !!(column.schema.default && isSerializedSQL(column.schema.default));
 }
 export {
   getCollectionChangeQueries,

package/dist/core/cli/migrations.js

@@ -1,6 +1,6 @@
 import deepDiff from "deep-diff";
 import { mkdir, readFile, readdir, writeFile } from "fs/promises";
-import { collectionsSchema } from "../types.js";
+import { tablesSchema } from "../types.js";
 import { cyan, green, yellow } from "kleur/colors";
 const { applyChange, diff: generateDiff } = deepDiff;
 async function getMigrationStatus(config) {
@@ -31,20 +31,28 @@ async function getMigrationStatus(config) {
     currentSnapshot
   };
 }
-const MIGRATIONS_CREATED = `${green("\u25A0 Migrations initialized!")}
+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!")}
+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!")}
+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!")}
+const MIGRATION_NEEDED = `${yellow(
+  "\u25B6 Changes detected!"
+)}
 
   To create the necessary migration file, run
   ${cyan("astro db sync")}
@@ -98,8 +106,8 @@ async function initializeFromMigrations(allMigrationFiles) {
   return prevSnapshot;
 }
 function createCurrentSnapshot(config) {
-  const collectionsConfig = collectionsSchema.parse(config.db?.collections ?? {});
-  const schema = JSON.parse(JSON.stringify(collectionsConfig));
+  const tablesConfig = tablesSchema.parse(config.db?.tables ?? {});
+  const schema = JSON.parse(JSON.stringify(tablesConfig));
   return { experimentalVersion: 1, schema };
 }
 function createEmptySnapshot() {

package/dist/core/errors.js

@@ -10,13 +10,17 @@ const MISSING_PROJECT_ID_ERROR = `${red("\u25B6 Directory not linked.")}
   ${cyan("astro db link")}
 `;
 const STUDIO_CONFIG_MISSING_WRITABLE_COLLECTIONS_ERROR = (collectionName) => `${red(
-  `\u25B6 Writable collection ${bold(collectionName)} requires Astro Studio or the ${yellow("unsafeWritable")} option.`
+  `\u25B6 Writable collection ${bold(collectionName)} 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 collections.
+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.
 `;
@@ -34,7 +38,7 @@ const MIGRATIONS_NOT_INITIALIZED = `${yellow(
 `;
 const SEED_WRITABLE_IN_PROD_ERROR = (collectionName) => {
   return `${red(
-    `Writable collections should not be seeded in production with data().`
+    `Writable tables should not be seeded in production with data().`
   )} You can seed ${bold(
     collectionName
   )} 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`;

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

@@ -8,7 +8,7 @@ async function copyFile(toDir, fromUrl, toUrl) {
 function fileURLIntegration() {
   const fileNames = [];
   function createVitePlugin(command) {
-    const referenceIds = [];
+    let referenceIds = [];
     return {
       name: "@astrojs/db/file-url",
       enforce: "pre",
@@ -34,6 +34,7 @@ function fileURLIntegration() {
         for (const referenceId of referenceIds) {
           fileNames.push(this.getFileName(referenceId));
         }
+        referenceIds = [];
       }
     };
   }

package/dist/core/integration/index.js

@@ -1,3 +1,43 @@
+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";
@@ -7,7 +47,10 @@ 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_COLLECTIONS_ERROR, UNSAFE_WRITABLE_WARNING } from "../errors.js";
+import {
+  STUDIO_CONFIG_MISSING_WRITABLE_COLLECTIONS_ERROR,
+  UNSAFE_WRITABLE_WARNING
+} from "../errors.js";
 import { errorMap } from "./error-map.js";
 import { dirname } from "path";
 import { fileURLToPath } from "url";
@@ -18,85 +61,91 @@ import { getManagedAppTokenOrExit } from "../tokens.js";
 function astroDBIntegration() {
   let connectedToRemote = false;
   let appToken;
+  let schemas = {
+    tables() {
+      throw new Error("tables not found");
+    }
+  };
+  let command;
   return {
     name: "astro:db",
     hooks: {
-      "astro:config:setup": async ({ logger, updateConfig, config, command }) => {
-        if (command === "preview")
+      "astro:config:setup": async ({ updateConfig, config, command: _command, logger }) => {
+        command = _command;
+        if (_command === "preview")
           return;
-        const configWithDb = astroConfigWithDbSchema.parse(config, { errorMap });
-        const collections = configWithDb.db?.collections ?? {};
-        const studio = configWithDb.db?.studio ?? false;
-        const unsafeWritable = Boolean(configWithDb.db?.unsafeWritable);
-        const foundWritableCollection = Object.entries(collections).find(([, c]) => c.writable);
-        const writableAllowed = studio || unsafeWritable;
-        if (!writableAllowed && foundWritableCollection) {
-          logger.error(
-            STUDIO_CONFIG_MISSING_WRITABLE_COLLECTIONS_ERROR(foundWritableCollection[0])
-          );
-          process.exit(1);
-        } else if (unsafeWritable && foundWritableCollection) {
-          logger.warn(UNSAFE_WRITABLE_WARNING);
-        }
-        let dbPlugin;
+        let dbPlugin = void 0;
+        const studio = config.db?.studio ?? false;
         if (studio && command === "build" && process.env.ASTRO_DB_TEST_ENV !== "1") {
           appToken = await getManagedAppTokenOrExit();
           connectedToRemote = true;
           dbPlugin = vitePluginDb({
             connectToStudio: true,
-            collections,
             appToken: appToken.token,
+            schemas,
             root: config.root
           });
         } else {
-          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 = await createLocalDatabaseClient({
-            collections,
-            dbUrl: dbUrl.toString(),
-            seeding: true
-          });
-          await recreateTables({ db, collections });
-          if (configWithDb.db?.data) {
-            await seedData({
-              db,
-              data: configWithDb.db.data,
-              logger,
-              mode: command === "dev" ? "dev" : "build"
-            });
-          }
-          logger.debug("Database setup complete.");
           dbPlugin = vitePluginDb({
             connectToStudio: false,
-            collections,
+            schemas,
             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, logger)]
           }
         });
-        await typegen({ collections, root: config.root });
+      },
+      "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_COLLECTIONS_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);
+          }
+        }
+        await typegen({ tables, root: config.root });
       },
       "astro:server:start": async ({ logger }) => {
         setTimeout(() => {

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

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