@astrojs/db 0.6.4 → 0.7.0

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

@@ -1,8 +1,230 @@
-export declare function loadDbConfigFile(root: URL): Promise<{
-    mod: {
-        default?: unknown;
-    } | undefined;
+import type { AstroConfig } from 'astro';
+/**
+ * Load a user’s `astro:db` configuration file and additional configuration files provided by integrations.
+ */
+export declare function resolveDbConfig({ root, integrations }: AstroConfig): Promise<{
+    /** Resolved `astro:db` config, including tables added by integrations. */
+    dbConfig: {
+        tables: Record<string, {
+            deprecated: boolean;
+            columns: Record<string, {
+                type: "boolean";
+                schema: {
+                    optional: boolean;
+                    unique: boolean;
+                    deprecated: boolean;
+                    name?: string | undefined;
+                    label?: string | undefined;
+                    collection?: string | undefined;
+                    default?: boolean | import("../runtime/types.js").SerializedSQL | undefined;
+                };
+            } | {
+                type: "number";
+                schema: ({
+                    unique: boolean;
+                    deprecated: boolean;
+                    name?: string | undefined;
+                    label?: string | undefined;
+                    collection?: string | undefined;
+                } & {
+                    optional: boolean;
+                    primaryKey: false;
+                    default?: number | import("../runtime/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("../runtime/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("../runtime/types.js").SerializedSQL | undefined;
+                    multiline?: boolean | undefined;
+                } & {
+                    primaryKey: true;
+                    optional?: false | undefined;
+                } & {
+                    references?: any | undefined;
+                });
+            } | {
+                type: "date";
+                schema: {
+                    optional: boolean;
+                    unique: boolean;
+                    deprecated: boolean;
+                    name?: string | undefined;
+                    label?: string | undefined;
+                    collection?: string | undefined;
+                    default?: string | import("../runtime/types.js").SerializedSQL | undefined;
+                };
+            } | {
+                type: "json";
+                schema: {
+                    optional: boolean;
+                    unique: boolean;
+                    deprecated: boolean;
+                    name?: string | undefined;
+                    label?: string | undefined;
+                    collection?: string | undefined;
+                    default?: unknown;
+                };
+            }>;
+            indexes?: Record<string, {
+                on: (string | string[]) & (string | string[] | undefined);
+                unique?: boolean | undefined;
+            }> | undefined;
+            foreignKeys?: (Omit<{
+                columns: import("./types.js").MaybeArray<string>;
+                references: () => import("./types.js").MaybeArray<Omit<{
+                    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;
+                    } & {
+                        references?: (() => any) | undefined;
+                    }) | ({
+                        name?: string | undefined;
+                        label?: string | undefined;
+                        unique?: boolean | undefined;
+                        deprecated?: boolean | undefined;
+                        collection?: string | undefined;
+                    } & {
+                        primaryKey: true;
+                        optional?: false | undefined;
+                        default?: undefined;
+                    } & {
+                        references?: (() => any) | undefined;
+                    });
+                } | {
+                    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;
+                    } & {
+                        references?: (() => any) | undefined;
+                    }) | ({
+                        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;
+                    } & {
+                        references?: (() => any) | undefined;
+                    });
+                }, "references">>;
+            }, "references"> & {
+                references: import("./types.js").MaybeArray<Omit<{
+                    type: "number";
+                    schema: ({
+                        unique: boolean;
+                        deprecated: boolean;
+                        name?: string | undefined;
+                        label?: string | undefined;
+                        collection?: string | undefined;
+                    } & {
+                        optional: boolean;
+                        primaryKey: false;
+                        default?: number | import("../runtime/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("../runtime/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("../runtime/types.js").SerializedSQL | undefined;
+                        multiline?: boolean | undefined;
+                    } & {
+                        primaryKey: true;
+                        optional?: false | undefined;
+                    } & {
+                        references?: any | undefined;
+                    });
+                }, "references">>;
+            })[] | undefined;
+        }>;
+    };
+    /** Dependencies imported into the user config file. */
     dependencies: string[];
