@astrojs/db 0.9.5 → 0.9.7

package/dist/_internal/core/types.d.ts

@@ -38,8 +38,6 @@ export interface TableConfig<TColumns extends ColumnsConfig = ColumnsConfig> ext
 interface IndexConfig<TColumns extends ColumnsConfig> extends z.input<typeof indexSchema> {
     on: MaybeArray<Extract<keyof TColumns, string>>;
 }
-/** @deprecated Use `TableConfig` instead */
-export type ResolvedCollectionConfig<TColumns extends ColumnsConfig = ColumnsConfig> = TableConfig<TColumns>;
 export type NumberColumnOpts = z.input<typeof numberColumnOptsSchema>;
 export type TextColumnOpts = z.input<typeof textColumnOptsSchema>;
 export type AstroDbIntegration = AstroIntegration & {

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

@@ -7,10 +7,10 @@ export declare function getMigrationQueries({ oldSnapshot, newSnapshot, reset, }
     queries: string[];
     confirmations: string[];
 }>;
-export declare function getCollectionChangeQueries({ collectionName, oldCollection, newCollection, }: {
-    collectionName: string;
-    oldCollection: DBTable;
-    newCollection: DBTable;
+export declare function getTableChangeQueries({ tableName, oldTable, newTable, }: {
+    tableName: string;
+    oldTable: DBTable;
+    newTable: DBTable;
 }): Promise<{
     queries: string[];
     confirmations: string[];

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

@@ -7,6 +7,7 @@ import { hasPrimaryKey } from "../../runtime/index.js";
 import {
   getCreateIndexQueries,
   getCreateTableQuery,
+  getDropTableIfExistsQuery,
   getModifiers,
   getReferencesConfig,
   hasDefault,
@@ -34,84 +35,79 @@ async function getMigrationQueries({
     oldSnapshot = createEmptySnapshot();
     queries.push(...getDropTableQueriesForSnapshot(currentSnapshot));
   }
-  const addedCollections = getAddedCollections(oldSnapshot, newSnapshot);
-  const droppedTables = getDroppedCollections(oldSnapshot, newSnapshot);
+  const addedTables = getAddedTables(oldSnapshot, newSnapshot);
+  const droppedTables = getDroppedTables(oldSnapshot, newSnapshot);
   const notDeprecatedDroppedTables = Object.fromEntries(
     Object.entries(droppedTables).filter(([, table]) => !table.deprecated)
   );
-  if (!isEmpty(addedCollections) && !isEmpty(notDeprecatedDroppedTables)) {
+  if (!isEmpty(addedTables) && !isEmpty(notDeprecatedDroppedTables)) {
     throw new Error(
-      RENAME_TABLE_ERROR(
-        Object.keys(addedCollections)[0],
-        Object.keys(notDeprecatedDroppedTables)[0]
-      )
+      RENAME_TABLE_ERROR(Object.keys(addedTables)[0], Object.keys(notDeprecatedDroppedTables)[0])
     );
   }
-  for (const [collectionName, collection] of Object.entries(addedCollections)) {
-    queries.push(getCreateTableQuery(collectionName, collection));
-    queries.push(...getCreateIndexQueries(collectionName, collection));
+  for (const [tableName, table] of Object.entries(addedTables)) {
+    queries.push(getCreateTableQuery(tableName, table));
+    queries.push(...getCreateIndexQueries(tableName, table));
   }
-  for (const [collectionName] of Object.entries(droppedTables)) {
-    const dropQuery = `DROP TABLE ${sqlite.escapeName(collectionName)}`;
+  for (const [tableName] of Object.entries(droppedTables)) {
+    const dropQuery = `DROP TABLE ${sqlite.escapeName(tableName)}`;
     queries.push(dropQuery);
   }
-  for (const [collectionName, newCollection] of Object.entries(newSnapshot.schema)) {
-    const oldCollection = oldSnapshot.schema[collectionName];
-    if (!oldCollection)
+  for (const [tableName, newTable] of Object.entries(newSnapshot.schema)) {
+    const oldTable = oldSnapshot.schema[tableName];
+    if (!oldTable)
       continue;
-    const addedColumns = getAdded(oldCollection.columns, newCollection.columns);
-    const droppedColumns = getDropped(oldCollection.columns, newCollection.columns);
+    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(
-          `${collectionName}.${Object.keys(addedColumns)[0]}`,
-          `${collectionName}.${Object.keys(notDeprecatedDroppedColumns)[0]}`
+          `${tableName}.${Object.keys(addedColumns)[0]}`,
+          `${tableName}.${Object.keys(notDeprecatedDroppedColumns)[0]}`
         )
       );
     }
-    const result = await getCollectionChangeQueries({
-      collectionName,
-      oldCollection,
-      newCollection
+    const result = await getTableChangeQueries({
+      tableName,
+      oldTable,
+      newTable
     });
     queries.push(...result.queries);
     confirmations.push(...result.confirmations);
   }
   return { queries, confirmations };
 }
-async function getCollectionChangeQueries({
-  collectionName,
-  oldCollection,
-  newCollection
+async function getTableChangeQueries({
+  tableName,
+  oldTable,
+  newTable
 }) {
   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)
-  );
+  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({
-        collectionName,
-        oldIndexes: oldCollection.indexes,
-        newIndexes: newCollection.indexes
+        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(collectionName, added, dropped),
+      ...getAlterTableQueries(tableName, added, dropped),
       ...getChangeIndexQueries({
-        collectionName,
-        oldIndexes: oldCollection.indexes,
-        newIndexes: newCollection.indexes
+        tableName,
+        oldIndexes: oldTable.indexes,
+        newIndexes: newTable.indexes
       })
     );
     return { queries, confirmations };
@@ -121,31 +117,31 @@ async function getCollectionChangeQueries({
     const { reason, columnName } = dataLossCheck;
     const reasonMsgs = {
       "added-required": `You added new required column '${color.bold(
-        collectionName + "." + columnName
+        tableName + "." + columnName
       )}' with no default value.
       This cannot be executed on an existing table.`,
       "updated-type": `Updating existing column ${color.bold(
-        collectionName + "." + columnName
+        tableName + "." + columnName
       )} to a new type that cannot be handled automatically.`
     };
     confirmations.push(reasonMsgs[reason]);
   }
-  const primaryKeyExists = Object.entries(newCollection.columns).find(
+  const primaryKeyExists = Object.entries(newTable.columns).find(
     ([, column]) => hasPrimaryKey(column)
   );
   const droppedPrimaryKey = Object.entries(dropped).find(([, column]) => hasPrimaryKey(column));
   const recreateTableQueries = getRecreateTableQueries({
-    collectionName,
-    newCollection,
+    tableName,
+    newTable,
     added,
     hasDataLoss: dataLossCheck.dataLoss,
     migrateHiddenPrimaryKey: !primaryKeyExists && !droppedPrimaryKey
   });
-  queries.push(...recreateTableQueries, ...getCreateIndexQueries(collectionName, newCollection));
+  queries.push(...recreateTableQueries, ...getCreateIndexQueries(tableName, newTable));
   return { queries, confirmations };
 }
 function getChangeIndexQueries({
-  collectionName,
+  tableName,
   oldIndexes = {},
   newIndexes = {}
 }) {
@@ -159,32 +155,32 @@ function getChangeIndexQueries({
     const dropQuery = `DROP INDEX ${sqlite.escapeName(indexName)}`;
     queries.push(dropQuery);
   }
-  queries.push(...getCreateIndexQueries(collectionName, { indexes: added }));
+  queries.push(...getCreateIndexQueries(tableName, { indexes: added }));
   return queries;
 }
-function getAddedCollections(oldCollections, newCollections) {
+function getAddedTables(oldTables, newTables) {
   const added = {};
-  for (const [key, newCollection] of Object.entries(newCollections.schema)) {
-    if (!(key in oldCollections.schema))
-      added[key] = newCollection;
+  for (const [key, newTable] of Object.entries(newTables.schema)) {
+    if (!(key in oldTables.schema))
+      added[key] = newTable;
   }
   return added;
 }
-function getDroppedCollections(oldCollections, newCollections) {
+function getDroppedTables(oldTables, newTables) {
   const dropped = {};
-  for (const [key, oldCollection] of Object.entries(oldCollections.schema)) {
-    if (!(key in newCollections.schema))
-      dropped[key] = oldCollection;
+  for (const [key, oldTable] of Object.entries(oldTables.schema)) {
+    if (!(key in newTables.schema))
+      dropped[key] = oldTable;
   }
   return dropped;
 }
-function getAlterTableQueries(unescapedCollectionName, added, dropped) {
+function getAlterTableQueries(unescTableName, added, dropped) {
   const queries = [];
-  const collectionName = sqlite.escapeName(unescapedCollectionName);
+  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 ${collectionName} ADD COLUMN ${columnName} ${type}${getModifiers(
+    const q = `ALTER TABLE ${tableName} ADD COLUMN ${columnName} ${type}${getModifiers(
       columnName,
       column
     )}`;
@@ -192,37 +188,34 @@ function getAlterTableQueries(unescapedCollectionName, added, dropped) {
   }
   for (const unescColumnName of Object.keys(dropped)) {
     const columnName = sqlite.escapeName(unescColumnName);
-    const q = `ALTER TABLE ${collectionName} DROP COLUMN ${columnName}`;
+    const q = `ALTER TABLE ${tableName} DROP COLUMN ${columnName}`;
     queries.push(q);
   }
   return queries;
 }
 function getRecreateTableQueries({
-  collectionName: unescCollectionName,
-  newCollection,
+  tableName: unescTableName,
+  newTable,
   added,
   hasDataLoss,
   migrateHiddenPrimaryKey
 }) {
-  const unescTempName = `${unescCollectionName}_${genTempTableName()}`;
+  const unescTempName = `${unescTableName}_${genTempTableName()}`;
   const tempName = sqlite.escapeName(unescTempName);
-  const collectionName = sqlite.escapeName(unescCollectionName);
+  const tableName = sqlite.escapeName(unescTableName);
   if (hasDataLoss) {
-    return [
-      `DROP TABLE ${collectionName}`,
-      getCreateTableQuery(unescCollectionName, newCollection)
-    ];
+    return [`DROP TABLE ${tableName}`, getCreateTableQuery(unescTableName, newTable)];
   }
-  const newColumns = [...Object.keys(newCollection.columns)];
+  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, newCollection),
-    `INSERT INTO ${tempName} (${escapedColumns}) SELECT ${escapedColumns} FROM ${collectionName}`,
-    `DROP TABLE ${collectionName}`,
-    `ALTER TABLE ${tempName} RENAME TO ${collectionName}`
+    getCreateTableQuery(unescTempName, newTable),
+    `INSERT INTO ${tempName} (${escapedColumns}) SELECT ${escapedColumns} FROM ${tableName}`,
+    `DROP TABLE ${tableName}`,
+    `ALTER TABLE ${tempName} RENAME TO ${tableName}`
   ];
 }
 function isEmpty(obj) {
@@ -354,8 +347,8 @@ async function getProductionCurrentSnapshot({
 }
 function getDropTableQueriesForSnapshot(snapshot) {
   const queries = [];
-  for (const collectionName of Object.keys(snapshot.schema)) {
-    const dropQuery = `DROP TABLE ${sqlite.escapeName(collectionName)}`;
+  for (const tableName of Object.keys(snapshot.schema)) {
+    const dropQuery = getDropTableIfExistsQuery(tableName);
     queries.unshift(dropQuery);
   }
   return queries;
@@ -387,7 +380,7 @@ export {
   createCurrentSnapshot,
   createEmptySnapshot,
   formatDataLossMessage,
-  getCollectionChangeQueries,
   getMigrationQueries,
-  getProductionCurrentSnapshot
+  getProductionCurrentSnapshot,
+  getTableChangeQueries
 };

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

@@ -27,7 +27,7 @@ function printHelp({
     message.push(
       linebreak(),
       `  ${bgGreen(black(` ${commandName} `))} ${green(
-        `v${"0.9.5"}`
+        `v${"0.9.7"}`
       )} ${headline}`
     );
   }

package/dist/core/errors.d.ts

@@ -5,12 +5,6 @@ export declare const RENAME_TABLE_ERROR: (oldTable: string, newTable: 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 SEED_ERROR: (error: string) => string;
 export declare const EXEC_ERROR: (error: string) => string;
-export declare const SEED_DEFAULT_EXPORT_ERROR: (fileName: string) => string;
 export declare const EXEC_DEFAULT_EXPORT_ERROR: (fileName: 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;
 export declare const INTEGRATION_TABLE_CONFLICT_ERROR: (integrationName: string, tableName: string, isUserConflict: boolean) => string;

package/dist/core/errors.js

@@ -29,42 +29,14 @@ const SHELL_QUERY_MISSING_ERROR = `${red(
   "\u25B6 Please provide a query to execute using the --query flag."
 )}
 `;
-const SEED_ERROR = (error) => {
-  return `${red(`Error while seeding database:`)}
-
-${error}`;
-};
 const EXEC_ERROR = (error) => {
   return `${red(`Error while executing file:`)}
 
 ${error}`;
 };
-const SEED_DEFAULT_EXPORT_ERROR = (fileName) => {
-  return SEED_ERROR(`Missing default function export in ${bold(fileName)}`);
-};
 const EXEC_DEFAULT_EXPORT_ERROR = (fileName) => {
   return EXEC_ERROR(`Missing default function export in ${bold(fileName)}`);
 };
-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.`;
-};
 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` : `
@@ -74,17 +46,11 @@ export {
   EXEC_DEFAULT_EXPORT_ERROR,
   EXEC_ERROR,
   FILE_NOT_FOUND_ERROR,
-  FOREIGN_KEY_DNE_ERROR,
-  FOREIGN_KEY_REFERENCES_EMPTY_ERROR,
-  FOREIGN_KEY_REFERENCES_LENGTH_ERROR,
   INTEGRATION_TABLE_CONFLICT_ERROR,
   MISSING_EXECUTE_PATH_ERROR,
   MISSING_PROJECT_ID_ERROR,
   MISSING_SESSION_ID_ERROR,
-  REFERENCE_DNE_ERROR,
   RENAME_COLUMN_ERROR,
   RENAME_TABLE_ERROR,
-  SEED_DEFAULT_EXPORT_ERROR,
-  SEED_ERROR,
   SHELL_QUERY_MISSING_ERROR
 };

package/dist/core/integration/index.js

@@ -1,8 +1,10 @@
 import { existsSync } from "fs";
 import { dirname } from "path";
 import { fileURLToPath } from "url";
+import { AstroError } from "astro/errors";
 import { mkdir, writeFile } from "fs/promises";
 import { blue, yellow } from "kleur/colors";
+import { loadEnv } from "vite";
 import parseArgs from "yargs-parser";
 import { CONFIG_FILE_NAMES, DB_PATH } from "../consts.js";
 import { resolveDbConfig } from "../load-file.js";
@@ -28,12 +30,14 @@ function astroDBIntegration() {
     }
   };
   let command;
+  let output = "server";
   return {
     name: "astro:db",
     hooks: {
       "astro:config:setup": async ({ updateConfig, config, command: _command, logger }) => {
         command = _command;
         root = config.root;
+        output = config.output;
         if (command === "preview")
           return;
         let dbPlugin = void 0;
@@ -98,6 +102,11 @@ function astroDBIntegration() {
         });
       },
       "astro:build:start": async ({ logger }) => {
+        if (!connectToStudio && !databaseFileEnvDefined() && (output === "server" || output === "hybrid")) {
+          const message = `Attempting to build without the --remote flag or the ASTRO_DATABASE_FILE environment variable defined. You probably want to pass --remote to astro build.`;
+          const hint = "Learn more connecting to Studio: https://docs.astro.build/en/guides/astro-db/#connect-to-astro-studio";
+          throw new AstroError(message, hint);
+        }
         logger.info("database: " + (connectToStudio ? yellow("remote") : blue("local database.")));
       },
       "astro:build:done": async ({}) => {
@@ -106,6 +115,10 @@ function astroDBIntegration() {
     }
   };
 }
+function databaseFileEnvDefined() {
+  const env = loadEnv("", process.cwd());
+  return env.ASTRO_DATABASE_FILE != null || process.env.ASTRO_DATABASE_FILE != null;
+}
 function integration() {
   return [astroDBIntegration(), fileURLIntegration()];
 }

package/dist/core/integration/typegen.js

@@ -9,7 +9,7 @@ async function typegen(astroConfig) {
 async function typegenInternal({ tables, root }) {
   const content = `// This file is generated by Astro DB
 declare module 'astro:db' {
-${Object.entries(tables).map(([name, collection]) => generateTableType(name, collection)).join("\n")}
+${Object.entries(tables).map(([name, table]) => generateTableType(name, table)).join("\n")}
 }
 `;
   const dotAstroDir = new URL(".astro/", root);
@@ -18,8 +18,8 @@ ${Object.entries(tables).map(([name, collection]) => generateTableType(name, col
   }
   await writeFile(new URL(DB_TYPES_FILE, dotAstroDir), content);
 }
-function generateTableType(name, collection) {
-  const sanitizedColumnsList = Object.entries(collection.columns).filter(([, val]) => !val.schema.deprecated);
+function generateTableType(name, table) {
+  const sanitizedColumnsList = Object.entries(table.columns).filter(([, val]) => !val.schema.deprecated);
   const sanitizedColumns = Object.fromEntries(sanitizedColumnsList);
   let tableType = `	export const ${name}: import(${RUNTIME_IMPORT}).Table<
 		${JSON.stringify(name)},

package/dist/core/integration/vite-plugin-db.js

@@ -78,7 +78,8 @@ import { asDrizzleTable, createLocalDatabaseClient } from ${RUNTIME_IMPORT};
 ${shouldSeed ? `import { seedLocal } from ${RUNTIME_IMPORT};` : ""}
 ${shouldSeed ? integrationSeedImportStatements.join("\n") : ""}
 
-const dbUrl = ${JSON.stringify(dbUrl)};
+const dbUrl = import.meta.env.ASTRO_DATABASE_FILE ?? ${JSON.stringify(dbUrl)};
+
 export const db = createLocalDatabaseClient({ dbUrl });
 
 ${shouldSeed ? `await seedLocal({
@@ -90,7 +91,7 @@ ${shouldSeed ? `await seedLocal({
 
 export * from ${RUNTIME_CONFIG_IMPORT};
 
-${getStringifiedCollectionExports(tables)}`;
+${getStringifiedTableExports(tables)}`;
 }
 function getStudioVirtualModContents({
   tables,
@@ -115,13 +116,13 @@ export const db = await createRemoteDatabaseClient(${appTokenArg()}, ${dbUrlArg(
 
 export * from ${RUNTIME_CONFIG_IMPORT};
 
-${getStringifiedCollectionExports(tables)}
+${getStringifiedTableExports(tables)}
 	`;
 }
-function getStringifiedCollectionExports(tables) {
+function getStringifiedTableExports(tables) {
   return Object.entries(tables).map(
-    ([name, collection]) => `export const ${name} = asDrizzleTable(${JSON.stringify(name)}, ${JSON.stringify(
-      collection
+    ([name, table]) => `export const ${name} = asDrizzleTable(${JSON.stringify(name)}, ${JSON.stringify(
+      table
     )}, false)`
   ).join("\n");
 }

package/dist/core/schemas.js

@@ -15,9 +15,9 @@ const baseColumnSchema = z.object({
   optional: z.boolean().optional().default(false),
   unique: z.boolean().optional().default(false),
   deprecated: z.boolean().optional().default(false),
-  // Defined when `defineReadableTable()` is called
+  // Defined when `defineDb()` is called to resolve `references`
   name: z.string().optional(),
-  // TODO: rename to `tableName`. Breaking schema change
+  // TODO: Update to `table`. Will need migration file version change
   collection: z.string().optional()
 });
 const booleanColumnSchema = z.object({

package/dist/core/types.d.ts

@@ -38,8 +38,6 @@ export interface TableConfig<TColumns extends ColumnsConfig = ColumnsConfig> ext
 interface IndexConfig<TColumns extends ColumnsConfig> extends z.input<typeof indexSchema> {
     on: MaybeArray<Extract<keyof TColumns, string>>;
 }
-/** @deprecated Use `TableConfig` instead */
-export type ResolvedCollectionConfig<TColumns extends ColumnsConfig = ColumnsConfig> = TableConfig<TColumns>;
 export type NumberColumnOpts = z.input<typeof numberColumnOptsSchema>;
 export type TextColumnOpts = z.input<typeof textColumnOptsSchema>;
 export type AstroDbIntegration = AstroIntegration & {

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-export type { ResolvedCollectionConfig, TableConfig } from './core/types.js';
+export type { TableConfig } from './core/types.js';
 export { cli } from './core/cli/index.js';
 export { integration as default } from './core/integration/index.js';
 export { typegen } from './core/integration/typegen.js';

package/dist/runtime/errors.d.ts

@@ -0,0 +1,6 @@
+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;
+export declare const REFERENCE_DNE_ERROR: (columnName: string) => string;
+export declare const SEED_ERROR: (error: string) => string;
+export declare const SEED_DEFAULT_EXPORT_ERROR: (fileName: string) => string;

package/dist/runtime/errors.js

@@ -0,0 +1,37 @@
+import { bold, red } from "kleur/colors";
+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.`;
+};
+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 SEED_ERROR = (error) => {
+  return `${red(`Error while seeding database:`)}
+
+${error}`;
+};
+const SEED_DEFAULT_EXPORT_ERROR = (fileName) => {
+  return SEED_ERROR(`Missing default function export in ${bold(fileName)}`);
+};
+export {
+  FOREIGN_KEY_DNE_ERROR,
+  FOREIGN_KEY_REFERENCES_EMPTY_ERROR,
+  FOREIGN_KEY_REFERENCES_LENGTH_ERROR,
+  REFERENCE_DNE_ERROR,
+  SEED_DEFAULT_EXPORT_ERROR,
+  SEED_ERROR
+};

package/dist/runtime/queries.js

@@ -6,7 +6,7 @@ import {
   FOREIGN_KEY_REFERENCES_EMPTY_ERROR,
   FOREIGN_KEY_REFERENCES_LENGTH_ERROR,
   REFERENCE_DNE_ERROR
-} from "../core/errors.js";
+} from "./errors.js";
 import { hasPrimaryKey } from "./index.js";
 import { isSerializedSQL } from "./types.js";
 const sqlite = new SQLiteAsyncDialect();

package/dist/runtime/seed-local.js

@@ -1,8 +1,8 @@
 import { LibsqlError } from "@libsql/client";
 import { sql } from "drizzle-orm";
 import { SQLiteAsyncDialect } from "drizzle-orm/sqlite-core";
-import { SEED_DEFAULT_EXPORT_ERROR, SEED_ERROR } from "../core/errors.js";
 import {} from "../core/types.js";
+import { SEED_DEFAULT_EXPORT_ERROR, SEED_ERROR } from "./errors.js";
 import { getCreateIndexQueries, getCreateTableQuery } from "./queries.js";
 const sqlite = new SQLiteAsyncDialect();
 async function seedLocal({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@astrojs/db",
-  "version": "0.9.5",
+  "version": "0.9.7",
   "description": "",
   "license": "MIT",
   "type": "module",