@astrojs/db 0.8.0 → 0.8.2

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

@@ -0,0 +1,55 @@
+import type { AstroIntegration } from 'astro';
+import type { z } from 'zod';
+import type { MaybeArray, booleanColumnSchema, columnSchema, columnsSchema, dateColumnSchema, dbConfigSchema, indexSchema, jsonColumnSchema, numberColumnOptsSchema, numberColumnSchema, referenceableColumnSchema, tableSchema, textColumnOptsSchema, textColumnSchema } from './schemas.js';
+export type Indexes = Record<string, z.infer<typeof indexSchema>>;
+export type BooleanColumn = z.infer<typeof booleanColumnSchema>;
+export type BooleanColumnInput = z.input<typeof booleanColumnSchema>;
+export type NumberColumn = z.infer<typeof numberColumnSchema>;
+export type NumberColumnInput = z.input<typeof numberColumnSchema>;
+export type TextColumn = z.infer<typeof textColumnSchema>;
+export type TextColumnInput = z.input<typeof textColumnSchema>;
+export type DateColumn = z.infer<typeof dateColumnSchema>;
+export type DateColumnInput = z.input<typeof dateColumnSchema>;
+export type JsonColumn = z.infer<typeof jsonColumnSchema>;
+export type JsonColumnInput = z.input<typeof jsonColumnSchema>;
+export type ColumnType = BooleanColumn['type'] | NumberColumn['type'] | TextColumn['type'] | DateColumn['type'] | JsonColumn['type'];
+export type DBColumn = z.infer<typeof columnSchema>;
+export type DBColumnInput = DateColumnInput | BooleanColumnInput | NumberColumnInput | TextColumnInput | JsonColumnInput;
+export type DBColumns = z.infer<typeof columnsSchema>;
+export type DBTable = z.infer<typeof tableSchema>;
+export type DBTables = Record<string, DBTable>;
+export type DBSnapshot = {
+    schema: Record<string, DBTable>;
+    version: string;
+};
+export type DBConfigInput = z.input<typeof dbConfigSchema>;
+export type DBConfig = z.infer<typeof dbConfigSchema>;
+export type ColumnsConfig = z.input<typeof tableSchema>['columns'];
+export type OutputColumnsConfig = z.output<typeof tableSchema>['columns'];
+export interface TableConfig<TColumns extends ColumnsConfig = ColumnsConfig> extends Pick<z.input<typeof tableSchema>, 'columns' | 'indexes' | 'foreignKeys'> {
+    columns: TColumns;
+    foreignKeys?: Array<{
+        columns: MaybeArray<Extract<keyof TColumns, string>>;
+        references: () => MaybeArray<z.input<typeof referenceableColumnSchema>>;
+    }>;
+    indexes?: Record<string, IndexConfig<TColumns>>;
+    deprecated?: boolean;
+}
+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 & {
+    hooks: {
+        'astro:db:setup'?: (options: {
+            extendDb: (options: {
+                configEntrypoint?: URL | string;
+                seedEntrypoint?: URL | string;
+            }) => void;
+        }) => void | Promise<void>;
+    };
+};
+export {};

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

@@ -0,0 +1,19 @@
+import type { AstroConfig, AstroIntegration } from 'astro';
+import type { AstroDbIntegration } from './types.js';
+export type VitePlugin = Required<AstroConfig['vite']>['plugins'][number];
+export declare function getAstroStudioEnv(envMode?: string): Record<`ASTRO_STUDIO_${string}`, string>;
+export declare function getRemoteDatabaseUrl(): string;
+export declare function getAstroStudioUrl(): string;
+export declare function getDbDirectoryUrl(root: URL | string): URL;
+export declare function defineDbIntegration(integration: AstroDbIntegration): AstroIntegration;
+/**
+ * Small wrapper around fetch that throws an error if the response is not OK. Allows for custom error handling as well through the onNotOK callback.
+ */
+export declare function safeFetch(url: Parameters<typeof fetch>[0], options?: Parameters<typeof fetch>[1], onNotOK?: (response: Response) => void | Promise<void>): Promise<Response>;
+export type Result<T> = {
+    success: true;
+    data: T;
+} | {
+    success: false;
+    data: unknown;
+};

package/dist/_internal/runtime/config.d.ts

