@astrojs/db 0.6.4 → 0.7.0

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

@@ -1,6 +1,13 @@
 import { existsSync } from "node:fs";
-import { FILE_NOT_FOUND_ERROR, MISSING_EXECUTE_PATH_ERROR } from "../../../errors.js";
-import { getStudioVirtualModContents } from "../../../integration/vite-plugin-db.js";
+import {
+  FILE_NOT_FOUND_ERROR,
+  MISSING_EXECUTE_PATH_ERROR,
+  SEED_DEFAULT_EXPORT_ERROR
+} from "../../../errors.js";
+import {
+  getLocalVirtualModContents,
+  getStudioVirtualModContents
+} from "../../../integration/vite-plugin-db.js";
 import { bundleFile, importBundledFile } from "../../../load-file.js";
 import { getManagedAppTokenOrExit } from "../../../tokens.js";
 import {} from "../../../types.js";
@@ -19,13 +26,28 @@ async function cmd({
     console.error(FILE_NOT_FOUND_ERROR(filePath));
     process.exit(1);
   }
-  const appToken = await getManagedAppTokenOrExit(flags.token);
-  const virtualModContents = getStudioVirtualModContents({
-    tables: dbConfig.tables ?? {},
-    appToken: appToken.token
-  });
+  let virtualModContents;
+  if (flags.remote) {
+    const appToken = await getManagedAppTokenOrExit(flags.token);
+    virtualModContents = getStudioVirtualModContents({
+      tables: dbConfig.tables ?? {},
+      appToken: appToken.token
+    });
+  } else {
+    virtualModContents = getLocalVirtualModContents({
+      tables: dbConfig.tables ?? {},
+      root: astroConfig.root,
+      shouldSeed: false,
+      seedFiles: []
+    });
+  }
   const { code } = await bundleFile({ virtualModContents, root: astroConfig.root, fileUrl });
-  await importBundledFile({ code, root: astroConfig.root });
+  const mod = await importBundledFile({ code, root: astroConfig.root });
+  if (typeof mod.default !== "function") {
+    console.error(SEED_DEFAULT_EXPORT_ERROR);
+    process.exit(1);
+  }
+  await mod.default();
 }
 export {
   cmd

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

@@ -1,4 +1,4 @@
-import { red } from "kleur/colors";
+import { MIGRATION_VERSION } from "../../../consts.js";
 import { getManagedAppTokenOrExit } from "../../../tokens.js";
 import {} from "../../../types.js";
 import { getRemoteDatabaseUrl } from "../../../utils.js";
@@ -57,7 +57,7 @@ async function pushSchema({
   const requestBody = {
     snapshot: currentSnapshot,
     sql: statements,
-    experimentalVersion: 1
+    version: MIGRATION_VERSION
   };
   if (isDryRun) {
     console.info("[DRY RUN] Batch query:", JSON.stringify(requestBody, null, 2));

package/dist/core/cli/commands/shell/index.d.ts

@@ -1,7 +1,7 @@
 import type { AstroConfig } from 'astro';
 import type { Arguments } from 'yargs-parser';
 import type { DBConfigInput } from '../../../types.js';
-export declare function cmd({ flags, }: {
+export declare function cmd({ flags, astroConfig, }: {
     dbConfig: DBConfigInput;
     astroConfig: AstroConfig;
     flags: Arguments;

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

@@ -1,16 +1,32 @@
 import { sql } from "drizzle-orm";
-import { createRemoteDatabaseClient } from "../../../../runtime/db-client.js";
+import {
+  createLocalDatabaseClient,
+  createRemoteDatabaseClient
+} from "../../../../runtime/db-client.js";
+import { DB_PATH } from "../../../consts.js";
+import { SHELL_QUERY_MISSING_ERROR } from "../../../errors.js";
 import { getManagedAppTokenOrExit } from "../../../tokens.js";
 import { getRemoteDatabaseUrl } from "../../../utils.js";
 async function cmd({
-  flags
+  flags,
+  astroConfig
 }) {
   const query = flags.query;
-  const appToken = await getManagedAppTokenOrExit(flags.token);
-  const db = createRemoteDatabaseClient(appToken.token, getRemoteDatabaseUrl());
-  const result = await db.run(sql.raw(query));
-  await appToken.destroy();
-  console.log(result);
+  if (!query) {
+    console.error(SHELL_QUERY_MISSING_ERROR);
+    process.exit(1);
+  }
+  if (flags.remote) {
+    const appToken = await getManagedAppTokenOrExit(flags.token);
+    const db = createRemoteDatabaseClient(appToken.token, getRemoteDatabaseUrl());
+    const result = await db.run(sql.raw(query));
+    await appToken.destroy();
+    console.log(result);
+  } else {
+    const db = createLocalDatabaseClient({ dbUrl: new URL(DB_PATH, astroConfig.root).href });
+    const result = await db.run(sql.raw(query));
+    console.log(result);
+  }
 }
 export {
   cmd

package/dist/core/cli/index.js

@@ -1,13 +1,11 @@
-import { loadDbConfigFile } from "../load-file.js";
-import { dbConfigSchema } from "../types.js";
+import { resolveDbConfig } from "../load-file.js";
 async function cli({
   flags,
   config: astroConfig
 }) {
   const args = flags._;
   const command = args[2] === "db" ? args[3] : args[2];
-  const { mod } = await loadDbConfigFile(astroConfig.root);
-  const dbConfig = dbConfigSchema.parse(mod?.default ?? {});
+  const { dbConfig } = await resolveDbConfig(astroConfig);
   switch (command) {
     case "shell": {
       const { cmd } = await import("./commands/shell/index.js");

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

@@ -14,6 +14,7 @@ import {
   schemaTypeToSqlType
 } from "../../runtime/queries.js";
 import { isSerializedSQL } from "../../runtime/types.js";
+import { MIGRATION_VERSION } from "../consts.js";
 import { RENAME_COLUMN_ERROR, RENAME_TABLE_ERROR } from "../errors.js";
 import {
   columnSchema
@@ -335,10 +336,10 @@ async function getProductionCurrentSnapshot({
 }
 function createCurrentSnapshot({ tables = {} }) {
   const schema = JSON.parse(JSON.stringify(tables));
-  return { experimentalVersion: 1, schema };
+  return { version: MIGRATION_VERSION, schema };
 }
 function createEmptySnapshot() {
-  return { experimentalVersion: 1, schema: {} };
+  return { version: MIGRATION_VERSION, schema: {} };
 }
 function formatDataLossMessage(confirmations, isColor = true) {
   const messages = [];

package/dist/core/consts.d.ts

@@ -1,8 +1,8 @@
 export declare const PACKAGE_NAME: any;
 export declare const RUNTIME_IMPORT: string;
-export declare const RUNTIME_DRIZZLE_IMPORT: string;
 export declare const RUNTIME_CONFIG_IMPORT: string;
 export declare const DB_TYPES_FILE = "db-types.d.ts";
 export declare const VIRTUAL_MODULE_ID = "astro:db";
-export declare const DB_PATH = ".astro/content.db";
+export declare const DB_PATH: string;
 export declare const CONFIG_FILE_NAMES: string[];
+export declare const MIGRATION_VERSION = "2024-03-12";

package/dist/core/consts.js

@@ -1,21 +1,22 @@
+import { randomUUID } from "node:crypto";
 import { readFileSync } from "node:fs";
 const PACKAGE_NAME = JSON.parse(
   readFileSync(new URL("../../package.json", import.meta.url), "utf8")
 ).name;
 const RUNTIME_IMPORT = JSON.stringify(`${PACKAGE_NAME}/runtime`);
-const RUNTIME_DRIZZLE_IMPORT = JSON.stringify(`${PACKAGE_NAME}/runtime/drizzle`);
 const RUNTIME_CONFIG_IMPORT = JSON.stringify(`${PACKAGE_NAME}/runtime/config`);
 const DB_TYPES_FILE = "db-types.d.ts";
 const VIRTUAL_MODULE_ID = "astro:db";
-const DB_PATH = ".astro/content.db";
+const DB_PATH = `.astro/${process.env.ASTRO_TEST_RANDOM_DB_ID ? randomUUID() : "content.db"}`;
 const CONFIG_FILE_NAMES = ["config.ts", "config.js", "config.mts", "config.mjs"];
+const MIGRATION_VERSION = "2024-03-12";
 export {
   CONFIG_FILE_NAMES,
   DB_PATH,
   DB_TYPES_FILE,
+  MIGRATION_VERSION,
   PACKAGE_NAME,
   RUNTIME_CONFIG_IMPORT,
-  RUNTIME_DRIZZLE_IMPORT,
   RUNTIME_IMPORT,
   VIRTUAL_MODULE_ID
 };

package/dist/core/errors.d.ts

@@ -4,8 +4,11 @@ export declare const MISSING_EXECUTE_PATH_ERROR: string;
 export declare const RENAME_TABLE_ERROR: (oldTable: string, newTable: string) => string;
 export declare const RENAME_COLUMN_ERROR: (oldSelector: string, newSelector: string) => string;
 export declare const FILE_NOT_FOUND_ERROR: (path: string) => string;
+export declare const SHELL_QUERY_MISSING_ERROR: string;
 export declare const SEED_ERROR: (error: string) => string;
+export declare const SEED_DEFAULT_EXPORT_ERROR: (fileName: string) => string;
 export declare const REFERENCE_DNE_ERROR: (columnName: string) => string;
 export declare const FOREIGN_KEY_DNE_ERROR: (tableName: string) => string;
 export declare const FOREIGN_KEY_REFERENCES_LENGTH_ERROR: (tableName: string) => string;
 export declare const FOREIGN_KEY_REFERENCES_EMPTY_ERROR: (tableName: string) => string;
+export declare const INTEGRATION_TABLE_CONFLICT_ERROR: (integrationName: string, tableName: string, isUserConflict: boolean) => string;

package/dist/core/errors.js

@@ -1,4 +1,4 @@
-import { bold, cyan, green, red, yellow } from "kleur/colors";
+import { bold, cyan, red } from "kleur/colors";
 const MISSING_SESSION_ID_ERROR = `${red("\u25B6 Login required!")}
 
   To authenticate with Astro Studio, run
@@ -25,11 +25,20 @@ const RENAME_COLUMN_ERROR = (oldSelector, newSelector) => {
 };
 const FILE_NOT_FOUND_ERROR = (path) => `${red("\u25B6 File not found:")} ${bold(path)}
 `;
+const SHELL_QUERY_MISSING_ERROR = `${red(
+  "\u25B6 Please provide a query to execute using the --query flag."
+)}
+`;
 const SEED_ERROR = (error) => {
   return `${red(`Error while seeding database:`)}
 
 ${error}`;
 };
+const SEED_DEFAULT_EXPORT_ERROR = (fileName) => {
+  return red("Error while seeding database:") + `
+
+Missing default function export in ${bold(fileName)}`;
+};
 const REFERENCE_DNE_ERROR = (columnName) => {
   return `Column ${bold(
     columnName
@@ -50,16 +59,24 @@ const FOREIGN_KEY_REFERENCES_EMPTY_ERROR = (tableName) => {
     tableName
   )} is misconfigured. \`references\` array cannot be empty.`;
 };
+const INTEGRATION_TABLE_CONFLICT_ERROR = (integrationName, tableName, isUserConflict) => {
+  return red("\u25B6 Conflicting table name in integration " + bold(integrationName)) + isUserConflict ? `
+  A user-defined table named ${bold(tableName)} already exists` : `
+  Another integration already added a table named ${bold(tableName)}`;
+};
 export {
   FILE_NOT_FOUND_ERROR,
   FOREIGN_KEY_DNE_ERROR,
   FOREIGN_KEY_REFERENCES_EMPTY_ERROR,
   FOREIGN_KEY_REFERENCES_LENGTH_ERROR,
+  INTEGRATION_TABLE_CONFLICT_ERROR,
   MISSING_EXECUTE_PATH_ERROR,
   MISSING_PROJECT_ID_ERROR,
   MISSING_SESSION_ID_ERROR,
   REFERENCE_DNE_ERROR,
   RENAME_COLUMN_ERROR,
   RENAME_TABLE_ERROR,
-  SEED_ERROR
+  SEED_DEFAULT_EXPORT_ERROR,
+  SEED_ERROR,
+  SHELL_QUERY_MISSING_ERROR
 };

package/dist/core/integration/index.js

@@ -3,12 +3,11 @@ import { dirname } from "path";
 import { fileURLToPath } from "url";
 import { mkdir, rm, writeFile } from "fs/promises";
 import { blue, yellow } from "kleur/colors";
+import parseArgs from "yargs-parser";
 import { CONFIG_FILE_NAMES, DB_PATH } from "../consts.js";
-import { loadDbConfigFile } from "../load-file.js";
+import { resolveDbConfig } 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";
@@ -18,12 +17,16 @@ function astroDBIntegration() {
   let configFileDependencies = [];
   let root;
   let appToken;
-  let dbConfig;
   let tables = {
     get() {
       throw new Error("[astro:db] INTERNAL Tables not loaded yet");
     }
   };
+  let seedFiles = {
+    get() {
+      throw new Error("[astro:db] INTERNAL Seed files not loaded yet");
+    }
+  };
   let command;
   return {
     name: "astro:db",
@@ -34,7 +37,8 @@ function astroDBIntegration() {
         if (command === "preview")
           return;
         let dbPlugin = void 0;
-        connectToStudio = command === "build";
+        const args = parseArgs(process.argv.slice(3));
+        connectToStudio = args["remote"];
         if (connectToStudio) {
           appToken = await getManagedAppTokenOrExit();
           dbPlugin = vitePluginDb({
@@ -48,6 +52,7 @@ function astroDBIntegration() {
           dbPlugin = vitePluginDb({
             connectToStudio: false,
             tables,
+            seedFiles,
             root: config.root,
             srcDir: config.srcDir
           });
@@ -60,13 +65,13 @@ function astroDBIntegration() {
         });
       },
       "astro:config:done": async ({ config }) => {
-        const { mod, dependencies } = await loadDbConfigFile(config.root);
+        if (command === "preview")
+          return;
+        const { dbConfig, dependencies, integrationSeedPaths } = await resolveDbConfig(config);
+        tables.get = () => dbConfig.tables;
+        seedFiles.get = () => integrationSeedPaths;
         configFileDependencies = dependencies;
-        dbConfig = dbConfigSchema.parse(mod?.default ?? {}, {
-          errorMap
-        });
-        tables.get = () => dbConfig.tables ?? {};
-        if (!connectToStudio && !process.env.TEST_IN_MEMORY_DB) {
+        if (!connectToStudio) {
           const dbUrl = new URL(DB_PATH, config.root);
           if (existsSync(dbUrl)) {
             await rm(dbUrl);

package/dist/core/integration/typegen.js

@@ -1,12 +1,12 @@
 import { existsSync } from "node:fs";
 import { mkdir, writeFile } from "node:fs/promises";
-import { DB_TYPES_FILE, RUNTIME_DRIZZLE_IMPORT, RUNTIME_IMPORT } from "../consts.js";
+import { DB_TYPES_FILE, RUNTIME_CONFIG_IMPORT, RUNTIME_IMPORT } from "../consts.js";
 async function typegen({ tables, root }) {
   const content = `// This file is generated by \`studio sync\`
 declare module 'astro:db' {
 	export const db: import(${RUNTIME_IMPORT}).SqliteDB;
 	export const dbUrl: string;
-	export * from ${RUNTIME_DRIZZLE_IMPORT};
+	export * from ${RUNTIME_CONFIG_IMPORT};
 
 ${Object.entries(tables).map(([name, collection]) => generateTableType(name, collection)).join("\n")}
 }

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

@@ -3,9 +3,13 @@ import { type VitePlugin } from '../utils.js';
 export type LateTables = {
     get: () => DBTables;
 };
+export type LateSeedFiles = {
+    get: () => Array<string | URL>;
+};
 type VitePluginDBParams = {
     connectToStudio: false;
     tables: LateTables;
+    seedFiles: LateSeedFiles;
     srcDir: URL;
     root: URL;
 } | {
@@ -17,8 +21,9 @@ type VitePluginDBParams = {
 };
 export declare function vitePluginDb(params: VitePluginDBParams): VitePlugin;
 export declare function getConfigVirtualModContents(): string;
-export declare function getLocalVirtualModContents({ tables, shouldSeed, }: {
+export declare function getLocalVirtualModContents({ tables, root, seedFiles, shouldSeed, }: {
     tables: DBTables;
+    seedFiles: Array<string | URL>;
     root: URL;
     shouldSeed: boolean;
 }): string;

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

@@ -1,47 +1,50 @@
+import { resolve } from "node:path";
 import { fileURLToPath } from "node:url";
+import { sql } from "drizzle-orm";
+import { SQLiteAsyncDialect } from "drizzle-orm/sqlite-core";
 import { normalizePath } from "vite";
-import { SEED_DEV_FILE_NAME } from "../../runtime/queries.js";
+import { createLocalDatabaseClient } from "../../runtime/db-client.js";
 import {
-  DB_PATH,
-  RUNTIME_CONFIG_IMPORT,
-  RUNTIME_DRIZZLE_IMPORT,
-  RUNTIME_IMPORT,
-  VIRTUAL_MODULE_ID
-} from "../consts.js";
+  SEED_DEV_FILE_NAME,
+  getCreateIndexQueries,
+  getCreateTableQuery
+} from "../../runtime/queries.js";
+import { DB_PATH, RUNTIME_CONFIG_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";
+const WITH_SEED_VIRTUAL_MODULE_ID = "astro:db:seed";
+const resolved = {
+  virtual: "\0" + VIRTUAL_MODULE_ID,
+  seedVirtual: "\0" + WITH_SEED_VIRTUAL_MODULE_ID
+};
 function vitePluginDb(params) {
   const srcDirPath = normalizePath(fileURLToPath(params.srcDir));
+  const seedFilePaths = SEED_DEV_FILE_NAME.map(
+    (name) => normalizePath(fileURLToPath(new URL(name, getDbDirectoryUrl(params.root))))
+  );
   return {
     name: "astro:db",
     enforce: "pre",
     async resolveId(id, rawImporter) {
-      if (id === LOCAL_DB_VIRTUAL_MODULE_ID)
-        return resolvedLocalDbVirtualModuleId;
       if (id !== VIRTUAL_MODULE_ID)
         return;
       if (params.connectToStudio)
-        return resolvedVirtualModuleId;
+        return resolved.virtual;
       const importer = rawImporter ? await this.resolve(rawImporter) : null;
       if (!importer)
-        return resolvedVirtualModuleId;
+        return resolved.virtual;
       if (importer.id.startsWith(srcDirPath)) {
-        return resolvedSeedVirtualModuleId;
+        return resolved.seedVirtual;
       }
-      return resolvedVirtualModuleId;
+      return resolved.virtual;
     },
-    load(id) {
-      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 });`;
+    async load(id) {
+      if (seedFilePaths.some((f) => id === f)) {
+        await recreateTables({
+          db: createLocalDatabaseClient({ dbUrl: new URL(DB_PATH, params.root).href }),
+          tables: params.tables.get()
+        });
       }
-      if (id !== resolvedVirtualModuleId && id !== resolvedSeedVirtualModuleId)
+      if (id !== resolved.virtual && id !== resolved.seedVirtual)
         return;
       if (params.connectToStudio) {
         return getStudioVirtualModContents({
@@ -52,7 +55,8 @@ function vitePluginDb(params) {
       return getLocalVirtualModContents({
         root: params.root,
         tables: params.tables.get(),
-        shouldSeed: id === resolvedSeedVirtualModuleId
+        seedFiles: params.seedFiles.get(),
+        shouldSeed: id === resolved.seedVirtual
       });
     }
   };
@@ -62,26 +66,35 @@ function getConfigVirtualModContents() {
 }
 function getLocalVirtualModContents({
   tables,
+  root,
+  seedFiles,
   shouldSeed
 }) {
-  const seedFilePaths = SEED_DEV_FILE_NAME.map(
+  const userSeedFilePaths = SEED_DEV_FILE_NAME.map(
     // Format as /db/[name].ts
     // for Vite import.meta.glob
     (name) => new URL(name, getDbDirectoryUrl("file:///")).pathname
   );
+  const resolveId = (id) => id.startsWith(".") ? resolve(fileURLToPath(root), id) : id;
+  const integrationSeedFilePaths = seedFiles.map(
+    (pathOrUrl) => typeof pathOrUrl === "string" ? resolveId(pathOrUrl) : pathOrUrl.pathname
+  );
+  const integrationSeedImports = integrationSeedFilePaths.map(
+    (filePath) => `() => import(${JSON.stringify(filePath)})`
+  );
+  const dbUrl = new URL(DB_PATH, root);
   return `
-import { asDrizzleTable, seedLocal } from ${RUNTIME_IMPORT};
-import { db as _db } from ${JSON.stringify(LOCAL_DB_VIRTUAL_MODULE_ID)};
+import { asDrizzleTable, createLocalDatabaseClient } from ${RUNTIME_IMPORT};
+${shouldSeed ? `import { seedLocal } from ${RUNTIME_IMPORT};` : ""}
 
-export const db = _db;
+const dbUrl = ${JSON.stringify(dbUrl)};
+export const db = createLocalDatabaseClient({ dbUrl });
 
 ${shouldSeed ? `await seedLocal({
-	db: _db,
-	tables: ${JSON.stringify(tables)},
-	fileGlob: import.meta.glob(${JSON.stringify(seedFilePaths)}),
-})` : ""}
+	userSeedGlob: import.meta.glob(${JSON.stringify(userSeedFilePaths)}, { eager: true }),
+	integrationSeedImports: [${integrationSeedImports.join(",")}],
+});` : ""}
 
-export * from ${RUNTIME_DRIZZLE_IMPORT};
 export * from ${RUNTIME_CONFIG_IMPORT};
 
 ${getStringifiedCollectionExports(tables)}`;
@@ -97,7 +110,7 @@ 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)}
@@ -110,6 +123,20 @@ function getStringifiedCollectionExports(tables) {
     )}, false)`
   ).join("\n");
 }
+const sqlite = new SQLiteAsyncDialect();
+async function recreateTables({ db, tables }) {
+  const setupQueries = [];
+  for (const [name, table] of Object.entries(tables)) {
+    const dropQuery = sql.raw(`DROP TABLE IF EXISTS ${sqlite.escapeName(name)}`);
+    const createQuery = sql.raw(getCreateTableQuery(name, table));
+    const indexQueries = getCreateIndexQueries(name, table);
+    setupQueries.push(dropQuery, createQuery, ...indexQueries.map((s) => sql.raw(s)));
+  }
+  await db.batch([
+    db.run(sql`pragma defer_foreign_keys=true;`),
+    ...setupQueries.map((q) => db.run(q))
+  ]);
+}
 export {
   getConfigVirtualModContents,
   getLocalVirtualModContents,