@astrojs/db 0.3.4 → 0.3.6-nightly-01234567890

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

@@ -1,5 +1,8 @@
 import * as color from "kleur/colors";
 import deepDiff from "deep-diff";
+import {
+  columnSchema
+} from "../types.js";
 import { SQLiteAsyncDialect } from "drizzle-orm/sqlite-core";
 import { customAlphabet } from "nanoid";
 import prompts from "prompts";
@@ -65,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)
   );
@@ -82,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(
@@ -100,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,
@@ -155,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 }))
           ]
         },
@@ -178,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 };
@@ -247,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) {
@@ -261,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;
@@ -293,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");
   }
@@ -308,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 };
@@ -374,21 +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)) {
-    const oldField = oldFields[key];
-    if (!oldField)
+  for (const [key, newColumn] of Object.entries(newColumns)) {
+    let oldColumn = oldColumns[key];
+    if (!oldColumn)
       continue;
-    const diff = deepDiff(oldField, newField, (path, objKey) => {
-      const isTypeKey = objKey === "type" && path.length === 0;
-      return (
-        // If we can safely update the type without a SQL query, ignore the diff
-        isTypeKey && oldField.type !== newField.type && canChangeTypeWithoutQuery(oldField, newField)
-      );
-    });
+    if (oldColumn.type !== newColumn.type && canChangeTypeWithoutQuery(oldColumn, newColumn)) {
+      const asNewColumn = columnSchema.safeParse({
+        type: newColumn.type,
+        schema: oldColumn.schema
+      });
+      if (asNewColumn.success) {
+        oldColumn = asNewColumn.data;
+      }
+    }
+    const diff = deepDiff(oldColumn, newColumn);
     if (diff) {
-      updated[key] = { old: oldField, new: newField };
+      updated[key] = { old: oldColumn, new: newColumn };
     }
   }
   return updated;
@@ -397,19 +403,14 @@ const typeChangesWithoutQuery = [
   { from: "boolean", to: "number" },
   { from: "date", to: "text" },
   { from: "json", to: "text" }
-  // TODO: decide on these. They *could* work with SQLite CAST
-  // { from: 'boolean', to: 'text' },
-  // { from: 'boolean', to: 'json' },
-  // { from: 'number', to: 'text' },
-  // { from: 'number', to: 'json' },
 ];
-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.d.ts

@@ -1,5 +1,7 @@
 export declare const MISSING_SESSION_ID_ERROR: string;
 export declare const MISSING_PROJECT_ID_ERROR: string;
 export declare const STUDIO_CONFIG_MISSING_WRITABLE_COLLECTIONS_ERROR: (collectionName: 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: (collectionName: string) => string;

package/dist/core/errors.js

@@ -1,37 +1,54 @@
 import { cyan, bold, red, green, yellow } from "kleur/colors";
-const MISSING_SESSION_ID_ERROR = `${red(
-  "\u25B6 Login required!"
-)}
+const MISSING_SESSION_ID_ERROR = `${red("\u25B6 Login required!")}
 
   To authenticate with Astro Studio, run
   ${cyan("astro db login")}
 `;
-const MISSING_PROJECT_ID_ERROR = `${red(
-  "\u25B6 Directory not linked."
-)}
+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_COLLECTIONS_ERROR = (collectionName) => `${red(`\u25B6 Writable collection ${bold(collectionName)} requires Astro Studio.`)}
+const STUDIO_CONFIG_MISSING_WRITABLE_COLLECTIONS_ERROR = (collectionName) => `${red(
+  `\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 tables.
+  Redeploying your app may result in wiping away your database.
+	I hope you know what you are doing.
+`;
 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 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 SEED_WRITABLE_IN_PROD_ERROR = (collectionName) => {
+  return `${red(
+    `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`;
+};
 export {
   MIGRATIONS_NOT_INITIALIZED,
   MISSING_PROJECT_ID_ERROR,
   MISSING_SESSION_ID_ERROR,
+  SEED_WRITABLE_IN_PROD_ERROR,
   STUDIO_CONFIG_MISSING_CLI_ERROR,
-  STUDIO_CONFIG_MISSING_WRITABLE_COLLECTIONS_ERROR
+  STUDIO_CONFIG_MISSING_WRITABLE_COLLECTIONS_ERROR,
+  UNSAFE_WRITABLE_WARNING
 };

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 } 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,81 +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 foundWritableCollection = Object.entries(collections).find(([, c]) => c.writable);
-        if (!studio && foundWritableCollection) {
-          logger.error(
-            STUDIO_CONFIG_MISSING_WRITABLE_COLLECTIONS_ERROR(foundWritableCollection[0])
-          );
-          process.exit(1);
-        }
-        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>;