@@ -0,0 +1,148 @@
+import type { ColumnsConfig, DBConfigInput, TableConfig } from '../core/types.js';
+export declare const column: {
+    number: <T extends ({
+        name?: string | undefined;
+        label?: string | undefined;
+        unique?: boolean | undefined;
+        deprecated?: boolean | undefined;
+        collection?: string | undefined;
+    } & ({
+        primaryKey?: false | undefined;
+        optional?: boolean | undefined;
+        default?: number | import("drizzle-orm").SQL<any> | undefined;
+    } | {
+        primaryKey: true;
+        optional?: false | undefined;
+        default?: undefined;
+    })) & {
+        references?: (() => {
+            type: "number";
+            schema: ({
+                name?: string | undefined;
+                label?: string | undefined;
+                unique?: boolean | undefined;
+                deprecated?: boolean | undefined;
+                collection?: string | undefined;
+            } & {
+                primaryKey?: false | undefined;
+                optional?: boolean | undefined;
+                default?: number | import("drizzle-orm").SQL<any> | undefined;
+            } & any) | ({
+                name?: string | undefined;
+                label?: string | undefined;
+                unique?: boolean | undefined;
+                deprecated?: boolean | undefined;
+                collection?: string | undefined;
+            } & {
+                primaryKey: true;
+                optional?: false | undefined;
+                default?: undefined;
+            } & any);
+        }) | undefined;
+    }>(opts?: T) => {
+        type: "number";
+        /**
+         * @internal
+         */
+        schema: T;
+    };
+    boolean: <T_1 extends {
+        name?: string | undefined;
+        label?: string | undefined;
+        optional?: boolean | undefined;
+        unique?: boolean | undefined;
+        deprecated?: boolean | undefined;
+        collection?: string | undefined;
+        default?: boolean | import("drizzle-orm").SQL<any> | undefined;
+    }>(opts?: T_1) => {
+        type: "boolean";
+        /**
+         * @internal
+         */
+        schema: T_1;
+    };
+    text: <T_2 extends ({
+        name?: string | undefined;
+        label?: string | undefined;
+        unique?: boolean | undefined;
+        deprecated?: boolean | undefined;
+        collection?: string | undefined;
+        default?: string | import("drizzle-orm").SQL<any> | undefined;
+        multiline?: boolean | undefined;
+    } & ({
+        primaryKey?: false | undefined;
+        optional?: boolean | undefined;
+    } | {
+        primaryKey: true;
+        optional?: false | undefined;
+    })) & {
+        references?: (() => {
+            type: "text";
+            schema: ({
+                name?: string | undefined;
+                label?: string | undefined;
+                unique?: boolean | undefined;
+                deprecated?: boolean | undefined;
+                collection?: string | undefined;
+                default?: string | import("drizzle-orm").SQL<any> | undefined;
+                multiline?: boolean | undefined;
+            } & {
+                primaryKey?: false | undefined;
+                optional?: boolean | undefined;
+            } & any) | ({
+                name?: string | undefined;
+                label?: string | undefined;
+                unique?: boolean | undefined;
+                deprecated?: boolean | undefined;
+                collection?: string | undefined;
+                default?: string | import("drizzle-orm").SQL<any> | undefined;
+                multiline?: boolean | undefined;
+            } & {
+                primaryKey: true;
+                optional?: false | undefined;
+            } & any);
+        }) | undefined;
+    }>(opts?: T_2) => {
+        type: "text";
+        /**
+         * @internal
+         */
+        schema: T_2;
+    };
+    date<T_3 extends {
+        name?: string | undefined;
+        label?: string | undefined;
+        optional?: boolean | undefined;
+        unique?: boolean | undefined;
+        deprecated?: boolean | undefined;
+        collection?: string | undefined;
+        default?: Date | import("drizzle-orm").SQL<any> | undefined;
+    }>(opts?: T_3): {
+        type: "date";
+        /**
+         * @internal
+         */
+        schema: T_3;
+    };
+    json<T_4 extends {
+        name?: string | undefined;
+        label?: string | undefined;
+        optional?: boolean | undefined;
+        unique?: boolean | undefined;
+        deprecated?: boolean | undefined;
+        collection?: string | undefined;
+        default?: unknown;
+    }>(opts?: T_4): {
+        type: "json";
+        /**
+         * @internal
+         */
+        schema: T_4;
+    };
+};
+export declare function defineTable<TColumns extends ColumnsConfig>(userConfig: TableConfig<TColumns>): TableConfig<TColumns>;
+export declare function defineDb(userConfig: DBConfigInput): {
+    tables?: unknown;
+};
+export { NOW, TRUE, FALSE } from './index.js';
+export { sql, eq, gt, gte, lt, lte, ne, isNull, isNotNull, inArray, notInArray, exists, notExists, between, notBetween, like, notIlike, not, asc, desc, and, or, } from 'drizzle-orm';

