@astrojs/db 0.0.0-10646-20240402132948

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

@@ -0,0 +1,55 @@
+import { mkdir, writeFile } from "node:fs/promises";
+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";
+import { getAstroStudioUrl } from "../../../utils.js";
+async function createServer() {
+  let resolve, reject;
+  const server = _createServer((req, res) => {
+    const url = new URL(req.url ?? "/", `http://${req.headers.host}`);
+    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 {
+      res.setHeader("location", getAstroStudioUrl() + "/auth/cli/success");
+      resolve(sessionParam);
+    }
+    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
+}) {
+  let session = flags.session;
+  if (!session) {
+    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 promise;
+    spinner.succeed("Successfully logged in!");
+  }
+  await mkdir(new URL(".", SESSION_LOGIN_FILE), { recursive: true });
+  await writeFile(SESSION_LOGIN_FILE, `${session}`);
+}
+export {
+  cmd
+};

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

@@ -0,0 +1 @@
+export declare function cmd(): Promise<void>;

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

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

package/dist/core/cli/commands/push/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({ dbConfig, flags, }: {
+    astroConfig: AstroConfig;
+    dbConfig: DBConfig;
+    flags: Arguments;
+}): Promise<void>;

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

@@ -0,0 +1,93 @@
+import { safeFetch } from "../../../../runtime/utils.js";
+import { MIGRATION_VERSION } from "../../../consts.js";
+import { getManagedAppTokenOrExit } from "../../../tokens.js";
+import {} from "../../../types.js";
+import { getRemoteDatabaseUrl } from "../../../utils.js";
+import {
+  createCurrentSnapshot,
+  createEmptySnapshot,
+  formatDataLossMessage,
+  getMigrationQueries,
+  getProductionCurrentSnapshot
+} from "../../migration-queries.js";
+async function cmd({
+  dbConfig,
+  flags
+}) {
+  const isDryRun = flags.dryRun;
+  const isForceReset = flags.forceReset;
+  const appToken = await getManagedAppTokenOrExit(flags.token);
+  const productionSnapshot = await getProductionCurrentSnapshot({ appToken: appToken.token });
+  const currentSnapshot = createCurrentSnapshot(dbConfig);
+  const isFromScratch = !productionSnapshot;
+  const { queries: migrationQueries, confirmations } = await getMigrationQueries({
+    oldSnapshot: isFromScratch ? createEmptySnapshot() : productionSnapshot,
+    newSnapshot: currentSnapshot,
+    reset: isForceReset
+  });
+  if (migrationQueries.length === 0) {
+    console.log("Database schema is up to date.");
+  } else {
+    console.log(`Database schema is out of date.`);
+  }
+  if (isForceReset) {
+    console.log(`Force-pushing to the database. All existing data will be erased.`);
+  } else if (confirmations.length > 0) {
+    console.log("\n" + formatDataLossMessage(confirmations) + "\n");
+    throw new Error("Exiting.");
+  }
+  if (isDryRun) {
+    console.log("Statements:", JSON.stringify(migrationQueries, void 0, 2));
+  } else {
+    console.log(`Pushing database schema updates...`);
+    await pushSchema({
+      statements: migrationQueries,
+      appToken: appToken.token,
+      isDryRun,
+      currentSnapshot
+    });
+  }
+  await appToken.destroy();
+  console.info("Push complete!");
+}
+async function pushSchema({
+  statements,
+  appToken,
+  isDryRun,
+  currentSnapshot
+}) {
+  const requestBody = {
+    snapshot: currentSnapshot,
+    sql: statements,
+    version: MIGRATION_VERSION
+  };
+  if (isDryRun) {
+    console.info("[DRY RUN] Batch query:", JSON.stringify(requestBody, null, 2));
+    return new Response(null, { status: 200 });
+  }
+  const url = new URL("/db/push", getRemoteDatabaseUrl());
+  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`);
+    console.error(await response.text());
+    throw new Error(`/db/push fetch unsuccessful`);
+  }
+}
+export {
+  cmd
+};

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

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

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

@@ -0,0 +1,33 @@
+import { sql } from "drizzle-orm";
+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,
+  astroConfig
+}) {
+  const query = flags.query;
+  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/commands/verify/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({ dbConfig, flags, }: {
+    astroConfig: AstroConfig;
+    dbConfig: DBConfig;
+    flags: Arguments;
+}): Promise<void>;

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

@@ -0,0 +1,46 @@
+import { getManagedAppTokenOrExit } from "../../../tokens.js";
+import {
+  createCurrentSnapshot,
+  createEmptySnapshot,
+  formatDataLossMessage,
+  getMigrationQueries,
+  getProductionCurrentSnapshot
+} from "../../migration-queries.js";
+async function cmd({
+  dbConfig,
+  flags
+}) {
+  const isJson = flags.json;
+  const appToken = await getManagedAppTokenOrExit(flags.token);
+  const productionSnapshot = await getProductionCurrentSnapshot({ appToken: appToken.token });
+  const currentSnapshot = createCurrentSnapshot(dbConfig);
+  const { queries: migrationQueries, confirmations } = await getMigrationQueries({
+    oldSnapshot: productionSnapshot || createEmptySnapshot(),
+    newSnapshot: currentSnapshot
+  });
+  const result = { exitCode: 0, message: "", code: "", data: void 0 };
+  if (migrationQueries.length === 0) {
+    result.code = "MATCH";
+    result.message = `Database schema is up to date.`;
+  } else {
+    result.code = "NO_MATCH";
+    result.message = `Database schema is out of date.
+Run 'astro db push' to push up your latest changes.`;
+  }
+  if (confirmations.length > 0) {
+    result.code = "DATA_LOSS";
+    result.exitCode = 1;
+    result.data = confirmations;
+    result.message = formatDataLossMessage(confirmations, !isJson);
+  }
+  if (isJson) {
+    console.log(JSON.stringify(result));
+  } else {
+    console.log(result.message);
+  }
+  await appToken.destroy();
+  process.exit(result.exitCode);
+}
+export {
+  cmd
+};

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

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

package/dist/core/cli/index.js

@@ -0,0 +1,76 @@
+import { resolveDbConfig } from "../load-file.js";
+import { printHelp } from "./print-help.js";
+async function cli({
+  flags,
+  config: astroConfig
+}) {
+  const args = flags._;
+  const command = args[2] === "db" ? args[3] : args[2];
+  const { dbConfig } = await resolveDbConfig(astroConfig);
+  switch (command) {
+    case "shell": {
+      const { cmd } = await import("./commands/shell/index.js");
+      return await cmd({ astroConfig, dbConfig, flags });
+    }
+    case "gen": {
+      console.log('"astro db gen" is no longer needed! Visit the docs for more information.');
+      return;
+    }
+    case "sync": {
+      console.log('"astro db sync" is no longer needed! Visit the docs for more information.');
+      return;
+    }
+    case "push": {
+      const { cmd } = await import("./commands/push/index.js");
+      return await cmd({ astroConfig, dbConfig, flags });
+    }
+    case "verify": {
+      const { cmd } = await import("./commands/verify/index.js");
+      return await cmd({ astroConfig, dbConfig, flags });
+    }
+    case "execute": {
+      const { cmd } = await import("./commands/execute/index.js");
+      return await cmd({ astroConfig, dbConfig, flags });
+    }
+    case "login": {
+      const { cmd } = await import("./commands/login/index.js");
+      return await cmd({ astroConfig, dbConfig, flags });
+    }
+    case "logout": {
+      const { cmd } = await import("./commands/logout/index.js");
+      return await cmd();
+    }
+    case "link": {
+      const { cmd } = await import("./commands/link/index.js");
+      return await cmd();
+    }
+    default: {
+      if (command != null) {
+        console.error(`Unknown command: ${command}`);
+      }
+      printHelp({
+        commandName: "astro db",
+        usage: "[command] [...flags]",
+        headline: " ",
+        tables: {
+          Commands: [
+            ["push", "Push table schema updates to Astro Studio."],
+            ["verify", "Test schema updates /w Astro Studio (good for CI)."],
+            [
+              "astro db execute <file-path>",
+              "Execute a ts/js file using astro:db. Use --remote to connect to Studio."
+            ],
+            [
+              "astro db shell --query <sql-string>",
+              "Execute a SQL string. Use --remote to connect to Studio."
+            ]
+          ]
+        }
+      });
+      return;
+    }
+  }
+}
+export {
+  cli
+};

package/dist/core/cli/migration-queries.d.ts

@@ -0,0 +1,23 @@
+import { type DBConfig, type DBSnapshot, type ResolvedDBTable } from '../types.js';
+export declare function getMigrationQueries({ oldSnapshot, newSnapshot, reset, }: {
+    oldSnapshot: DBSnapshot;
+    newSnapshot: DBSnapshot;
+    reset?: boolean;
+}): Promise<{
+    queries: string[];
+    confirmations: string[];
+}>;
+export declare function getTableChangeQueries({ tableName, oldTable, newTable, }: {
+    tableName: string;
+    oldTable: ResolvedDBTable;
+    newTable: ResolvedDBTable;
+}): Promise<{
+    queries: string[];
+    confirmations: string[];
+}>;
+export declare function getProductionCurrentSnapshot({ appToken, }: {
+    appToken: string;
+}): Promise<DBSnapshot | undefined>;
+export declare function createCurrentSnapshot({ tables }: DBConfig): DBSnapshot;
+export declare function createEmptySnapshot(): DBSnapshot;
+export declare function formatDataLossMessage(confirmations: string[], isColor?: boolean): string;