@astrojs/db 0.0.0-db-export-bug-20240307130354

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

@@ -0,0 +1,81 @@
+import fs from "node:fs";
+import path from "node:path";
+import { pathToFileURL } from "node:url";
+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);
+          await fs.promises.rmdir(assetDir).catch(() => []);
+        } 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,112 @@
+import { existsSync } from "fs";
+import { dirname } from "path";
+import { fileURLToPath } from "url";
+import { mkdir, rm, writeFile } from "fs/promises";
+import { blue, yellow } from "kleur/colors";
+import { CONFIG_FILE_NAMES, DB_PATH } from "../consts.js";
+import { loadDbConfigFile } from "../load-file.js";
+import { getManagedAppTokenOrExit } from "../tokens.js";
+import { dbConfigSchema } from "../types.js";
+import { getDbDirectoryUrl } from "../utils.js";
+import { errorMap } from "./error-map.js";
+import { fileURLIntegration } from "./file-url.js";
+import { typegen } from "./typegen.js";
+import { vitePluginDb } from "./vite-plugin-db.js";
+import { vitePluginInjectEnvTs } from "./vite-plugin-inject-env-ts.js";
+function astroDBIntegration() {
+  let connectToStudio = false;
+  let configFileDependencies = [];
+  let root;
+  let appToken;
+  let dbConfig;
+  let tables = {
+    get() {
+      throw new Error("[astro:db] INTERNAL Tables not loaded yet");
+    }
+  };
+  let command;
+  return {
+    name: "astro:db",
+    hooks: {
+      "astro:config:setup": async ({ updateConfig, config, command: _command, logger }) => {
+        command = _command;
+        root = config.root;
+        if (command === "preview")
+          return;
+        let dbPlugin = void 0;
+        connectToStudio = command === "build";
+        if (connectToStudio) {
+          appToken = await getManagedAppTokenOrExit();
+          dbPlugin = vitePluginDb({
+            connectToStudio,
+            appToken: appToken.token,
+            tables,
+            root: config.root,
+            srcDir: config.srcDir
+          });
+        } else {
+          dbPlugin = vitePluginDb({
+            connectToStudio: false,
+            tables,
+            root: config.root,
+            srcDir: config.srcDir
+          });
+        }
+        updateConfig({
+          vite: {
+            assetsInclude: [DB_PATH],
+            plugins: [dbPlugin, vitePluginInjectEnvTs(config, logger)]
+          }
+        });
+      },
+      "astro:config:done": async ({ config }) => {
+        const { mod, dependencies } = await loadDbConfigFile(config.root);
+        configFileDependencies = dependencies;
+        dbConfig = dbConfigSchema.parse(mod?.default ?? {}, {
+          errorMap
+        });
+        tables.get = () => dbConfig.tables ?? {};
+        if (!connectToStudio && !process.env.TEST_IN_MEMORY_DB) {
+          const dbUrl = new URL(DB_PATH, config.root);
+          if (existsSync(dbUrl)) {
+            await rm(dbUrl);
+          }
+          await mkdir(dirname(fileURLToPath(dbUrl)), { recursive: true });
+          await writeFile(dbUrl, "");
+        }
+        await typegen({ tables: tables.get() ?? {}, root: config.root });
+      },
+      "astro:server:start": async ({ logger }) => {
+        setTimeout(() => {
+          logger.info(
+            connectToStudio ? "Connected to remote database." : "New local database created."
+          );
+        }, 100);
+      },
+      "astro:server:setup": async ({ server }) => {
+        const filesToWatch = [
+          ...CONFIG_FILE_NAMES.map((c) => new URL(c, getDbDirectoryUrl(root))),
+          ...configFileDependencies.map((c) => new URL(c, root))
+        ];
+        server.watcher.on("all", (event, relativeEntry) => {
+          const entry = new URL(relativeEntry, root);
+          if (filesToWatch.some((f) => entry.href === f.href)) {
+            server.restart();
+          }
+        });
+      },
+      "astro:build:start": async ({ logger }) => {
+        logger.info("database: " + (connectToStudio ? yellow("remote") : blue("local database.")));
+      },
+      "astro:build:done": async ({}) => {
+        await appToken?.destroy();
+      }
+    }
+  };
+}
+function integration() {
+  return [astroDBIntegration(), fileURLIntegration()];
+}
+export {
+  integration
+};

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,31 @@
+import { existsSync } from "node:fs";
+import { mkdir, writeFile } from "node:fs/promises";
+import { DB_TYPES_FILE, RUNTIME_CONFIG_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_CONFIG_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) {
+  const sanitizedColumnsList = Object.entries(collection.columns).filter(([key, val]) => !val.schema.deprecated);
+  const sanitizedColumns = Object.fromEntries(sanitizedColumnsList);
+  let tableType = `	export const ${name}: import(${RUNTIME_IMPORT}).Table<
+		${JSON.stringify(name)},
+		${JSON.stringify(sanitizedColumns)}
+	>;`;
+  return tableType;
+}
+export {
+  typegen
+};

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

