@astrojs/db 0.1.0

package/dist/cli/queries.js

@@ -0,0 +1,453 @@
+import * as color from "kleur/colors";
+import { SQLiteAsyncDialect } from "drizzle-orm/sqlite-core";
+import { customAlphabet } from "nanoid";
+import prompts from "prompts";
+const sqlite = new SQLiteAsyncDialect();
+const genTempTableName = customAlphabet("abcdefghijklmnopqrstuvwxyz", 10);
+async function getMigrationQueries({
+  oldCollections,
+  newCollections,
+  promptResponses
+}) {
+  const queries = [];
+  let added = getAddedCollections(oldCollections, newCollections);
+  let dropped = getDroppedCollections(oldCollections, newCollections);
+  if (!isEmpty(added) && !isEmpty(dropped)) {
+    const resolved = await resolveCollectionRenames(
+      added,
+      dropped,
+      promptResponses?.collectionRenames
+    );
+    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);
+    }
+  }
+  for (const [collectionName, collection] of Object.entries(added)) {
+    queries.push(getCreateTableQuery(collectionName, collection));
+  }
+  for (const [collectionName] of Object.entries(dropped)) {
+    const dropQuery = `DROP TABLE ${sqlite.escapeName(collectionName)}`;
+    queries.push(dropQuery);
+  }
+  for (const [collectionName, newCollection] of Object.entries(newCollections)) {
+    const oldCollection = oldCollections[collectionName];
+    if (!oldCollection)
+      continue;
+    const collectionChangeQueries = await getCollectionChangeQueries({
+      collectionName,
+      oldCollection,
+      newCollection,
+      promptResponses
+    });
+    queries.push(...collectionChangeQueries);
+  }
+  return queries;
+}
+async function getCollectionChangeQueries({
+  collectionName,
+  oldCollection,
+  newCollection,
+  promptResponses
+}) {
+  const queries = [];
+  const updated = getUpdatedFields(oldCollection.fields, newCollection.fields);
+  let added = getAddedFields(oldCollection.fields, newCollection.fields);
+  let dropped = getDroppedFields(oldCollection.fields, newCollection.fields);
+  if (isEmpty(updated) && isEmpty(added) && isEmpty(dropped)) {
+    return [];
+  }
+  if (!isEmpty(added) && !isEmpty(dropped)) {
+    const resolved = await resolveFieldRenames(
+      collectionName,
+      added,
+      dropped,
+      promptResponses?.fieldRenames
+    );
+    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)) {
+    queries.push(...getAlterTableQueries(collectionName, added, dropped));
+    return queries;
+  }
+  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.`,
+      "updated-required": `Changing ${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!")}`,
+      "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!"
+      )}`
+    };
+    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.log("Exiting without changes \u{1F44B}");
+      process.exit(0);
+    }
+  }
+  const recreateTableQueries = getRecreateTableQueries({
+    unescCollectionName: collectionName,
+    newCollection,
+    added,
+    hasDataLoss: dataLossCheck.dataLoss
+  });
+  queries.push(...recreateTableQueries);
+  return queries;
+}
+async function resolveFieldRenames(collectionName, mightAdd, mightDrop, renamePromptResponses) {
+  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;
+    }
+    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) {
+      added[fieldName] = field;
+      continue;
+    }
+    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;
+    }
+  }
+  return { added, dropped, renamed };
+}
+async function resolveCollectionRenames(mightAdd, mightDrop, renamePromptResponses) {
+  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;
+    }
+    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) {
+      added[collectionName] = collection;
+      continue;
+    }
+    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;
+    }
+  }
+  return { added, dropped, renamed };
+}
+function getAddedCollections(oldCollections, newCollections) {
+  const added = {};
+  for (const [key, newCollection] of Object.entries(newCollections)) {
+    if (!(key in oldCollections))
+      added[key] = newCollection;
+  }
+  return added;
+}
+function getDroppedCollections(oldCollections, newCollections) {
+  const dropped = {};
+  for (const [key, oldCollection] of Object.entries(oldCollections)) {
+    if (!(key in newCollections))
+      dropped[key] = oldCollection;
+  }
+  return dropped;
+}
+function getFieldRenameQueries(unescCollectionName, renamed) {
+  const queries = [];
+  const collectionName = sqlite.escapeName(unescCollectionName);
+  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(unescCollectionName, added, dropped) {
+  const queries = [];
+  const collectionName = sqlite.escapeName(unescCollectionName);
+  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
+    )}`;
+    queries.push(q);
+  }
+  for (const unescFieldName of Object.keys(dropped)) {
+    const fieldName = sqlite.escapeName(unescFieldName);
+    const q = `ALTER TABLE ${collectionName} DROP COLUMN ${fieldName}`;
+    queries.push(q);
+  }
+  return queries;
+}
+function getRecreateTableQueries({
+  unescCollectionName,
+  newCollection,
+  added,
+  hasDataLoss
+}) {
+  const unescTempName = `${unescCollectionName}_${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}`
+    );
+  }
+  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";
+  }
+}
+function isEmpty(obj) {
+  return Object.keys(obj).length === 0;
+}
+function canAlterTableAddColumn(column) {
+  if (column.unique)
+    return false;
+  if (hasRuntimeDefault(column))
+    return false;
+  if (!column.optional && !hasDefault(column))
+    return false;
+  return true;
+}
+function canAlterTableDropColumn(column) {
+  if (column.unique)
+    return false;
+  return true;
+}
+function canRecreateTableWithoutDataLoss(added, updated) {
+  for (const [fieldName, a] of Object.entries(added)) {
+    if (!a.optional && !hasDefault(a))
+      return { dataLoss: true, fieldName, reason: "added-required" };
+  }
+  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))
+      return { dataLoss: true, fieldName, reason: "updated-type" };
+  }
+  return { dataLoss: false };
+}
+function getAddedFields(oldFields, newFields) {
+  const added = {};
+  for (const [key, newField] of Object.entries(newFields)) {
+    if (!(key in oldFields))
+      added[key] = newField;
+  }
+  return added;
+}
+function getDroppedFields(oldFields, newFields) {
+  const dropped = {};
+  for (const [key, oldField] of Object.entries(oldFields)) {
+    if (!(key in newFields))
+      dropped[key] = oldField;
+  }
+  return dropped;
+}
+function getUpdatedFields(oldFields, newFields) {
+  const updated = {};
+  for (const [key, newField] of Object.entries(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 };
+  }
+  return updated;
+}
+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) {
+  return typeChangesWithoutQuery.some(
+    ({ 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;
+  for (const [key, value] of Object.entries(a)) {
+    if (JSON.stringify(b[key]) !== JSON.stringify(value)) {
+      return false;
+    }
+  }
+  return true;
+}
+export {
+  getCollectionChangeQueries,
+  getCreateTableQuery,
+  getMigrationQueries
+};

package/dist/cli/seed.d.ts

@@ -0,0 +1,6 @@
+import type { DBCollections } from 'circle-rhyme-yes-measure';
+export declare function seed({ collections, projectId, appToken, }: {
+    collections: DBCollections;
+    projectId: string;
+    appToken: string;
+}): Promise<void>;

package/dist/cli/sync/admin.d.ts

@@ -0,0 +1,33 @@
+export declare const STUDIO_ADMIN_TABLE = "ReservedAstroStudioAdmin";
+export declare const STUDIO_ADMIN_TABLE_ROW_ID = "admin";
+export declare const adminTable: import("drizzle-orm/sqlite-core").SQLiteTableWithColumns<{
+    name: "ReservedAstroStudioAdmin";
+    schema: undefined;
+    columns: {
+        id: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "id";
+            tableName: "ReservedAstroStudioAdmin";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+        }, object>;
+        collections: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "collections";
+            tableName: "ReservedAstroStudioAdmin";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+        }, object>;
+    };
+    dialect: "sqlite";
+}>;

package/dist/cli/sync/index.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/cli/sync/migrate.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/cli/sync/queries.d.ts

@@ -0,0 +1,19 @@
+import type { DBCollection, DBCollections } 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;
+    promptResponses?: PromptResponses;
+}): Promise<string[]>;
+export declare function getCollectionChangeQueries({ collectionName, oldCollection, newCollection, promptResponses, }: {
+    collectionName: string;
+    oldCollection: DBCollection;
+    newCollection: DBCollection;
+    promptResponses?: PromptResponses;
+}): Promise<string[]>;
+export declare function getCreateTableQuery(collectionName: string, collection: DBCollection): string;
+export {};

package/dist/cli/sync/remote-db.d.ts

@@ -0,0 +1 @@
+export declare function createDb(appToken: string): any;