package/dist/_internal/runtime/db-client.d.ts

@@ -0,0 +1,5 @@
+import type { LibSQLDatabase } from 'drizzle-orm/libsql';
+export declare function createLocalDatabaseClient({ dbUrl }: {
+    dbUrl: string;
+}): LibSQLDatabase;
+export declare function createRemoteDatabaseClient(appToken: string, remoteDbURL: string): import("drizzle-orm/sqlite-proxy").SqliteRemoteDatabase<Record<string, never>>;

package/dist/_internal/runtime/index.d.ts

@@ -0,0 +1,31 @@
+import { type ColumnDataType, sql } from 'drizzle-orm';
+import type { LibSQLDatabase } from 'drizzle-orm/libsql';
+import { type DBColumn, type DBTable } from '../core/types.js';
+export { sql };
+export type SqliteDB = LibSQLDatabase;
+export type { Table } from './types.js';
+export { createRemoteDatabaseClient, createLocalDatabaseClient } from './db-client.js';
+export { seedLocal } from './seed-local.js';
+export declare function hasPrimaryKey(column: DBColumn): boolean;
+export declare const NOW: import("drizzle-orm").SQL<unknown>;
+export declare const TRUE: import("drizzle-orm").SQL<unknown>;
+export declare const FALSE: import("drizzle-orm").SQL<unknown>;
+export declare function asDrizzleTable(name: string, table: DBTable): import("drizzle-orm/sqlite-core").SQLiteTableWithColumns<{
+    name: string;
+    schema: undefined;
+    columns: {
+        [x: string]: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: string;
+            tableName: string;
+            dataType: ColumnDataType;
+            columnType: string;
+            data: unknown;
+            driverParam: unknown;
+            notNull: false;
+            hasDefault: false;
+            enumValues: string[] | undefined;
+            baseColumn: never;
+        }, object>;
+    };
+    dialect: "sqlite";
+}>;

package/dist/_internal/runtime/queries.d.ts

@@ -0,0 +1,71 @@
+import type { BooleanColumn, ColumnType, DBColumn, DBTable, DateColumn, JsonColumn, NumberColumn, TextColumn } from '../core/types.js';
+export declare const SEED_DEV_FILE_NAME: string[];
+export declare function getDropTableIfExistsQuery(tableName: string): string;
+export declare function getCreateTableQuery(tableName: string, table: DBTable): string;
+export declare function getCreateIndexQueries(tableName: string, table: Pick<DBTable, 'indexes'>): string[];
+export declare function getCreateForeignKeyQueries(tableName: string, table: DBTable): string[];
+export declare function schemaTypeToSqlType(type: ColumnType): 'text' | 'integer';
+export declare function getModifiers(columnName: string, column: DBColumn): string;
+export declare function getReferencesConfig(column: DBColumn): {
+    type: "number";
+    schema: ({
+        unique: boolean;
+        deprecated: boolean;
+        name?: string | undefined;
+        label?: string | undefined;
+        collection?: string | undefined;
+    } & {
+        optional: boolean;
+        primaryKey: false;
+        default?: number | import("./types.js").SerializedSQL | undefined;
+    } & {
+        references?: any | undefined;
+    }) | ({
+        unique: boolean;
+        deprecated: boolean;
+        name?: string | undefined;
+        label?: string | undefined;
+        collection?: string | undefined;
+    } & {
+        primaryKey: true;
+        optional?: false | undefined;
+        default?: undefined;
+    } & {
+        references?: any | undefined;
+    });
+} | {
+    type: "text";
+    schema: ({
+        unique: boolean;
+        deprecated: boolean;
+        name?: string | undefined;
+        label?: string | undefined;
+        collection?: string | undefined;
+        default?: string | import("./types.js").SerializedSQL | undefined;
+        multiline?: boolean | undefined;
+    } & {
+        optional: boolean;
+        primaryKey: false;
+    } & {
+        references?: any | undefined;
+    }) | ({
+        unique: boolean;
+        deprecated: boolean;
+        name?: string | undefined;
+        label?: string | undefined;
+        collection?: string | undefined;
+        default?: string | import("./types.js").SerializedSQL | undefined;
+        multiline?: boolean | undefined;
+    } & {
+        primaryKey: true;
+        optional?: false | undefined;
+    } & {
+        references?: any | undefined;
+    });
+} | undefined;
+type WithDefaultDefined<T extends DBColumn> = T & {
+    schema: Required<Pick<T['schema'], 'default'>>;
+};
+type DBColumnWithDefault = WithDefaultDefined<TextColumn> | WithDefaultDefined<DateColumn> | WithDefaultDefined<NumberColumn> | WithDefaultDefined<BooleanColumn> | WithDefaultDefined<JsonColumn>;
+export declare function hasDefault(column: DBColumn): column is DBColumnWithDefault;
+export {};