@@ -0,0 +1,29 @@
+import type { DBTables } from '../types.js';
+import { type VitePlugin } from '../utils.js';
+export type LateTables = {
+    get: () => DBTables;
+};
+type VitePluginDBParams = {
+    connectToStudio: false;
+    tables: LateTables;
+    srcDir: URL;
+    root: URL;
+} | {
+    connectToStudio: true;
+    tables: LateTables;
+    appToken: string;
+    srcDir: URL;
+    root: URL;
+};
+export declare function vitePluginDb(params: VitePluginDBParams): VitePlugin;
+export declare function getConfigVirtualModContents(): string;
+export declare function getLocalVirtualModContents({ tables, shouldSeed, }: {
+    tables: DBTables;
+    root: URL;
+    shouldSeed: boolean;
+}): string;
+export declare function getStudioVirtualModContents({ tables, appToken, }: {
+    tables: DBTables;
+    appToken: string;
+}): string;
+export {};

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

@@ -0,0 +1,111 @@
+import { fileURLToPath } from "node:url";
+import { normalizePath } from "vite";
+import { SEED_DEV_FILE_NAME } from "../../runtime/queries.js";
+import { DB_PATH, RUNTIME_CONFIG_IMPORT, RUNTIME_IMPORT, VIRTUAL_MODULE_ID } from "../consts.js";
+import { getDbDirectoryUrl, getRemoteDatabaseUrl } from "../utils.js";
+const LOCAL_DB_VIRTUAL_MODULE_ID = "astro:local";
+const resolvedVirtualModuleId = "\0" + VIRTUAL_MODULE_ID;
+const resolvedLocalDbVirtualModuleId = LOCAL_DB_VIRTUAL_MODULE_ID + "/local-db";
+const resolvedSeedVirtualModuleId = "\0" + VIRTUAL_MODULE_ID + "?shouldSeed";
+function vitePluginDb(params) {
+  const srcDirPath = normalizePath(fileURLToPath(params.srcDir));
+  return {
+    name: "astro:db",
+    enforce: "pre",
+    async resolveId(id, rawImporter) {
+      if (id === LOCAL_DB_VIRTUAL_MODULE_ID)
+        return resolvedLocalDbVirtualModuleId;
+      if (id !== VIRTUAL_MODULE_ID)
+        return;
+      if (params.connectToStudio)
+        return resolvedVirtualModuleId;
+      const importer = rawImporter ? await this.resolve(rawImporter) : null;
+      if (!importer)
+        return resolvedVirtualModuleId;
+      if (importer.id.startsWith(srcDirPath)) {
+        return resolvedSeedVirtualModuleId;
+      }
+      return resolvedVirtualModuleId;
+    },
+    load(id) {
+      if (id === resolvedLocalDbVirtualModuleId) {
+        const dbUrl = new URL(DB_PATH, params.root);
+        return `import { createLocalDatabaseClient } from ${RUNTIME_IMPORT};
+				const dbUrl = ${JSON.stringify(dbUrl)};
+
+				export const db = createLocalDatabaseClient({ dbUrl });`;
+      }
+      if (id !== resolvedVirtualModuleId && id !== resolvedSeedVirtualModuleId)
+        return;
+      if (params.connectToStudio) {
+        return getStudioVirtualModContents({
+          appToken: params.appToken,
+          tables: params.tables.get()
+        });
+      }
+      return getLocalVirtualModContents({
+        root: params.root,
+        tables: params.tables.get(),
+        shouldSeed: id === resolvedSeedVirtualModuleId
+      });
+    }
+  };
+}
+function getConfigVirtualModContents() {
+  return `export * from ${RUNTIME_CONFIG_IMPORT}`;
+}
+function getLocalVirtualModContents({
+  tables,
+  shouldSeed
+}) {
+  const seedFilePaths = SEED_DEV_FILE_NAME.map(
+    // Format as /db/[name].ts
+    // for Vite import.meta.glob
+    (name) => new URL(name, getDbDirectoryUrl("file:///")).pathname
+  );
+  return `
+import { asDrizzleTable, seedLocal } from ${RUNTIME_IMPORT};
+import { db as _db } from ${JSON.stringify(LOCAL_DB_VIRTUAL_MODULE_ID)};
+
+export const db = _db;
+
+${shouldSeed ? `await seedLocal({
+	db: _db,
+	tables: ${JSON.stringify(tables)},
+	fileGlob: import.meta.glob(${JSON.stringify(seedFilePaths)}),
+})` : ""}
+
+export * from ${RUNTIME_CONFIG_IMPORT};
+
+${getStringifiedCollectionExports(tables)}`;
+}
+function getStudioVirtualModContents({
+  tables,
+  appToken
+}) {
+  return `
+import {asDrizzleTable, createRemoteDatabaseClient} from ${RUNTIME_IMPORT};
+
+export const db = await createRemoteDatabaseClient(${JSON.stringify(
+    appToken
+    // Respect runtime env for user overrides in SSR
+  )}, import.meta.env.ASTRO_STUDIO_REMOTE_DB_URL ?? ${JSON.stringify(getRemoteDatabaseUrl())});
+
+export * from ${RUNTIME_CONFIG_IMPORT};
+
+${getStringifiedCollectionExports(tables)}
+	`;
+}
+function getStringifiedCollectionExports(tables) {
+  return Object.entries(tables).map(
+    ([name, collection]) => `export const ${name} = asDrizzleTable(${JSON.stringify(name)}, ${JSON.stringify(
+      collection
+    )}, false)`
+  ).join("\n");
+}
+export {
+  getConfigVirtualModContents,
+  getLocalVirtualModContents,
+  getStudioVirtualModContents,
+  vitePluginDb
+};

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

