@astrojs/db 0.0.0-edge-nested-20240223135627

package/dist/core/integration/error-map.js

@@ -0,0 +1,79 @@
+const errorMap = (baseError, ctx) => {
+  const baseErrorPath = flattenErrorPath(baseError.path);
+  if (baseError.code === "invalid_union") {
+    const typeOrLiteralErrByPath = /* @__PURE__ */ new Map();
+    for (const unionError of baseError.unionErrors.flatMap((e) => e.errors)) {
+      if (unionError.code === "invalid_type" || unionError.code === "invalid_literal") {
+        const flattenedErrorPath = flattenErrorPath(unionError.path);
+        const typeOrLiteralErr = typeOrLiteralErrByPath.get(flattenedErrorPath);
+        if (typeOrLiteralErr) {
+          typeOrLiteralErr.expected.push(unionError.expected);
+        } else {
+          typeOrLiteralErrByPath.set(flattenedErrorPath, {
+            code: unionError.code,
+            received: unionError.received,
+            expected: [unionError.expected]
+          });
+        }
+      }
+    }
+    const messages = [
+      prefix(
+        baseErrorPath,
+        typeOrLiteralErrByPath.size ? "Did not match union:" : "Did not match union."
+      )
+    ];
+    return {
+      message: messages.concat(
+        [...typeOrLiteralErrByPath.entries()].filter(([, error]) => error.expected.length === baseError.unionErrors.length).map(
+          ([key, error]) => (
+            // Avoid printing the key again if it's a base error
+            key === baseErrorPath ? `> ${getTypeOrLiteralMsg(error)}` : `> ${prefix(key, getTypeOrLiteralMsg(error))}`
+          )
+        )
+      ).join("\n")
+    };
+  }
+  if (baseError.code === "invalid_literal" || baseError.code === "invalid_type") {
+    return {
+      message: prefix(
+        baseErrorPath,
+        getTypeOrLiteralMsg({
+          code: baseError.code,
+          received: baseError.received,
+          expected: [baseError.expected]
+        })
+      )
+    };
+  } else if (baseError.message) {
+    return { message: prefix(baseErrorPath, baseError.message) };
+  } else {
+    return { message: prefix(baseErrorPath, ctx.defaultError) };
+  }
+};
+const getTypeOrLiteralMsg = (error) => {
+  if (error.received === "undefined")
+    return "Required";
+  const expectedDeduped = new Set(error.expected);
+  switch (error.code) {
+    case "invalid_type":
+      return `Expected type \`${unionExpectedVals(expectedDeduped)}\`, received ${JSON.stringify(
+        error.received
+      )}`;
+    case "invalid_literal":
+      return `Expected \`${unionExpectedVals(expectedDeduped)}\`, received ${JSON.stringify(
+        error.received
+      )}`;
+  }
+};
+const prefix = (key, msg) => key.length ? `**${key}**: ${msg}` : msg;
+const unionExpectedVals = (expectedVals) => [...expectedVals].map((expectedVal, idx) => {
+  if (idx === 0)
+    return JSON.stringify(expectedVal);
+  const sep = " | ";
+  return `${sep}${JSON.stringify(expectedVal)}`;
+}).join("");
+const flattenErrorPath = (errorPath) => errorPath.join(".");
+export {
+  errorMap
+};

package/dist/core/integration/file-url.d.ts

@@ -0,0 +1,2 @@
+import type { AstroIntegration } from 'astro';
+export declare function fileURLIntegration(): AstroIntegration;

package/dist/core/integration/file-url.js

