@astrojs/db 0.4.1 → 0.5.0

package/dist/core/integration/index.js

@@ -1,66 +1,27 @@
-var __knownSymbol = (name, symbol) => {
-  return (symbol = Symbol[name]) ? symbol : Symbol.for("Symbol." + name);
-};
-var __using = (stack, value, async) => {
-  if (value != null) {
-    if (typeof value !== "object" && typeof value !== "function")
-      throw TypeError("Object expected");
-    var dispose;
-    if (async)
-      dispose = value[__knownSymbol("asyncDispose")];
-    if (dispose === void 0)
-      dispose = value[__knownSymbol("dispose")];
-    if (typeof dispose !== "function")
-      throw TypeError("Object not disposable");
-    stack.push([async, dispose, value]);
-  } else if (async) {
-    stack.push([async]);
-  }
-  return value;
-};
-var __callDispose = (stack, error, hasError) => {
-  var E = typeof SuppressedError === "function" ? SuppressedError : function(e, s, m, _) {
-    return _ = Error(m), _.name = "SuppressedError", _.error = e, _.suppressed = s, _;
-  };
-  var fail = (e) => error = hasError ? new E(e, error, "An error was suppressed during disposal") : (hasError = true, e);
-  var next = (it) => {
-    while (it = stack.pop()) {
-      try {
-        var result = it[1] && it[1].call(it[2]);
-        if (it[0])
-          return Promise.resolve(result).then(next, (e) => (fail(e), next()));
-      } catch (e) {
-        fail(e);
-      }
-    }
-    if (hasError)
-      throw error;
-  };
-  return next();
-};
-import { vitePluginDb } from "./vite-plugin-db.js";
-import { vitePluginInjectEnvTs } from "./vite-plugin-inject-env-ts.js";
-import { typegen } from "./typegen.js";
 import { existsSync } from "fs";
-import { mkdir, rm, writeFile } from "fs/promises";
-import { DB_PATH } from "../consts.js";
-import { createLocalDatabaseClient } from "../../runtime/db-client.js";
-import { astroConfigWithDbSchema } from "../types.js";
-import {} from "../utils.js";
-import { STUDIO_CONFIG_MISSING_WRITABLE_TABLE_ERROR, UNSAFE_WRITABLE_WARNING } from "../errors.js";
-import { errorMap } from "./error-map.js";
 import { dirname } from "path";
 import { fileURLToPath } from "url";
+import { mkdir, rm, writeFile } from "fs/promises";
 import { blue, yellow } from "kleur/colors";
-import { fileURLIntegration } from "./file-url.js";
-import { recreateTables, seedData } from "../queries.js";
+import { CONFIG_FILE_NAMES, DB_PATH } from "../consts.js";
+import { loadDbConfigFile } from "../load-file.js";
 import { getManagedAppTokenOrExit } from "../tokens.js";
