@astrojs/db 0.4.0 → 0.5.0

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

@@ -0,0 +1,8 @@
+import type { AstroConfig } from 'astro';
+import type { Arguments } from 'yargs-parser';
+import { type DBConfig } from '../../../types.js';
+export declare function cmd({ astroConfig, dbConfig, flags, }: {
+    astroConfig: AstroConfig;
+    dbConfig: DBConfig;
+    flags: Arguments;
+}): Promise<void>;

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

@@ -0,0 +1,32 @@
+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 { bundleFile, importBundledFile } from "../../../load-file.js";
+import { getManagedAppTokenOrExit } from "../../../tokens.js";
+import {} from "../../../types.js";
+async function cmd({
+  astroConfig,
+  dbConfig,
+  flags
+}) {
+  const filePath = flags._[4];
+  if (typeof filePath !== "string") {
+    console.error(MISSING_EXECUTE_PATH_ERROR);
+    process.exit(1);
+  }
+  const fileUrl = new URL(filePath, astroConfig.root);
+  if (!existsSync(fileUrl)) {
+    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
+  });
+  const { code } = await bundleFile({ virtualModContents, root: astroConfig.root, fileUrl });
+  await importBundledFile({ code, root: astroConfig.root });
+}
+export {
+  cmd
+};

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

@@ -1,6 +1,8 @@
 import type { AstroConfig } from 'astro';
 import type { Arguments } from 'yargs-parser';