+    /** Additional `astro:db` seed file paths provided by integrations. */
+    integrationSeedPaths: (string | URL)[];
 }>;
 /**
  * Bundle arbitrary `mjs` or `ts` file.

package/dist/core/load-file.js

@@ -1,11 +1,62 @@
 import { existsSync } from "node:fs";
 import { unlink, writeFile } from "node:fs/promises";
-import { fileURLToPath } from "node:url";
+import { createRequire } from "node:module";
+import { fileURLToPath, pathToFileURL } from "node:url";
 import { build as esbuild } from "esbuild";
 import { CONFIG_FILE_NAMES, VIRTUAL_MODULE_ID } from "./consts.js";
+import { INTEGRATION_TABLE_CONFLICT_ERROR } from "./errors.js";
+import { errorMap } from "./integration/error-map.js";
 import { getConfigVirtualModContents } from "./integration/vite-plugin-db.js";
+import { dbConfigSchema } from "./types.js";
 import { getDbDirectoryUrl } from "./utils.js";
-async function loadDbConfigFile(root) {
+const isDbIntegration = (integration) => "astro:db:setup" in integration.hooks;
+async function resolveDbConfig({ root, integrations }) {
+  const { mod, dependencies } = await loadUserConfigFile(root);
+  const userDbConfig = dbConfigSchema.parse(mod?.default ?? {}, { errorMap });
+  const dbConfig = { tables: userDbConfig.tables ?? {} };
+  const integrationDbConfigPaths = [];
+  const integrationSeedPaths = [];
+  for (const integration of integrations) {
+    if (!isDbIntegration(integration))
+      continue;
+    const { name, hooks } = integration;
+    if (hooks["astro:db:setup"]) {
+      hooks["astro:db:setup"]({
+        extendDb({ configEntrypoint, seedEntrypoint }) {
+          if (configEntrypoint) {
+            integrationDbConfigPaths.push({ name, configEntrypoint });
+          }
+          if (seedEntrypoint) {
+            integrationSeedPaths.push(seedEntrypoint);
+          }
+        }
+      });
+    }
+  }
+  for (const { name, configEntrypoint } of integrationDbConfigPaths) {
+    const loadedConfig = await loadIntegrationConfigFile(root, configEntrypoint);
+    const integrationDbConfig = dbConfigSchema.parse(loadedConfig.mod?.default ?? {}, {
+      errorMap
+    });
+    for (const key in integrationDbConfig.tables) {
+      if (key in dbConfig.tables) {
+        const isUserConflict = key in (userDbConfig.tables ?? {});
+        throw new Error(INTEGRATION_TABLE_CONFLICT_ERROR(name, key, isUserConflict));
+      } else {
+        dbConfig.tables[key] = integrationDbConfig.tables[key];
+      }
+    }
+  }
+  return {
+    /** Resolved `astro:db` config, including tables added by integrations. */
+    dbConfig,
+    /** Dependencies imported into the user config file. */
+    dependencies,
+    /** Additional `astro:db` seed file paths provided by integrations. */
+    integrationSeedPaths
+  };
+}
+async function loadUserConfigFile(root) {
   let configFileUrl;
   for (const fileName of CONFIG_FILE_NAMES) {
     const fileUrl = new URL(fileName, getDbDirectoryUrl(root));
@@ -13,13 +64,30 @@ async function loadDbConfigFile(root) {
       configFileUrl = fileUrl;
     }
   }
-  if (!configFileUrl) {
+  return await loadAndBundleDbConfigFile({ root, fileUrl: configFileUrl });
+}
+async function loadIntegrationConfigFile(root, filePathOrUrl) {
+  let fileUrl;
+  if (typeof filePathOrUrl === "string") {
+    const { resolve } = createRequire(root);
+    const resolvedFilePath = resolve(filePathOrUrl);
+    fileUrl = pathToFileURL(resolvedFilePath);
+  } else {
+    fileUrl = filePathOrUrl;
+  }
+  return await loadAndBundleDbConfigFile({ root, fileUrl });
+}
+async function loadAndBundleDbConfigFile({
+  root,
+  fileUrl
+}) {
+  if (!fileUrl) {
     return { mod: void 0, dependencies: [] };
   }
   const { code, dependencies } = await bundleFile({
     virtualModContents: getConfigVirtualModContents(),
     root,
-    fileUrl: configFileUrl
+    fileUrl
   });
   return {
     mod: await importBundledFile({ code, root }),
@@ -94,5 +162,5 @@ async function importBundledFile({
 export {
   bundleFile,
   importBundledFile,
-  loadDbConfigFile
+  resolveDbConfig
 };

package/dist/core/types.d.ts

@@ -1,3 +1,4 @@
+import type { AstroIntegration } from 'astro';
 import { SQL } from 'drizzle-orm';
 import { type ZodTypeDef, z } from 'zod';
 import { type SerializedSQL } from '../runtime/types.js';
@@ -3118,11 +3119,7 @@ export type DBTable = z.infer<typeof tableSchema>;
 export type DBTables = Record<string, DBTable>;
 export type DBSnapshot = {
     schema: Record<string, DBTable>;
-    /**
-     * Snapshot version. Breaking changes to the snapshot format increment this number.
-     * @todo Rename to "version" once closer to release.
-     */
-    experimentalVersion: number;
+    version: string;
 };
 export declare const dbConfigSchema: z.ZodObject<{
     tables: z.ZodOptional<z.ZodEffects<z.ZodRecord<z.ZodString, z.ZodObject<{
@@ -3898,4 +3895,14 @@ interface IndexConfig<TColumns extends ColumnsConfig> extends z.input<typeof ind
 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/core/utils.d.ts

@@ -1,6 +1,8 @@
-import type { AstroConfig } from 'astro';
+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;

package/dist/core/utils.js

@@ -14,7 +14,11 @@ function getAstroStudioUrl() {
 function getDbDirectoryUrl(root) {
   return new URL("db/", root);
 }
+function defineDbIntegration(integration) {
+  return integration;
+}
 export {
+  defineDbIntegration,
   getAstroStudioEnv,
   getAstroStudioUrl,
   getDbDirectoryUrl,

package/dist/runtime/config.d.ts

@@ -141,7 +141,8 @@ export declare const column: {
     };
 };
 export declare function defineTable<TColumns extends ColumnsConfig>(userConfig: TableConfig<TColumns>): TableConfig<TColumns>;
-export declare function defineDB(userConfig: DBConfigInput): {
+export declare function defineDb(userConfig: DBConfigInput): {
     tables?: unknown;
 };
-export { sql, NOW, TRUE, FALSE } from './index.js';
+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/runtime/config.js

@@ -27,16 +27,61 @@ const column = {
 function defineTable(userConfig) {
   return userConfig;
 }
-function defineDB(userConfig) {
+function defineDb(userConfig) {
   return userConfig;
 }
-import { sql, NOW, TRUE, FALSE } from "./index.js";
+import { NOW, TRUE, FALSE } from "./index.js";
+import {
+  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";
 export {
   FALSE,
   NOW,
   TRUE,
+  and,
+  asc,
+  between,
   column,
-  defineDB,
+  defineDb,
   defineTable,
+  desc,
+  eq,
+  exists,
+  gt,
+  gte,
+  inArray,
+  isNotNull,
+  isNull,
+  like,
+  lt,
+  lte,
+  ne,
+  not,
+  notBetween,
+  notExists,
+  notIlike,
+  notInArray,
+  or,
   sql
 };

package/dist/runtime/db-client.js

@@ -5,57 +5,107 @@ import { z } from "zod";
 const isWebContainer = !!process.versions?.webcontainer;
 function createLocalDatabaseClient({ dbUrl }) {
   const url = isWebContainer ? "file:content.db" : dbUrl;
-  const client = createClient({ url: process.env.TEST_IN_MEMORY_DB ? ":memory:" : url });
+  const client = createClient({ url });
   const db = drizzleLibsql(client);
   return db;
 }
+const remoteResultSchema = z.object({
+  columns: z.array(z.string()),
+  columnTypes: z.array(z.string()),
+  rows: z.array(z.array(z.unknown())),
+  rowsAffected: z.number(),
+  lastInsertRowid: z.unknown().optional()
+});
 function createRemoteDatabaseClient(appToken, remoteDbURL) {
   const url = new URL("/db/query", remoteDbURL);
-  const db = drizzleProxy(async (sql, parameters, method) => {
-    const requestBody = { sql, args: parameters };
-    const res = await fetch(url, {
-      method: "POST",
-      headers: {
-        Authorization: `Bearer ${appToken}`,
-        "Content-Type": "application/json"
-      },
-      body: JSON.stringify(requestBody)
-    });
-    if (!res.ok) {
-      throw new Error(
-        `Failed to execute query.
+  const db = drizzleProxy(
+    async (sql, parameters, method) => {
+      const requestBody = { sql, args: parameters };
+      const res = await fetch(url, {
+        method: "POST",
+        headers: {
+          Authorization: `Bearer ${appToken}`,
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify(requestBody)
+      });
+      if (!res.ok) {
+        throw new Error(
+          `Failed to execute query.
 Query: ${sql}
 Full error: ${res.status} ${await res.text()}}`
-      );
-    }
-    const queryResultSchema = z.object({
-      rows: z.array(z.unknown())
-    });
-    let rows;
-    try {
-      const json = await res.json();
-      rows = queryResultSchema.parse(json).rows;
-    } catch (e) {
-      throw new Error(
-        `Failed to execute query.
+        );
+      }
+      let remoteResult;
+      try {
+        const json = await res.json();
+        remoteResult = remoteResultSchema.parse(json);
+      } catch (e) {
+        throw new Error(
+          `Failed to execute query.
 Query: ${sql}
 Full error: Unexpected JSON response. ${e instanceof Error ? e.message : String(e)}`
-      );
-    }
-    const rowValues = [];
-    for (const row of rows) {
-      if (row != null && typeof row === "object") {
-        rowValues.push(Object.values(row));
+        );
       }
+      if (method === "run")
+        return remoteResult;
+      const rowValues = [];
+      for (const row of remoteResult.rows) {
+        if (row != null && typeof row === "object") {
+          rowValues.push(Object.values(row));
+        }
+      }
+      if (method === "get") {
+        return { rows: rowValues[0] };
+      }
+      return { rows: rowValues };
+    },
+    async (queries) => {
+      const stmts = queries.map(({ sql, params }) => ({ sql, args: params }));
+      const res = await fetch(url, {
+        method: "POST",
+        headers: {
+          Authorization: `Bearer ${appToken}`,
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify(stmts)
+      });
+      if (!res.ok) {
+        throw new Error(
+          `Failed to execute batch queries.
+Full error: ${res.status} ${await res.text()}}`
+        );
+      }
+      let remoteResults;
+      try {
+        const json = await res.json();
+        remoteResults = z.array(remoteResultSchema).parse(json);
+      } catch (e) {
+        throw new Error(
+          `Failed to execute batch queries.
+Full error: Unexpected JSON response. ${e instanceof Error ? e.message : String(e)}`
+        );
+      }
+      let results = [];
+      for (const [idx, rawResult] of remoteResults.entries()) {
+        if (queries[idx]?.method === "run") {
+          results.push(rawResult);
+          continue;
+        }
+        const rowValues = [];
+        for (const row of rawResult.rows) {
+          if (row != null && typeof row === "object") {
+            rowValues.push(Object.values(row));
+          }
+        }
+        if (queries[idx]?.method === "get") {
+          results.push({ rows: rowValues[0] });
+        }
+        results.push({ rows: rowValues });
+      }
+      return results;
     }
-    if (method === "get") {
-      return { rows: rowValues[0] };
-    }
-    return { rows: rowValues };
-  });
-  db.batch = (_drizzleQueries) => {
-    throw new Error("db.batch() is not currently supported.");
-  };
+  );
   return db;
 }
 export {

package/dist/runtime/index.d.ts

@@ -5,7 +5,14 @@ export { sql };
 export type SqliteDB = LibSQLDatabase;
 export type { Table } from './types.js';
 export { createRemoteDatabaseClient, createLocalDatabaseClient } from './db-client.js';
-export { seedLocal } from './queries.js';
+export declare function seedLocal({ userSeedGlob, integrationSeedImports, }: {
+    userSeedGlob: Record<string, {
+        default?: () => Promise<void>;
+    }>;
+    integrationSeedImports: Array<() => Promise<{
+        default: () => Promise<void>;
+    }>>;
+}): Promise<void>;
 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>;

package/dist/runtime/index.js

@@ -1,3 +1,4 @@
+import { LibsqlError } from "@libsql/client";
 import { sql } from "drizzle-orm";
 import {
   customType,
@@ -6,10 +7,40 @@ import {
   sqliteTable,
   text
 } from "drizzle-orm/sqlite-core";
+import { SEED_DEFAULT_EXPORT_ERROR, SEED_ERROR } from "../core/errors.js";
 import {} from "../core/types.js";
 import { isSerializedSQL } from "./types.js";
 import { createRemoteDatabaseClient, createLocalDatabaseClient } from "./db-client.js";
-import { seedLocal } from "./queries.js";
+async function seedLocal({
+  // Glob all potential seed files to catch renames and deletions.
+  userSeedGlob,
+  integrationSeedImports
+}) {
+  const seedFilePath = Object.keys(userSeedGlob)[0];
+  if (seedFilePath) {
+    const mod = userSeedGlob[seedFilePath];
+    if (!mod.default) {
+      throw new Error(SEED_DEFAULT_EXPORT_ERROR(seedFilePath));
+    }
+    try {
+      await mod.default();
+    } catch (e) {
+      if (e instanceof LibsqlError) {
+        throw new Error(SEED_ERROR(e.message));
+      }
+      throw e;
+    }
+  }
+  for (const importModule of integrationSeedImports) {
+    const mod = await importModule();
+    await mod.default().catch((e) => {
+      if (e instanceof LibsqlError) {
+        throw new Error(SEED_ERROR(e.message));
+      }
+      throw e;
+    });
+  }
+}
 function hasPrimaryKey(column) {
   return "primaryKey" in column.schema && !!column.schema.primaryKey;
 }