@astrojs/db 0.0.0-db-export-bug-20240307130354

package/dist/core/cli/index.js

@@ -0,0 +1,77 @@
+import { loadDbConfigFile } from "../load-file.js";
+import { dbConfigSchema } from "../types.js";
+async function cli({
+  flags,
+  config: astroConfig
+}) {
+  const args = flags._;
+  const command = args[2] === "db" ? args[3] : args[2];
+  const { mod } = await loadDbConfigFile(astroConfig.root);
+  const dbConfig = dbConfigSchema.parse(mod?.default ?? {});
+  switch (command) {
+    case "shell": {
+      const { cmd } = await import("./commands/shell/index.js");
+      return await cmd({ astroConfig, dbConfig, flags });
+    }
+    case "gen": {
+      console.log('"astro db gen" is no longer needed! Visit the docs for more information.');
+      return;
+    }
+    case "sync": {
+      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");
+      return await cmd({ astroConfig, dbConfig, flags });
+    }
+    case "verify": {
+      const { cmd } = await import("./commands/verify/index.js");
+      return await cmd({ astroConfig, dbConfig, flags });
+    }
+    case "execute": {
+      const { cmd } = await import("./commands/execute/index.js");
+      return await cmd({ astroConfig, dbConfig, flags });
+    }
+    case "login": {
+      const { cmd } = await import("./commands/login/index.js");
+      return await cmd({ astroConfig, dbConfig, flags });
+    }
+    case "logout": {
+      const { cmd } = await import("./commands/logout/index.js");
+      return await cmd();
+    }
+    case "link": {
+      const { cmd } = await import("./commands/link/index.js");
+      return await cmd();
+    }
+    default: {
+      if (command == null) {
+        console.error(`No command provided.
+
+${showHelp()}`);
+      } else {
+        console.error(`Unknown command: ${command}
+
+${showHelp()}`);
+      }
+      return;
+    }
+  }
+  function showHelp() {
+    return `astro db <command>
+		
+Usage:
+
+astro login          Authenticate your machine with Astro Studio
+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 schema updates to Astro Studio
+astro db verify      Tests schema updates /w Astro Studio (good for CI)`;
+  }
+}
+export {
+  cli
+};

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

@@ -0,0 +1,22 @@
+import { type DBConfig, type DBSnapshot, type DBTable } from '../types.js';
+export declare function getMigrationQueries({ oldSnapshot, newSnapshot, }: {
+    oldSnapshot: DBSnapshot;
+    newSnapshot: DBSnapshot;
+}): Promise<{
+    queries: string[];
+    confirmations: string[];
+}>;
+export declare function getCollectionChangeQueries({ collectionName, oldCollection, newCollection, }: {
+    collectionName: string;
+    oldCollection: DBTable;
+    newCollection: DBTable;
+}): Promise<{
+    queries: string[];
+    confirmations: string[];
+}>;
+export declare function getProductionCurrentSnapshot({ appToken, }: {
+    appToken: string;
+}): Promise<DBSnapshot>;
+export declare function createCurrentSnapshot({ tables }: DBConfig): DBSnapshot;
+export declare function createEmptySnapshot(): DBSnapshot;
+export declare function formatDataLossMessage(confirmations: string[], isColor?: boolean): string;

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

