@astrojs/db 0.0.0-10646-20240402132948

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

@@ -0,0 +1,386 @@
+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 { safeFetch } from "../../runtime/utils.js";
+import { MIGRATION_VERSION } from "../consts.js";
+import { RENAME_COLUMN_ERROR, RENAME_TABLE_ERROR } from "../errors.js";
+import { columnSchema } from "../schemas.js";
+import {
+} from "../types.js";
+import { getRemoteDatabaseUrl } from "../utils.js";
+const sqlite = new SQLiteAsyncDialect();
+const genTempTableName = customAlphabet("abcdefghijklmnopqrstuvwxyz", 10);
+async function getMigrationQueries({
+  oldSnapshot,
+  newSnapshot,
+  reset = false
+}) {
+  const queries = [];
+  const confirmations = [];
+  if (reset) {
+    const currentSnapshot = oldSnapshot;
+    oldSnapshot = createEmptySnapshot();
+    queries.push(...getDropTableQueriesForSnapshot(currentSnapshot));
+  }
+  const addedTables = getAddedTables(oldSnapshot, newSnapshot);
+  const droppedTables = getDroppedTables(oldSnapshot, newSnapshot);
+  const notDeprecatedDroppedTables = Object.fromEntries(
+    Object.entries(droppedTables).filter(([, table]) => !table.deprecated)
+  );
+  if (!isEmpty(addedTables) && !isEmpty(notDeprecatedDroppedTables)) {
+    throw new Error(
+      RENAME_TABLE_ERROR(Object.keys(addedTables)[0], Object.keys(notDeprecatedDroppedTables)[0])
+    );
+  }
+  for (const [tableName, table] of Object.entries(addedTables)) {
+    queries.push(getCreateTableQuery(tableName, table));
+    queries.push(...getCreateIndexQueries(tableName, table));
+  }
+  for (const [tableName] of Object.entries(droppedTables)) {
+    const dropQuery = `DROP TABLE ${sqlite.escapeName(tableName)}`;
+    queries.push(dropQuery);
+  }
+  for (const [tableName, newTable] of Object.entries(newSnapshot.schema)) {
+    const oldTable = oldSnapshot.schema[tableName];
+    if (!oldTable)
+      continue;
+    const addedColumns = getAdded(oldTable.columns, newTable.columns);
+    const droppedColumns = getDropped(oldTable.columns, newTable.columns);
+    const notDeprecatedDroppedColumns = Object.fromEntries(
+      Object.entries(droppedColumns).filter(([, col]) => !col.schema.deprecated)
+    );
+    if (!isEmpty(addedColumns) && !isEmpty(notDeprecatedDroppedColumns)) {
+      throw new Error(
+        RENAME_COLUMN_ERROR(
+          `${tableName}.${Object.keys(addedColumns)[0]}`,
+          `${tableName}.${Object.keys(notDeprecatedDroppedColumns)[0]}`
+        )
+      );
+    }
+    const result = await getTableChangeQueries({
+      tableName,
+      oldTable,
+      newTable
+    });
+    queries.push(...result.queries);
+    confirmations.push(...result.confirmations);
+  }
+  return { queries, confirmations };
+}
+async function getTableChangeQueries({
+  tableName,
+  oldTable,
+  newTable
+}) {
+  const queries = [];
+  const confirmations = [];
+  const updated = getUpdatedColumns(oldTable.columns, newTable.columns);
+  const added = getAdded(oldTable.columns, newTable.columns);
+  const dropped = getDropped(oldTable.columns, newTable.columns);
+  const hasForeignKeyChanges = Boolean(deepDiff(oldTable.foreignKeys, newTable.foreignKeys));
+  if (!hasForeignKeyChanges && isEmpty(updated) && isEmpty(added) && isEmpty(dropped)) {
+    return {
+      queries: getChangeIndexQueries({
+        tableName,
+        oldIndexes: oldTable.indexes,
+        newIndexes: newTable.indexes
+      }),
+      confirmations
+    };
+  }
+  if (!hasForeignKeyChanges && isEmpty(updated) && Object.values(dropped).every(canAlterTableDropColumn) && Object.values(added).every(canAlterTableAddColumn)) {
+    queries.push(
+      ...getAlterTableQueries(tableName, added, dropped),
+      ...getChangeIndexQueries({
+        tableName,
+        oldIndexes: oldTable.indexes,
+        newIndexes: newTable.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(
+        tableName + "." + columnName
+      )}' with no default value.
+      This cannot be executed on an existing table.`,
+      "updated-type": `Updating existing column ${color.bold(
+        tableName + "." + columnName
+      )} to a new type that cannot be handled automatically.`
+    };
+    confirmations.push(reasonMsgs[reason]);
+  }
+  const primaryKeyExists = Object.entries(newTable.columns).find(
+    ([, column]) => hasPrimaryKey(column)
+  );
+  const droppedPrimaryKey = Object.entries(dropped).find(([, column]) => hasPrimaryKey(column));
+  const recreateTableQueries = getRecreateTableQueries({
+    tableName,
+    newTable,
+    added,
+    hasDataLoss: dataLossCheck.dataLoss,
+    migrateHiddenPrimaryKey: !primaryKeyExists && !droppedPrimaryKey
+  });
+  queries.push(...recreateTableQueries, ...getCreateIndexQueries(tableName, newTable));
+  return { queries, confirmations };
+}
+function getChangeIndexQueries({
+  tableName,
+  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(tableName, { indexes: added }));
+  return queries;
+}
+function getAddedTables(oldTables, newTables) {
+  const added = {};
+  for (const [key, newTable] of Object.entries(newTables.schema)) {
+    if (!(key in oldTables.schema))
+      added[key] = newTable;
+  }
+  return added;
+}
+function getDroppedTables(oldTables, newTables) {
+  const dropped = {};
+  for (const [key, oldTable] of Object.entries(oldTables.schema)) {
+    if (!(key in newTables.schema))
+      dropped[key] = oldTable;
+  }
+  return dropped;
+}
+function getAlterTableQueries(unescTableName, added, dropped) {
+  const queries = [];
+  const tableName = sqlite.escapeName(unescTableName);
+  for (const [unescColumnName, column] of Object.entries(added)) {
+    const columnName = sqlite.escapeName(unescColumnName);
+    const type = schemaTypeToSqlType(column.type);
+    const q = `ALTER TABLE ${tableName} 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 ${tableName} DROP COLUMN ${columnName}`;
+    queries.push(q);
+  }
+  return queries;
+}
+function getRecreateTableQueries({
+  tableName: unescTableName,
+  newTable,
+  added,
+  hasDataLoss,
+  migrateHiddenPrimaryKey
+}) {
+  const unescTempName = `${unescTableName}_${genTempTableName()}`;
+  const tempName = sqlite.escapeName(unescTempName);
+  const tableName = sqlite.escapeName(unescTableName);
+  if (hasDataLoss) {
+    return [`DROP TABLE ${tableName}`, getCreateTableQuery(unescTableName, newTable)];
+  }
+  const newColumns = [...Object.keys(newTable.columns)];
+  if (migrateHiddenPrimaryKey) {
+    newColumns.unshift("_id");
+  }
+  const escapedColumns = newColumns.filter((i) => !(i in added)).map((c) => sqlite.escapeName(c)).join(", ");
+  return [
+    getCreateTableQuery(unescTempName, newTable),
+    `INSERT INTO ${tempName} (${escapedColumns}) SELECT ${escapedColumns} FROM ${tableName}`,
+    `DROP TABLE ${tableName}`,
+    `ALTER TABLE ${tempName} RENAME TO ${tableName}`
+  ];
+}
+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 safeFetch(
+    url,
+    {
+      method: "POST",
+      headers: new Headers({
+        Authorization: `Bearer ${appToken}`
+      })
+    },
+    async (res) => {
+      console.error(`${url.toString()} failed: ${res.status} ${res.statusText}`);
+      console.error(await res.text());
+      throw new Error(`/db/schema fetch failed: ${res.status} ${res.statusText}`);
+    }
+  );
+  const result = await response.json();
+  if (!result.success) {
+    console.error(`${url.toString()} unsuccessful`);
+    console.error(await response.text());
+    throw new Error(`/db/schema fetch unsuccessful`);
+  }
+  return result.data;
+}
+function getDropTableQueriesForSnapshot(snapshot) {
+  const queries = [];
+  for (const tableName of Object.keys(snapshot.schema)) {
+    const dropQuery = getDropTableIfExistsQuery(tableName);
+    queries.unshift(dropQuery);
+  }
+  return queries;
+}
+function createCurrentSnapshot({ tables = {} }) {
+  const schema = JSON.parse(JSON.stringify(tables));
+  return { version: MIGRATION_VERSION, schema };
+}
+function createEmptySnapshot() {
+  return { version: MIGRATION_VERSION, 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,
+  getMigrationQueries,
+  getProductionCurrentSnapshot,
+  getTableChangeQueries
+};

package/dist/core/cli/print-help.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Uses implementation from Astro core
+ * @see https://github.com/withastro/astro/blob/main/packages/astro/src/core/messages.ts#L303
+ */
+export declare function printHelp({ commandName, headline, usage, tables, description, }: {
+    commandName: string;
+    headline?: string;
+    usage?: string;
+    tables?: Record<string, [command: string, help: string][]>;
+    description?: string;
+}): void;

package/dist/core/cli/print-help.js

@@ -0,0 +1,55 @@
+import { bgGreen, bgWhite, black, bold, dim, green } from "kleur/colors";
+function printHelp({
+  commandName,
+  headline,
+  usage,
+  tables,
+  description
+}) {
+  const linebreak = () => "";
+  const title = (label) => `  ${bgWhite(black(` ${label} `))}`;
+  const table = (rows, { padding }) => {
+    const split = process.stdout.columns < 60;
+    let raw = "";
+    for (const row of rows) {
+      if (split) {
+        raw += `    ${row[0]}
+    `;
+      } else {
+        raw += `${`${row[0]}`.padStart(padding)}`;
+      }
+      raw += "  " + dim(row[1]) + "\n";
+    }
+    return raw.slice(0, -1);
+  };
+  let message = [];
+  if (headline) {
+    message.push(
+      linebreak(),
+      `  ${bgGreen(black(` ${commandName} `))} ${green(
+        `v${"0.0.0-10646-20240402132948"}`
+      )} ${headline}`
+    );
+  }
+  if (usage) {
+    message.push(linebreak(), `  ${green(commandName)} ${bold(usage)}`);
+  }
+  if (tables) {
+    let calculateTablePadding2 = function(rows) {
+      return rows.reduce((val, [first]) => Math.max(val, first.length), 0) + 2;
+    };
+    var calculateTablePadding = calculateTablePadding2;
+    const tableEntries = Object.entries(tables);
+    const padding = Math.max(...tableEntries.map(([, rows]) => calculateTablePadding2(rows)));
+    for (const [tableTitle, tableRows] of tableEntries) {
+      message.push(linebreak(), title(tableTitle), table(tableRows, { padding }));
+    }
+  }
+  if (description) {
+    message.push(linebreak(), `${description}`);
+  }
+  console.log(message.join("\n") + "\n");
+}
+export {
+  printHelp
+};

package/dist/core/consts.d.ts

@@ -0,0 +1,8 @@
+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[];
+export declare const MIGRATION_VERSION = "2024-03-12";

package/dist/core/consts.js

@@ -0,0 +1,21 @@
+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}/dist/runtime/config.js`);
+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"];
+const MIGRATION_VERSION = "2024-03-12";
+export {
+  CONFIG_FILE_NAMES,
+  DB_PATH,
+  DB_TYPES_FILE,
+  MIGRATION_VERSION,
+  PACKAGE_NAME,
+  RUNTIME_CONFIG_IMPORT,
+  RUNTIME_IMPORT,
+  VIRTUAL_MODULE_ID
+};

package/dist/core/errors.d.ts

@@ -0,0 +1,10 @@
+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 SHELL_QUERY_MISSING_ERROR: string;
+export declare const EXEC_ERROR: (error: string) => string;
+export declare const EXEC_DEFAULT_EXPORT_ERROR: (fileName: string) => string;
+export declare const INTEGRATION_TABLE_CONFLICT_ERROR: (integrationName: string, tableName: string, isUserConflict: boolean) => string;

package/dist/core/errors.js

@@ -0,0 +1,56 @@
+import { bold, cyan, red } 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 SHELL_QUERY_MISSING_ERROR = `${red(
+  "\u25B6 Please provide a query to execute using the --query flag."
+)}
+`;
+const EXEC_ERROR = (error) => {
+  return `${red(`Error while executing file:`)}
+
+${error}`;
+};
+const EXEC_DEFAULT_EXPORT_ERROR = (fileName) => {
+  return EXEC_ERROR(`Missing default function export in ${bold(fileName)}`);
+};
+const INTEGRATION_TABLE_CONFLICT_ERROR = (integrationName, tableName, isUserConflict) => {
+  return red("\u25B6 Conflicting table name in integration " + bold(integrationName)) + isUserConflict ? `
+  A user-defined table named ${bold(tableName)} already exists` : `
+  Another integration already added a table named ${bold(tableName)}`;
+};
+export {
+  EXEC_DEFAULT_EXPORT_ERROR,
+  EXEC_ERROR,
+  FILE_NOT_FOUND_ERROR,
+  INTEGRATION_TABLE_CONFLICT_ERROR,
+  MISSING_EXECUTE_PATH_ERROR,
+  MISSING_PROJECT_ID_ERROR,
+  MISSING_SESSION_ID_ERROR,
+  RENAME_COLUMN_ERROR,
+  RENAME_TABLE_ERROR,
+  SHELL_QUERY_MISSING_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;