+import { dbConfigSchema } from "../types.js";
+import { getDbDirectoryUrl } from "../utils.js";
+import { errorMap } from "./error-map.js";
+import { fileURLIntegration } from "./file-url.js";
+import { typegen } from "./typegen.js";
+import { vitePluginDb } from "./vite-plugin-db.js";
+import { vitePluginInjectEnvTs } from "./vite-plugin-inject-env-ts.js";
 function astroDBIntegration() {
-  let connectedToRemote = false;
+  let connectToStudio = false;
+  let configFileDependencies = [];
+  let root;
   let appToken;
-  let schemas = {
-    tables() {
-      throw new Error("tables not found");
+  let dbConfig;
+  let tables = {
+    get() {
+      throw new Error("[astro:db] INTERNAL Tables not loaded yet");
     }
   };
   let command;
@@ -69,24 +30,26 @@ function astroDBIntegration() {
     hooks: {
       "astro:config:setup": async ({ updateConfig, config, command: _command, logger }) => {
         command = _command;
-        if (_command === "preview")
+        root = config.root;
+        if (command === "preview")
           return;
         let dbPlugin = void 0;
-        const studio = config.db?.studio ?? false;
-        if (studio && command === "build" && process.env.ASTRO_DB_TEST_ENV !== "1") {
+        connectToStudio = command === "build";
+        if (connectToStudio) {
           appToken = await getManagedAppTokenOrExit();
-          connectedToRemote = true;
           dbPlugin = vitePluginDb({
-            connectToStudio: true,
+            connectToStudio,
             appToken: appToken.token,
-            schemas,
-            root: config.root
+            tables,
+            root: config.root,
+            srcDir: config.srcDir
           });
         } else {
           dbPlugin = vitePluginDb({
             connectToStudio: false,
-            schemas,
-            root: config.root
+            tables,
+            root: config.root,
+            srcDir: config.srcDir
           });
         }
         updateConfig({
@@ -96,63 +59,44 @@ function astroDBIntegration() {
           }
         });
       },
-      "astro:config:done": async ({ config, logger }) => {
-        const configWithDb = astroConfigWithDbSchema.parse(config, { errorMap });
-        const tables = configWithDb.db?.tables ?? {};
-        schemas.tables = () => tables;
-        const studio = configWithDb.db?.studio ?? false;
-        const unsafeWritable = Boolean(configWithDb.db?.unsafeWritable);
-        const foundWritableCollection = Object.entries(tables).find(([, c]) => c.writable);
-        const writableAllowed = studio || unsafeWritable;
-        if (!writableAllowed && foundWritableCollection) {
-          logger.error(STUDIO_CONFIG_MISSING_WRITABLE_TABLE_ERROR(foundWritableCollection[0]));
-          process.exit(1);
-        } else if (unsafeWritable && foundWritableCollection) {
-          logger.warn(UNSAFE_WRITABLE_WARNING);
-        }
-        if (!connectedToRemote) {
-          var _stack = [];
-          try {
-            const dbUrl = new URL(DB_PATH, config.root);
-            if (existsSync(dbUrl)) {
-              await rm(dbUrl);
-            }
-            await mkdir(dirname(fileURLToPath(dbUrl)), { recursive: true });
-            await writeFile(dbUrl, "");
-            const db = __using(_stack, await createLocalDatabaseClient({
-              tables,
-              dbUrl: dbUrl.toString(),
-              seeding: true
-            }));
-            await recreateTables({ db, tables });
-            if (configWithDb.db?.data) {
-              await seedData({
-                db,
-                data: configWithDb.db.data,
-                logger,
-                mode: command === "dev" ? "dev" : "build"
-              });
-            }
-            logger.debug("Database setup complete.");
-          } catch (_) {
-            var _error = _, _hasError = true;
-          } finally {
-            __callDispose(_stack, _error, _hasError);
+      "astro:config:done": async ({ config }) => {
+        const { mod, dependencies } = await loadDbConfigFile(config.root);
+        configFileDependencies = dependencies;
+        dbConfig = dbConfigSchema.parse(mod?.default ?? {}, {
+          errorMap
+        });
+        tables.get = () => dbConfig.tables ?? {};
+        if (!connectToStudio && !process.env.TEST_IN_MEMORY_DB) {
+          const dbUrl = new URL(DB_PATH, config.root);
+          if (existsSync(dbUrl)) {
+            await rm(dbUrl);
           }
+          await mkdir(dirname(fileURLToPath(dbUrl)), { recursive: true });
+          await writeFile(dbUrl, "");
         }
-        await typegen({ tables, root: config.root });
+        await typegen({ tables: tables.get() ?? {}, root: config.root });
       },
       "astro:server:start": async ({ logger }) => {
         setTimeout(() => {
           logger.info(
-            connectedToRemote ? "Connected to remote database." : "New local database created."
+            connectToStudio ? "Connected to remote database." : "New local database created."
           );
         }, 100);
       },
+      "astro:server:setup": async ({ server }) => {
+        const filesToWatch = [
+          ...CONFIG_FILE_NAMES.map((c) => new URL(c, getDbDirectoryUrl(root))),
+          ...configFileDependencies.map((c) => new URL(c, root))
+        ];
+        server.watcher.on("all", (event, relativeEntry) => {
+          const entry = new URL(relativeEntry, root);
+          if (filesToWatch.some((f) => entry.href === f.href)) {
+            server.restart();
+          }
+        });
+      },
       "astro:build:start": async ({ logger }) => {
-        logger.info(
-          "database: " + (connectedToRemote ? yellow("remote") : blue("local database."))
-        );
+        logger.info("database: " + (connectToStudio ? yellow("remote") : blue("local database.")));
       },
       "astro:build:done": async ({}) => {
         await appToken?.destroy();

package/dist/core/integration/typegen.js

@@ -20,19 +20,7 @@ ${Object.entries(tables).map(([name, collection]) => generateTableType(name, col
 function generateTableType(name, collection) {
   let tableType = `	export const ${name}: import(${RUNTIME_IMPORT}).Table<
 		${JSON.stringify(name)},
-		${JSON.stringify(
-    Object.fromEntries(
-      Object.entries(collection.columns).map(([columnName, column]) => [
-        columnName,
-        {
-          // Only select columns Drizzle needs for inference
-          type: column.type,
-          optional: column.schema.optional,
-          default: column.schema.default
-        }
-      ])
-    )
-  )}
+		${JSON.stringify(collection.columns)}
 	>;`;
   return tableType;
 }

package/dist/core/integration/vite-plugin-db.d.ts

@@ -1,22 +1,26 @@
 import type { DBTables } from '../types.js';
 import { type VitePlugin } from '../utils.js';
-type LateSchema = {
-    tables: () => DBTables;
+export type LateTables = {
+    get: () => DBTables;
 };
 type VitePluginDBParams = {
     connectToStudio: false;
-    schemas: LateSchema;
+    tables: LateTables;
+    srcDir: URL;
     root: URL;
 } | {
     connectToStudio: true;
-    schemas: LateSchema;
+    tables: LateTables;
     appToken: string;
+    srcDir: URL;
     root: URL;
 };
 export declare function vitePluginDb(params: VitePluginDBParams): VitePlugin;
-export declare function getVirtualModContents({ tables, root }: {
+export declare function getConfigVirtualModContents(): string;
+export declare function getLocalVirtualModContents({ tables, shouldSeed, }: {
     tables: DBTables;
     root: URL;
+    shouldSeed: boolean;
 }): string;
 export declare function getStudioVirtualModContents({ tables, appToken, }: {
     tables: DBTables;

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

@@ -1,75 +1,118 @@
-import { DB_PATH, RUNTIME_DRIZZLE_IMPORT, RUNTIME_IMPORT, VIRTUAL_MODULE_ID } from "../consts.js";
-import { getRemoteDatabaseUrl } from "../utils.js";
+import { fileURLToPath } from "node:url";
+import { normalizePath } from "vite";
+import { SEED_DEV_FILE_NAME } from "../../runtime/queries.js";
+import {
+  DB_PATH,
+  RUNTIME_CONFIG_IMPORT,
+  RUNTIME_DRIZZLE_IMPORT,
+  RUNTIME_IMPORT,
+  VIRTUAL_MODULE_ID
+} from "../consts.js";
+import { getDbDirectoryUrl, getRemoteDatabaseUrl } from "../utils.js";
+const LOCAL_DB_VIRTUAL_MODULE_ID = "astro:local";
 const resolvedVirtualModuleId = "\0" + VIRTUAL_MODULE_ID;
+const resolvedLocalDbVirtualModuleId = LOCAL_DB_VIRTUAL_MODULE_ID + "/local-db";
+const resolvedSeedVirtualModuleId = "\0" + VIRTUAL_MODULE_ID + "?shouldSeed";
 function vitePluginDb(params) {
+  const srcDirPath = normalizePath(fileURLToPath(params.srcDir));
   return {
     name: "astro:db",
     enforce: "pre",
-    resolveId(id) {
-      if (id === VIRTUAL_MODULE_ID) {
+    async resolveId(id, rawImporter) {
+      if (id === LOCAL_DB_VIRTUAL_MODULE_ID)
+        return resolvedLocalDbVirtualModuleId;
+      if (id !== VIRTUAL_MODULE_ID)
+        return;
+      if (params.connectToStudio)
+        return resolvedVirtualModuleId;
+      const importer = rawImporter ? await this.resolve(rawImporter) : null;
+      if (!importer)
         return resolvedVirtualModuleId;
+      if (importer.id.startsWith(srcDirPath)) {
+        return resolvedSeedVirtualModuleId;
       }
+      return resolvedVirtualModuleId;
     },
     load(id) {
-      if (id !== resolvedVirtualModuleId)
+      if (id === resolvedLocalDbVirtualModuleId) {
+        const dbUrl = new URL(DB_PATH, params.root);
+        return `import { createLocalDatabaseClient } from ${RUNTIME_IMPORT};
+				const dbUrl = ${JSON.stringify(dbUrl)};
+
+				export const db = createLocalDatabaseClient({ dbUrl });`;
+      }
+      if (id !== resolvedVirtualModuleId && id !== resolvedSeedVirtualModuleId)
         return;
       if (params.connectToStudio) {
         return getStudioVirtualModContents({
           appToken: params.appToken,
-          tables: params.schemas.tables()
+          tables: params.tables.get()
         });
       }
-      return getVirtualModContents({
+      return getLocalVirtualModContents({
         root: params.root,
-        tables: params.schemas.tables()
+        tables: params.tables.get(),
+        shouldSeed: id === resolvedSeedVirtualModuleId
       });
     }
   };
 }
-function getVirtualModContents({ tables, root }) {
-  const dbUrl = new URL(DB_PATH, root);
+function getConfigVirtualModContents() {
+  return `export * from ${RUNTIME_CONFIG_IMPORT}`;
+}
+function getLocalVirtualModContents({
+  tables,
+  shouldSeed
+}) {
+  const seedFilePaths = SEED_DEV_FILE_NAME.map(
+    // Format as /db/[name].ts
+    // for Vite import.meta.glob
+    (name) => new URL(name, getDbDirectoryUrl("file:///")).pathname
+  );
   return `
-import { collectionToTable, createLocalDatabaseClient } from ${RUNTIME_IMPORT};
-import dbUrl from ${JSON.stringify(`${dbUrl}?fileurl`)};
+import { asDrizzleTable, seedLocal } from ${RUNTIME_IMPORT};
+import { db as _db } from ${JSON.stringify(LOCAL_DB_VIRTUAL_MODULE_ID)};
 
-const params = ${JSON.stringify({
-    tables,
-    seeding: false
-  })};
-params.dbUrl = dbUrl;
+export const db = _db;
 
-export const db = await createLocalDatabaseClient(params);
+${shouldSeed ? `await seedLocal({
+	db: _db,
+	tables: ${JSON.stringify(tables)},
+	fileGlob: import.meta.glob(${JSON.stringify(seedFilePaths)}),
+})` : ""}
 
 export * from ${RUNTIME_DRIZZLE_IMPORT};
+export * from ${RUNTIME_CONFIG_IMPORT};
 
-${getStringifiedCollectionExports(tables)}
-`;
+${getStringifiedCollectionExports(tables)}`;
 }
 function getStudioVirtualModContents({
   tables,
   appToken
 }) {
   return `
-import {collectionToTable, createRemoteDatabaseClient} from ${RUNTIME_IMPORT};
+import {asDrizzleTable, createRemoteDatabaseClient} from ${RUNTIME_IMPORT};
 
 export const db = await createRemoteDatabaseClient(${JSON.stringify(
     appToken
     // Respect runtime env for user overrides in SSR
   )}, import.meta.env.ASTRO_STUDIO_REMOTE_DB_URL ?? ${JSON.stringify(getRemoteDatabaseUrl())});
 export * from ${RUNTIME_DRIZZLE_IMPORT};
+export * from ${RUNTIME_CONFIG_IMPORT};
 
 ${getStringifiedCollectionExports(tables)}
 	`;
 }
 function getStringifiedCollectionExports(tables) {
   return Object.entries(tables).map(
-    ([name, collection]) => `export const ${name} = collectionToTable(${JSON.stringify(name)}, ${JSON.stringify(
+    ([name, collection]) => `export const ${name} = asDrizzleTable(${JSON.stringify(name)}, ${JSON.stringify(
       collection
     )}, false)`
   ).join("\n");
 }
 export {
+  getConfigVirtualModContents,
+  getLocalVirtualModContents,
   getStudioVirtualModContents,
-  getVirtualModContents,
   vitePluginDb
 };

package/dist/core/integration/vite-plugin-inject-env-ts.d.ts

@@ -1,5 +1,5 @@
-import type { VitePlugin } from '../utils.js';
 import type { AstroIntegrationLogger } from 'astro';
+import type { VitePlugin } from '../utils.js';
 export declare function vitePluginInjectEnvTs({ srcDir, root }: {
     srcDir: URL;
     root: URL;

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

@@ -0,0 +1,31 @@
+export declare function loadDbConfigFile(root: URL): Promise<{
+    mod: {
+        default?: unknown;
+    } | undefined;
+    dependencies: string[];
+}>;
+/**
+ * Bundle arbitrary `mjs` or `ts` file.
+ * Simplified fork from Vite's `bundleConfigFile` function.
+ *
+ * @see https://github.com/vitejs/vite/blob/main/packages/vite/src/node/config.ts#L961
+ */
+export declare function bundleFile({ fileUrl, root, virtualModContents, }: {
+    fileUrl: URL;
+    root: URL;
+    virtualModContents: string;
+}): Promise<{
+    code: string;
+    dependencies: string[];
+}>;
+/**
+ * Forked from Vite config loader, replacing CJS-based path concat with ESM only
+ *
+ * @see https://github.com/vitejs/vite/blob/main/packages/vite/src/node/config.ts#L1074
+ */
+export declare function importBundledFile({ code, root, }: {
+    code: string;
+    root: URL;
+}): Promise<{
+    default?: unknown;
+}>;

package/dist/core/load-file.js

@@ -0,0 +1,98 @@
+import { existsSync } from "node:fs";
+import { unlink, writeFile } from "node:fs/promises";
+import { fileURLToPath } from "node:url";
+import { build as esbuild } from "esbuild";
+import { CONFIG_FILE_NAMES, VIRTUAL_MODULE_ID } from "./consts.js";
+import { getConfigVirtualModContents } from "./integration/vite-plugin-db.js";
+import { getDbDirectoryUrl } from "./utils.js";
+async function loadDbConfigFile(root) {
+  let configFileUrl;
+  for (const fileName of CONFIG_FILE_NAMES) {
+    const fileUrl = new URL(fileName, getDbDirectoryUrl(root));
+    if (existsSync(fileUrl)) {
+      configFileUrl = fileUrl;
+    }
+  }
+  if (!configFileUrl) {
+    return { mod: void 0, dependencies: [] };
+  }
+  const { code, dependencies } = await bundleFile({
+    virtualModContents: getConfigVirtualModContents(),
+    root,
+    fileUrl: configFileUrl
+  });
+  return {
+    mod: await importBundledFile({ code, root }),
+    dependencies
+  };
+}
+async function bundleFile({
+  fileUrl,
+  root,
+  virtualModContents
+}) {
+  const result = await esbuild({
+    absWorkingDir: process.cwd(),
+    entryPoints: [fileURLToPath(fileUrl)],
+    outfile: "out.js",
+    packages: "external",
+    write: false,
+    target: ["node16"],
+    platform: "node",
+    bundle: true,
+    format: "esm",
+    sourcemap: "inline",
+    metafile: true,
+    define: {
+      "import.meta.env.ASTRO_STUDIO_REMOTE_DB_URL": "undefined"
+    },
+    plugins: [
+      {
+        name: "resolve-astro-db",
+        setup(build) {
+          build.onResolve({ filter: /^astro:db$/ }, ({ path }) => {
+            return { path, namespace: VIRTUAL_MODULE_ID };
+          });
+          build.onLoad({ namespace: VIRTUAL_MODULE_ID, filter: /.*/ }, () => {
+            return {
+              contents: virtualModContents,
+              // Needed to resolve runtime dependencies
+              resolveDir: fileURLToPath(root)
+            };
+          });
+        }
+      }
+    ]
+  });
+  const file = result.outputFiles[0];
+  if (!file) {
+    throw new Error(`Unexpected: no output file`);
+  }
+  return {
+    code: file.text,
+    dependencies: Object.keys(result.metafile.inputs)
+  };
+}
+async function importBundledFile({
+  code,
+  root
+}) {
+  const tmpFileUrl = new URL(`./db.timestamp-${Date.now()}.mjs`, root);
+  await writeFile(tmpFileUrl, code, { encoding: "utf8" });
+  try {
+    return await import(
+      /* @vite-ignore */
+      tmpFileUrl.pathname
+    );
+  } finally {
+    try {
+      await unlink(tmpFileUrl);
+    } catch {
+    }
+  }
+}
+export {
+  bundleFile,
+  importBundledFile,
+  loadDbConfigFile
+};

package/dist/core/tokens.js

@@ -2,8 +2,8 @@ import { readFile } from "node:fs/promises";
 import { homedir } from "node:os";
 import { join } from "node:path";
 import { pathToFileURL } from "node:url";
-import { getAstroStudioEnv, getAstroStudioUrl } from "./utils.js";
 import { MISSING_PROJECT_ID_ERROR, MISSING_SESSION_ID_ERROR } from "./errors.js";
+import { getAstroStudioEnv, getAstroStudioUrl } from "./utils.js";
 const SESSION_LOGIN_FILE = pathToFileURL(join(homedir(), ".astro", "session-token"));
 const PROJECT_ID_FILE = pathToFileURL(join(process.cwd(), ".astro", "link"));
 class ManagedLocalAppToken {