@@ -0,0 +1,366 @@
+import deepDiff from "deep-diff";
+import { SQLiteAsyncDialect } from "drizzle-orm/sqlite-core";
+import * as color from "kleur/colors";
+import { customAlphabet } from "nanoid";
+import stripAnsi from "strip-ansi";
+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
+}) {
+  const queries = [];
+  const confirmations = [];
+  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(addedCollections)) {
+    queries.push(getDropTableIfExistsQuery(collectionName));
+    queries.push(getCreateTableQuery(collectionName, collection));
+    queries.push(...getCreateIndexQueries(collectionName, collection));
+  }
+  for (const [collectionName] of Object.entries(droppedTables)) {
+    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 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,
+      newCollection
+    });
+    queries.push(...result.queries);
+    confirmations.push(...result.confirmations);
+  }
+  return { queries, confirmations };
+}
+async function getCollectionChangeQueries({
+  collectionName,
+  oldCollection,
+  newCollection
+}) {
+  const queries = [];
+  const confirmations = [];
+  const updated = getUpdatedColumns(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)
+  );
+  if (!hasForeignKeyChanges && isEmpty(updated) && isEmpty(added) && isEmpty(dropped)) {
+    return {
+      queries: getChangeIndexQueries({
+        collectionName,
+        oldIndexes: oldCollection.indexes,
+        newIndexes: newCollection.indexes
+      }),
+      confirmations
+    };
+  }
+  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": `You added new required column '${color.bold(
+        collectionName + "." + columnName
+      )}' with no default value.
+      This cannot be executed on an existing table.`,
+      "updated-type": `Updating existing column ${color.bold(
+        collectionName + "." + columnName
+      )} to a new type that cannot be handled automatically.`
+    };
+    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;
+}
+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 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" };
+    }
+  }
+  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));
+}
+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: {} };
+}
+function formatDataLossMessage(confirmations, isColor = true) {
+  const messages = [];
+  messages.push(color.red("\u2716 We found some schema changes that cannot be handled automatically:"));
+  messages.push(``);
+  messages.push(...confirmations.map((m, i) => color.red(`  (${i + 1}) `) + m));
+  messages.push(``);
+  messages.push(`To resolve, revert these changes or update your schema, and re-run the command.`);
+  messages.push(
+    `You may also run 'astro db push --force-reset' to ignore all warnings and force-push your local database schema to production instead. All data will be lost and the database will be reset.`
+  );
+  let finalMessage = messages.join("\n");
+  if (!isColor) {
+    finalMessage = stripAnsi(finalMessage);
+  }
+  return finalMessage;
+}
+export {
+  createCurrentSnapshot,
+  createEmptySnapshot,
+  formatDataLossMessage,
+  getCollectionChangeQueries,
+  getMigrationQueries,
+  getProductionCurrentSnapshot
+};

package/dist/core/consts.d.ts

@@ -0,0 +1,7 @@
+export declare const PACKAGE_NAME: any;
+export declare const RUNTIME_IMPORT: string;
+export declare const RUNTIME_CONFIG_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";
+export declare const CONFIG_FILE_NAMES: string[];

package/dist/core/consts.js

@@ -0,0 +1,19 @@
+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_CONFIG_IMPORT = JSON.stringify(`${PACKAGE_NAME}/runtime/config`);
+const DB_TYPES_FILE = "db-types.d.ts";
+const VIRTUAL_MODULE_ID = "astro:db";
+const DB_PATH = ".astro/content.db";
+const CONFIG_FILE_NAMES = ["config.ts", "config.js", "config.mts", "config.mjs"];
+export {
+  CONFIG_FILE_NAMES,
+  DB_PATH,
+  DB_TYPES_FILE,
+  PACKAGE_NAME,
+  RUNTIME_CONFIG_IMPORT,
+  RUNTIME_IMPORT,
+  VIRTUAL_MODULE_ID
+};

package/dist/core/errors.d.ts

@@ -0,0 +1,11 @@
+export declare const MISSING_SESSION_ID_ERROR: string;
+export declare const MISSING_PROJECT_ID_ERROR: 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;
+export declare const FOREIGN_KEY_DNE_ERROR: (tableName: string) => string;
+export declare const FOREIGN_KEY_REFERENCES_LENGTH_ERROR: (tableName: string) => string;
+export declare const FOREIGN_KEY_REFERENCES_EMPTY_ERROR: (tableName: string) => string;

package/dist/core/errors.js

@@ -0,0 +1,65 @@
+import { bold, cyan, green, red, 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 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) => {
+  return `${red(`Error while seeding database:`)}
+
+${error}`;
+};
+const REFERENCE_DNE_ERROR = (columnName) => {
+  return `Column ${bold(
+    columnName
+  )} references a table that does not exist. Did you apply the referenced table to the \`tables\` object in your db config?`;
+};
+const FOREIGN_KEY_DNE_ERROR = (tableName) => {
+  return `Table ${bold(
+    tableName
+  )} references a table that does not exist. Did you apply the referenced table to the \`tables\` object in your db config?`;
+};
+const FOREIGN_KEY_REFERENCES_LENGTH_ERROR = (tableName) => {
+  return `Foreign key on ${bold(
+    tableName
+  )} is misconfigured. \`columns\` and \`references\` must be the same length.`;
+};
+const FOREIGN_KEY_REFERENCES_EMPTY_ERROR = (tableName) => {
+  return `Foreign key on ${bold(
+    tableName
+  )} is misconfigured. \`references\` array cannot be empty.`;
+};
+export {
+  FILE_NOT_FOUND_ERROR,
+  FOREIGN_KEY_DNE_ERROR,
+  FOREIGN_KEY_REFERENCES_EMPTY_ERROR,
+  FOREIGN_KEY_REFERENCES_LENGTH_ERROR,
+  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/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;

package/dist/core/integration/error-map.js

@@ -0,0 +1,79 @@
+const errorMap = (baseError, ctx) => {
+  const baseErrorPath = flattenErrorPath(baseError.path);
+  if (baseError.code === "invalid_union") {
+    const typeOrLiteralErrByPath = /* @__PURE__ */ new Map();
+    for (const unionError of baseError.unionErrors.flatMap((e) => e.errors)) {
+      if (unionError.code === "invalid_type" || unionError.code === "invalid_literal") {
+        const flattenedErrorPath = flattenErrorPath(unionError.path);
+        const typeOrLiteralErr = typeOrLiteralErrByPath.get(flattenedErrorPath);
+        if (typeOrLiteralErr) {
+          typeOrLiteralErr.expected.push(unionError.expected);
+        } else {
+          typeOrLiteralErrByPath.set(flattenedErrorPath, {
+            code: unionError.code,
+            received: unionError.received,
+            expected: [unionError.expected]
+          });
+        }
+      }
+    }
+    const messages = [
+      prefix(
+        baseErrorPath,
+        typeOrLiteralErrByPath.size ? "Did not match union:" : "Did not match union."
+      )
+    ];
+    return {
+      message: messages.concat(
+        [...typeOrLiteralErrByPath.entries()].filter(([, error]) => error.expected.length === baseError.unionErrors.length).map(
+          ([key, error]) => (
+            // Avoid printing the key again if it's a base error
+            key === baseErrorPath ? `> ${getTypeOrLiteralMsg(error)}` : `> ${prefix(key, getTypeOrLiteralMsg(error))}`
+          )
+        )
+      ).join("\n")
+    };
+  }
+  if (baseError.code === "invalid_literal" || baseError.code === "invalid_type") {
+    return {
+      message: prefix(
+        baseErrorPath,
+        getTypeOrLiteralMsg({
+          code: baseError.code,
+          received: baseError.received,
+          expected: [baseError.expected]
+        })
+      )
+    };
+  } else if (baseError.message) {
+    return { message: prefix(baseErrorPath, baseError.message) };
+  } else {
+    return { message: prefix(baseErrorPath, ctx.defaultError) };
+  }
+};
+const getTypeOrLiteralMsg = (error) => {
+  if (error.received === "undefined")
+    return "Required";
+  const expectedDeduped = new Set(error.expected);
+  switch (error.code) {
+    case "invalid_type":
+      return `Expected type \`${unionExpectedVals(expectedDeduped)}\`, received ${JSON.stringify(
+        error.received
+      )}`;
+    case "invalid_literal":
+      return `Expected \`${unionExpectedVals(expectedDeduped)}\`, received ${JSON.stringify(
+        error.received
+      )}`;
+  }
+};
+const prefix = (key, msg) => key.length ? `**${key}**: ${msg}` : msg;
+const unionExpectedVals = (expectedVals) => [...expectedVals].map((expectedVal, idx) => {
+  if (idx === 0)
+    return JSON.stringify(expectedVal);
+  const sep = " | ";
+  return `${sep}${JSON.stringify(expectedVal)}`;
+}).join("");
+const flattenErrorPath = (errorPath) => errorPath.join(".");
+export {
+  errorMap
+};

package/dist/core/integration/file-url.d.ts

@@ -0,0 +1,2 @@
+import type { AstroIntegration } from 'astro';
+export declare function fileURLIntegration(): AstroIntegration;