@astrojs/db 0.2.1 → 0.3.0

package/dist/core/integration/index.js

@@ -6,42 +6,42 @@ 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 { getAstroStudioEnv } from "../utils.js";
-import { appTokenError } from "../errors.js";
+import {} from "../utils.js";
+import { STUDIO_CONFIG_MISSING_WRITABLE_COLLECTIONS_ERROR } from "../errors.js";
 import { errorMap } from "./error-map.js";
 import { dirname } from "path";
 import { fileURLToPath } from "url";
-import { bold } from "kleur/colors";
+import { blue, yellow } from "kleur/colors";
 import { fileURLIntegration } from "./file-url.js";
 import { setupDbTables } from "../queries.js";
+import { getManagedAppTokenOrExit } from "../tokens.js";
 function astroDBIntegration() {
+  let connectedToRemote = false;
+  let appToken;
   return {
     name: "astro:db",
     hooks: {
-      async "astro:config:setup"({ logger, updateConfig, config, command }) {
+      "astro:config:setup": async ({ logger, updateConfig, config, command }) => {
         if (command === "preview")
           return;
         const configWithDb = astroConfigWithDbSchema.parse(config, { errorMap });
         const collections = configWithDb.db?.collections ?? {};
         const studio = configWithDb.db?.studio ?? false;
-        if (!studio && Object.values(collections).some((c) => c.writable)) {
-          logger.warn(
-            `Writable collections should only be used with Astro Studio. Did you set the ${bold(
-              "studio"
-            )} flag in your astro config?`
+        const foundWritableCollection = Object.entries(collections).find(([, c]) => c.writable);
+        if (!studio && foundWritableCollection) {
+          logger.error(
+            STUDIO_CONFIG_MISSING_WRITABLE_COLLECTIONS_ERROR(foundWritableCollection[0])
           );
+          process.exit(1);
         }
         let dbPlugin;
-        if (studio && command === "build") {
-          const appToken = getAstroStudioEnv().ASTRO_STUDIO_APP_TOKEN;
-          if (!appToken) {
-            logger.error(appTokenError);
-            process.exit(0);
-          }
+        if (studio && command === "build" && process.env.ASTRO_DB_TEST_ENV !== "1") {
+          appToken = await getManagedAppTokenOrExit();
+          connectedToRemote = true;
           dbPlugin = vitePluginDb({
             connectToStudio: true,
             collections,
-            appToken,
+            appToken: appToken.token,
             root: config.root
           });
         } else {
@@ -63,7 +63,7 @@ function astroDBIntegration() {
             logger,
             mode: command === "dev" ? "dev" : "build"
           });
-          logger.info("Collections set up \u{1F680}");
+          logger.debug("Database setup complete.");
           dbPlugin = vitePluginDb({
             connectToStudio: false,
             collections,
@@ -91,6 +91,21 @@ function astroDBIntegration() {
           }
         });
         await typegen({ collections, root: config.root });
+      },
+      "astro:server:start": async ({ logger }) => {
+        setTimeout(() => {
+          logger.info(
+            connectedToRemote ? "Connected to remote database." : "New local database created."
+          );
+        }, 100);
+      },
+      "astro:build:start": async ({ logger }) => {
+        logger.info(
+          "database: " + (connectedToRemote ? yellow("remote") : blue("local database."))
+        );
+      },
+      "astro:build:done": async ({}) => {
+        await appToken?.destroy();
       }
     }
   };

package/dist/core/integration/typegen.js

@@ -27,8 +27,8 @@ function generateTableType(name, collection) {
         {
           // Only select fields Drizzle needs for inference
           type: field.type,
-          optional: field.optional,
-          default: field.default
+          optional: field.schema.optional,
+          default: field.schema.default
         }
       ])
     )

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

@@ -10,7 +10,7 @@ export declare function vitePluginDb(params: {
     appToken: string;
     root: URL;
 }): VitePlugin;
-export declare function getVirtualModContents({ collections, root }: {
+export declare function getVirtualModContents({ collections, root, }: {
     collections: DBCollections;
     root: URL;
 }): string;

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

@@ -1,5 +1,4 @@
-import { RUNTIME_IMPORT, VIRTUAL_MODULE_ID, DB_PATH, RUNTIME_DRIZZLE_IMPORT } from "../consts.js";
-import { fileURLToPath } from "node:url";
+import { DB_PATH, RUNTIME_DRIZZLE_IMPORT, RUNTIME_IMPORT, VIRTUAL_MODULE_ID } from "../consts.js";
 const resolvedVirtualModuleId = "\0" + VIRTUAL_MODULE_ID;
 function vitePluginDb(params) {
   return {
@@ -20,11 +19,14 @@ function vitePluginDb(params) {
     }
   };
 }
-function getVirtualModContents({ collections, root }) {
+function getVirtualModContents({
+  collections,
+  root
+}) {
   const dbUrl = new URL(DB_PATH, root);
   return `
 import { collectionToTable, createLocalDatabaseClient } from ${RUNTIME_IMPORT};
-import dbUrl from '${fileURLToPath(dbUrl)}?fileurl';
+import dbUrl from ${JSON.stringify(`${dbUrl}?fileurl`)};
 
 const params = ${JSON.stringify({
     collections,

package/dist/core/queries.d.ts

@@ -11,9 +11,65 @@ export declare function setupDbTables({ db, data, collections, logger, mode, }:
 }): Promise<void>;
 export declare function getCreateTableQuery(collectionName: string, collection: DBCollection): string;
 export declare function getCreateIndexQueries(collectionName: string, collection: Pick<DBCollection, 'indexes'>): string[];
+export declare function getCreateForeignKeyQueries(collectionName: string, collection: DBCollection): string[];
 export declare function schemaTypeToSqlType(type: FieldType): 'text' | 'integer';
 export declare function getModifiers(fieldName: string, field: DBField): string;
-type WithDefaultDefined<T extends DBField> = T & Required<Pick<T, 'default'>>;
+export declare function getReferencesConfig(field: DBField): {
+    type: "number";
+    schema: ({
+        name?: string | undefined;
+        label?: string | undefined;
+        unique?: boolean | undefined;
+        collection?: string | undefined;
+    } & {
+        primaryKey?: false | undefined;
+        optional?: boolean | undefined;
+        default?: number | import("../runtime/types.js").SerializedSQL | undefined;
+    } & {
+        references?: any | undefined;
+    }) | ({
+        name?: string | undefined;
+        label?: string | undefined;
+        unique?: 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;
+        collection?: string | undefined;
+        default?: string | import("../runtime/types.js").SerializedSQL | undefined;
+        multiline?: boolean | undefined;
+    } & {
+        primaryKey?: false | undefined;
+        optional?: boolean | undefined;
+    } & {
+        references?: any | undefined;
+    }) | ({
+        name?: string | undefined;
+        label?: string | undefined;
+        unique?: boolean | undefined;
+        collection?: string | undefined;
+        default?: string | import("../runtime/types.js").SerializedSQL | undefined;
+        multiline?: boolean | undefined;
+    } & {
+        primaryKey: true;
+        optional?: false | undefined;
+    } & {
+        references?: any | undefined;
+    });
+} | undefined;
+type WithDefaultDefined<T extends DBField> = T & {
+    schema: Required<Pick<T['schema'], 'default'>>;
+};
 type DBFieldWithDefault = WithDefaultDefined<TextField> | WithDefaultDefined<DateField> | WithDefaultDefined<NumberField> | WithDefaultDefined<BooleanField> | WithDefaultDefined<JsonField>;
 export declare function hasDefault(field: DBField): field is DBFieldWithDefault;
 export {};

package/dist/core/queries.js

@@ -3,7 +3,8 @@ import {
 import { bold } from "kleur/colors";
 import { sql } from "drizzle-orm";
 import { SQLiteAsyncDialect } from "drizzle-orm/sqlite-core";
-import { collectionToTable, hasPrimaryKey } from "../runtime/index.js";
+import { hasPrimaryKey } from "../runtime/index.js";
+import { isSerializedSQL } from "../runtime/types.js";
 const sqlite = new SQLiteAsyncDialect();
 async function setupDbTables({
   db,
@@ -11,6 +12,7 @@ async function setupDbTables({
   collections,
   logger,
   mode
+  // TODO: Remove once Turso has foreign key PRAGMA support
 }) {
   const setupQueries = [];
   for (const [name, collection] of Object.entries(collections)) {
@@ -23,28 +25,20 @@ async function setupDbTables({
     await db.run(q);
   }
   if (data) {
-    for (const [name, collection] of Object.entries(collections)) {
-      const table = collectionToTable(name, collection);
-      collection._setMeta?.({ table });
-    }
     try {
       await data({
-        async seed({ table }, values) {
-          const result = Array.isArray(values) ? (
-            // TODO: fix values typing once we can infer fields type correctly
-            await db.insert(table).values(values).returning()
-          ) : await db.insert(table).values(values).returning().get();
+        seed: async ({ table }, values) => {
+          const result = Array.isArray(values) ? db.insert(table).values(values).returning() : db.insert(table).values(values).returning().get();
           return result;
         },
         db,
         mode
       });
-    } catch (e) {
+    } catch (error) {
       (logger ?? console).error(
-        `Failed to seed data. Did you update to match recent schema changes? Full error:
-
-${e}`
+        `Failed to seed data. Did you update to match recent schema changes?`
       );
+      (logger ?? console).error(error);
     }
   }
 }
@@ -63,13 +57,14 @@ function getCreateTableQuery(collectionName, collection) {
     )}${getModifiers(columnName, column)}`;
     colQueries.push(colQuery);
   }
+  colQueries.push(...getCreateForeignKeyQueries(collectionName, collection));
   query += colQueries.join(", ") + ")";
   return query;
 }
 function getCreateIndexQueries(collectionName, collection) {
   let queries = [];
   for (const [indexName, indexProps] of Object.entries(collection.indexes ?? {})) {
-    const onColNames = Array.isArray(indexProps.on) ? indexProps.on : [indexProps.on];
+    const onColNames = asArray(indexProps.on);
     const onCols = onColNames.map((colName) => sqlite.escapeName(colName));
     const unique = indexProps.unique ? "UNIQUE " : "";
     const indexQuery = `CREATE ${unique}INDEX ${sqlite.escapeName(
@@ -79,6 +74,30 @@ function getCreateIndexQueries(collectionName, collection) {
   }
   return queries;
 }
+function getCreateForeignKeyQueries(collectionName, collection) {
+  let queries = [];
+  for (const foreignKey of collection.foreignKeys ?? []) {
+    const fields = asArray(foreignKey.fields);
+    const references = asArray(foreignKey.references);
+    if (fields.length !== references.length) {
+      throw new Error(
+        `Foreign key on ${collectionName} is misconfigured. \`fields\` and \`references\` must be the same length.`
+      );
+    }
+    const referencedCollection = references[0]?.schema.collection;
+    if (!referencedCollection) {
+      throw new Error(
+        `Foreign key on ${collectionName} is misconfigured. \`references\` cannot be empty.`
+      );
+    }
+    const query = `FOREIGN KEY (${fields.map((f) => sqlite.escapeName(f)).join(", ")}) REFERENCES ${sqlite.escapeName(referencedCollection)}(${references.map((r) => sqlite.escapeName(r.schema.name)).join(", ")})`;
+    queries.push(query);
+  }
+  return queries;
+}
+function asArray(value) {
+  return Array.isArray(value) ? value : [value];
+}
 function schemaTypeToSqlType(type) {
   switch (type) {
     case "date":
@@ -95,19 +114,35 @@ function getModifiers(fieldName, field) {
   if (hasPrimaryKey(field)) {
     return " PRIMARY KEY";
   }
-  if (!field.optional) {
+  if (!field.schema.optional) {
     modifiers += " NOT NULL";
   }
-  if (field.unique) {
+  if (field.schema.unique) {
     modifiers += " UNIQUE";
   }
   if (hasDefault(field)) {
     modifiers += ` DEFAULT ${getDefaultValueSql(fieldName, field)}`;
   }
+  const references = getReferencesConfig(field);
+  if (references) {
+    const { collection, name } = references.schema;
+    if (!collection || !name) {
+      throw new Error(
+        `Invalid reference for field ${fieldName}. This is an unexpected error that should be reported to the Astro team.`
+      );
+    }
+    modifiers += ` REFERENCES ${sqlite.escapeName(collection)} (${sqlite.escapeName(name)})`;
+  }
   return modifiers;
 }
+function getReferencesConfig(field) {
+  const canHaveReferences = field.type === "number" || field.type === "text";
+  if (!canHaveReferences)
+    return void 0;
+  return field.schema.references;
+}
 function hasDefault(field) {
-  if (field.default !== void 0) {
+  if (field.schema.default !== void 0) {
     return true;
   }
   if (hasPrimaryKey(field) && field.type === "number") {
@@ -115,20 +150,30 @@ function hasDefault(field) {
   }
   return false;
 }
+function toDefault(def) {
+  const type = typeof def;
+  if (type === "string") {
+    return sqlite.escapeString(def);
+  } else if (type === "boolean") {
+    return def ? "TRUE" : "FALSE";
+  } else {
+    return def + "";
+  }
+}
 function getDefaultValueSql(columnName, column) {
+  if (isSerializedSQL(column.schema.default)) {
+    return column.schema.default.sql;
+  }
   switch (column.type) {
     case "boolean":
-      return column.default ? "TRUE" : "FALSE";
     case "number":
-      return `${column.default || "AUTOINCREMENT"}`;
     case "text":
-      return sqlite.escapeString(column.default);
     case "date":
-      return column.default === "now" ? "CURRENT_TIMESTAMP" : sqlite.escapeString(column.default);
+      return toDefault(column.schema.default);
     case "json": {
       let stringified = "";
       try {
-        stringified = JSON.stringify(column.default);
+        stringified = JSON.stringify(column.schema.default);
       } catch (e) {
         console.log(
           `Invalid default value for column ${bold(
@@ -142,9 +187,11 @@ function getDefaultValueSql(columnName, column) {
   }
 }
 export {
+  getCreateForeignKeyQueries,
   getCreateIndexQueries,
   getCreateTableQuery,
   getModifiers,
+  getReferencesConfig,
   hasDefault,
   schemaTypeToSqlType,
   setupDbTables

package/dist/core/tokens.d.ts

@@ -0,0 +1,11 @@
+/// <reference types="node" resolution-mode="require"/>
+export declare const SESSION_LOGIN_FILE: import("url").URL;
+export declare const PROJECT_ID_FILE: import("url").URL;
+export interface ManagedAppToken {
+    token: string;
+    renew(): Promise<void>;
+    destroy(): Promise<void>;
+}
+export declare function getProjectIdFromFile(): Promise<string | undefined>;
+export declare function getSessionIdFromFile(): Promise<string | undefined>;
+export declare function getManagedAppTokenOrExit(token?: string): Promise<ManagedAppToken>;

package/dist/core/tokens.js

@@ -0,0 +1,131 @@
+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";
+const SESSION_LOGIN_FILE = pathToFileURL(join(homedir(), ".astro", "session-token"));
+const PROJECT_ID_FILE = pathToFileURL(join(process.cwd(), ".astro", "link"));
+class ManagedLocalAppToken {
+  token;
+  constructor(token) {
+    this.token = token;
+  }
+  async renew() {
+  }
+  async destroy() {
+  }
+}
+class ManagedRemoteAppToken {
+  token;
+  session;
+  projectId;
+  ttl;
+  renewTimer;
+  static async create(sessionToken, projectId) {
+    const response = await fetch(new URL(`${getAstroStudioUrl()}/auth/cli/token-create`), {
+      method: "POST",
+      headers: new Headers({
+        Authorization: `Bearer ${sessionToken}`
+      }),
+      body: JSON.stringify({ projectId })
+    });
+    const { token: shortLivedAppToken, ttl } = await response.json();
+    return new ManagedRemoteAppToken({
+      token: shortLivedAppToken,
+      session: sessionToken,
+      projectId,
+      ttl
+    });
+  }
+  constructor(options) {
+    this.token = options.token;
+    this.session = options.session;
+    this.projectId = options.projectId;
+    this.ttl = options.ttl;
+    this.renewTimer = setTimeout(() => this.renew(), 1e3 * 60 * 5 / 2);
+  }
+  async fetch(url, body) {
+    return fetch(`${getAstroStudioUrl()}${url}`, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${this.session}`,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify(body)
+    });
+  }
+  async renew() {
+    clearTimeout(this.renewTimer);
+    delete this.renewTimer;
+    try {
+      const response = await this.fetch("/auth/cli/token-renew", {
+        token: this.token,
+        projectId: this.projectId
+      });
+      if (response.status === 200) {
+        this.renewTimer = setTimeout(() => this.renew(), 1e3 * 60 * this.ttl / 2);
+      } else {
+        throw new Error(`Unexpected response: ${response.status} ${response.statusText}`);
+      }
+    } catch (error) {
+      const retryIn = 60 * this.ttl / 10;
+      console.error(`Failed to renew token. Retrying in ${retryIn} seconds.`, error?.message);
+      this.renewTimer = setTimeout(() => this.renew(), retryIn * 1e3);
+    }
+  }
+  async destroy() {
+    try {
+      const response = await this.fetch("/auth/cli/token-delete", {
+        token: this.token,
+        projectId: this.projectId
+      });
+      if (response.status !== 200) {
+        throw new Error(`Unexpected response: ${response.status} ${response.statusText}`);
+      }
+    } catch (error) {
+      console.error("Failed to delete token.", error?.message);
+    }
+  }
+}
+async function getProjectIdFromFile() {
+  try {
+    return await readFile(PROJECT_ID_FILE, "utf-8");
+  } catch (error) {
+    return void 0;
+  }
+}
+async function getSessionIdFromFile() {
+  try {
+    return await readFile(SESSION_LOGIN_FILE, "utf-8");
+  } catch (error) {
+    return void 0;
+  }
+}
+async function getManagedAppTokenOrExit(token) {
+  if (token) {
+    return new ManagedLocalAppToken(token);
+  }
+  const { ASTRO_STUDIO_APP_TOKEN } = getAstroStudioEnv();
+  if (ASTRO_STUDIO_APP_TOKEN) {
+    return new ManagedLocalAppToken(ASTRO_STUDIO_APP_TOKEN);
+  }
+  const sessionToken = await getSessionIdFromFile();
+  if (!sessionToken) {
+    console.error(MISSING_SESSION_ID_ERROR);
+    process.exit(1);
+  }
+  const projectId = await getProjectIdFromFile();
+  if (!sessionToken || !projectId) {
+    console.error(MISSING_PROJECT_ID_ERROR);
+    process.exit(1);
+  }
+  return ManagedRemoteAppToken.create(sessionToken, projectId);
+}
+export {
+  PROJECT_ID_FILE,
+  SESSION_LOGIN_FILE,
+  getManagedAppTokenOrExit,
+  getProjectIdFromFile,
+  getSessionIdFromFile
+};