package/dist/_internal/runtime/seed-local.d.ts

@@ -0,0 +1,10 @@
+import type { LibSQLDatabase } from 'drizzle-orm/libsql';
+import { type DBTables } from '../core/types.js';
+export declare function seedLocal({ db, tables, userSeedGlob, integrationSeedFunctions, }: {
+    db: LibSQLDatabase;
+    tables: DBTables;
+    userSeedGlob: Record<string, {
+        default?: () => Promise<void>;
+    }>;
+    integrationSeedFunctions: Array<() => Promise<void>>;
+}): Promise<void>;

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

@@ -0,0 +1,69 @@
+import type { ColumnBaseConfig, ColumnDataType } from 'drizzle-orm';
+import type { SQLiteColumn, SQLiteTableWithColumns } from 'drizzle-orm/sqlite-core';
+import type { ColumnsConfig, DBColumn, OutputColumnsConfig } from '../core/types.js';
+type GeneratedConfig<T extends ColumnDataType = ColumnDataType> = Pick<ColumnBaseConfig<T, string>, 'name' | 'tableName' | 'notNull' | 'hasDefault'>;
+export type AstroText<T extends GeneratedConfig<'string'>> = SQLiteColumn<T & {
+    data: string;
+    dataType: 'string';
+    columnType: 'SQLiteText';
+    driverParam: string;
+    enumValues: never;
+    baseColumn: never;
+}>;
+export type AstroDate<T extends GeneratedConfig<'custom'>> = SQLiteColumn<T & {
+    data: Date;
+    dataType: 'custom';
+    columnType: 'SQLiteCustomColumn';
+    driverParam: string;
+    enumValues: never;
+    baseColumn: never;
+}>;
+export type AstroBoolean<T extends GeneratedConfig<'boolean'>> = SQLiteColumn<T & {
+    data: boolean;
+    dataType: 'boolean';
+    columnType: 'SQLiteBoolean';
+    driverParam: number;
+    enumValues: never;
+    baseColumn: never;
+}>;
+export type AstroNumber<T extends GeneratedConfig<'number'>> = SQLiteColumn<T & {
+    data: number;
+    dataType: 'number';
+    columnType: 'SQLiteInteger';
+    driverParam: number;
+    enumValues: never;
+    baseColumn: never;
+}>;
+export type AstroJson<T extends GeneratedConfig<'custom'>> = SQLiteColumn<T & {
+    data: unknown;
+    dataType: 'custom';
+    columnType: 'SQLiteCustomColumn';
+    driverParam: string;
+    enumValues: never;
+    baseColumn: never;
+}>;
+export type Column<T extends DBColumn['type'], S extends GeneratedConfig> = T extends 'boolean' ? AstroBoolean<S> : T extends 'number' ? AstroNumber<S> : T extends 'text' ? AstroText<S> : T extends 'date' ? AstroDate<S> : T extends 'json' ? AstroJson<S> : never;
+export type Table<TTableName extends string, TColumns extends OutputColumnsConfig | ColumnsConfig> = SQLiteTableWithColumns<{
+    name: TTableName;
+    schema: undefined;
+    dialect: 'sqlite';
+    columns: {
+        [K in Extract<keyof TColumns, string>]: Column<TColumns[K]['type'], {
+            tableName: TTableName;
+            name: K;
+            hasDefault: TColumns[K]['schema'] extends {
+                default: NonNullable<unknown>;
+            } ? true : TColumns[K]['schema'] extends {
+                primaryKey: true;
+            } ? true : false;
+            notNull: TColumns[K]['schema']['optional'] extends true ? false : true;
+        }>;
+    };
+}>;
+export declare const SERIALIZED_SQL_KEY = "__serializedSQL";
+export type SerializedSQL = {
+    [SERIALIZED_SQL_KEY]: true;
+    sql: string;
+};
+export declare function isSerializedSQL(value: any): value is SerializedSQL;
+export {};

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

