@astrojs/db 0.0.0-edge-nested-20240223135627

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

@@ -0,0 +1,418 @@
+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";
+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,
+  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, 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);
+    }
+  }
+  for (const [collectionName, collection] of Object.entries(added)) {
+    queries.push(getCreateTableQuery(collectionName, collection));
+    queries.push(...getCreateIndexQueries(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(newSnapshot.schema)) {
+    const oldCollection = oldSnapshot.schema[collectionName];
+    if (!oldCollection)
+      continue;
+    const result = await getCollectionChangeQueries({
+      collectionName,
+      oldCollection,
+      newCollection
+    });
+    queries.push(...result.queries);
+    confirmations.push(...result.confirmations);
+  }
+  return { queries, confirmations };
+}
+async function getCollectionChangeQueries({
+  collectionName,
+  oldCollection,
+  newCollection,
+  ambiguityResponses
+}) {
+  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 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 (!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),
+      ...getChangeIndexQueries({
+        collectionName,
+        oldIndexes: oldCollection.indexes,
+        newIndexes: newCollection.indexes
+      })
+    );
+    return { queries, confirmations };
+  }
+  const dataLossCheck = canRecreateTableWithoutDataLoss(added, updated);
+  if (dataLossCheck.dataLoss) {
+    const { reason, columnName } = dataLossCheck;
+    const reasonMsgs = {
+      "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 column ${color.bold(
+        collectionName + "." + columnName
+      )} is marked as unique.
+This requires deleting existing data in the ${color.bold(
+        collectionName
+      )} collection.`,
+      "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.columns).find(
+    ([, column]) => hasPrimaryKey(column)
+  );
+  const droppedPrimaryKey = Object.entries(dropped).find(([, column]) => hasPrimaryKey(column));
+  const recreateTableQueries = getRecreateTableQueries({
+    collectionName,
+    newCollection,
+    added,
+    hasDataLoss: dataLossCheck.dataLoss,
+    migrateHiddenPrimaryKey: !primaryKeyExists && !droppedPrimaryKey
+  });
+  queries.push(...recreateTableQueries, ...getCreateIndexQueries(collectionName, newCollection));
+  return { queries, confirmations };
+}
+function getChangeIndexQueries({
+  collectionName,
+  oldIndexes = {},
+  newIndexes = {}
+}) {
+  const added = getAdded(oldIndexes, newIndexes);
+  const dropped = getDropped(oldIndexes, newIndexes);
+  const updated = getUpdated(oldIndexes, newIndexes);
+  Object.assign(dropped, updated);
+  Object.assign(added, updated);
+  const queries = [];
+  for (const indexName of Object.keys(dropped)) {
+    const dropQuery = `DROP INDEX ${sqlite.escapeName(indexName)}`;
+    queries.push(dropQuery);
+  }
+  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)) {
+    if (!(key in oldCollections.schema))
+      added[key] = newCollection;
+  }
+  return added;
+}
+function getDroppedCollections(oldCollections, newCollections) {
+  const dropped = {};
+  for (const [key, oldCollection] of Object.entries(oldCollections.schema)) {
+    if (!(key in newCollections.schema))
+      dropped[key] = oldCollection;
+  }
+  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);
+  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 unescColumnName of Object.keys(dropped)) {
+    const columnName = sqlite.escapeName(unescColumnName);
+    const q = `ALTER TABLE ${collectionName} DROP COLUMN ${columnName}`;
+    queries.push(q);
+  }
+  return queries;
+}
+function getRecreateTableQueries({
+  collectionName: unescCollectionName,
+  newCollection,
+  added,
+  hasDataLoss,
+  migrateHiddenPrimaryKey
+}) {
+  const unescTempName = `${unescCollectionName}_${genTempTableName()}`;
+  const tempName = sqlite.escapeName(unescTempName);
+  const collectionName = sqlite.escapeName(unescCollectionName);
+  if (hasDataLoss) {
+    return [
+      `DROP TABLE ${collectionName}`,
+      getCreateTableQuery(unescCollectionName, newCollection)
+    ];
+  }
+  const newColumns = [...Object.keys(newCollection.columns)];
+  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.schema.unique)
+    return false;
+  if (hasRuntimeDefault(column))
+    return false;
+  if (!column.schema.optional && !hasDefault(column))
+    return false;
+  if (hasPrimaryKey(column))
+    return false;
+  if (getReferencesConfig(column))
+    return false;
+  return true;
+}
+function canAlterTableDropColumn(column) {
+  if (column.schema.unique)
+    return false;
+  if (hasPrimaryKey(column))
+    return false;
+  return true;
+}
+function canRecreateTableWithoutDataLoss(added, updated) {
+  for (const [columnName, a] of Object.entries(added)) {
+    if (hasPrimaryKey(a) && a.type !== "number" && !hasDefault(a)) {
+      return { dataLoss: true, columnName, reason: "added-required" };
+    }
+    if (!a.schema.optional && !hasDefault(a)) {
+      return { dataLoss: true, columnName, reason: "added-required" };
+    }
+    if (!a.schema.optional && a.schema.unique) {
+      return { dataLoss: true, columnName, reason: "added-unique" };
+    }
+  }
+  for (const [columnName, u] of Object.entries(updated)) {
+    if (u.old.type !== u.new.type && !canChangeTypeWithoutQuery(u.old, u.new)) {
+      return { dataLoss: true, columnName, reason: "updated-type" };
+    }
+  }
+  return { dataLoss: false };
+}
+function getAdded(oldObj, newObj) {
+  const added = {};
+  for (const [key, value] of Object.entries(newObj)) {
+    if (!(key in oldObj))
+      added[key] = value;
+  }
+  return added;
+}
+function getDropped(oldObj, newObj) {
+  const dropped = {};
+  for (const [key, value] of Object.entries(oldObj)) {
+    if (!(key in newObj))
+      dropped[key] = value;
+  }
+  return dropped;
+}
+function getUpdated(oldObj, newObj) {
+  const updated = {};
+  for (const [key, value] of Object.entries(newObj)) {
+    const oldValue = oldObj[key];
+    if (!oldValue)
+      continue;
+    if (deepDiff(oldValue, value))
+      updated[key] = value;
+  }
+  return updated;
+}
+function getUpdatedColumns(oldColumns, newColumns) {
+  const updated = {};
+  for (const [key, newColumn] of Object.entries(newColumns)) {
+    let oldColumn = oldColumns[key];
+    if (!oldColumn)
+      continue;
+    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: oldColumn, new: newColumn };
+    }
+  }
+  return updated;
+}
+const typeChangesWithoutQuery = [
+  { from: "boolean", to: "number" },
+  { from: "date", to: "text" },
+  { from: "json", to: "text" }
+];
+function canChangeTypeWithoutQuery(oldColumn, newColumn) {
+  return typeChangesWithoutQuery.some(
+    ({ from, to }) => oldColumn.type === from && newColumn.type === to
+  );
+}
+function hasRuntimeDefault(column) {
+  return !!(column.schema.default && isSerializedSQL(column.schema.default));
+}
+export {
+  getCollectionChangeQueries,
+  getMigrationQueries
+};

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

@@ -0,0 +1,34 @@
+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;
+    newFileContent?: 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>;
+export declare function initializeFromMigrations(allMigrationFiles: string[]): Promise<DBSnapshot>;
+export declare function createCurrentSnapshot(config: AstroConfig): DBSnapshot;
+export declare function createEmptySnapshot(): DBSnapshot;

package/dist/core/cli/migrations.js

@@ -0,0 +1,129 @@
+import deepDiff from "deep-diff";
+import { mkdir, readFile, readdir, writeFile } from "fs/promises";
+import { tablesSchema } 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") {
+      return [];
+    }
+    throw err;
+  });
+  return migrationFiles;
+}
+async function loadMigration(migration) {
+  return JSON.parse(await readFile(`./migrations/${migration}`, "utf-8"));
+}
+async function loadInitialSnapshot() {
+  const snapshot = JSON.parse(await readFile("./migrations/0000_snapshot.json", "utf-8"));
+  if (snapshot.experimentalVersion === 1) {
+    return snapshot;
+  }
+  if (!snapshot.schema) {
+    return { experimentalVersion: 1, schema: snapshot };
+  }
+  throw new Error("Invalid snapshot format");
+}
+async function initializeMigrationsDirectory(currentSnapshot) {
+  await mkdir("./migrations", { recursive: true });
+  await writeFile("./migrations/0000_snapshot.json", JSON.stringify(currentSnapshot, void 0, 2));
+}
+async function initializeFromMigrations(allMigrationFiles) {
+  const prevSnapshot = await loadInitialSnapshot();
+  for (const migration of allMigrationFiles) {
+    if (migration === "0000_snapshot.json")
+      continue;
+    const migrationContent = await loadMigration(migration);
+    migrationContent.diff.forEach((change) => {
+      applyChange(prevSnapshot, {}, change);
+    });
+  }
+  return prevSnapshot;
+}
+function createCurrentSnapshot(config) {
+  const tablesConfig = tablesSchema.parse(config.db?.tables ?? {});
+  const schema = JSON.parse(JSON.stringify(tablesConfig));
+  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,
+  loadInitialSnapshot,
+  loadMigration
+};

package/dist/core/consts.d.ts

@@ -0,0 +1,6 @@
+export declare const PACKAGE_NAME: any;
+export declare const RUNTIME_IMPORT: string;
+export declare const RUNTIME_DRIZZLE_IMPORT: string;
+export declare const DB_TYPES_FILE = "db-types.d.ts";
+export declare const VIRTUAL_MODULE_ID = "astro:db";
+export declare const DB_PATH = ".astro/content.db";

package/dist/core/consts.js

@@ -0,0 +1,17 @@
+import { readFileSync } from "node:fs";
+const PACKAGE_NAME = JSON.parse(
+  readFileSync(new URL("../../package.json", import.meta.url), "utf8")
+).name;
+const RUNTIME_IMPORT = JSON.stringify(`${PACKAGE_NAME}/runtime`);
+const RUNTIME_DRIZZLE_IMPORT = JSON.stringify(`${PACKAGE_NAME}/runtime/drizzle`);
+const DB_TYPES_FILE = "db-types.d.ts";
+const VIRTUAL_MODULE_ID = "astro:db";
+const DB_PATH = ".astro/content.db";
+export {
+  DB_PATH,
+  DB_TYPES_FILE,
+  PACKAGE_NAME,
+  RUNTIME_DRIZZLE_IMPORT,
+  RUNTIME_IMPORT,
+  VIRTUAL_MODULE_ID
+};

package/dist/core/errors.d.ts

@@ -0,0 +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

@@ -0,0 +1,54 @@
+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 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!"
+)}
+
+  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,
+  UNSAFE_WRITABLE_WARNING
+};

package/dist/core/integration/error-map.d.ts

@@ -0,0 +1,6 @@
+/**
+ * This is a modified version of Astro's error map. source:
+ * https://github.com/withastro/astro/blob/main/packages/astro/src/content/error-map.ts
+ */
+import type { z } from 'astro/zod';
+export declare const errorMap: z.ZodErrorMap;