@astrojs/db 0.0.0-edge-nested-20240223135627

package/dist/core/queries.d.ts

@@ -0,0 +1,78 @@
+import type { SqliteRemoteDatabase } from 'drizzle-orm/sqlite-proxy';
+import { type BooleanColumn, type DBTable, type DBTables, type DBColumn, type DateColumn, type ColumnType, type JsonColumn, type NumberColumn, type TextColumn } from '../core/types.js';
+import type { AstroIntegrationLogger } from 'astro';
+import type { DBUserConfig } from '../core/types.js';
+export declare function recreateTables({ db, tables, }: {
+    db: SqliteRemoteDatabase;
+    tables: DBTables;
+}): Promise<void>;
+export declare function seedData({ db, data, logger, mode, }: {
+    db: SqliteRemoteDatabase;
+    data: DBUserConfig['data'];
+    logger?: AstroIntegrationLogger;
+    mode: 'dev' | 'build';
+}): Promise<void>;
+export declare function getCreateTableQuery(collectionName: string, collection: DBTable): string;
+export declare function getCreateIndexQueries(collectionName: string, collection: Pick<DBTable, 'indexes'>): string[];
+export declare function getCreateForeignKeyQueries(collectionName: string, collection: DBTable): string[];
+export declare function schemaTypeToSqlType(type: ColumnType): 'text' | 'integer';
+export declare function getModifiers(columnName: string, column: DBColumn): string;
+export declare function getReferencesConfig(column: DBColumn): {
+    type: "number";
+    schema: ({
+        unique: boolean;
+        name?: string | undefined;
+        label?: string | undefined;
+        collection?: string | undefined;
+    } & {
+        optional: boolean;
+        primaryKey: false;
+        default?: number | import("../runtime/types.js").SerializedSQL | undefined;
+    } & {
+        references?: any | undefined;
+    }) | ({
+        unique: boolean;
+        name?: string | undefined;
+        label?: string | undefined;
+        collection?: string | undefined;
+    } & {
+        primaryKey: true;
+        optional?: false | undefined;
+        default?: undefined;
+    } & {
+        references?: any | undefined;
+    });
+} | {
+    type: "text";
+    schema: ({
+        unique: boolean;
+        name?: string | undefined;
+        label?: string | undefined;
+        collection?: string | undefined;
+        default?: string | import("../runtime/types.js").SerializedSQL | undefined;
+        multiline?: boolean | undefined;
+    } & {
+        optional: boolean;
+        primaryKey: false;
+    } & {
+        references?: any | undefined;
+    }) | ({
+        unique: boolean;
+        name?: string | undefined;
+        label?: string | 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 DBColumn> = T & {
+    schema: Required<Pick<T['schema'], 'default'>>;
+};
+type DBColumnWithDefault = WithDefaultDefined<TextColumn> | WithDefaultDefined<DateColumn> | WithDefaultDefined<NumberColumn> | WithDefaultDefined<BooleanColumn> | WithDefaultDefined<JsonColumn>;
+export declare function hasDefault(column: DBColumn): column is DBColumnWithDefault;
+export {};

package/dist/core/queries.js

@@ -0,0 +1,218 @@
+import {
+} from "../core/types.js";
+import { bold } from "kleur/colors";
+import { sql, getTableName } from "drizzle-orm";
+import { SQLiteAsyncDialect } from "drizzle-orm/sqlite-core";
+import { hasPrimaryKey } from "../runtime/index.js";
+import { isSerializedSQL } from "../runtime/types.js";
+import { SEED_WRITABLE_IN_PROD_ERROR } from "./errors.js";
+const sqlite = new SQLiteAsyncDialect();
+async function recreateTables({
+  db,
+  tables
+}) {
+  const setupQueries = [];
+  for (const [name, collection] of Object.entries(tables)) {
+    const dropQuery = sql.raw(`DROP TABLE IF EXISTS ${sqlite.escapeName(name)}`);
+    const createQuery = sql.raw(getCreateTableQuery(name, collection));
+    const indexQueries = getCreateIndexQueries(name, collection);
+    setupQueries.push(dropQuery, createQuery, ...indexQueries.map((s) => sql.raw(s)));
+  }
+  for (const q of setupQueries) {
+    await db.run(q);
+  }
+}
+async function seedData({
+  db,
+  data,
+  logger,
+  mode
+}) {
+  try {
+    const dataFns = Array.isArray(data) ? data : [data];
+    for (const dataFn of dataFns) {
+      await dataFn({
+        seed: async ({ table, writable }, values) => {
+          if (writable && mode === "build" && process.env.ASTRO_DB_TEST_ENV !== "1") {
+            (logger ?? console).error(SEED_WRITABLE_IN_PROD_ERROR(getTableName(table)));
+            process.exit(1);
+          }
+          await db.insert(table).values(values);
+        },
+        seedReturning: async ({ table, writable }, values) => {
+          if (writable && mode === "build" && process.env.ASTRO_DB_TEST_ENV !== "1") {
+            (logger ?? console).error(SEED_WRITABLE_IN_PROD_ERROR(getTableName(table)));
+            process.exit(1);
+          }
+          let result = db.insert(table).values(values).returning();
+          if (!Array.isArray(values)) {
+            result = result.get();
+          }
+          return result;
+        },
+        db,
+        mode
+      });
+    }
+  } catch (error) {
+    (logger ?? console).error(
+      `Failed to seed data. Did you update to match recent schema changes?`
+    );
+    (logger ?? console).error(error);
+  }
+}
+function getCreateTableQuery(collectionName, collection) {
+  let query = `CREATE TABLE ${sqlite.escapeName(collectionName)} (`;
+  const colQueries = [];
+  const colHasPrimaryKey = Object.entries(collection.columns).find(
+    ([, column]) => hasPrimaryKey(column)
+  );
+  if (!colHasPrimaryKey) {
+    colQueries.push("_id INTEGER PRIMARY KEY");
+  }
+  for (const [columnName, column] of Object.entries(collection.columns)) {
+    const colQuery = `${sqlite.escapeName(columnName)} ${schemaTypeToSqlType(
+      column.type
+    )}${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 = asArray(indexProps.on);
+    const onCols = onColNames.map((colName) => sqlite.escapeName(colName));
+    const unique = indexProps.unique ? "UNIQUE " : "";
+    const indexQuery = `CREATE ${unique}INDEX ${sqlite.escapeName(
+      indexName
+    )} ON ${sqlite.escapeName(collectionName)} (${onCols.join(", ")})`;
+    queries.push(indexQuery);
+  }
+  return queries;
+}
+function getCreateForeignKeyQueries(collectionName, collection) {
+  let queries = [];
+  for (const foreignKey of collection.foreignKeys ?? []) {
+    const columns = asArray(foreignKey.columns);
+    const references = asArray(foreignKey.references);
+    if (columns.length !== references.length) {
+      throw new Error(
+        `Foreign key on ${collectionName} is misconfigured. \`columns\` 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 (${columns.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":
+    case "text":
+    case "json":
+      return "text";
+    case "number":
+    case "boolean":
+      return "integer";
+  }
+}
+function getModifiers(columnName, column) {
+  let modifiers = "";
+  if (hasPrimaryKey(column)) {
+    return " PRIMARY KEY";
+  }
+  if (!column.schema.optional) {
+    modifiers += " NOT NULL";
+  }
+  if (column.schema.unique) {
+    modifiers += " UNIQUE";
+  }
+  if (hasDefault(column)) {
+    modifiers += ` DEFAULT ${getDefaultValueSql(columnName, column)}`;
+  }
+  const references = getReferencesConfig(column);
+  if (references) {
+    const { collection, name } = references.schema;
+    if (!collection || !name) {
+      throw new Error(
+        `Column ${collection}.${name} references a collection that does not exist. Did you apply the referenced collection to the \`tables\` object in your Astro config?`
+      );
+    }
+    modifiers += ` REFERENCES ${sqlite.escapeName(collection)} (${sqlite.escapeName(name)})`;
+  }
+  return modifiers;
+}
+function getReferencesConfig(column) {
+  const canHaveReferences = column.type === "number" || column.type === "text";
+  if (!canHaveReferences)
+    return void 0;
+  return column.schema.references;
+}
+function hasDefault(column) {
+  if (column.schema.default !== void 0) {
+    return true;
+  }
+  if (hasPrimaryKey(column) && column.type === "number") {
+    return true;
+  }
+  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":
+    case "number":
+    case "text":
+    case "date":
+      return toDefault(column.schema.default);
+    case "json": {
+      let stringified = "";
+      try {
+        stringified = JSON.stringify(column.schema.default);
+      } catch (e) {
+        console.log(
+          `Invalid default value for column ${bold(
+            columnName
+          )}. Defaults must be valid JSON when using the \`json()\` type.`
+        );
+        process.exit(0);
+      }
+      return sqlite.escapeString(stringified);
+    }
+  }
+}
+export {
+  getCreateForeignKeyQueries,
+  getCreateIndexQueries,
+  getCreateTableQuery,
+  getModifiers,
+  getReferencesConfig,
+  hasDefault,
+  recreateTables,
+  schemaTypeToSqlType,
+  seedData
+};

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
+};