@astrojs/db 0.1.0

package/dist/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/migrations.d.ts

@@ -0,0 +1,9 @@
+import type { DBCollections } from './types.js';
+export declare function getMigrations(): Promise<string[]>;
+export declare function loadMigration(migration: string): Promise<{
+    diff: any[];
+    db: string[];
+}>;
+export declare function loadInitialSnapshot(): Promise<DBCollections>;
+export declare function initializeMigrationsDirectory(currentSnapshot: unknown): Promise<void>;
+export declare function initializeFromMigrations(allMigrationFiles: string[]): Promise<DBCollections>;

package/dist/migrations.js

@@ -0,0 +1,41 @@
+import deepDiff from "deep-diff";
+import { mkdir, readFile, readdir, writeFile } from "fs/promises";
+const { applyChange } = deepDiff;
+async function getMigrations() {
+  const migrationFiles = await readdir("./migrations").catch((err) => {
+    if (err.code === "ENOENT") {
+      return [];
+    }
+    throw err;
+  });
+  return migrationFiles;
+}
+async function loadMigration(migration) {
+  return JSON.parse(await readFile(`./migrations/${migration}`, "utf-8"));
+}
+async function loadInitialSnapshot() {
+  return JSON.parse(await readFile("./migrations/0000_snapshot.json", "utf-8"));
+}
+async function initializeMigrationsDirectory(currentSnapshot) {
+  await mkdir("./migrations", { recursive: true });
+  await writeFile("./migrations/0000_snapshot.json", JSON.stringify(currentSnapshot, void 0, 2));
+}
+async function initializeFromMigrations(allMigrationFiles) {
+  const prevSnapshot = await loadInitialSnapshot();
+  for (const migration of allMigrationFiles) {
+    if (migration === "0000_snapshot.json")
+      continue;
+    const migrationContent = await loadMigration(migration);
+    migrationContent.diff.forEach((change) => {
+      applyChange(prevSnapshot, {}, change);
+    });
+  }
+  return prevSnapshot;
+}
+export {
+  getMigrations,
+  initializeFromMigrations,
+  initializeMigrationsDirectory,
+  loadInitialSnapshot,
+  loadMigration
+};

package/dist/typegen.d.ts

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

package/dist/typegen.js

@@ -0,0 +1,57 @@
+import { existsSync } from "node:fs";
+import { mkdir, writeFile } from "node:fs/promises";
+import { DB_TYPES_FILE, DRIZZLE_MOD_IMPORT, INTERNAL_MOD_IMPORT } from "./consts.js";
+async function typegen({ collections, root }) {
+  const content = `// This file is generated by \`studio sync\`
+declare module 'astro:db' {
+	export const db: import(${INTERNAL_MOD_IMPORT}).SqliteDB;
+	export * from ${DRIZZLE_MOD_IMPORT}
+
+${Object.entries(collections).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(${INTERNAL_MOD_IMPORT}).AstroTable<{
+		name: ${JSON.stringify(name)};
+		columns: {
+			id: import(${INTERNAL_MOD_IMPORT}).AstroId<{
+				tableName: ${JSON.stringify(name)};
+			}>;`;
+  for (const [fieldName, field] of Object.entries(collection.fields)) {
+    const drizzleInterface = schemaTypeToDrizzleInterface(field.type);
+    tableType += `
+			${fieldName}: import(${INTERNAL_MOD_IMPORT}).${drizzleInterface}<{
+				tableName: ${JSON.stringify(name)};
+				name: ${JSON.stringify(fieldName)};
+				notNull: ${field.optional ? "false" : "true"};
+				hasDefault: ${typeof field.default !== "undefined" ? "true" : "false"};
+			}>;`;
+  }
+  tableType += `
+		};
+	}>;`;
+  return tableType;
+}
+function schemaTypeToDrizzleInterface(type) {
+  switch (type) {
+    case "text":
+      return "AstroText";
+    case "number":
+      return "AstroNumber";
+    case "boolean":
+      return "AstroBoolean";
+    case "date":
+      return "AstroDate";
+    case "json":
+      return "AstroJson";
+  }
+}
+export {
+  typegen
+};