@astrojs/db 0.19.0 → 0.20.0

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

@@ -1,4 +1,4 @@
-import type { z } from 'zod';
+import type * as z from 'zod/v4';
 import type { booleanColumnSchema, columnSchema, columnsSchema, dateColumnSchema, dbConfigSchema, indexSchema, jsonColumnSchema, MaybeArray, numberColumnOptsSchema, numberColumnSchema, referenceableColumnSchema, resolvedIndexSchema, tableSchema, textColumnOptsSchema, textColumnSchema } from './schemas.js';
 export type ResolvedIndexes = z.output<typeof dbConfigSchema>['tables'][string]['indexes'];
 export type BooleanColumn = z.infer<typeof booleanColumnSchema>;

package/dist/core/cli/commands/push/index.js

@@ -1,5 +1,5 @@
+import * as clack from "@clack/prompts";
 import { sql } from "drizzle-orm";
-import prompts from "prompts";
 import { MIGRATION_VERSION } from "../../../consts.js";
 import { createClient } from "../../../db-client/libsql-node.js";
 import {
@@ -35,13 +35,12 @@ async function cmd({
     console.log(`Database schema is out of date.`);
   }
   if (isForceReset) {
-    const { begin } = await prompts({
-      type: "confirm",
-      name: "begin",
+    const begin = await clack.confirm({
       message: `Reset your database? All of your data will be erased and your schema created from scratch.`,
-      initial: false
+      initialValue: false,
+      withGuide: false
     });
-    if (!begin) {
+    if (begin !== true) {
       console.log("Canceled.");
       process.exit(0);
     }

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

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

package/dist/core/db-client/utils.js

@@ -1,5 +1,5 @@
-import z from "zod";
-const rawLibSQLOptions = z.record(z.string());
+import * as z from "zod/v4";
+const rawLibSQLOptions = z.record(z.string(), z.string());
 const parseNumber = (value) => z.coerce.number().parse(value);
 const parseBoolean = (value) => z.coerce.boolean().parse(value);
 const booleanValues = ["true", "false"];
@@ -36,7 +36,7 @@ const parseLibSQLConfig = (config) => {
     return libSQLConfigTransformed.parse(config);
   } catch (error) {
     if (error instanceof z.ZodError) {
-      throw new Error(`Invalid LibSQL config: ${error.errors.map((e) => e.message).join(", ")}`);
+      throw new Error(`Invalid LibSQL config: ${error.issues.map((e) => e.message).join(", ")}`);
     }
     throw error;
   }

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

@@ -1,6 +1,2 @@
-/**
- * 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;
+import type { $ZodErrorMap } from 'zod/v4/core';
+export declare const errorMap: $ZodErrorMap;

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

@@ -1,77 +1,101 @@
-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 errorMap = (issue) => {
+  const baseErrorPath = flattenErrorPath(issue.path ?? []);
+  if (issue.code === "invalid_union") {
+    let typeOrLiteralErrByPath = /* @__PURE__ */ new Map();
+    for (const unionError of issue.errors.flat()) {
+      if (unionError.code === "invalid_type") {
         const flattenedErrorPath = flattenErrorPath(unionError.path);
-        const typeOrLiteralErr = typeOrLiteralErrByPath.get(flattenedErrorPath);
-        if (typeOrLiteralErr) {
-          typeOrLiteralErr.expected.push(unionError.expected);
+        if (typeOrLiteralErrByPath.has(flattenedErrorPath)) {
+          typeOrLiteralErrByPath.get(flattenedErrorPath).expected.push(unionError.expected);
         } else {
           typeOrLiteralErrByPath.set(flattenedErrorPath, {
             code: unionError.code,
             received: unionError.received,
-            expected: [unionError.expected]
+            expected: [unionError.expected],
+            message: unionError.message
           });
         }
       }
     }
-    const messages = [
-      prefix(
-        baseErrorPath,
-        typeOrLiteralErrByPath.size ? "Did not match union:" : "Did not match union."
-      )
-    ];
+    const messages = [prefix(baseErrorPath, "Did not match union.")];
+    const details = [...typeOrLiteralErrByPath.entries()].filter(([, error]) => error.expected.length === issue.errors.flat().length).map(
+      ([key, error]) => key === baseErrorPath ? (
+        // Avoid printing the key again if it's a base error
+        `> ${getTypeOrLiteralMsg(error)}`
+      ) : `> ${prefix(key, getTypeOrLiteralMsg(error))}`
+    );
+    if (details.length === 0) {
+      const expectedShapes = [];
+      for (const unionErrors of issue.errors) {
+        const expectedShape = [];
+        for (const _issue of unionErrors) {
+          if (_issue.code === "invalid_union") {
+            return errorMap(_issue);
+          }
+          const relativePath = flattenErrorPath(_issue.path).replace(baseErrorPath, "").replace(leadingPeriod, "");
+          if ("expected" in _issue && typeof _issue.expected === "string") {
+            expectedShape.push(
+              relativePath ? `${relativePath}: ${_issue.expected}` : _issue.expected
+            );
+          } else if ("values" in _issue) {
+            expectedShape.push(
+              ..._issue.values.filter((v) => typeof v === "string").map((v) => `"${v}"`)
+            );
+          } else if (relativePath) {
+            expectedShape.push(relativePath);
+          }
+        }
+        if (expectedShape.length === 1 && !expectedShape[0]?.includes(":")) {
+          expectedShapes.push(expectedShape.join(""));
+        } else if (expectedShape.length > 0) {
+          expectedShapes.push(`{ ${expectedShape.join("; ")} }`);
+        }
+      }
+      if (expectedShapes.length) {
+        details.push("> Expected type `" + expectedShapes.join(" | ") + "`");
+        details.push("> Received `" + stringify(issue.input) + "`");
+      }
+    }
     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")
+      message: messages.concat(details).join("\n")
     };
-  }
-  if (baseError.code === "invalid_literal" || baseError.code === "invalid_type") {
+  } else if (issue.code === "invalid_type") {
     return {
       message: prefix(
         baseErrorPath,
         getTypeOrLiteralMsg({
-          code: baseError.code,
-          received: baseError.received,
-          expected: [baseError.expected]
+          code: issue.code,
+          received: typeof issue.input,
+          expected: [issue.expected],
+          message: issue.message
         })
       )
     };
-  } else if (baseError.message) {
-    return { message: prefix(baseErrorPath, baseError.message) };
-  } else {
-    return { message: prefix(baseErrorPath, ctx.defaultError) };
+  } else if (issue.message) {
+    return { message: prefix(baseErrorPath, issue.message) };
   }
 };
 const getTypeOrLiteralMsg = (error) => {
-  if (error.received === "undefined") return "Required";
+  if (typeof error.received === "undefined" || error.received === "undefined")
+    return error.message ?? "Required";
   const expectedDeduped = new Set(error.expected);
   switch (error.code) {
     case "invalid_type":
-      return `Expected type \`${unionExpectedVals(expectedDeduped)}\`, received ${JSON.stringify(
+      return `Expected type \`${unionExpectedVals(expectedDeduped)}\`, received \`${stringify(
         error.received
-      )}`;
+      )}\``;
     case "invalid_literal":
-      return `Expected \`${unionExpectedVals(expectedDeduped)}\`, received ${JSON.stringify(
+      return `Expected \`${unionExpectedVals(expectedDeduped)}\`, received \`${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 unionExpectedVals = (expectedVals) => [...expectedVals].map((expectedVal) => stringify(expectedVal)).join(" | ");
 const flattenErrorPath = (errorPath) => errorPath.join(".");
+const stringify = (val) => JSON.stringify(val, null, 1).split(newlinePlusWhitespace).join(" ");
+const newlinePlusWhitespace = /\n\s*/;
+const leadingPeriod = /^\./;
 export {
   errorMap
 };

package/dist/core/integration/file-url.js

@@ -12,8 +12,11 @@ function fileURLIntegration() {
     return {
       name: "@astrojs/db/file-url",
       enforce: "pre",
-      async load(id) {
-        if (id.endsWith("?fileurl")) {
+      load: {
+        filter: {
+          id: /\?fileurl$/
+        },
+        async handler(id) {
           const filePath = id.slice(0, id.indexOf("?"));
           if (command === "build") {
             const data = await fs.promises.readFile(filePath);

package/dist/core/integration/index.d.ts

@@ -1,19 +1,8 @@
 import type { AstroIntegration } from 'astro';
-import { z } from 'zod';
-declare const astroDBConfigSchema: z.ZodDefault<z.ZodOptional<z.ZodObject<{
-    /**
-     * Sets the mode of the underlying `@libsql/client` connection.
-     *
-     * In most cases, the default 'node' mode is sufficient. On platforms like Cloudflare, or Deno, you may need to set this to 'web'.
-     *
-     * @default 'node'
-     */
-    mode: z.ZodDefault<z.ZodOptional<z.ZodUnion<[z.ZodLiteral<"node">, z.ZodLiteral<"web">]>>>;
-}, "strip", z.ZodTypeAny, {
-    mode: "node" | "web";
-}, {
-    mode?: "node" | "web" | undefined;
-}>>>;
+import * as z from 'zod/v4';
+declare const astroDBConfigSchema: z.ZodPrefault<z.ZodOptional<z.ZodObject<{
+    mode: z.ZodDefault<z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"node">, z.ZodLiteral<"web">]>>>;
+}, z.core.$strip>>>;
 export type AstroDBConfig = z.infer<typeof astroDBConfigSchema>;
 export declare function integration(options?: AstroDBConfig): AstroIntegration[];
 export {};

package/dist/core/integration/index.js

@@ -9,7 +9,7 @@ import {
   mergeConfig
 } from "vite";
 import parseArgs from "yargs-parser";
-import { z } from "zod";
+import * as z from "zod/v4";
 import { AstroDbError, isDbError } from "../../runtime/utils.js";
 import { CONFIG_FILE_NAMES, DB_PATH, VIRTUAL_MODULE_ID } from "../consts.js";
 import { EXEC_DEFAULT_EXPORT_ERROR, EXEC_ERROR } from "../errors.js";
@@ -31,7 +31,7 @@ const astroDBConfigSchema = z.object({
    * @default 'node'
    */
   mode: z.union([z.literal("node"), z.literal("web")]).optional().default("node")
-}).optional().default({});
+}).optional().prefault({});
 function astroDBIntegration(options) {
   const resolvedConfig = astroDBConfigSchema.parse(options);
   let connectToRemote = false;
@@ -117,8 +117,9 @@ function astroDBIntegration(options) {
         });
       },
       "astro:server:setup": async ({ server, logger }) => {
+        const environment = server.environments.ssr;
         seedHandler.execute = async (fileUrl) => {
-          await executeSeedFile({ fileUrl, viteServer: server });
+          await executeSeedFile({ fileUrl, environment });
         };
         const filesToWatch = [
           ...CONFIG_FILE_NAMES.map((c) => new URL(c, getDbDirectoryUrl(root))),
@@ -130,20 +131,18 @@ function astroDBIntegration(options) {
             server.restart();
           }
         });
-        setTimeout(() => {
-          logger.info(
-            connectToRemote ? "Connected to remote database." : "New local database created."
-          );
-          if (connectToRemote) return;
-          const localSeedPaths = SEED_DEV_FILE_NAME.map(
-            (name) => new URL(name, getDbDirectoryUrl(root))
-          );
-          if (seedFiles.get().length || localSeedPaths.find((path) => existsSync(path))) {
-            server.ssrLoadModule(VIRTUAL_MODULE_ID).catch((e) => {
-              logger.error(e instanceof Error ? e.message : String(e));
-            });
-          }
-        }, 100);
+        logger.info(
+          connectToRemote ? "Connected to remote database." : "New local database created."
+        );
+        if (connectToRemote) return;
+        const localSeedPaths = SEED_DEV_FILE_NAME.map(
+          (name) => new URL(name, getDbDirectoryUrl(root))
+        );
+        if (seedFiles.get().length || localSeedPaths.find((path) => existsSync(path))) {
+          await environment.runner.import(VIRTUAL_MODULE_ID).catch((e) => {
+            logger.error(e instanceof Error ? e.message : String(e));
+          });
+        }
       },
       "astro:build:start": async ({ logger }) => {
         if (!connectToRemote && !databaseFileEnvDefined() && finalBuildOutput === "server") {
@@ -157,11 +156,12 @@ function astroDBIntegration(options) {
       },
       "astro:build:setup": async ({ vite }) => {
         tempViteServer = await getTempViteServer({ viteConfig: vite });
+        const environment = tempViteServer.environments.ssr;
         seedHandler.execute = async (fileUrl) => {
-          await executeSeedFile({ fileUrl, viteServer: tempViteServer });
+          await executeSeedFile({ fileUrl, environment });
         };
       },
-      "astro:build:done": async ({}) => {
+      "astro:build:done": async () => {
         await tempViteServer?.close();
       }
     }
@@ -176,10 +176,10 @@ function integration(options) {
 }
 async function executeSeedFile({
   fileUrl,
-  viteServer
+  environment
 }) {
   const pathname = decodeURIComponent(fileUrl.pathname);
-  const mod = await viteServer.ssrLoadModule(pathname);
+  const mod = await environment.runner.import(pathname);
   if (typeof mod.default !== "function") {
     throw new AstroDbError(EXEC_DEFAULT_EXPORT_ERROR(fileURLToPath(fileUrl)));
   }
@@ -201,8 +201,8 @@ async function getTempViteServer({ viteConfig }) {
       logLevel: "silent"
     })
   );
-  const hotSend = tempViteServer.hot.send;
-  tempViteServer.hot.send = (payload) => {
+  const hotSend = tempViteServer.environments.client.hot.send;
+  tempViteServer.environments.client.hot.send = (payload) => {
     if (payload.type === "error") {
       throw payload.err;
     }

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

@@ -21,18 +21,26 @@ function vitePluginDbClient(params) {
   return {
     name: "virtual:astro:db-client",
     enforce: "pre",
-    async resolveId(id) {
-      if (id !== VIRTUAL_CLIENT_MODULE_ID) return;
-      return resolved;
+    resolveId: {
+      filter: {
+        id: new RegExp(`^${VIRTUAL_CLIENT_MODULE_ID}$`)
+      },
+      handler() {
+        return resolved;
+      }
     },
-    async load(id) {
-      if (id !== resolved) return;
-      switch (params.connectToRemote) {
-        case true:
-          return getRemoteClientModule(params.mode);
-        case false:
-        default:
-          return getLocalClientModule(params.mode);
+    load: {
+      filter: {
+        id: new RegExp(`^${resolved}$`)
+      },
+      handler() {
+        switch (params.connectToRemote) {
+          case true:
+            return getRemoteClientModule(params.mode);
+          case false:
+          default:
+            return getLocalClientModule(params.mode);
+        }
       }
     }
   };

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

@@ -31,49 +31,57 @@ function vitePluginDb(params) {
     configResolved(resolvedConfig) {
       command = resolvedConfig.command;
     },
-    async resolveId(id) {
-      if (id !== VIRTUAL_MODULE_ID) return;
-      if (params.seedHandler.inProgress) {
-        return resolved.importedFromSeedFile;
+    resolveId: {
+      filter: {
+        id: new RegExp(`^${VIRTUAL_MODULE_ID}$`)
+      },
+      handler() {
+        if (params.seedHandler.inProgress) {
+          return resolved.importedFromSeedFile;
+        }
+        return resolved.module;
       }
-      return resolved.module;
     },
-    async load(id) {
-      if (id !== resolved.module && id !== resolved.importedFromSeedFile) return;
-      if (params.connectToRemote) {
-        return getRemoteVirtualModContents({
-          appToken: params.appToken,
-          tables: params.tables.get(),
-          isBuild: command === "build",
-          output: params.output,
-          localExecution: false
-        });
-      }
-      if (id === resolved.importedFromSeedFile) {
+    load: {
+      filter: {
+        id: new RegExp(`^(${resolved.module}|${resolved.importedFromSeedFile})$`)
+      },
+      async handler(id) {
+        if (params.connectToRemote) {
+          return getRemoteVirtualModContents({
+            appToken: params.appToken,
+            tables: params.tables.get(),
+            isBuild: command === "build",
+            output: params.output,
+            localExecution: false
+          });
+        }
+        if (id === resolved.importedFromSeedFile) {
+          return getLocalVirtualModContents({
+            root: params.root,
+            tables: params.tables.get(),
+            localExecution: false
+          });
+        }
+        await recreateTables(params);
+        const seedFiles = getResolvedSeedFiles(params);
+        for await (const seedFile of seedFiles) {
+          this.addWatchFile(fileURLToPath(seedFile));
+          if (existsSync(seedFile)) {
+            params.seedHandler.inProgress = true;
+            await params.seedHandler.execute(seedFile);
+          }
+        }
+        if (params.seedHandler.inProgress) {
+          (params.logger ?? console).info("Seeded database.");
+          params.seedHandler.inProgress = false;
+        }
         return getLocalVirtualModContents({
           root: params.root,
           tables: params.tables.get(),
           localExecution: false
         });
       }
-      await recreateTables(params);
-      const seedFiles = getResolvedSeedFiles(params);
-      for await (const seedFile of seedFiles) {
-        this.addWatchFile(fileURLToPath(seedFile));
-        if (existsSync(seedFile)) {
-          params.seedHandler.inProgress = true;
-          await params.seedHandler.execute(seedFile);
-        }
-      }
-      if (params.seedHandler.inProgress) {
-        (params.logger ?? console).info("Seeded database.");
-        params.seedHandler.inProgress = false;
-      }
-      return getLocalVirtualModContents({
-        root: params.root,
-        tables: params.tables.get(),
-        localExecution: false
-      });
     }
   };
 }

package/dist/core/load-file.d.ts

@@ -11,17 +11,16 @@ export declare function resolveDbConfig({ root, integrations, }: Pick<AstroConfi
                 on: string | string[];
                 unique?: boolean | undefined;
             }>;
-            deprecated: boolean;
             columns: Record<string, {
                 type: "boolean";
                 schema: {
                     optional: boolean;
                     unique: boolean;
                     deprecated: boolean;
-                    default?: boolean | import("../runtime/types.js").SerializedSQL | undefined;
-                    name?: string | undefined;
                     label?: string | undefined;
+                    name?: string | undefined;
                     collection?: string | undefined;
+                    default?: boolean | import("../runtime/types.js").SerializedSQL | undefined;
                 };
             } | {
                 type: "number";
@@ -32,13 +31,13 @@ export declare function resolveDbConfig({ root, integrations, }: Pick<AstroConfi
                     label?: string | undefined;
                     collection?: string | undefined;
                 } & ({
-                    optional: boolean;
                     primaryKey: false;
+                    optional: boolean;
                     default?: number | import("../runtime/types.js").SerializedSQL | undefined;
                 } | {
                     primaryKey: true;
-                    default?: undefined;
                     optional?: false | undefined;
+                    default?: undefined;
                 })) & {
                     references?: import("./types.js").NumberColumn;
                 };
@@ -47,15 +46,15 @@ export declare function resolveDbConfig({ root, integrations, }: Pick<AstroConfi
                 schema: ({
                     unique: boolean;
                     deprecated: boolean;
-                    default?: string | import("../runtime/types.js").SerializedSQL | undefined;
                     name?: string | undefined;
                     label?: string | undefined;
                     collection?: string | undefined;
+                    default?: string | import("../runtime/types.js").SerializedSQL | undefined;
                     multiline?: boolean | undefined;
                     enum?: [string, ...string[]] | undefined;
                 } & ({
-                    optional: boolean;
                     primaryKey: false;
+                    optional: boolean;
                 } | {
                     primaryKey: true;
                     optional?: false | undefined;
@@ -68,10 +67,10 @@ export declare function resolveDbConfig({ root, integrations, }: Pick<AstroConfi
                     optional: boolean;
                     unique: boolean;
                     deprecated: boolean;
-                    default?: string | import("../runtime/types.js").SerializedSQL | undefined;
-                    name?: string | undefined;
                     label?: string | undefined;
+                    name?: string | undefined;
                     collection?: string | undefined;
+                    default?: string | import("../runtime/types.js").SerializedSQL | undefined;
                 };
             } | {
                 type: "json";
@@ -79,17 +78,18 @@ export declare function resolveDbConfig({ root, integrations, }: Pick<AstroConfi
                     optional: boolean;
                     unique: boolean;
                     deprecated: boolean;
-                    default?: unknown;
-                    name?: string | undefined;
                     label?: string | undefined;
+                    name?: string | undefined;
                     collection?: string | undefined;
+                    default?: unknown;
                 };
             }>;
+            deprecated: boolean;
             foreignKeys?: (Omit<{
                 columns: import("./schemas.js").MaybeArray<string>;
-                references: () => import("./schemas.js").MaybeArray<Omit<import("zod").input<typeof import("./schemas.js").referenceableColumnSchema>, "references">>;
+                references: () => import("./schemas.js").MaybeArray<Omit<import("zod/v4").input<typeof import("./schemas.js").referenceableColumnSchema>, "references">>;
             }, "references"> & {
-                references: import("./schemas.js").MaybeArray<Omit<import("zod").output<typeof import("./schemas.js").referenceableColumnSchema>, "references">>;
+                references: import("./schemas.js").MaybeArray<Omit<import("zod/v4").infer<typeof import("./schemas.js").referenceableColumnSchema>, "references">>;
             })[] | undefined;
         }>;
     };

package/dist/core/load-file.js

@@ -15,7 +15,7 @@ async function resolveDbConfig({
   integrations
 }) {
   const { mod, dependencies } = await loadUserConfigFile(root);
-  const userDbConfig = dbConfigSchema.parse(mod?.default ?? {}, { errorMap });
+  const userDbConfig = dbConfigSchema.parse(mod?.default ?? {}, { error: errorMap });
   const dbConfig = { tables: userDbConfig.tables ?? {} };
   const integrationDbConfigPaths = [];
   const integrationSeedPaths = [];
@@ -37,7 +37,7 @@ async function resolveDbConfig({
   for (const { name, configEntrypoint } of integrationDbConfigPaths) {
     const loadedConfig = await loadIntegrationConfigFile(root, configEntrypoint);
     const integrationDbConfig = dbConfigSchema.parse(loadedConfig.mod?.default ?? {}, {
-      errorMap
+      error: errorMap
     });
     for (const key in integrationDbConfig.tables) {
       if (key in dbConfig.tables) {

package/dist/core/queries.d.ts

@@ -14,13 +14,13 @@ export declare function getReferencesConfig(column: DBColumn): {
         label?: string | undefined;
         collection?: string | undefined;
     } & ({
-        optional: boolean;
         primaryKey: false;
+        optional: boolean;
         default?: number | import("../runtime/types.js").SerializedSQL | undefined;
     } | {
         primaryKey: true;
-        default?: undefined;
         optional?: false | undefined;
+        default?: undefined;
     })) & {
         references?: NumberColumn;
     };
@@ -29,15 +29,15 @@ export declare function getReferencesConfig(column: DBColumn): {
     schema: ({
         unique: boolean;
         deprecated: boolean;
-        default?: string | import("../runtime/types.js").SerializedSQL | undefined;
         name?: string | undefined;
         label?: string | undefined;
         collection?: string | undefined;
+        default?: string | import("../runtime/types.js").SerializedSQL | undefined;
         multiline?: boolean | undefined;
         enum?: [string, ...string[]] | undefined;
     } & ({
-        optional: boolean;
         primaryKey: false;
+        optional: boolean;
     } | {
         primaryKey: true;
         optional?: false | undefined;