@astrojs/db 0.1.2 → 0.1.4

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

@@ -4,6 +4,8 @@ import { SQLiteAsyncDialect } from "drizzle-orm/sqlite-core";
 import { appTokenError } from "../../../errors.js";
 import { collectionToTable, createLocalDatabaseClient } from "../../../internal.js";
 import {
+  createCurrentSnapshot,
+  createEmptySnapshot,
   getMigrations,
   initializeFromMigrations,
   loadInitialSnapshot,
@@ -24,8 +26,7 @@ async function cmd({ config, flags }) {
   const isSeedData = flags.seed;
   const isDryRun = flags.dryRun;
   const appToken = flags.token ?? getAstroStudioEnv().ASTRO_STUDIO_APP_TOKEN;
-  const currentDb = config.db?.collections ?? {};
-  const currentSnapshot = JSON.parse(JSON.stringify(currentDb));
+  const currentSnapshot = createCurrentSnapshot(config);
   const allMigrationFiles = await getMigrations();
   if (allMigrationFiles.length === 0) {
     console.log("Project not yet initialized!");
@@ -35,6 +36,7 @@ async function cmd({ config, flags }) {
   const calculatedDiff = diff(prevSnapshot, currentSnapshot);
   if (calculatedDiff) {
     console.log("Changes detected!");
+    console.log(calculatedDiff);
     process.exit(1);
   }
   if (!appToken) {
@@ -58,7 +60,7 @@ async function cmd({ config, flags }) {
   }
   if (isSeedData) {
     console.info("Pushing data...");
-    await tempDataPush({ currentDb, appToken, isDryRun });
+    await pushData({ config, appToken, isDryRun });
   }
   console.info("Push complete!");
 }
@@ -73,8 +75,8 @@ async function pushSchema({
   const filteredMigrations = migrations.filter((m) => m !== "0000_snapshot.json");
   const missingMigrationContents = await Promise.all(filteredMigrations.map(loadMigration));
   const initialMigrationBatch = initialSnapshot ? await getMigrationQueries({
-    oldCollections: {},
-    newCollections: await loadInitialSnapshot()
+    oldSnapshot: createEmptySnapshot(),
+    newSnapshot: await loadInitialSnapshot()
   }) : [];
   const missingMigrationBatch = missingMigrationContents.reduce((acc, curr) => {
     return [...acc, ...curr.db];
@@ -84,26 +86,24 @@ async function pushSchema({
   await db.insert(migrationsTable).values(migrations.map((m) => ({ name: m })));
   await db.update(adminTable).set({ collections: JSON.stringify(currentSnapshot) }).where(eq(adminTable.id, STUDIO_ADMIN_TABLE_ROW_ID));
 }
-async function tempDataPush({
-  currentDb,
+async function pushData({
+  config,
   appToken,
   isDryRun
 }) {
   const db = await createLocalDatabaseClient({
-    collections: JSON.parse(JSON.stringify(currentDb)),
+    collections: config.db.collections,
     dbUrl: ":memory:",
     seeding: true
   });
   const queries = [];
-  for (const [name, collection] of Object.entries(currentDb)) {
-    console.log(name, collection);
+  for (const [name, collection] of Object.entries(config.db.collections)) {
     if (collection.writable || !collection.data)
       continue;
     const table = collectionToTable(name, collection);
     const insert = db.insert(table).values(await collection.data());
     queries.push(insert.toSQL());
   }
-  console.log(queries);
   const url = new URL("/db/query", getRemoteDatabaseUrl());
   const requestBody = queries.map((q) => ({
     sql: q.sql,

package/dist/cli/commands/shell/index.d.ts

@@ -0,0 +1,6 @@
+import type { AstroConfig } from 'astro';
+import type { Arguments } from 'yargs-parser';
+export declare function cmd({ config, flags }: {
+    config: AstroConfig;
+    flags: Arguments;
+}): Promise<void>;

package/dist/cli/commands/shell/index.js

@@ -0,0 +1,17 @@
+import { sql } from "drizzle-orm";
+import { appTokenError } from "../../../errors.js";
+import { createRemoteDatabaseClient, getAstroStudioEnv } from "../../../utils.js";
+async function cmd({ config, flags }) {
+  const query = flags.query;
+  const appToken = flags.token ?? getAstroStudioEnv().ASTRO_STUDIO_APP_TOKEN;
+  if (!appToken) {
+    console.error(appTokenError);
+    process.exit(1);
+  }
+  const db = createRemoteDatabaseClient(appToken);
+  const result = await db.run(sql.raw(query));
+  console.log(result);
+}
+export {
+  cmd
+};

package/dist/cli/commands/sync/index.js

@@ -1,6 +1,7 @@
 import deepDiff from "deep-diff";
 import { writeFile } from "fs/promises";
 import {
+  createCurrentSnapshot,
   getMigrations,
   initializeFromMigrations,
   initializeMigrationsDirectory
@@ -8,7 +9,7 @@ import {
 import { getMigrationQueries } from "../../queries.js";
 const { diff } = deepDiff;
 async function cmd({ config }) {
-  const currentSnapshot = JSON.parse(JSON.stringify(config.db?.collections ?? {}));
+  const currentSnapshot = createCurrentSnapshot(config);
   const allMigrationFiles = await getMigrations();
   if (allMigrationFiles.length === 0) {
     await initializeMigrationsDirectory(currentSnapshot);
@@ -22,8 +23,8 @@ async function cmd({ config }) {
     return;
   }
   const migrationQueries = await getMigrationQueries({
-    oldCollections: prevSnapshot,
-    newCollections: currentSnapshot
+    oldSnapshot: prevSnapshot,
+    newSnapshot: currentSnapshot
   });
   const largestNumber = allMigrationFiles.reduce((acc, curr) => {
     const num = parseInt(curr.split("_")[0]);

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

@@ -1,9 +1,6 @@
 import deepDiff from "deep-diff";
-import {
-  getMigrations,
-  initializeFromMigrations
-} from "../../../migrations.js";
-const { diff, applyChange } = deepDiff;
+import { getMigrations, initializeFromMigrations } from "../../../migrations.js";
+const { diff } = deepDiff;
 async function cmd({ config }) {
   const currentSnapshot = JSON.parse(JSON.stringify(config.db?.collections ?? {}));
   const allMigrationFiles = await getMigrations();

package/dist/cli/index.js

@@ -1,6 +1,10 @@
 async function cli({ flags, config }) {
   const command = flags._[3];
   switch (command) {
+    case "shell": {
+      const { cmd: shellCommand } = await import("./commands/shell/index.js");
+      return await shellCommand({ config, flags });
+    }
     case "sync": {
       const { cmd: syncCommand } = await import("./commands/sync/index.js");
       return await syncCommand({ config, flags });

package/dist/cli/queries.d.ts

@@ -1,12 +1,12 @@
-import type { DBCollection, DBCollections } from '../types.js';
+import type { DBCollection, DBSnapshot } from '../types.js';
 interface PromptResponses {
     allowDataLoss: boolean;
     fieldRenames: Record<string, string | false>;
     collectionRenames: Record<string, string | false>;
 }
-export declare function getMigrationQueries({ oldCollections, newCollections, promptResponses, }: {
-    oldCollections: DBCollections;
-    newCollections: DBCollections;
+export declare function getMigrationQueries({ oldSnapshot, newSnapshot, promptResponses, }: {
+    oldSnapshot: DBSnapshot;
+    newSnapshot: DBSnapshot;
     promptResponses?: PromptResponses;
 }): Promise<string[]>;
 export declare function getCollectionChangeQueries({ collectionName, oldCollection, newCollection, promptResponses, }: {
@@ -15,5 +15,4 @@ export declare function getCollectionChangeQueries({ collectionName, oldCollecti
     newCollection: DBCollection;
     promptResponses?: PromptResponses;
 }): Promise<string[]>;
-export declare function getCreateTableQuery(collectionName: string, collection: DBCollection): string;
 export {};

package/dist/cli/queries.js

@@ -2,16 +2,17 @@ import * as color from "kleur/colors";
 import { SQLiteAsyncDialect } from "drizzle-orm/sqlite-core";
 import { customAlphabet } from "nanoid";
 import prompts from "prompts";
+import { getCreateTableQuery, getModifiers, hasDefault, hasPrimaryKey, schemaTypeToSqlType } from "../internal.js";
 const sqlite = new SQLiteAsyncDialect();
 const genTempTableName = customAlphabet("abcdefghijklmnopqrstuvwxyz", 10);
 async function getMigrationQueries({
-  oldCollections,
-  newCollections,
+  oldSnapshot,
+  newSnapshot,
   promptResponses
 }) {
   const queries = [];
-  let added = getAddedCollections(oldCollections, newCollections);
-  let dropped = getDroppedCollections(oldCollections, newCollections);
+  let added = getAddedCollections(oldSnapshot, newSnapshot);
+  let dropped = getDroppedCollections(oldSnapshot, newSnapshot);
   if (!isEmpty(added) && !isEmpty(dropped)) {
     const resolved = await resolveCollectionRenames(
       added,
@@ -34,8 +35,8 @@ async function getMigrationQueries({
     const dropQuery = `DROP TABLE ${sqlite.escapeName(collectionName)}`;
     queries.push(dropQuery);
   }
-  for (const [collectionName, newCollection] of Object.entries(newCollections)) {
-    const oldCollection = oldCollections[collectionName];
+  for (const [collectionName, newCollection] of Object.entries(newSnapshot.schema)) {
+    const oldCollection = oldSnapshot.schema[collectionName];
     if (!oldCollection)
       continue;
     const collectionChangeQueries = await getCollectionChangeQueries({
@@ -89,12 +90,9 @@ async function getCollectionChangeQueries({
       )} 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.`,
-      "updated-required": `Changing ${color.blue(color.bold(collectionName))} field ${color.blue(
+      "added-unique": `Adding unique ${color.blue(color.bold(collectionName))} field ${color.blue(
         color.bold(fieldName)
-      )} to required. ${color.red("This will delete all existing data in the collection!")}`,
-      "updated-unique": `Changing ${color.blue(color.bold(collectionName))} field ${color.blue(
-        color.bold(fieldName)
-      )} to unique. ${color.red("This will delete all existing data in the collection!")}`,
+      )}. ${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(
@@ -117,11 +115,21 @@ async function getCollectionChangeQueries({
       process.exit(0);
     }
   }
+  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 recreateTableQueries = getRecreateTableQueries({
-    unescCollectionName: collectionName,
+    unescapedCollectionName: collectionName,
     newCollection,
     added,
-    hasDataLoss: dataLossCheck.dataLoss
+    hasDataLoss: dataLossCheck.dataLoss,
+    migrateHiddenPrimaryKey: !addedPrimaryKey && !droppedPrimaryKey && !updatedPrimaryKey
   });
   queries.push(...recreateTableQueries);
   return queries;
@@ -222,23 +230,23 @@ async function resolveCollectionRenames(mightAdd, mightDrop, renamePromptRespons
 }
 function getAddedCollections(oldCollections, newCollections) {
   const added = {};
-  for (const [key, newCollection] of Object.entries(newCollections)) {
-    if (!(key in oldCollections))
+  for (const [key, newCollection] of Object.entries(newCollections.schema)) {
+    if (!(key in oldCollections.schema))
       added[key] = newCollection;
   }
   return added;
 }
 function getDroppedCollections(oldCollections, newCollections) {
   const dropped = {};
-  for (const [key, oldCollection] of Object.entries(oldCollections)) {
-    if (!(key in newCollections))
+  for (const [key, oldCollection] of Object.entries(oldCollections.schema)) {
+    if (!(key in newCollections.schema))
       dropped[key] = oldCollection;
   }
   return dropped;
 }
-function getFieldRenameQueries(unescCollectionName, renamed) {
+function getFieldRenameQueries(unescapedCollectionName, renamed) {
   const queries = [];
-  const collectionName = sqlite.escapeName(unescCollectionName);
+  const collectionName = sqlite.escapeName(unescapedCollectionName);
   for (const { from, to } of renamed) {
     const q = `ALTER TABLE ${collectionName} RENAME COLUMN ${sqlite.escapeName(
       from
@@ -247,9 +255,9 @@ function getFieldRenameQueries(unescCollectionName, renamed) {
   }
   return queries;
 }
-function getAlterTableQueries(unescCollectionName, added, dropped) {
+function getAlterTableQueries(unescapedCollectionName, added, dropped) {
   const queries = [];
-  const collectionName = sqlite.escapeName(unescCollectionName);
+  const collectionName = sqlite.escapeName(unescapedCollectionName);
   for (const [unescFieldName, field] of Object.entries(added)) {
     const fieldName = sqlite.escapeName(unescFieldName);
     const type = schemaTypeToSqlType(field.type);
@@ -267,92 +275,67 @@ function getAlterTableQueries(unescCollectionName, added, dropped) {
   return queries;
 }
 function getRecreateTableQueries({
-  unescCollectionName,
+  unescapedCollectionName,
   newCollection,
   added,
-  hasDataLoss
+  hasDataLoss,
+  migrateHiddenPrimaryKey
 }) {
-  const unescTempName = `${unescCollectionName}_${genTempTableName()}`;
+  const unescTempName = `${unescapedCollectionName}_${genTempTableName()}`;
   const tempName = sqlite.escapeName(unescTempName);
-  const collectionName = sqlite.escapeName(unescCollectionName);
-  const queries = [getCreateTableQuery(unescTempName, newCollection)];
-  if (!hasDataLoss) {
-    const newColumns = ["id", ...Object.keys(newCollection.fields)];
-    const originalColumns = newColumns.filter((i) => !(i in added));
-    const escapedColumns = originalColumns.map((c) => sqlite.escapeName(c)).join(", ");
-    queries.push(
-      `INSERT INTO ${tempName} (${escapedColumns}) SELECT ${escapedColumns} FROM ${collectionName}`
-    );
+  const collectionName = sqlite.escapeName(unescapedCollectionName);
+  if (hasDataLoss) {
+    return [`DROP TABLE ${collectionName}`, getCreateTableQuery(collectionName, newCollection)];
   }
-  queries.push(`DROP TABLE ${collectionName}`);
-  queries.push(`ALTER TABLE ${tempName} RENAME TO ${collectionName}`);
-  return queries;
-}
-function getCreateTableQuery(collectionName, collection) {
-  let query = `CREATE TABLE ${sqlite.escapeName(collectionName)} (`;
-  const colQueries = ['"id" text PRIMARY KEY'];
-  for (const [columnName, column] of Object.entries(collection.fields)) {
-    const colQuery = `${sqlite.escapeName(columnName)} ${schemaTypeToSqlType(
-      column.type
-    )}${getModifiers(columnName, column)}`;
-    colQueries.push(colQuery);
-  }
-  query += colQueries.join(", ") + ")";
-  return query;
-}
-function getModifiers(columnName, column) {
-  let modifiers = "";
-  if (!column.optional) {
-    modifiers += " NOT NULL";
-  }
-  if (column.unique) {
-    modifiers += " UNIQUE";
-  }
-  if (hasDefault(column)) {
-    modifiers += ` DEFAULT ${getDefaultValueSql(columnName, column)}`;
-  }
-  return modifiers;
-}
-function schemaTypeToSqlType(type) {
-  switch (type) {
-    case "date":
-    case "text":
-    case "json":
-      return "text";
-    case "number":
-    case "boolean":
-      return "integer";
+  const newColumns = [...Object.keys(newCollection.fields)];
+  if (migrateHiddenPrimaryKey) {
+    newColumns.unshift("_id");
   }
+  const escapedColumns = newColumns.filter((i) => !(i in added)).map((c) => sqlite.escapeName(c)).join(", ");
+  return [
+    getCreateTableQuery(unescTempName, newCollection),
+    `INSERT INTO ${tempName} (${escapedColumns}) SELECT ${escapedColumns} FROM ${collectionName}`,
+    `DROP TABLE ${collectionName}`,
+    `ALTER TABLE ${tempName} RENAME TO ${collectionName}`
+  ];
 }
 function isEmpty(obj) {
   return Object.keys(obj).length === 0;
 }
-function canAlterTableAddColumn(column) {
-  if (column.unique)
+function canAlterTableAddColumn(field) {
+  if (field.unique)
     return false;
-  if (hasRuntimeDefault(column))
+  if (hasRuntimeDefault(field))
     return false;
-  if (!column.optional && !hasDefault(column))
+  if (!field.optional && !hasDefault(field))
+    return false;
+  if (hasPrimaryKey(field))
     return false;
   return true;
 }
-function canAlterTableDropColumn(column) {
-  if (column.unique)
+function canAlterTableDropColumn(field) {
+  if (field.unique)
+    return false;
+  if (hasPrimaryKey(field))
     return false;
   return true;
 }
 function canRecreateTableWithoutDataLoss(added, updated) {
   for (const [fieldName, a] of Object.entries(added)) {
-    if (!a.optional && !hasDefault(a))
+    if (hasPrimaryKey(a) && a.type !== "number" && !hasDefault(a)) {
+      return { dataLoss: true, fieldName, reason: "added-required" };
+    }
+    if (!a.optional && !hasDefault(a)) {
       return { dataLoss: true, fieldName, reason: "added-required" };
+    }
+    if (a.unique) {
+      return { dataLoss: true, fieldName, reason: "added-unique" };
+    }
   }
   for (const [fieldName, u] of Object.entries(updated)) {
-    if (u.old.optional && !u.new.optional)
-      return { dataLoss: true, fieldName, reason: "updated-required" };
-    if (!u.old.unique && u.new.unique)
-      return { dataLoss: true, fieldName, reason: "updated-unique" };
-    if (u.old.type !== u.new.type && !canChangeTypeWithoutQuery(u.old, u.new))
+    if (u.old.type !== u.new.type && !canChangeTypeWithoutQuery(u.old, u.new)) {
       return { dataLoss: true, fieldName, reason: "updated-type" };
+    }
   }
   return { dataLoss: false };
 }
@@ -404,38 +387,9 @@ function canChangeTypeWithoutQuery(oldField, newField) {
     ({ from, to }) => oldField.type === from && newField.type === to
   );
 }
-function hasDefault(field) {
-  return field.default !== void 0;
-}
 function hasRuntimeDefault(field) {
   return field.type === "date" && field.default === "now";
 }
-function getDefaultValueSql(columnName, column) {
-  switch (column.type) {
-    case "boolean":
-      return column.default ? "TRUE" : "FALSE";
-    case "number":
-      return `${column.default}`;
-    case "text":
-      return sqlite.escapeString(column.default);
-    case "date":
-      return column.default === "now" ? "CURRENT_TIMESTAMP" : sqlite.escapeString(column.default);
-    case "json": {
-      let stringified = "";
-      try {
-        stringified = JSON.stringify(column.default);
-      } catch (e) {
-        console.log(
-          `Invalid default value for column ${color.bold(
-            columnName
-          )}. Defaults must be valid JSON when using the \`json()\` type.`
-        );
-        process.exit(0);
-      }
-      return sqlite.escapeString(stringified);
-    }
-  }
-}
 function objShallowEqual(a, b) {
   if (Object.keys(a).length !== Object.keys(b).length)
     return false;
@@ -448,6 +402,5 @@ function objShallowEqual(a, b) {
 }
 export {
   getCollectionChangeQueries,
-  getCreateTableQuery,
   getMigrationQueries
 };