@@ -0,0 +1,11 @@
+import type { AstroIntegrationLogger } from 'astro';
+import type { VitePlugin } from '../utils.js';
+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
+};

package/dist/core/load-file.d.ts

@@ -0,0 +1,31 @@
+export declare function loadDbConfigFile(root: URL): Promise<{
+    mod: {
+        default?: unknown;
+    } | undefined;
+    dependencies: string[];
+}>;
+/**
+ * Bundle arbitrary `mjs` or `ts` file.
+ * Simplified fork from Vite's `bundleConfigFile` function.
+ *
+ * @see https://github.com/vitejs/vite/blob/main/packages/vite/src/node/config.ts#L961
+ */
+export declare function bundleFile({ fileUrl, root, virtualModContents, }: {
+    fileUrl: URL;
+    root: URL;
+    virtualModContents: string;
+}): Promise<{
+    code: string;
+    dependencies: string[];
+}>;
+/**
+ * Forked from Vite config loader, replacing CJS-based path concat with ESM only
+ *
+ * @see https://github.com/vitejs/vite/blob/main/packages/vite/src/node/config.ts#L1074
+ */
+export declare function importBundledFile({ code, root, }: {
+    code: string;
+    root: URL;
+}): Promise<{
+    default?: unknown;
+}>;

package/dist/core/load-file.js

@@ -0,0 +1,98 @@
+import { existsSync } from "node:fs";
+import { unlink, writeFile } from "node:fs/promises";
+import { fileURLToPath } from "node:url";
+import { build as esbuild } from "esbuild";
+import { CONFIG_FILE_NAMES, VIRTUAL_MODULE_ID } from "./consts.js";
+import { getConfigVirtualModContents } from "./integration/vite-plugin-db.js";
+import { getDbDirectoryUrl } from "./utils.js";
+async function loadDbConfigFile(root) {
+  let configFileUrl;
+  for (const fileName of CONFIG_FILE_NAMES) {
+    const fileUrl = new URL(fileName, getDbDirectoryUrl(root));
+    if (existsSync(fileUrl)) {
+      configFileUrl = fileUrl;
+    }
+  }
+  if (!configFileUrl) {
+    return { mod: void 0, dependencies: [] };
+  }
+  const { code, dependencies } = await bundleFile({
+    virtualModContents: getConfigVirtualModContents(),
+    root,
+    fileUrl: configFileUrl
+  });
+  return {
+    mod: await importBundledFile({ code, root }),
+    dependencies
+  };
+}
+async function bundleFile({
+  fileUrl,
+  root,
+  virtualModContents
+}) {
+  const result = await esbuild({
+    absWorkingDir: process.cwd(),
+    entryPoints: [fileURLToPath(fileUrl)],
+    outfile: "out.js",
+    packages: "external",
+    write: false,
+    target: ["node16"],
+    platform: "node",
+    bundle: true,
+    format: "esm",
+    sourcemap: "inline",
+    metafile: true,
+    define: {
+      "import.meta.env.ASTRO_STUDIO_REMOTE_DB_URL": "undefined"
+    },
+    plugins: [
+      {
+        name: "resolve-astro-db",
+        setup(build) {
+          build.onResolve({ filter: /^astro:db$/ }, ({ path }) => {
+            return { path, namespace: VIRTUAL_MODULE_ID };
+          });
+          build.onLoad({ namespace: VIRTUAL_MODULE_ID, filter: /.*/ }, () => {
+            return {
+              contents: virtualModContents,
+              // Needed to resolve runtime dependencies
+              resolveDir: fileURLToPath(root)
+            };
+          });
+        }
+      }
+    ]
+  });
+  const file = result.outputFiles[0];
+  if (!file) {
+    throw new Error(`Unexpected: no output file`);
+  }
+  return {
+    code: file.text,
+    dependencies: Object.keys(result.metafile.inputs)
+  };
+}
+async function importBundledFile({
+  code,
+  root
+}) {
+  const tmpFileUrl = new URL(`./db.timestamp-${Date.now()}.mjs`, root);
+  await writeFile(tmpFileUrl, code, { encoding: "utf8" });
+  try {
+    return await import(
+      /* @vite-ignore */
+      tmpFileUrl.toString()
+    );
+  } finally {
+    try {
+      await unlink(tmpFileUrl);
+    } catch {
+    }
+  }
+}
+export {
+  bundleFile,
+  importBundledFile,
+  loadDbConfigFile
+};

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