@@ -0,0 +1,84 @@
+import fs from "node:fs";
+import { pathToFileURL } from "node:url";
+import path from "node:path";
+async function copyFile(toDir, fromUrl, toUrl) {
+  await fs.promises.mkdir(toDir, { recursive: true });
+  await fs.promises.rename(fromUrl, toUrl);
+}
+function fileURLIntegration() {
+  const fileNames = [];
+  function createVitePlugin(command) {
+    let referenceIds = [];
+    return {
+      name: "@astrojs/db/file-url",
+      enforce: "pre",
+      async load(id) {
+        if (id.endsWith("?fileurl")) {
+          const filePath = id.slice(0, id.indexOf("?"));
+          if (command === "build") {
+            const data = await fs.promises.readFile(filePath);
+            const name = path.basename(filePath);
+            const referenceId = this.emitFile({
+              name,
+              source: data,
+              type: "asset"
+            });
+            referenceIds.push(referenceId);
+            return `export default import.meta.ROLLUP_FILE_URL_${referenceId};`;
+          } else {
+            return `export default new URL(${JSON.stringify(pathToFileURL(filePath).toString())})`;
+          }
+        }
+      },
+      generateBundle() {
+        for (const referenceId of referenceIds) {
+          fileNames.push(this.getFileName(referenceId));
+        }
+        referenceIds = [];
+      }
+    };
+  }
+  let config;
+  return {
+    name: "@astrojs/db/file-url",
+    hooks: {
+      "astro:config:setup"({ updateConfig, command }) {
+        updateConfig({
+          vite: {
+            plugins: [createVitePlugin(command)]
+          }
+        });
+      },
+      "astro:config:done": ({ config: _config }) => {
+        config = _config;
+      },
+      async "astro:build:done"() {
+        if (config.output === "static") {
+          const unlinks = [];
+          for (const fileName of fileNames) {
+            const url = new URL(fileName, config.outDir);
+            unlinks.push(fs.promises.unlink(url));
+          }
+          await Promise.all(unlinks);
+          const assetDir = new URL(config.build.assets, config.outDir);
+          const assetFiles = await fs.promises.readdir(assetDir);
+          if (!assetFiles.length) {
+            await fs.promises.rmdir(assetDir);
+          }
+        } else {
+          const moves = [];
+          for (const fileName of fileNames) {
+            const fromUrl = new URL(fileName, config.build.client);
+            const toUrl = new URL(fileName, config.build.server);
+            const toDir = new URL("./", toUrl);
+            moves.push(copyFile(toDir, fromUrl, toUrl));
+          }
+          await Promise.all(moves);
+        }
+      }
+    }
+  };
+}
+export {
+  fileURLIntegration
+};

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

@@ -0,0 +1,2 @@
+import type { AstroIntegration } from 'astro';
+export declare function integration(): AstroIntegration[];

package/dist/core/integration/index.js