@@ -7,7 +7,7 @@ import ora from "ora";
 import prompts from "prompts";
 import { MISSING_SESSION_ID_ERROR } from "../../../errors.js";
 import { PROJECT_ID_FILE, getSessionIdFromFile } from "../../../tokens.js";
-import { getAstroStudioUrl } from "../../../utils.js";
+import { getAstroStudioUrl, safeFetch } from "../../../utils.js";
 async function cmd() {
   const sessionToken = await getSessionIdFromFile();
   if (!sessionToken) {
@@ -45,30 +45,33 @@ async function linkProject(id) {
 }
 async function getWorkspaceId() {
   const linkUrl = new URL(getAstroStudioUrl() + "/api/cli/workspaces.list");
-  const response = await fetch(linkUrl, {
-    method: "POST",
-    headers: {
-      Authorization: `Bearer ${await getSessionIdFromFile()}`,
-      "Content-Type": "application/json"
-    }
-  });
-  if (!response.ok) {
-    if (response.status === 401) {
-      console.error(
-        `${bgRed("Unauthorized")}
+  const response = await safeFetch(
+    linkUrl,
+    {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${await getSessionIdFromFile()}`,
+        "Content-Type": "application/json"
+      }
+    },
+    (res) => {
+      if (res.status === 401) {
+        console.error(
+          `${bgRed("Unauthorized")}
 
   Are you logged in?
   Run ${cyan(
-          "astro db login"
-        )} to authenticate and then try linking again.
+            "astro db login"
+          )} to authenticate and then try linking again.
 
 `
-      );
+        );
+        process.exit(1);
+      }
+      console.error(`Failed to fetch user workspace: ${res.status} ${res.statusText}`);
       process.exit(1);
     }
-    console.error(`Failed to fetch user workspace: ${response.status} ${response.statusText}`);
-    process.exit(1);
-  }
+  );
   const { data, success } = await response.json();
   if (!success) {
     console.error(`Failed to fetch user's workspace.`);
@@ -82,31 +85,34 @@ async function createNewProject({
   region
 }) {
   const linkUrl = new URL(getAstroStudioUrl() + "/api/cli/projects.create");
-  const response = await fetch(linkUrl, {
-    method: "POST",
-    headers: {
-      Authorization: `Bearer ${await getSessionIdFromFile()}`,
-      "Content-Type": "application/json"
+  const response = await safeFetch(
+    linkUrl,
+    {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${await getSessionIdFromFile()}`,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({ workspaceId, name, region })
     },
-    body: JSON.stringify({ workspaceId, name, region })
-  });
-  if (!response.ok) {
-    if (response.status === 401) {
-      console.error(
-        `${bgRed("Unauthorized")}
+    (res) => {
+      if (res.status === 401) {
+        console.error(
+          `${bgRed("Unauthorized")}
 
   Are you logged in?
   Run ${cyan(
-          "astro db login"
-        )} to authenticate and then try linking again.
+            "astro db login"
+          )} to authenticate and then try linking again.
 
 `
-      );
+        );
+        process.exit(1);
+      }
+      console.error(`Failed to create project: ${res.status} ${res.statusText}`);
       process.exit(1);
     }
-    console.error(`Failed to create project: ${response.status} ${response.statusText}`);
-    process.exit(1);
-  }
+  );
   const { data, success } = await response.json();
   if (!success) {
     console.error(`Failed to create project.`);
@@ -116,31 +122,34 @@ async function createNewProject({
 }
 async function promptExistingProjectName({ workspaceId }) {
   const linkUrl = new URL(getAstroStudioUrl() + "/api/cli/projects.list");
-  const response = await fetch(linkUrl, {
-    method: "POST",
-    headers: {
-      Authorization: `Bearer ${await getSessionIdFromFile()}`,
-      "Content-Type": "application/json"
+  const response = await safeFetch(
+    linkUrl,
+    {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${await getSessionIdFromFile()}`,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({ workspaceId })
     },
-    body: JSON.stringify({ workspaceId })
-  });
-  if (!response.ok) {
-    if (response.status === 401) {
-      console.error(
-        `${bgRed("Unauthorized")}
+    (res) => {
+      if (res.status === 401) {
+        console.error(
+          `${bgRed("Unauthorized")}
 
   Are you logged in?
   Run ${cyan(
-          "astro db login"
-        )} to authenticate and then try linking again.
+            "astro db login"
+          )} to authenticate and then try linking again.
 
 `
-      );
+        );
+        process.exit(1);
+      }
+      console.error(`Failed to fetch projects: ${res.status} ${res.statusText}`);
       process.exit(1);
     }
-    console.error(`Failed to fetch projects: ${response.status} ${response.statusText}`);
-    process.exit(1);
-  }
+  );
   const { data, success } = await response.json();
   if (!success) {
     console.error(`Failed to fetch projects.`);

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

@@ -1,7 +1,7 @@
 import { MIGRATION_VERSION } from "../../../consts.js";
 import { getManagedAppTokenOrExit } from "../../../tokens.js";
 import {} from "../../../types.js";
-import { getRemoteDatabaseUrl } from "../../../utils.js";
+import { getRemoteDatabaseUrl, safeFetch } from "../../../utils.js";
 import {
   createCurrentSnapshot,
   createEmptySnapshot,
@@ -64,18 +64,21 @@ async function pushSchema({
     return new Response(null, { status: 200 });
   }
   const url = new URL("/db/push", getRemoteDatabaseUrl());
-  const response = await fetch(url, {
-    method: "POST",
-    headers: new Headers({
-      Authorization: `Bearer ${appToken}`
-    }),
-    body: JSON.stringify(requestBody)
-  });
-  if (!response.ok) {
-    console.error(`${url.toString()} failed: ${response.status} ${response.statusText}`);
-    console.error(await response.text());
-    throw new Error(`/db/push fetch failed: ${response.status} ${response.statusText}`);
-  }
+  const response = await safeFetch(
+    url,
+    {
+      method: "POST",
+      headers: new Headers({
+        Authorization: `Bearer ${appToken}`
+      }),
+      body: JSON.stringify(requestBody)
+    },
+    async (res) => {
+      console.error(`${url.toString()} failed: ${res.status} ${res.statusText}`);
+      console.error(await res.text());
+      throw new Error(`/db/push fetch failed: ${res.status} ${res.statusText}`);
+    }
+  );
   const result = await response.json();
   if (!result.success) {
     console.error(`${url.toString()} unsuccessful`);

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

@@ -19,7 +19,7 @@ import { RENAME_COLUMN_ERROR, RENAME_TABLE_ERROR } from "../errors.js";
 import { columnSchema } from "../schemas.js";
 import {
 } from "../types.js";
-import { getRemoteDatabaseUrl } from "../utils.js";
+import { getRemoteDatabaseUrl, safeFetch } from "../utils.js";
 const sqlite = new SQLiteAsyncDialect();
 const genTempTableName = customAlphabet("abcdefghijklmnopqrstuvwxyz", 10);
 async function getMigrationQueries({
@@ -324,17 +324,20 @@ async function getProductionCurrentSnapshot({
   appToken
 }) {
   const url = new URL("/db/schema", getRemoteDatabaseUrl());
-  const response = await fetch(url, {
-    method: "POST",
-    headers: new Headers({
-      Authorization: `Bearer ${appToken}`
-    })
-  });
-  if (!response.ok) {
-    console.error(`${url.toString()} failed: ${response.status} ${response.statusText}`);
-    console.error(await response.text());
-    throw new Error(`/db/schema fetch failed: ${response.status} ${response.statusText}`);
-  }
+  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`);