-export declare function cmd({ config }: {
-    config: AstroConfig;
+import type { DBConfig } from '../../../types.js';
+export declare function cmd({ astroConfig, dbConfig, }: {
+    astroConfig: AstroConfig;
+    dbConfig: DBConfig;
     flags: Arguments;
 }): Promise<void>;

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

@@ -1,16 +1,23 @@
 import { writeFile } from "node:fs/promises";
+import { relative } from "node:path";
+import { fileURLToPath } from "node:url";
+import { bgRed, bold, red, reset } from "kleur/colors";
+import { getMigrationsDirectoryUrl } from "../../../utils.js";
+import { getMigrationQueries } from "../../migration-queries.js";
 import {
   MIGRATIONS_CREATED,
   MIGRATIONS_UP_TO_DATE,
   getMigrationStatus,
   initializeMigrationsDirectory
 } from "../../migrations.js";
-import { getMigrationQueries } from "../../migration-queries.js";
-import { bgRed, red, reset } from "kleur/colors";
-async function cmd({ config }) {
-  const migration = await getMigrationStatus(config);
+async function cmd({
+  astroConfig,
+  dbConfig
+}) {
+  const migration = await getMigrationStatus({ dbConfig, root: astroConfig.root });
+  const migrationsDir = getMigrationsDirectoryUrl(astroConfig.root);
   if (migration.state === "no-migrations-found") {
-    await initializeMigrationsDirectory(migration.currentSnapshot);
+    await initializeMigrationsDirectory(migration.currentSnapshot, migrationsDir);
     console.log(MIGRATIONS_CREATED);
     return;
   } else if (migration.state === "up-to-date") {
@@ -23,16 +30,17 @@ async function cmd({ config }) {
     newSnapshot
   });
   confirmations.map((message) => console.log(bgRed(" !!! ") + " " + red(message)));
-  const migrationFileContent = {
+  const content = {
     diff,
     db: migrationQueries,
     // TODO(fks): Encode the relevant data, instead of the raw message.
     // This will give `db push` more control over the formatting of the message.
     confirm: confirmations.map((c) => reset(c))
   };
-  const migrationFileName = `./migrations/${newFilename}`;
-  await writeFile(migrationFileName, JSON.stringify(migrationFileContent, void 0, 2));
-  console.log(migrationFileName + " created!");
+  const fileUrl = new URL(newFilename, migrationsDir);
+  const relativePath = relative(fileURLToPath(astroConfig.root), fileURLToPath(fileUrl));
+  await writeFile(fileUrl, JSON.stringify(content, void 0, 2));
+  console.log(bold(relativePath) + " created!");
 }
 export {
   cmd

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

@@ -1,8 +1,20 @@
-import type { AstroConfig } from 'astro';
-import type { Arguments } from 'yargs-parser';
-export declare function cmd({ flags }: {
-    config: AstroConfig;
-    flags: Arguments;
-}): Promise<void>;
-export declare function promptProjectName(defaultName?: string): Promise<string>;
-export declare function promptWorkspaceName(defaultName?: string): Promise<string>;
+export declare function cmd(): Promise<void>;
+export declare function createNewProject({ workspaceId, name, region, }: {
+    workspaceId: string;
+    name: string;
+    region: string;
+}): Promise<{
+    id: string;
+    idName: string;
+}>;
+export declare function promptExistingProjectName({ workspaceId }: {
+    workspaceId: string;
+}): Promise<{
+    id: string;
+    idName: string;
+}>;
+export declare function promptBegin(): Promise<void>;
+export declare function promptLinkExisting(): Promise<boolean>;
+export declare function promptLinkNew(): Promise<boolean>;
+export declare function promptNewProjectName(): Promise<string>;
+export declare function promptNewProjectRegion(): Promise<string>;

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

@@ -1,29 +1,94 @@
 import { mkdir, writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { basename } from "node:path";
+import { slug } from "github-slugger";
 import { bgRed, cyan } from "kleur/colors";
+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 { MISSING_SESSION_ID_ERROR } from "../../../errors.js";
-async function cmd({ flags }) {
-  const linkUrl = new URL(getAstroStudioUrl() + "/auth/cli/link");
+async function cmd() {
   const sessionToken = await getSessionIdFromFile();
   if (!sessionToken) {
     console.error(MISSING_SESSION_ID_ERROR);
     process.exit(1);
   }
-  let body = { id: flags._[4] };
-  if (!body.id) {
-    const workspaceIdName = await promptWorkspaceName();
-    const projectIdName = await promptProjectName();
-    body = { projectIdName, workspaceIdName };
+  const getWorkspaceIdAsync = getWorkspaceId();
+  await promptBegin();
+  const isLinkExisting = await promptLinkExisting();
+  if (isLinkExisting) {
+    const workspaceId = await getWorkspaceIdAsync;
+    const existingProjectData = await promptExistingProjectName({ workspaceId });
+    return await linkProject(existingProjectData.id);
+  }
+  const isLinkNew = await promptLinkNew();
+  if (isLinkNew) {
+    const workspaceId = await getWorkspaceIdAsync;
+    const newProjectName = await promptNewProjectName();
+    const newProjectRegion = await promptNewProjectRegion();
+    const spinner = ora("Creating new project...").start();
+    const newProjectData = await createNewProject({
+      workspaceId,
+      name: newProjectName,
+      region: newProjectRegion
+    });
+    await new Promise((r) => setTimeout(r, 4e3));
+    spinner.succeed("Project created!");
+    return await linkProject(newProjectData.id);
   }
+}
+async function linkProject(id) {
+  await mkdir(new URL(".", PROJECT_ID_FILE), { recursive: true });
+  await writeFile(PROJECT_ID_FILE, `${id}`);
+  console.info("Project linked.");
+}
+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")}
+
+  Are you logged in?
+  Run ${cyan(
+          "astro db login"
+        )} to authenticate and then try linking again.
+
+`
+      );
+      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.`);
+    process.exit(1);
+  }
+  return data[0].id;
+}
+async function createNewProject({
+  workspaceId,
+  name,
+  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"
     },
-    body: JSON.stringify(body)
+    body: JSON.stringify({ workspaceId, name, region })
   });
   if (!response.ok) {
     if (response.status === 401) {
@@ -39,40 +104,135 @@ async function cmd({ flags }) {
       );
       process.exit(1);
     }
-    console.error(`Failed to link project: ${response.status} ${response.statusText}`);
+    console.error(`Failed to create project: ${response.status} ${response.statusText}`);
     process.exit(1);
   }
-  const { data } = await response.json();
-  await mkdir(new URL(".", PROJECT_ID_FILE), { recursive: true });
-  await writeFile(PROJECT_ID_FILE, `${data.id}`);
-  console.info("Project linked.");
+  const { data, success } = await response.json();
+  if (!success) {
+    console.error(`Failed to create project.`);
+    process.exit(1);
+  }
+  return { id: data.id, idName: data.idName };
 }
-async function promptProjectName(defaultName) {
-  const { projectName } = await prompts({
-    type: "text",
-    name: "projectName",
-    message: "Project ID",
-    initial: defaultName
+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"
+    },
+    body: JSON.stringify({ workspaceId })
+  });
+  if (!response.ok) {
+    if (response.status === 401) {
+      console.error(
+        `${bgRed("Unauthorized")}
+
+  Are you logged in?
+  Run ${cyan(
+          "astro db login"
+        )} to authenticate and then try linking again.
+
+`
+      );
+      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.`);
+    process.exit(1);
+  }
+  const { projectId } = await prompts({
+    type: "autocomplete",
+    name: "projectId",
+    message: "What is your project name?",
+    limit: 5,
+    choices: data.map((p) => ({ title: p.name, value: p.id }))
   });
-  if (typeof projectName !== "string") {
+  if (typeof projectId !== "string") {
+    console.log("Canceled.");
     process.exit(0);
   }
-  return projectName;
+  const selectedProjectData = data.find((p) => p.id === projectId);
+  return selectedProjectData;
 }
-async function promptWorkspaceName(defaultName) {
-  const { workspaceName } = await prompts({
+async function promptBegin() {
+  const prettyCwd = process.cwd().replace(homedir(), "~");
+  const { begin } = await prompts({
+    type: "confirm",
+    name: "begin",
+    message: `Link "${prettyCwd}" with Astro Studio?`,
+    initial: true
+  });
+  if (!begin) {
+    console.log("Canceled.");
+    process.exit(0);
+  }
+}
+async function promptLinkExisting() {
+  const { linkExisting } = await prompts({
+    type: "confirm",
+    name: "linkExisting",
+    message: `Link with an existing project in Astro Studio?`,
+    initial: true
+  });
+  return !!linkExisting;
+}
+async function promptLinkNew() {
+  const { linkNew } = await prompts({
+    type: "confirm",
+    name: "linkNew",
+    message: `Create a new project in Astro Studio?`,
+    initial: true
+  });
+  if (!linkNew) {
+    console.log("Canceled.");
+    process.exit(0);
+  }
+  return true;
+}
+async function promptNewProjectName() {
+  const { newProjectName } = await prompts({
     type: "text",
-    name: "workspaceName",
-    message: "Workspace ID",
-    initial: defaultName
+    name: "newProjectName",
+    message: `What is your new project's name?`,
+    initial: basename(process.cwd()),
+    format: (val) => slug(val)
+  });
+  if (!newProjectName) {
+    console.log("Canceled.");
+    process.exit(0);
+  }
+  return newProjectName;
+}
+async function promptNewProjectRegion() {
+  const { newProjectRegion } = await prompts({
+    type: "select",
+    name: "newProjectRegion",
+    message: `Where should your new database live?`,
+    choices: [
+      { title: "North America (East)", value: "NorthAmericaEast" },
+      { title: "North America (West)", value: "NorthAmericaWest" }
+    ],
+    initial: 0
   });
-  if (typeof workspaceName !== "string") {
+  if (!newProjectRegion) {
+    console.log("Canceled.");
     process.exit(0);
   }
-  return workspaceName;
+  return newProjectRegion;
 }
 export {
   cmd,
-  promptProjectName,
-  promptWorkspaceName
+  createNewProject,
+  promptBegin,
+  promptExistingProjectName,
+  promptLinkExisting,
+  promptLinkNew,
+  promptNewProjectName,
+  promptNewProjectRegion
 };

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

@@ -1,6 +1,8 @@
 import type { AstroConfig } from 'astro';
 import type { Arguments } from 'yargs-parser';
-export declare function cmd({ flags }: {
-    config: AstroConfig;
+import type { DBConfig } from '../../../types.js';
+export declare function cmd({ flags, }: {
+    astroConfig: AstroConfig;
+    dbConfig: DBConfig;
     flags: Arguments;
 }): Promise<void>;

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

@@ -1,41 +1,50 @@
-import { cyan } from "kleur/colors";
 import { mkdir, writeFile } from "node:fs/promises";
-import { createServer } from "node:http";
-import ora from "ora";
-import { getAstroStudioUrl } from "../../../utils.js";
+import { createServer as _createServer } from "node:http";
+import { listen } from "async-listen";
+import { cyan } from "kleur/colors";
 import open from "open";
+import ora from "ora";
 import { SESSION_LOGIN_FILE } from "../../../tokens.js";
-function serveAndResolveSession() {
+import { getAstroStudioUrl } from "../../../utils.js";
+async function createServer() {
   let resolve, reject;
-  const sessionPromise = new Promise((_resolve, _reject) => {
-    resolve = _resolve;
-    reject = _reject;
-  });
-  const server = createServer((req, res) => {
-    res.writeHead(200);
-    res.end();
+  const server = _createServer((req, res) => {
     const url = new URL(req.url ?? "/", `http://${req.headers.host}`);
-    const session = url.searchParams.get("session");
-    if (!session) {
-      reject();
+    const sessionParam = url.searchParams.get("session");
+    res.statusCode = 302;
+    if (!sessionParam) {
+      res.setHeader("location", getAstroStudioUrl() + "/auth/cli/error");
+      reject(new Error("Failed to log in"));
     } else {
-      resolve(session);
+      res.setHeader("location", getAstroStudioUrl() + "/auth/cli/success");
+      resolve(sessionParam);
     }
-  }).listen(5710, "localhost");
-  return sessionPromise.finally(() => {
+    res.end();
+  });
+  const { port } = await listen(server, 0, "127.0.0.1");
+  const serverUrl = `http://localhost:${port}`;
+  const sessionPromise = new Promise((_resolve, _reject) => {
+    resolve = _resolve;
+    reject = _reject;
+  }).finally(() => {
     server.closeAllConnections();
     server.close();
   });
+  return { url: serverUrl, promise: sessionPromise };
 }
-async function cmd({ flags }) {
+async function cmd({
+  flags
+}) {
   let session = flags.session;
-  const loginUrl = getAstroStudioUrl() + "/auth/cli";
   if (!session) {
-    console.log(`Opening ${cyan(loginUrl)} in your browser...`);
+    const { url, promise } = await createServer();
+    const loginUrl = getAstroStudioUrl() + "/auth/cli/login?returnTo=" + encodeURIComponent(url);
+    console.log(`Opening the following URL in your browser...`);
+    console.log(cyan(loginUrl));
     console.log(`If something goes wrong, copy-and-paste the URL into your browser.`);
     open(loginUrl);
     const spinner = ora("Waiting for confirmation...");
-    session = await serveAndResolveSession();
+    session = await promise;
     spinner.succeed("Successfully logged in!");
   }
   await mkdir(new URL(".", SESSION_LOGIN_FILE), { recursive: true });

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

@@ -1,6 +1 @@
-import type { AstroConfig } from 'astro';
-import type { Arguments } from 'yargs-parser';
-export declare function cmd({}: {
-    config: AstroConfig;
-    flags: Arguments;
-}): Promise<void>;
+export declare function cmd(): Promise<void>;

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

@@ -1,6 +1,6 @@
 import { unlink } from "node:fs/promises";
 import { SESSION_LOGIN_FILE } from "../../../tokens.js";
-async function cmd({}) {
+async function cmd() {
   await unlink(SESSION_LOGIN_FILE);
   console.log("Successfully logged out of Astro Studio.");
 }

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

@@ -1,6 +1,8 @@
 import type { AstroConfig } from 'astro';
 import type { Arguments } from 'yargs-parser';
-export declare function cmd({ config, flags }: {
-    config: AstroConfig;
+import { type DBConfig } from '../../../types.js';
+export declare function cmd({ astroConfig, dbConfig, flags, }: {
+    astroConfig: AstroConfig;
+    dbConfig: DBConfig;
     flags: Arguments;
 }): Promise<void>;

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

@@ -1,29 +1,29 @@
-import { createClient } from "@libsql/client";
-import { drizzle as drizzleProxy } from "drizzle-orm/sqlite-proxy";
-import { drizzle as drizzleLibsql } from "drizzle-orm/libsql";
-import { SQLiteAsyncDialect } from "drizzle-orm/sqlite-core";
 import { red } from "kleur/colors";
 import prompts from "prompts";
-import { recreateTables, seedData } from "../../../queries.js";
+import { MISSING_SESSION_ID_ERROR } from "../../../errors.js";
 import { getManagedAppTokenOrExit } from "../../../tokens.js";
-import { tablesSchema } from "../../../types.js";
-import { getRemoteDatabaseUrl } from "../../../utils.js";
+import {} from "../../../types.js";
+import { getMigrationsDirectoryUrl, getRemoteDatabaseUrl } from "../../../utils.js";
 import { getMigrationQueries } from "../../migration-queries.js";
 import {
+  INITIAL_SNAPSHOT,
+  MIGRATIONS_NOT_INITIALIZED,
+  MIGRATIONS_UP_TO_DATE,
+  MIGRATION_NEEDED,
   createEmptySnapshot,
-  getMigrations,
   getMigrationStatus,
+  getMigrations,
   loadInitialSnapshot,
-  loadMigration,
-  MIGRATION_NEEDED,
-  MIGRATIONS_NOT_INITIALIZED,
-  MIGRATIONS_UP_TO_DATE
+  loadMigration
 } from "../../migrations.js";
-import { MISSING_SESSION_ID_ERROR } from "../../../errors.js";
-async function cmd({ config, flags }) {
+async function cmd({
+  astroConfig,
+  dbConfig,
+  flags
+}) {
   const isDryRun = flags.dryRun;
   const appToken = await getManagedAppTokenOrExit(flags.token);
-  const migration = await getMigrationStatus(config);
+  const migration = await getMigrationStatus({ dbConfig, root: astroConfig.root });
   if (migration.state === "no-migrations-found") {
     console.log(MIGRATIONS_NOT_INITIALIZED);
     process.exit(1);
@@ -31,7 +31,8 @@ async function cmd({ config, flags }) {
     console.log(MIGRATION_NEEDED);
     process.exit(1);
   }
-  const allLocalMigrations = await getMigrations();
+  const migrationsDir = getMigrationsDirectoryUrl(astroConfig.root);
+  const allLocalMigrations = await getMigrations(migrationsDir);
   let missingMigrations = [];
   try {
     const { data } = await prepareMigrateQuery({
@@ -57,28 +58,30 @@ async function cmd({ config, flags }) {
     console.log(`Pushing ${missingMigrations.length} migrations...`);
     await pushSchema({
       migrations: missingMigrations,
+      migrationsDir,
       appToken: appToken.token,
       isDryRun,
       currentSnapshot: migration.currentSnapshot
     });
   }
-  console.info("Pushing data...");
-  await pushData({ config, appToken: appToken.token, isDryRun });
   await appToken.destroy();
   console.info("Push complete!");
 }
 async function pushSchema({
   migrations,
+  migrationsDir,
   appToken,
   isDryRun,
   currentSnapshot
 }) {
-  const initialSnapshot = migrations.find((m) => m === "0000_snapshot.json");
-  const filteredMigrations = migrations.filter((m) => m !== "0000_snapshot.json");
-  const missingMigrationContents = await Promise.all(filteredMigrations.map(loadMigration));
+  const initialSnapshot = migrations.find((m) => m === INITIAL_SNAPSHOT);
+  const filteredMigrations = migrations.filter((m) => m !== INITIAL_SNAPSHOT);
+  const missingMigrationContents = await Promise.all(
+    filteredMigrations.map((m) => loadMigration(m, migrationsDir))
+  );
   const initialMigrationBatch = initialSnapshot ? (await getMigrationQueries({
     oldSnapshot: createEmptySnapshot(),
-    newSnapshot: await loadInitialSnapshot()
+    newSnapshot: await loadInitialSnapshot(migrationsDir)
   })).queries : [];
   const confirmations = missingMigrationContents.reduce((acc, curr) => {
     return [...acc, ...curr.confirm || []];
@@ -101,61 +104,6 @@ async function pushSchema({
   }, initialMigrationBatch);
   await runMigrateQuery({ queries, migrations, snapshot: currentSnapshot, appToken, isDryRun });
 }
-const sqlite = new SQLiteAsyncDialect();
-async function pushData({
-  config,
-  appToken,
-  isDryRun
-}) {
-  const queries = [];
-  if (config.db?.data) {
-    const libsqlClient = createClient({ url: ":memory:" });
-    await recreateTables({
-      db: drizzleLibsql(libsqlClient),
-      tables: tablesSchema.parse(config.db.tables ?? {})
-    });
-    for (const [collectionName, { writable }] of Object.entries(config.db.tables ?? {})) {
-      if (!writable) {
-        queries.push({
-          sql: `DELETE FROM ${sqlite.escapeName(collectionName)}`,
-          args: []
-        });
-      }
-    }
-    const db = await drizzleProxy(async (sqlQuery, params, method) => {
-      const stmt = { sql: sqlQuery, args: params };
-      queries.push(stmt);
-      const { rows } = await libsqlClient.execute(stmt);
-      const rowValues = [];
-      for (const row of rows) {
-        if (row != null && typeof row === "object") {
-          rowValues.push(Object.values(row));
-        }
-      }
-      if (method === "get") {
-        return { rows: rowValues[0] };
-      }
-      return { rows: rowValues };
-    });
-    await seedData({
-      db,
-      mode: "build",
-      data: config.db.data
-    });
-  }
-  const url = new URL("/db/query", getRemoteDatabaseUrl());
-  if (isDryRun) {
-    console.info("[DRY RUN] Batch data seed:", JSON.stringify(queries, null, 2));
-    return new Response(null, { status: 200 });
-  }
-  return await fetch(url, {
-    method: "POST",
-    headers: new Headers({
-      Authorization: `Bearer ${appToken}`
-    }),
-    body: JSON.stringify(queries)
-  });
-}
 async function runMigrateQuery({
   queries: baseQueries,
   migrations,