@@ -0,0 +1,173 @@
+var __knownSymbol = (name, symbol) => {
+  return (symbol = Symbol[name]) ? symbol : Symbol.for("Symbol." + name);
+};
+var __using = (stack, value, async) => {
+  if (value != null) {
+    if (typeof value !== "object" && typeof value !== "function")
+      throw TypeError("Object expected");
+    var dispose;
+    if (async)
+      dispose = value[__knownSymbol("asyncDispose")];
+    if (dispose === void 0)
+      dispose = value[__knownSymbol("dispose")];
+    if (typeof dispose !== "function")
+      throw TypeError("Object not disposable");
+    stack.push([async, dispose, value]);
+  } else if (async) {
+    stack.push([async]);
+  }
+  return value;
+};
+var __callDispose = (stack, error, hasError) => {
+  var E = typeof SuppressedError === "function" ? SuppressedError : function(e, s, m, _) {
+    return _ = Error(m), _.name = "SuppressedError", _.error = e, _.suppressed = s, _;
+  };
+  var fail = (e) => error = hasError ? new E(e, error, "An error was suppressed during disposal") : (hasError = true, e);
+  var next = (it) => {
+    while (it = stack.pop()) {
+      try {
+        var result = it[1] && it[1].call(it[2]);
+        if (it[0])
+          return Promise.resolve(result).then(next, (e) => (fail(e), next()));
+      } catch (e) {
+        fail(e);
+      }
+    }
+    if (hasError)
+      throw error;
+  };
+  return next();
+};
+import { vitePluginDb } from "./vite-plugin-db.js";
+import { vitePluginInjectEnvTs } from "./vite-plugin-inject-env-ts.js";
+import { typegen } from "./typegen.js";
+import { existsSync } from "fs";
+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 {} from "../utils.js";
+import {
+  STUDIO_CONFIG_MISSING_WRITABLE_COLLECTIONS_ERROR,
+  UNSAFE_WRITABLE_WARNING
+} from "../errors.js";
+import { errorMap } from "./error-map.js";
+import { dirname } from "path";
+import { fileURLToPath } from "url";
+import { blue, yellow } from "kleur/colors";
+import { fileURLIntegration } from "./file-url.js";
+import { recreateTables, seedData } from "../queries.js";
+import { getManagedAppTokenOrExit } from "../tokens.js";
+function astroDBIntegration() {
+  let connectedToRemote = false;
+  let appToken;
+  let schemas = {
+    tables() {
+      throw new Error("tables not found");
+    }
+  };
+  let command;
+  return {
+    name: "astro:db",
+    hooks: {
+      "astro:config:setup": async ({ updateConfig, config, command: _command, logger }) => {
+        command = _command;
+        if (_command === "preview")
+          return;
+        let dbPlugin = void 0;
+        const studio = config.db?.studio ?? false;
+        if (studio && command === "build" && process.env.ASTRO_DB_TEST_ENV !== "1") {
+          appToken = await getManagedAppTokenOrExit();
+          connectedToRemote = true;
+          dbPlugin = vitePluginDb({
+            connectToStudio: true,
+            appToken: appToken.token,
+            schemas,
+            root: config.root
+          });
+        } else {
+          dbPlugin = vitePluginDb({
+            connectToStudio: false,
+            schemas,
+            root: config.root
+          });
+        }
+        updateConfig({
+          vite: {
+            assetsInclude: [DB_PATH],
+            plugins: [dbPlugin, vitePluginInjectEnvTs(config, logger)]
+          }
+        });
+      },
+      "astro:config:done": async ({ config, logger }) => {
+        const configWithDb = astroConfigWithDbSchema.parse(config, { errorMap });
+        const tables = configWithDb.db?.tables ?? {};
+        schemas.tables = () => tables;
+        const studio = configWithDb.db?.studio ?? false;
+        const unsafeWritable = Boolean(configWithDb.db?.unsafeWritable);
+        const foundWritableCollection = Object.entries(tables).find(([, c]) => c.writable);
+        const writableAllowed = studio || unsafeWritable;
+        if (!writableAllowed && foundWritableCollection) {
+          logger.error(
+            STUDIO_CONFIG_MISSING_WRITABLE_COLLECTIONS_ERROR(foundWritableCollection[0])
+          );
+          process.exit(1);
+        } else if (unsafeWritable && foundWritableCollection) {
+          logger.warn(UNSAFE_WRITABLE_WARNING);
+        }
+        if (!connectedToRemote) {
+          var _stack = [];
+          try {
+            const dbUrl = new URL(DB_PATH, config.root);
+            if (existsSync(dbUrl)) {
+              await rm(dbUrl);
+            }
+            await mkdir(dirname(fileURLToPath(dbUrl)), { recursive: true });
+            await writeFile(dbUrl, "");
+            const db = __using(_stack, await createLocalDatabaseClient({
+              tables,
+              dbUrl: dbUrl.toString(),
+              seeding: true
+            }));
+            await recreateTables({ db, tables });
+            if (configWithDb.db?.data) {
+              await seedData({
+                db,
+                data: configWithDb.db.data,
+                logger,
+                mode: command === "dev" ? "dev" : "build"
+              });
+            }
+            logger.debug("Database setup complete.");
+          } catch (_) {
+            var _error = _, _hasError = true;
+          } finally {
+            __callDispose(_stack, _error, _hasError);
+          }
+        }
+        await typegen({ tables, 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();
+      }
+    }
+  };
+}
+function integration() {
+  return [astroDBIntegration(), fileURLIntegration()];
+}
+export {
+  integration
+};

package/dist/core/integration/load-astro-config.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Pulled from the mothership, Astro core ❤️
+ *
+ * @see https://github.com/withastro/astro/blob/main/packages/astro/src/core/config/config.ts#L121
+ */
+export declare function loadAstroConfig(root: string): Promise<Record<string, unknown>>;

package/dist/core/integration/load-astro-config.js

@@ -0,0 +1,79 @@
+import fs from "node:fs";
+import path from "node:path";
+import { pathToFileURL } from "node:url";
+import { bold, red } from "kleur/colors";
+import { createServer } from "vite";
+async function loadAstroConfig(root) {
+  const configPath = search(root);
+  if (!configPath)
+    return {};
+  try {
+    return await loadConfigWithVite(configPath);
+  } catch (e) {
+    console.error(`${bold(red("[astro]"))} Unable to load Astro config.
+`);
+    throw e;
+  }
+}
+function search(root) {
+  const paths = [
+    "astro.config.mjs",
+    "astro.config.js",
+    "astro.config.ts",
+    "astro.config.mts",
+    "astro.config.cjs",
+    "astro.config.cts"
+  ].map((p) => path.join(root, p));
+  for (const file of paths) {
+    if (fs.existsSync(file)) {
+      return file;
+    }
+  }
+}
+async function loadConfigWithVite(configPath) {
+  if (/\.[cm]?js$/.test(configPath)) {
+    try {
+      const config = await import(
+        /* @vite-ignore */
+        pathToFileURL(configPath).toString() + "?t=" + Date.now()
+      );
+      return config.default ?? {};
+    } catch (e) {
+    }
+  }
+  let server;
+  try {
+    server = await createViteServer();
+    const mod = await server.ssrLoadModule(configPath, { fixStacktrace: true });
+    return mod.default ?? {};
+  } finally {
+    if (server) {
+      await server.close();
+    }
+  }
+}
+async function createViteServer() {
+  const viteServer = await createServer({
+    server: { middlewareMode: true, hmr: false, watch: { ignored: ["**"] } },
+    optimizeDeps: { disabled: true },
+    clearScreen: false,
+    appType: "custom",
+    ssr: {
+      // NOTE: Vite doesn't externalize linked packages by default. During testing locally,
+      // these dependencies trip up Vite's dev SSR transform. Awaiting upstream feature:
+      // https://github.com/vitejs/vite/pull/10939
+      external: [
+        "@astrojs/tailwind",
+        "@astrojs/mdx",
+        "@astrojs/react",
+        "@astrojs/preact",
+        "@astrojs/sitemap",
+        "@astrojs/markdoc"
+      ]
+    }
+  });
+  return viteServer;
+}
+export {
+  loadAstroConfig
+};

package/dist/core/integration/typegen.d.ts

@@ -0,0 +1,5 @@
+import type { DBTables } from '../types.js';
+export declare function typegen({ tables, root }: {
+    tables: DBTables;
+    root: URL;
+}): Promise<void>;

package/dist/core/integration/typegen.js

@@ -0,0 +1,41 @@
+import { existsSync } from "node:fs";
+import { mkdir, writeFile } from "node:fs/promises";
+import { DB_TYPES_FILE, RUNTIME_DRIZZLE_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};
+
+${Object.entries(tables).map(([name, collection]) => generateTableType(name, collection)).join("\n")}
+}
+`;
+  const dotAstroDir = new URL(".astro/", root);
+  if (!existsSync(dotAstroDir)) {
+    await mkdir(dotAstroDir);
+  }
+  await writeFile(new URL(DB_TYPES_FILE, dotAstroDir), content);
+}
+function generateTableType(name, collection) {
+  let tableType = `	export const ${name}: import(${RUNTIME_IMPORT}).Table<
+		${JSON.stringify(name)},
+		${JSON.stringify(
+    Object.fromEntries(
+      Object.entries(collection.columns).map(([columnName, column]) => [
+        columnName,
+        {
+          // Only select columns Drizzle needs for inference
+          type: column.type,
+          optional: column.schema.optional,
+          default: column.schema.default
+        }
+      ])
+    )
+  )}
+	>;`;
+  return tableType;
+}
+export {
+  typegen
+};

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

@@ -0,0 +1,25 @@
+import type { DBTables } from '../types.js';
+import type { VitePlugin } from '../utils.js';
+type LateSchema = {
+    tables: () => DBTables;
+};
+type VitePluginDBParams = {
+    connectToStudio: false;
+    schemas: LateSchema;
+    root: URL;
+} | {
+    connectToStudio: true;
+    schemas: LateSchema;
+    appToken: string;
+    root: URL;
+};
+export declare function vitePluginDb(params: VitePluginDBParams): VitePlugin;
+export declare function getVirtualModContents({ tables, root }: {
+    tables: DBTables;
+    root: URL;
+}): string;
+export declare function getStudioVirtualModContents({ tables, appToken, }: {
+    tables: DBTables;
+    appToken: string;
+}): string;
+export {};

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

@@ -0,0 +1,73 @@
+import { DB_PATH, RUNTIME_DRIZZLE_IMPORT, RUNTIME_IMPORT, VIRTUAL_MODULE_ID } from "../consts.js";
+const resolvedVirtualModuleId = "\0" + VIRTUAL_MODULE_ID;
+function vitePluginDb(params) {
+  return {
+    name: "astro:db",
+    enforce: "pre",
+    resolveId(id) {
+      if (id === VIRTUAL_MODULE_ID) {
+        return resolvedVirtualModuleId;
+      }
+    },
+    load(id) {
+      if (id !== resolvedVirtualModuleId)
+        return;
+      if (params.connectToStudio) {
+        return getStudioVirtualModContents({
+          appToken: params.appToken,
+          tables: params.schemas.tables()
+        });
+      }
+      return getVirtualModContents({
+        root: params.root,
+        tables: params.schemas.tables()
+      });
+    }
+  };
+}
+function getVirtualModContents({ tables, root }) {
+  const dbUrl = new URL(DB_PATH, root);
+  return `
+import { collectionToTable, createLocalDatabaseClient } from ${RUNTIME_IMPORT};
+import dbUrl from ${JSON.stringify(`${dbUrl}?fileurl`)};
+
+const params = ${JSON.stringify({
+    tables,
+    seeding: false
+  })};
+params.dbUrl = dbUrl;
+
+export const db = await createLocalDatabaseClient(params);
+
+export * from ${RUNTIME_DRIZZLE_IMPORT};
+
+${getStringifiedCollectionExports(tables)}
+`;
+}
+function getStudioVirtualModContents({
+  tables,
+  appToken
+}) {
+  return `
+import {collectionToTable, createRemoteDatabaseClient} from ${RUNTIME_IMPORT};
+
+export const db = await createRemoteDatabaseClient(${JSON.stringify(
+    appToken
+  )}, import.meta.env.ASTRO_STUDIO_REMOTE_DB_URL);
+export * from ${RUNTIME_DRIZZLE_IMPORT};
+
+${getStringifiedCollectionExports(tables)}
+	`;
+}
+function getStringifiedCollectionExports(tables) {
+  return Object.entries(tables).map(
+    ([name, collection]) => `export const ${name} = collectionToTable(${JSON.stringify(name)}, ${JSON.stringify(
+      collection
+    )}, false)`
+  ).join("\n");
+}
+export {
+  getStudioVirtualModContents,
+  getVirtualModContents,
+  vitePluginDb
+};

package/dist/core/integration/vite-plugin-inject-env-ts.d.ts

@@ -0,0 +1,11 @@
+import type { VitePlugin } from '../utils.js';
+import type { AstroIntegrationLogger } from 'astro';
+export declare function vitePluginInjectEnvTs({ srcDir, root }: {
+    srcDir: URL;
+    root: URL;
+}, logger: AstroIntegrationLogger): VitePlugin;
+export declare function setUpEnvTs({ srcDir, root, logger, }: {
+    srcDir: URL;
+    root: URL;
+    logger: AstroIntegrationLogger;
+}): Promise<void>;

package/dist/core/integration/vite-plugin-inject-env-ts.js

@@ -0,0 +1,53 @@
+import { existsSync } from "node:fs";
+import { readFile, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { bold, cyan } from "kleur/colors";
+import { normalizePath } from "vite";
+import { DB_TYPES_FILE } from "../consts.js";
+function vitePluginInjectEnvTs({ srcDir, root }, logger) {
+  return {
+    name: "db-inject-env-ts",
+    enforce: "post",
+    async config() {
+      await setUpEnvTs({ srcDir, root, logger });
+    }
+  };
+}
+async function setUpEnvTs({
+  srcDir,
+  root,
+  logger
+}) {
+  const envTsPath = getEnvTsPath({ srcDir });
+  const envTsPathRelativetoRoot = normalizePath(
+    path.relative(fileURLToPath(root), fileURLToPath(envTsPath))
+  );
+  if (existsSync(envTsPath)) {
+    let typesEnvContents = await readFile(envTsPath, "utf-8");
+    const dotAstroDir = new URL(".astro/", root);
+    if (!existsSync(dotAstroDir))
+      return;
+    const dbTypeReference = getDBTypeReference({ srcDir, dotAstroDir });
+    if (!typesEnvContents.includes(dbTypeReference)) {
+      typesEnvContents = `${dbTypeReference}
+${typesEnvContents}`;
+      await writeFile(envTsPath, typesEnvContents, "utf-8");
+      logger.info(`${cyan(bold("[astro:db]"))} Added ${bold(envTsPathRelativetoRoot)} types`);
+    }
+  }
+}
+function getDBTypeReference({ srcDir, dotAstroDir }) {
+  const dbTypesFile = new URL(DB_TYPES_FILE, dotAstroDir);
+  const contentTypesRelativeToSrcDir = normalizePath(
+    path.relative(fileURLToPath(srcDir), fileURLToPath(dbTypesFile))
+  );
+  return `/// <reference path=${JSON.stringify(contentTypesRelativeToSrcDir)} />`;
+}
+function getEnvTsPath({ srcDir }) {
+  return new URL("env.d.ts", srcDir);
+}
+export {
+  setUpEnvTs,
+  vitePluginInjectEnvTs
+};