@astrojs/db 0.2.1 → 0.3.0

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

@@ -7,26 +7,25 @@ import {
   getCreateIndexQueries,
   getCreateTableQuery,
   getModifiers,
+  getReferencesConfig,
   hasDefault,
   schemaTypeToSqlType
 } from "../queries.js";
 import { hasPrimaryKey } from "../../runtime/index.js";
+import { isSerializedSQL } from "../../runtime/types.js";
 const sqlite = new SQLiteAsyncDialect();
 const genTempTableName = customAlphabet("abcdefghijklmnopqrstuvwxyz", 10);
 async function getMigrationQueries({
   oldSnapshot,
   newSnapshot,
-  promptResponses
+  ambiguityResponses
 }) {
   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,
-      promptResponses?.collectionRenames
-    );
+    const resolved = await resolveCollectionRenames(added, dropped, ambiguityResponses);
     added = resolved.added;
     dropped = resolved.dropped;
     for (const { from, to } of resolved.renamed) {
@@ -48,45 +47,47 @@ async function getMigrationQueries({
     const oldCollection = oldSnapshot.schema[collectionName];
     if (!oldCollection)
       continue;
-    const collectionChangeQueries = await getCollectionChangeQueries({
+    const result = await getCollectionChangeQueries({
       collectionName,
       oldCollection,
-      newCollection,
-      promptResponses
+      newCollection
     });
-    queries.push(...collectionChangeQueries);
+    queries.push(...result.queries);
+    confirmations.push(...result.confirmations);
   }
-  return queries;
+  return { queries, confirmations };
 }
 async function getCollectionChangeQueries({
   collectionName,
   oldCollection,
   newCollection,
-  promptResponses
+  ambiguityResponses
 }) {
   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);
-  if (isEmpty(updated) && isEmpty(added) && isEmpty(dropped)) {
-    return getChangeIndexQueries({
-      collectionName,
-      oldIndexes: oldCollection.indexes,
-      newIndexes: newCollection.indexes
-    });
+  const hasForeignKeyChanges = Boolean(
+    deepDiff(oldCollection.foreignKeys, newCollection.foreignKeys)
+  );
+  if (!hasForeignKeyChanges && isEmpty(updated) && isEmpty(added) && isEmpty(dropped)) {
+    return {
+      queries: getChangeIndexQueries({
+        collectionName,
+        oldIndexes: oldCollection.indexes,
+        newIndexes: newCollection.indexes
+      }),
+      confirmations
+    };
   }
-  if (!isEmpty(added) && !isEmpty(dropped)) {
-    const resolved = await resolveFieldRenames(
-      collectionName,
-      added,
-      dropped,
-      promptResponses?.fieldRenames
-    );
+  if (!hasForeignKeyChanges && !isEmpty(added) && !isEmpty(dropped)) {
+    const resolved = await resolveFieldRenames(collectionName, added, dropped, ambiguityResponses);
     added = resolved.added;
     dropped = resolved.dropped;
     queries.push(...getFieldRenameQueries(collectionName, resolved.renamed));
   }
-  if (isEmpty(updated) && Object.values(dropped).every(canAlterTableDropColumn) && Object.values(added).every(canAlterTableAddColumn)) {
+  if (!hasForeignKeyChanges && isEmpty(updated) && Object.values(dropped).every(canAlterTableDropColumn) && Object.values(added).every(canAlterTableAddColumn)) {
     queries.push(
       ...getAlterTableQueries(collectionName, added, dropped),
       ...getChangeIndexQueries({
@@ -95,60 +96,46 @@ async function getCollectionChangeQueries({
         newIndexes: newCollection.indexes
       })
     );
-    return queries;
+    return { queries, confirmations };
   }
   const dataLossCheck = canRecreateTableWithoutDataLoss(added, updated);
   if (dataLossCheck.dataLoss) {
-    let allowDataLoss = promptResponses?.allowDataLoss;
-    const nameMsg = `Type the collection name ${color.blue(
-      collectionName
-    )} to confirm you want to delete all data:`;
     const { reason, fieldName } = dataLossCheck;
     const reasonMsgs = {
-      "added-required": `Adding required ${color.blue(
-        color.bold(collectionName)
-      )} field ${color.blue(color.bold(fieldName))}. ${color.red(
-        "This will delete all existing data in the collection!"
-      )} We recommend setting a default value to avoid data loss.`,
-      "added-unique": `Adding unique ${color.blue(color.bold(collectionName))} field ${color.blue(
-        color.bold(fieldName)
-      )}. ${color.red("This will delete all existing data in the collection!")}`,
-      "updated-type": `Changing the type of ${color.blue(
-        color.bold(collectionName)
-      )} field ${color.blue(color.bold(fieldName))}. ${color.red(
-        "This will delete all existing data in the collection!"
-      )}`
+      "added-required": `New field ${color.bold(
+        collectionName + "." + fieldName
+      )} 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
+      )} 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.
+This requires deleting existing data in the ${color.bold(
+        collectionName
+      )} collection.`
     };
-    if (allowDataLoss === void 0) {
-      const res = await prompts({
-        type: "text",
-        name: "allowDataLoss",
-        message: `${reasonMsgs[reason]} ${nameMsg}`,
-        validate: (name) => name === collectionName || "Incorrect collection name"
-      });
-      if (typeof res.allowDataLoss !== "string")
-        process.exit(0);
-      allowDataLoss = !!res.allowDataLoss;
-    }
-    if (!allowDataLoss) {
-      console.info("Exiting without changes \u{1F44B}");
-      process.exit(0);
-    }
+    confirmations.push(reasonMsgs[reason]);
   }
-  const addedPrimaryKey = Object.entries(added).find(([, field]) => hasPrimaryKey(field));
-  const droppedPrimaryKey = Object.entries(dropped).find(([, field]) => hasPrimaryKey(field));
-  const updatedPrimaryKey = Object.entries(updated).find(
-    ([, field]) => hasPrimaryKey(field.old) || hasPrimaryKey(field.new)
+  const primaryKeyExists = Object.entries(newCollection.fields).find(
+    ([, field]) => hasPrimaryKey(field)
   );
+  const droppedPrimaryKey = Object.entries(dropped).find(([, field]) => hasPrimaryKey(field));
   const recreateTableQueries = getRecreateTableQueries({
     collectionName,
     newCollection,
     added,
     hasDataLoss: dataLossCheck.dataLoss,
-    migrateHiddenPrimaryKey: !addedPrimaryKey && !droppedPrimaryKey && !updatedPrimaryKey
+    migrateHiddenPrimaryKey: !primaryKeyExists && !droppedPrimaryKey
   });
   queries.push(...recreateTableQueries, ...getCreateIndexQueries(collectionName, newCollection));
-  return queries;
+  return { queries, confirmations };
 }
 function getChangeIndexQueries({
   collectionName,
@@ -168,96 +155,78 @@ function getChangeIndexQueries({
   queries.push(...getCreateIndexQueries(collectionName, { indexes: added }));
   return queries;
 }
-async function resolveFieldRenames(collectionName, mightAdd, mightDrop, renamePromptResponses) {
+async function resolveFieldRenames(collectionName, mightAdd, mightDrop, ambiguityResponses) {
   const added = {};
   const dropped = {};
   const renamed = [];
   for (const [fieldName, field] of Object.entries(mightAdd)) {
-    const promptResponse = renamePromptResponses?.[fieldName];
-    if (promptResponse === false) {
-      added[fieldName] = field;
-      continue;
-    } else if (promptResponse) {
-      renamed.push({ from: promptResponse, to: fieldName });
-      continue;
+    let oldFieldName = ambiguityResponses ? ambiguityResponses.fieldRenames[collectionName]?.[fieldName] ?? "__NEW__" : void 0;
+    if (!oldFieldName) {
+      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?",
+          choices: [
+            { title: "New field (not renamed from existing)", value: "__NEW__" },
+            ...Object.keys(mightDrop).filter((key) => !(key in renamed)).map((key) => ({ title: key, value: key }))
+          ]
+        },
+        {
+          onCancel: () => {
+            process.exit(1);
+          }
+        }
+      );
+      oldFieldName = res.fieldName;
     }
-    const res = await prompts({
-      type: "toggle",
-      name: "isRename",
-      message: `Is the field ${color.blue(color.bold(fieldName))} in collection ${color.blue(
-        color.bold(collectionName)
-      )} a new field, or renaming an existing field?`,
-      initial: false,
-      active: "Rename",
-      inactive: "New field"
-    });
-    if (typeof res.isRename !== "boolean")
-      process.exit(0);
-    if (!res.isRename) {
+    if (oldFieldName === "__NEW__") {
       added[fieldName] = field;
-      continue;
+    } else {
+      renamed.push({ from: oldFieldName, to: fieldName });
     }
-    const choices = Object.keys(mightDrop).filter((key) => !(key in renamed)).map((key) => ({ title: key, value: key }));
-    const { oldFieldName } = await prompts({
-      type: "select",
-      name: "oldFieldName",
-      message: `Which field in ${color.blue(
-        color.bold(collectionName)
-      )} should be renamed to ${color.blue(color.bold(fieldName))}?`,
-      choices
-    });
-    if (typeof oldFieldName !== "string")
-      process.exit(0);
-    renamed.push({ from: oldFieldName, to: fieldName });
-    for (const [droppedFieldName, droppedField] of Object.entries(mightDrop)) {
-      if (!renamed.find((r) => r.from === droppedFieldName))
-        dropped[droppedFieldName] = droppedField;
+  }
+  for (const [droppedFieldName, droppedField] of Object.entries(mightDrop)) {
+    if (!renamed.find((r) => r.from === droppedFieldName)) {
+      dropped[droppedFieldName] = droppedField;
     }
   }
   return { added, dropped, renamed };
 }
-async function resolveCollectionRenames(mightAdd, mightDrop, renamePromptResponses) {
+async function resolveCollectionRenames(mightAdd, mightDrop, ambiguityResponses) {
   const added = {};
   const dropped = {};
   const renamed = [];
   for (const [collectionName, collection] of Object.entries(mightAdd)) {
-    const promptResponse = renamePromptResponses?.[collectionName];
-    if (promptResponse === false) {
-      added[collectionName] = collection;
-      continue;
-    } else if (promptResponse) {
-      renamed.push({ from: promptResponse, to: collectionName });
-      continue;
+    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;
     }
-    const res = await prompts({
-      type: "toggle",
-      name: "isRename",
-      message: `Is the collection ${color.blue(
-        color.bold(collectionName)
-      )} a new collection, or renaming an existing collection?`,
-      initial: false,
-      active: "Rename",
-      inactive: "New collection"
-    });
-    if (typeof res.isRename !== "boolean")
-      process.exit(0);
-    if (!res.isRename) {
+    if (oldCollectionName === "__NEW__") {
       added[collectionName] = collection;
-      continue;
+    } else {
+      renamed.push({ from: oldCollectionName, to: collectionName });
     }
-    const choices = Object.keys(mightDrop).filter((key) => !(key in renamed)).map((key) => ({ title: key, value: key }));
-    const { oldCollectionName } = await prompts({
-      type: "select",
-      name: "oldCollectionName",
-      message: `Which collection should be renamed to ${color.blue(color.bold(collectionName))}?`,
-      choices
-    });
-    if (typeof oldCollectionName !== "string")
-      process.exit(0);
-    renamed.push({ from: oldCollectionName, to: collectionName });
-    for (const [droppedCollectionName, droppedCollection] of Object.entries(mightDrop)) {
-      if (!renamed.find((r) => r.from === droppedCollectionName))
-        dropped[droppedCollectionName] = droppedCollection;
+  }
+  for (const [droppedCollectionName, droppedCollection] of Object.entries(mightDrop)) {
+    if (!renamed.find((r) => r.from === droppedCollectionName)) {
+      dropped[droppedCollectionName] = droppedCollection;
     }
   }
   return { added, dropped, renamed };
@@ -340,18 +309,20 @@ function isEmpty(obj) {
   return Object.keys(obj).length === 0;
 }
 function canAlterTableAddColumn(field) {
-  if (field.unique)
+  if (field.schema.unique)
     return false;
   if (hasRuntimeDefault(field))
     return false;
-  if (!field.optional && !hasDefault(field))
+  if (!field.schema.optional && !hasDefault(field))
     return false;
   if (hasPrimaryKey(field))
     return false;
+  if (getReferencesConfig(field))
+    return false;
   return true;
 }
 function canAlterTableDropColumn(field) {
-  if (field.unique)
+  if (field.schema.unique)
     return false;
   if (hasPrimaryKey(field))
     return false;
@@ -362,10 +333,10 @@ function canRecreateTableWithoutDataLoss(added, updated) {
     if (hasPrimaryKey(a) && a.type !== "number" && !hasDefault(a)) {
       return { dataLoss: true, fieldName, reason: "added-required" };
     }
-    if (!a.optional && !hasDefault(a)) {
+    if (!a.schema.optional && !hasDefault(a)) {
       return { dataLoss: true, fieldName, reason: "added-required" };
     }
-    if (!a.optional && a.unique) {
+    if (!a.schema.optional && a.schema.unique) {
       return { dataLoss: true, fieldName, reason: "added-unique" };
     }
   }
@@ -409,14 +380,16 @@ function getUpdatedFields(oldFields, newFields) {
     const oldField = oldFields[key];
     if (!oldField)
       continue;
-    if (objShallowEqual(oldField, newField))
-      continue;
-    const oldFieldSqlType = { ...oldField, type: schemaTypeToSqlType(oldField.type) };
-    const newFieldSqlType = { ...newField, type: schemaTypeToSqlType(newField.type) };
-    const isSafeTypeUpdate = objShallowEqual(oldFieldSqlType, newFieldSqlType) && canChangeTypeWithoutQuery(oldField, newField);
-    if (isSafeTypeUpdate)
-      continue;
-    updated[key] = { old: oldField, new: newField };
+    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 (diff) {
+      updated[key] = { old: oldField, new: newField };
+    }
   }
   return updated;
 }
@@ -436,17 +409,7 @@ function canChangeTypeWithoutQuery(oldField, newField) {
   );
 }
 function hasRuntimeDefault(field) {
-  return field.type === "date" && field.default === "now";
-}
-function objShallowEqual(a, b) {
-  if (Object.keys(a).length !== Object.keys(b).length)
-    return false;
-  for (const [key, value] of Object.entries(a)) {
-    if (JSON.stringify(b[key]) !== JSON.stringify(value)) {
-      return false;
-    }
-  }
-  return true;
+  return !!(field.schema.default && isSerializedSQL(field.schema.default));
 }
 export {
   getCollectionChangeQueries,

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

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

package/dist/core/cli/migrations.js

@@ -1,6 +1,64 @@
 import deepDiff from "deep-diff";
 import { mkdir, readFile, readdir, writeFile } from "fs/promises";
-const { applyChange } = deepDiff;
+import { collectionsSchema } from "../types.js";
+import { cyan, green, yellow } from "kleur/colors";
+const { applyChange, diff: generateDiff } = deepDiff;
+async function getMigrationStatus(config) {
+  const currentSnapshot = createCurrentSnapshot(config);
+  const allMigrationFiles = await getMigrations();
+  if (allMigrationFiles.length === 0) {
+    return {
+      state: "no-migrations-found",
+      currentSnapshot
+    };
+  }
+  const previousSnapshot = await initializeFromMigrations(allMigrationFiles);
+  const diff = generateDiff(previousSnapshot, currentSnapshot);
+  if (diff) {
+    const n = getNewMigrationNumber(allMigrationFiles);
+    const newFilename = `${String(n + 1).padStart(4, "0")}_migration.json`;
+    return {
+      state: "ahead",
+      oldSnapshot: previousSnapshot,
+      newSnapshot: currentSnapshot,
+      diff,
+      newFilename,
+      summary: generateDiffSummary(diff)
+    };
+  }
+  return {
+    state: "up-to-date",
+    currentSnapshot
+  };
+}
+const MIGRATIONS_CREATED = `${green("\u25A0 Migrations initialized!")}
+
+  To execute your migrations, run
+  ${cyan("astro db push")}`;
+const MIGRATIONS_UP_TO_DATE = `${green("\u25A0 No migrations needed!")}
+
+  Your database is up to date.
+`;
+const MIGRATIONS_NOT_INITIALIZED = `${yellow("\u25B6 No migrations found!")}
+
+  To scaffold your migrations folder, run
+  ${cyan("astro db sync")}
+`;
+const MIGRATION_NEEDED = `${yellow("\u25B6 Changes detected!")}
+
+  To create the necessary migration file, run
+  ${cyan("astro db sync")}
+`;
+function generateDiffSummary(diff) {
+  return JSON.stringify(diff, null, 2);
+}
+function getNewMigrationNumber(allMigrationFiles) {
+  const len = allMigrationFiles.length - 1;
+  return allMigrationFiles.reduce((acc, curr) => {
+    const num = Number.parseInt(curr.split("_")[0] ?? len, 10);
+    return num > acc ? num : acc;
+  }, 0);
+}
 async function getMigrations() {
   const migrationFiles = await readdir("./migrations").catch((err) => {
     if (err.code === "ENOENT") {
@@ -40,15 +98,21 @@ async function initializeFromMigrations(allMigrationFiles) {
   return prevSnapshot;
 }
 function createCurrentSnapshot(config) {
-  const schema = JSON.parse(JSON.stringify(config.db?.collections ?? {}));
+  const collectionsConfig = collectionsSchema.parse(config.db?.collections ?? {});
+  const schema = JSON.parse(JSON.stringify(collectionsConfig));
   return { experimentalVersion: 1, schema };
 }
 function createEmptySnapshot() {
   return { experimentalVersion: 1, schema: {} };
 }
 export {
+  MIGRATIONS_CREATED,
+  MIGRATIONS_NOT_INITIALIZED,
+  MIGRATIONS_UP_TO_DATE,
+  MIGRATION_NEEDED,
   createCurrentSnapshot,
   createEmptySnapshot,
+  getMigrationStatus,
   getMigrations,
   initializeFromMigrations,
   initializeMigrationsDirectory,

package/dist/core/errors.d.ts

@@ -1 +1,5 @@
-export declare const appTokenError: string;
+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 STUDIO_CONFIG_MISSING_CLI_ERROR: string;
+export declare const MIGRATIONS_NOT_INITIALIZED: string;

package/dist/core/errors.js

@@ -1,7 +1,37 @@
-import { red } from "kleur/colors";
-const appTokenError = `${red(
-  "\u26A0\uFE0F App token invalid or expired."
-)} Please generate a new one from your the Studio dashboard under project settings.`;
+import { cyan, bold, red, green, yellow } from "kleur/colors";
+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."
+)}
+
+  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.`)}
+
+  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 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!")}
+
+  To scaffold your migrations folder, run
+  ${cyan("astro db sync")}
+`;
 export {
-  appTokenError
+  MIGRATIONS_NOT_INITIALIZED,
+  MISSING_PROJECT_ID_ERROR,
+  MISSING_SESSION_ID_ERROR,
+  STUDIO_CONFIG_MISSING_CLI_ERROR,
+  STUDIO_CONFIG_MISSING_WRITABLE_COLLECTIONS_ERROR
 };