@astrojs/db 0.5.0 → 0.6.0

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

@@ -1,7 +1,7 @@
 import type { AstroConfig } from 'astro';
 import type { Arguments } from 'yargs-parser';
 import { type DBConfig } from '../../../types.js';
-export declare function cmd({ astroConfig, dbConfig, flags, }: {
+export declare function cmd({ dbConfig, flags, }: {
     astroConfig: AstroConfig;
     dbConfig: DBConfig;
     flags: Arguments;

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

@@ -1,128 +1,61 @@
-import { red } from "kleur/colors";
-import prompts from "prompts";
-import { MISSING_SESSION_ID_ERROR } from "../../../errors.js";
 import { getManagedAppTokenOrExit } from "../../../tokens.js";
 import {} from "../../../types.js";
-import { getMigrationsDirectoryUrl, getRemoteDatabaseUrl } from "../../../utils.js";
-import { getMigrationQueries } from "../../migration-queries.js";
+import { getRemoteDatabaseUrl } from "../../../utils.js";
 import {
-  INITIAL_SNAPSHOT,
-  MIGRATIONS_NOT_INITIALIZED,
-  MIGRATIONS_UP_TO_DATE,
-  MIGRATION_NEEDED,
+  createCurrentSnapshot,
   createEmptySnapshot,
-  getMigrationStatus,
-  getMigrations,
-  loadInitialSnapshot,
-  loadMigration
-} from "../../migrations.js";
+  getMigrationQueries,
+  getProductionCurrentSnapshot
+} from "../../migration-queries.js";
 async function cmd({
-  astroConfig,
   dbConfig,
   flags
 }) {
   const isDryRun = flags.dryRun;
+  const isForceReset = flags.forceReset;
   const appToken = await getManagedAppTokenOrExit(flags.token);
-  const migration = await getMigrationStatus({ dbConfig, root: astroConfig.root });
-  if (migration.state === "no-migrations-found") {
-    console.log(MIGRATIONS_NOT_INITIALIZED);
-    process.exit(1);
-  } else if (migration.state === "ahead") {
-    console.log(MIGRATION_NEEDED);
-    process.exit(1);
-  }
-  const migrationsDir = getMigrationsDirectoryUrl(astroConfig.root);
-  const allLocalMigrations = await getMigrations(migrationsDir);
-  let missingMigrations = [];
-  try {
-    const { data } = await prepareMigrateQuery({
-      migrations: allLocalMigrations,
-      appToken: appToken.token
-    });
-    missingMigrations = data;
-  } catch (error) {
-    if (error instanceof Error) {
-      if (error.message.startsWith("{")) {
-        const { error: { code } = { code: "" } } = JSON.parse(error.message);
-        if (code === "TOKEN_UNAUTHORIZED") {
-          console.error(MISSING_SESSION_ID_ERROR);
-        }
-      }
-    }
-    console.error(error);
-    process.exit(1);
+  const productionSnapshot = await getProductionCurrentSnapshot({ appToken: appToken.token });
+  const currentSnapshot = createCurrentSnapshot(dbConfig);
+  const isFromScratch = isForceReset || JSON.stringify(productionSnapshot) === "{}";
+  const { queries: migrationQueries } = await getMigrationQueries({
+    oldSnapshot: isFromScratch ? createEmptySnapshot() : productionSnapshot,
+    newSnapshot: currentSnapshot
+  });
+  if (migrationQueries.length === 0) {
+    console.log("Database schema is up to date.");
+  } else {
+    console.log(`Database schema is out of date.`);
   }
-  if (missingMigrations.length === 0) {
-    console.log(MIGRATIONS_UP_TO_DATE);
+  if (isDryRun) {
+    console.log("Statements:", JSON.stringify(migrationQueries, void 0, 2));
   } else {
-    console.log(`Pushing ${missingMigrations.length} migrations...`);
+    console.log(`Pushing database schema updates...`);
     await pushSchema({
-      migrations: missingMigrations,
-      migrationsDir,
+      statements: migrationQueries,
       appToken: appToken.token,
       isDryRun,
-      currentSnapshot: migration.currentSnapshot
+      currentSnapshot
     });
   }
   await appToken.destroy();
   console.info("Push complete!");
 }
 async function pushSchema({
-  migrations,
-  migrationsDir,
+  statements,
   appToken,
   isDryRun,
   currentSnapshot
 }) {
-  const initialSnapshot = migrations.find((m) => m === INITIAL_SNAPSHOT);
-  const filteredMigrations = migrations.filter((m) => m !== INITIAL_SNAPSHOT);
-  const missingMigrationContents = await Promise.all(
-    filteredMigrations.map((m) => loadMigration(m, migrationsDir))
-  );
-  const initialMigrationBatch = initialSnapshot ? (await getMigrationQueries({
-    oldSnapshot: createEmptySnapshot(),
-    newSnapshot: await loadInitialSnapshot(migrationsDir)
-  })).queries : [];
-  const confirmations = missingMigrationContents.reduce((acc, curr) => {
-    return [...acc, ...curr.confirm || []];
-  }, []);
-  if (confirmations.length > 0) {
-    const response = await prompts([
-      ...confirmations.map((message, index) => ({
-        type: "confirm",
-        name: String(index),
-        message: red("Warning: ") + message + "\nContinue?",
-        initial: true
-      }))
-    ]);
-    if (Object.values(response).length === 0 || Object.values(response).some((value) => value === false)) {
-      process.exit(1);
-    }
-  }
-  const queries = missingMigrationContents.reduce((acc, curr) => {
-    return [...acc, ...curr.db];
-  }, initialMigrationBatch);
-  await runMigrateQuery({ queries, migrations, snapshot: currentSnapshot, appToken, isDryRun });
-}
-async function runMigrateQuery({
-  queries: baseQueries,
-  migrations,
-  snapshot,
-  appToken,
-  isDryRun
-}) {
-  const queries = ["pragma defer_foreign_keys=true;", ...baseQueries];
   const requestBody = {
-    snapshot,
-    migrations,
-    sql: queries,
+    snapshot: currentSnapshot,
+    sql: statements,
     experimentalVersion: 1
   };
   if (isDryRun) {
     console.info("[DRY RUN] Batch query:", JSON.stringify(requestBody, null, 2));
     return new Response(null, { status: 200 });
   }
-  const url = new URL("/migrations/run", getRemoteDatabaseUrl());
+  const url = new URL("/db/push", getRemoteDatabaseUrl());
   return await fetch(url, {
     method: "POST",
     headers: new Headers({
@@ -131,27 +64,6 @@ async function runMigrateQuery({
     body: JSON.stringify(requestBody)
   });
 }
-async function prepareMigrateQuery({
-  migrations,
-  appToken
-}) {
-  const url = new URL("/migrations/prepare", getRemoteDatabaseUrl());
-  const requestBody = {
-    migrations,
-    experimentalVersion: 1
-  };
-  const result = await fetch(url, {
-    method: "POST",
-    headers: new Headers({
-      Authorization: `Bearer ${appToken}`
-    }),
-    body: JSON.stringify(requestBody)
-  });
-  if (result.status >= 400) {
-    throw new Error(await result.text());
-  }
-  return await result.json();
-}
 export {
   cmd
 };

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

@@ -1,7 +1,7 @@
 import type { AstroConfig } from 'astro';
 import type { Arguments } from 'yargs-parser';
 import type { DBConfig } from '../../../types.js';
-export declare function cmd({ astroConfig, dbConfig, flags, }: {
+export declare function cmd({ dbConfig, flags, }: {
     astroConfig: AstroConfig;
     dbConfig: DBConfig;
     flags: Arguments;

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

@@ -1,46 +1,28 @@
-import { getMigrationQueries } from "../../migration-queries.js";
+import { getManagedAppTokenOrExit } from "../../../tokens.js";
 import {
-  MIGRATIONS_NOT_INITIALIZED,
-  MIGRATIONS_UP_TO_DATE,
-  MIGRATION_NEEDED,
-  getMigrationStatus
-} from "../../migrations.js";
+  createCurrentSnapshot,
+  createEmptySnapshot,
+  getMigrationQueries,
+  getProductionCurrentSnapshot
+} from "../../migration-queries.js";
 async function cmd({
-  astroConfig,
   dbConfig,
   flags
 }) {
-  const status = await getMigrationStatus({ dbConfig, root: astroConfig.root });
-  const { state } = status;
-  if (flags.json) {
-    if (state === "ahead") {
-      const { queries: migrationQueries } = await getMigrationQueries({
-        oldSnapshot: status.oldSnapshot,
-        newSnapshot: status.newSnapshot
-      });
-      const newFileContent = {
-        diff: status.diff,
-        db: migrationQueries
-      };
-      status.newFileContent = JSON.stringify(newFileContent, null, 2);
-    }
-    console.log(JSON.stringify(status));
-    process.exit(state === "up-to-date" ? 0 : 1);
-  }
-  switch (state) {
-    case "no-migrations-found": {
-      console.log(MIGRATIONS_NOT_INITIALIZED);
-      process.exit(1);
-    }
-    case "ahead": {
-      console.log(MIGRATION_NEEDED);
-      process.exit(1);
-    }
-    case "up-to-date": {
-      console.log(MIGRATIONS_UP_TO_DATE);
-      return;
-    }
+  const appToken = await getManagedAppTokenOrExit(flags.token);
+  const productionSnapshot = await getProductionCurrentSnapshot({ appToken: appToken.token });
+  const currentSnapshot = createCurrentSnapshot(dbConfig);
+  const { queries: migrationQueries } = await getMigrationQueries({
+    oldSnapshot: JSON.stringify(productionSnapshot) !== "{}" ? productionSnapshot : createEmptySnapshot(),
+    newSnapshot: currentSnapshot
+  });
+  if (migrationQueries.length === 0) {
+    console.log(`Database schema is up to date.`);
+  } else {
+    console.log(`Database schema is out of date.`);
+    console.log(`Run 'astro db push' to push up your latest changes.`);
   }
+  await appToken.destroy();
 }
 export {
   cmd

package/dist/core/cli/index.js

@@ -13,10 +13,13 @@ async function cli({
       const { cmd } = await import("./commands/shell/index.js");
       return await cmd({ astroConfig, dbConfig, flags });
     }
-    case "gen":
+    case "gen": {
+      console.log('"astro db gen" is no longer needed! Visit the docs for more information.');
+      return;
+    }
     case "sync": {
-      const { cmd } = await import("./commands/gen/index.js");
-      return await cmd({ astroConfig, dbConfig, flags });
+      console.log('"astro db sync" is no longer needed! Visit the docs for more information.');
+      return;
     }
     case "push": {
       const { cmd } = await import("./commands/push/index.js");
@@ -65,8 +68,8 @@ astro logout         End your authenticated session with Astro Studio
 astro link           Link this directory to an Astro Studio project
 
 astro db gen         Creates snapshot based on your schema
-astro db push        Pushes migrations to Astro Studio
-astro db verify      Verifies migrations have been pushed and errors if not`;
+astro db push        Pushes schema updates to Astro Studio
+astro db verify      Tests schema updates /w Astro Studio (good for CI)`;
   }
 }
 export {

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

@@ -1,26 +1,21 @@
-import { type DBSnapshot, type DBTable } from '../types.js';
-/** Dependency injected for unit testing */
-type AmbiguityResponses = {
-    collectionRenames: Record<string, string>;
-    columnRenames: {
-        [collectionName: string]: Record<string, string>;
-    };
-};
-export declare function getMigrationQueries({ oldSnapshot, newSnapshot, ambiguityResponses, }: {
+import { type DBConfig, type DBSnapshot, type DBTable } from '../types.js';
+export declare function getMigrationQueries({ oldSnapshot, newSnapshot, }: {
     oldSnapshot: DBSnapshot;
     newSnapshot: DBSnapshot;
-    ambiguityResponses?: AmbiguityResponses;
 }): Promise<{
     queries: string[];
     confirmations: string[];
 }>;
-export declare function getCollectionChangeQueries({ collectionName, oldCollection, newCollection, ambiguityResponses, }: {
+export declare function getCollectionChangeQueries({ collectionName, oldCollection, newCollection, }: {
     collectionName: string;
     oldCollection: DBTable;
     newCollection: DBTable;
-    ambiguityResponses?: AmbiguityResponses;
 }): Promise<{
     queries: string[];
     confirmations: string[];
 }>;
-export {};
+export declare function getProductionCurrentSnapshot({ appToken, }: {
+    appToken: string;
+}): Promise<DBSnapshot>;
+export declare function createCurrentSnapshot({ tables }: DBConfig): DBSnapshot;
+export declare function createEmptySnapshot(): DBSnapshot;

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

@@ -2,47 +2,49 @@ import deepDiff from "deep-diff";
 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 "../../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/errors.d.ts

@@ -1,7 +1,8 @@
 export declare const MISSING_SESSION_ID_ERROR: string;
 export declare const MISSING_PROJECT_ID_ERROR: string;
-export declare const MIGRATIONS_NOT_INITIALIZED: 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;

package/dist/core/errors.js

@@ -9,17 +9,20 @@ 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 MIGRATIONS_NOT_INITIALIZED = `${yellow(
-  "\u25B6 No migrations found!"
-)}
-
-  To scaffold your migrations folder, run
-  ${cyan("astro db sync")}
-`;
 const MISSING_EXECUTE_PATH_ERROR = `${red(
   "\u25B6 No file path provided."
 )} Provide a path by running ${cyan("astro db execute <path>")}
 `;
+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 SEED_ERROR = (error) => {
@@ -52,10 +55,11 @@ export {
   FOREIGN_KEY_DNE_ERROR,
   FOREIGN_KEY_REFERENCES_EMPTY_ERROR,
   FOREIGN_KEY_REFERENCES_LENGTH_ERROR,
-  MIGRATIONS_NOT_INITIALIZED,
   MISSING_EXECUTE_PATH_ERROR,
   MISSING_PROJECT_ID_ERROR,
   MISSING_SESSION_ID_ERROR,
   REFERENCE_DNE_ERROR,
+  RENAME_COLUMN_ERROR,
+  RENAME_TABLE_ERROR,
   SEED_ERROR
 };

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

@@ -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/typegen.js

@@ -18,9 +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(collection.columns)}
+		${JSON.stringify(sanitizedColumns)}
 	>;`;
   return tableType;
 }