@astrojs/db 0.0.0-10646-20240402132948

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

@@ -0,0 +1,253 @@
+import type { AstroConfig } from 'astro';
+/**
+ * Load a user’s `astro:db` configuration file and additional configuration files provided by integrations.
+ */
+export declare function resolveDbConfig({ root, integrations, }: Pick<AstroConfig, 'root' | 'integrations'>): Promise<{
+    /** Resolved `astro:db` config, including tables added by integrations. */
+    dbConfig: {
+        tables: Record<string, {
+            indexes: Record<string, {
+                on: (string | string[]) & (string | string[] | undefined);
+                unique?: boolean | undefined;
+            }>;
+            deprecated: boolean;
+            columns: Record<string, {
+                type: "boolean";
+                schema: {
+                    optional: boolean;
+                    unique: boolean;
+                    deprecated: boolean;
+                    name?: string | undefined;
+                    label?: string | undefined;
+                    collection?: string | undefined;
+                    default?: boolean | import("../runtime/types.js").SerializedSQL | undefined;
+                };
+            } | {
+                type: "number";
+                schema: ({
+                    unique: boolean;
+                    deprecated: 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;
+                    deprecated: 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;
+                    deprecated: 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;
+                    deprecated: 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;
+                });
+            } | {
+                type: "date";
+                schema: {
+                    optional: boolean;
+                    unique: boolean;
+                    deprecated: boolean;
+                    name?: string | undefined;
+                    label?: string | undefined;
+                    collection?: string | undefined;
+                    default?: string | import("../runtime/types.js").SerializedSQL | undefined;
+                };
+            } | {
+                type: "json";
+                schema: {
+                    optional: boolean;
+                    unique: boolean;
+                    deprecated: boolean;
+                    name?: string | undefined;
+                    label?: string | undefined;
+                    collection?: string | undefined;
+                    default?: unknown;
+                };
+            }>;
+            foreignKeys?: (Omit<{
+                columns: import("./schemas.js").MaybeArray<string>;
+                references: () => import("./schemas.js").MaybeArray<Omit<{
+                    type: "number";
+                    schema: ({
+                        name?: string | undefined;
+                        label?: string | undefined;
+                        unique?: boolean | undefined;
+                        deprecated?: boolean | undefined;
+                        collection?: string | undefined;
+                    } & {
+                        primaryKey?: false | undefined;
+                        optional?: boolean | undefined;
+                        default?: number | import("drizzle-orm").SQL<any> | undefined;
+                    } & {
+                        references?: (() => any) | undefined;
+                    }) | ({
+                        name?: string | undefined;
+                        label?: string | undefined;
+                        unique?: boolean | undefined;
+                        deprecated?: 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;
+                        deprecated?: boolean | undefined;
+                        collection?: string | undefined;
+                        default?: string | import("drizzle-orm").SQL<any> | undefined;
+                        multiline?: boolean | undefined;
+                    } & {
+                        primaryKey?: false | undefined;
+                        optional?: boolean | undefined;
+                    } & {
+                        references?: (() => any) | undefined;
+                    }) | ({
+                        name?: string | undefined;
+                        label?: string | undefined;
+                        unique?: boolean | undefined;
+                        deprecated?: boolean | undefined;
+                        collection?: string | undefined;
+                        default?: string | import("drizzle-orm").SQL<any> | undefined;
+                        multiline?: boolean | undefined;
+                    } & {
+                        primaryKey: true;
+                        optional?: false | undefined;
+                    } & {
+                        references?: (() => any) | undefined;
+                    });
+                }, "references">>;
+            }, "references"> & {
+                references: import("./schemas.js").MaybeArray<Omit<{
+                    type: "number";
+                    schema: ({
+                        unique: boolean;
+                        deprecated: 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;
+                        deprecated: 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;
+                        deprecated: 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;
+                        deprecated: 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;
+                    });
+                }, "references">>;
+            })[] | undefined;
+        }>;
+    };
+    /** Dependencies imported into the user config file. */
+    dependencies: string[];
+    /** Additional `astro:db` seed file paths provided by integrations. */
+    integrationSeedPaths: (string | URL)[];
+}>;
+/**
+ * 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,170 @@
+import { existsSync } from "node:fs";
+import { unlink, writeFile } from "node:fs/promises";
+import { createRequire } from "node:module";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import { build as esbuild } from "esbuild";
+import { CONFIG_FILE_NAMES, VIRTUAL_MODULE_ID } from "./consts.js";
+import { INTEGRATION_TABLE_CONFLICT_ERROR } from "./errors.js";
+import { errorMap } from "./integration/error-map.js";
+import { getConfigVirtualModContents } from "./integration/vite-plugin-db.js";
+import { dbConfigSchema } from "./schemas.js";
+import {} from "./types.js";
+import { getDbDirectoryUrl } from "./utils.js";
+const isDbIntegration = (integration) => "astro:db:setup" in integration.hooks;
+async function resolveDbConfig({
+  root,
+  integrations
+}) {
+  const { mod, dependencies } = await loadUserConfigFile(root);
+  const userDbConfig = dbConfigSchema.parse(mod?.default ?? {}, { errorMap });
+  const dbConfig = { tables: userDbConfig.tables ?? {} };
+  const integrationDbConfigPaths = [];
+  const integrationSeedPaths = [];
+  for (const integration of integrations) {
+    if (!isDbIntegration(integration))
+      continue;
+    const { name, hooks } = integration;
+    if (hooks["astro:db:setup"]) {
+      hooks["astro:db:setup"]({
+        extendDb({ configEntrypoint, seedEntrypoint }) {
+          if (configEntrypoint) {
+            integrationDbConfigPaths.push({ name, configEntrypoint });
+          }
+          if (seedEntrypoint) {
+            integrationSeedPaths.push(seedEntrypoint);
+          }
+        }
+      });
+    }
+  }
+  for (const { name, configEntrypoint } of integrationDbConfigPaths) {
+    const loadedConfig = await loadIntegrationConfigFile(root, configEntrypoint);
+    const integrationDbConfig = dbConfigSchema.parse(loadedConfig.mod?.default ?? {}, {
+      errorMap
+    });
+    for (const key in integrationDbConfig.tables) {
+      if (key in dbConfig.tables) {
+        const isUserConflict = key in (userDbConfig.tables ?? {});
+        throw new Error(INTEGRATION_TABLE_CONFLICT_ERROR(name, key, isUserConflict));
+      } else {
+        dbConfig.tables[key] = integrationDbConfig.tables[key];
+      }
+    }
+  }
+  return {
+    /** Resolved `astro:db` config, including tables added by integrations. */
+    dbConfig,
+    /** Dependencies imported into the user config file. */
+    dependencies,
+    /** Additional `astro:db` seed file paths provided by integrations. */
+    integrationSeedPaths
+  };
+}
+async function loadUserConfigFile(root) {
+  let configFileUrl;
+  for (const fileName of CONFIG_FILE_NAMES) {
+    const fileUrl = new URL(fileName, getDbDirectoryUrl(root));
+    if (existsSync(fileUrl)) {
+      configFileUrl = fileUrl;
+    }
+  }
+  return await loadAndBundleDbConfigFile({ root, fileUrl: configFileUrl });
+}
+async function loadIntegrationConfigFile(root, filePathOrUrl) {
+  let fileUrl;
+  if (typeof filePathOrUrl === "string") {
+    const { resolve } = createRequire(root);
+    const resolvedFilePath = resolve(filePathOrUrl);
+    fileUrl = pathToFileURL(resolvedFilePath);
+  } else {
+    fileUrl = filePathOrUrl;
+  }
+  return await loadAndBundleDbConfigFile({ root, fileUrl });
+}
+async function loadAndBundleDbConfigFile({
+  root,
+  fileUrl
+}) {
+  if (!fileUrl) {
+    return { mod: void 0, dependencies: [] };
+  }
+  const { code, dependencies } = await bundleFile({
+    virtualModContents: getConfigVirtualModContents(),
+    root,
+    fileUrl
+  });
+  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,
+  resolveDbConfig
+};