@graphenedata/cli 0.0.15 → 0.0.16

package/dist/cli/clickhouse-ZN5AN2UL.js

@@ -0,0 +1,64 @@
+// connections/clickhouse.ts
+import { createClient } from "@clickhouse/client";
+var ClickHouseConnection = class {
+  client;
+  defaultDatabase;
+  constructor(options) {
+    this.defaultDatabase = options.database || "default";
+    this.client = createClient({
+      url: options.url,
+      username: options.username,
+      password: options.password,
+      database: this.defaultDatabase,
+      application: "Graphene"
+    });
+  }
+  async runQuery(sql, _params) {
+    let result = await this.client.query({ query: sql, format: "JSONEachRow" });
+    let rows = await result.json();
+    return { rows, totalRows: rows.length };
+  }
+  async listDatasets() {
+    let res = await this.runQuery(`
+      select name
+      from system.databases
+      where lower(name) not in ('system', 'information_schema')
+      order by name
+    `);
+    return res.rows.map((row) => String(row["name"]).toLowerCase());
+  }
+  async listTables(database = this.defaultDatabase) {
+    let sql = `
+      select database, name
+      from system.tables
+      where lower(database) = lower('${escapeClickHouseString(database)}')
+      order by name
+    `.trim();
+    let res = await this.runQuery(sql);
+    return res.rows.map((row) => `${String(row["database"]).toLowerCase()}.${String(row["name"]).toLowerCase()}`);
+  }
+  async describeTable(target) {
+    let parts = target.split(".").filter(Boolean);
+    let table = parts.pop() || "";
+    let database = parts.join(".") || this.defaultDatabase;
+    let sql = `
+      select name, type, position
+      from system.columns
+      where lower(database) = lower('${escapeClickHouseString(database)}')
+        and lower(table) = lower('${escapeClickHouseString(table)}')
+      order by position
+    `.trim();
+    let res = await this.runQuery(sql);
+    return res.rows.map((row) => ({ name: String(row["name"]).toLowerCase(), dataType: String(row["type"]) }));
+  }
+  async close() {
+    await this.client.close();
+  }
+};
+function escapeClickHouseString(value) {
+  return value.replace(/\\/g, "\\\\").replace(/'/g, "\\'");
+}
+export {
+  ClickHouseConnection
+};
+//# sourceMappingURL=clickhouse-ZN5AN2UL.js.map

package/dist/cli/clickhouse-ZN5AN2UL.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../connections/clickhouse.ts"],
+  "sourcesContent": ["import {createClient, type ClickHouseClient} from '@clickhouse/client'\n\nimport {type QueryConnection, type QueryResult, type QueryParams, type SchemaColumn} from './types.ts'\n\nexport interface ClickHouseOptions {\n  url: string\n  username: string\n  password: string\n  database?: string\n}\n\nexport class ClickHouseConnection implements QueryConnection {\n  private client: ClickHouseClient\n  private defaultDatabase: string\n\n  constructor(options: ClickHouseOptions) {\n    this.defaultDatabase = options.database || 'default'\n    this.client = createClient({\n      url: options.url,\n      username: options.username,\n      password: options.password,\n      database: this.defaultDatabase,\n      application: 'Graphene',\n    })\n  }\n\n  async runQuery(sql: string, _params?: QueryParams): Promise<QueryResult> {\n    let result = await this.client.query({query: sql, format: 'JSONEachRow'})\n    let rows = (await result.json()) as Array<Record<string, unknown>>\n    return {rows, totalRows: rows.length}\n  }\n\n  async listDatasets(): Promise<string[]> {\n    let res = await this.runQuery(`\n      select name\n      from system.databases\n      where lower(name) not in ('system', 'information_schema')\n      order by name\n    `)\n    return res.rows.map(row => String(row['name']).toLowerCase())\n  }\n\n  async listTables(database = this.defaultDatabase): Promise<string[]> {\n    let sql = `\n      select database, name\n      from system.tables\n      where lower(database) = lower('${escapeClickHouseString(database)}')\n      order by name\n    `.trim()\n    let res = await this.runQuery(sql)\n    return res.rows.map(row => `${String(row['database']).toLowerCase()}.${String(row['name']).toLowerCase()}`)\n  }\n\n  async describeTable(target: string): Promise<SchemaColumn[]> {\n    let parts = target.split('.').filter(Boolean)\n    let table = parts.pop() || ''\n    let database = parts.join('.') || this.defaultDatabase\n    let sql = `\n      select name, type, position\n      from system.columns\n      where lower(database) = lower('${escapeClickHouseString(database)}')\n        and lower(table) = lower('${escapeClickHouseString(table)}')\n      order by position\n    `.trim()\n    let res = await this.runQuery(sql)\n    return res.rows.map(row => ({name: String(row['name']).toLowerCase(), dataType: String(row['type'])}))\n  }\n\n  async close(): Promise<void> {\n    await this.client.close()\n  }\n}\n\nfunction escapeClickHouseString(value: string) {\n  return value.replace(/\\\\/g, '\\\\\\\\').replace(/'/g, \"\\\\'\")\n}\n"],
+  "mappings": ";AAAA,SAAQ,oBAA0C;AAW3C,IAAM,uBAAN,MAAsD;AAAA,EACnD;AAAA,EACA;AAAA,EAER,YAAY,SAA4B;AACtC,SAAK,kBAAkB,QAAQ,YAAY;AAC3C,SAAK,SAAS,aAAa;AAAA,MACzB,KAAK,QAAQ;AAAA,MACb,UAAU,QAAQ;AAAA,MAClB,UAAU,QAAQ;AAAA,MAClB,UAAU,KAAK;AAAA,MACf,aAAa;AAAA,IACf,CAAC;AAAA,EACH;AAAA,EAEA,MAAM,SAAS,KAAa,SAA6C;AACvE,QAAI,SAAS,MAAM,KAAK,OAAO,MAAM,EAAC,OAAO,KAAK,QAAQ,cAAa,CAAC;AACxE,QAAI,OAAQ,MAAM,OAAO,KAAK;AAC9B,WAAO,EAAC,MAAM,WAAW,KAAK,OAAM;AAAA,EACtC;AAAA,EAEA,MAAM,eAAkC;AACtC,QAAI,MAAM,MAAM,KAAK,SAAS;AAAA;AAAA;AAAA;AAAA;AAAA,KAK7B;AACD,WAAO,IAAI,KAAK,IAAI,SAAO,OAAO,IAAI,MAAM,CAAC,EAAE,YAAY,CAAC;AAAA,EAC9D;AAAA,EAEA,MAAM,WAAW,WAAW,KAAK,iBAAoC;AACnE,QAAI,MAAM;AAAA;AAAA;AAAA,uCAGyB,uBAAuB,QAAQ,CAAC;AAAA;AAAA,MAEjE,KAAK;AACP,QAAI,MAAM,MAAM,KAAK,SAAS,GAAG;AACjC,WAAO,IAAI,KAAK,IAAI,SAAO,GAAG,OAAO,IAAI,UAAU,CAAC,EAAE,YAAY,CAAC,IAAI,OAAO,IAAI,MAAM,CAAC,EAAE,YAAY,CAAC,EAAE;AAAA,EAC5G;AAAA,EAEA,MAAM,cAAc,QAAyC;AAC3D,QAAI,QAAQ,OAAO,MAAM,GAAG,EAAE,OAAO,OAAO;AAC5C,QAAI,QAAQ,MAAM,IAAI,KAAK;AAC3B,QAAI,WAAW,MAAM,KAAK,GAAG,KAAK,KAAK;AACvC,QAAI,MAAM;AAAA;AAAA;AAAA,uCAGyB,uBAAuB,QAAQ,CAAC;AAAA,oCACnC,uBAAuB,KAAK,CAAC;AAAA;AAAA,MAE3D,KAAK;AACP,QAAI,MAAM,MAAM,KAAK,SAAS,GAAG;AACjC,WAAO,IAAI,KAAK,IAAI,UAAQ,EAAC,MAAM,OAAO,IAAI,MAAM,CAAC,EAAE,YAAY,GAAG,UAAU,OAAO,IAAI,MAAM,CAAC,EAAC,EAAE;AAAA,EACvG;AAAA,EAEA,MAAM,QAAuB;AAC3B,UAAM,KAAK,OAAO,MAAM;AAAA,EAC1B;AACF;AAEA,SAAS,uBAAuB,OAAe;AAC7C,SAAO,MAAM,QAAQ,OAAO,MAAM,EAAE,QAAQ,MAAM,KAAK;AACzD;",
+  "names": []
+}

package/dist/cli/duckdb-IYBIO5KJ.js

@@ -0,0 +1,87 @@
+import {
+  config
+} from "./chunk-QAXEOZ43.js";
+
+// connections/duckdb.ts
+import { DuckDBTimestampValue, DuckDBInstance, DuckDBDateValue, DuckDBDecimalValue } from "@duckdb/node-api";
+import { promises as fs } from "fs";
+import path from "path";
+var DuckDBConnection = class {
+  options;
+  ready;
+  connection = null;
+  constructor(options) {
+    this.options = options || {};
+    this.ready = this.initialize();
+  }
+  async initialize() {
+    let dbPath = this.options.path || config.duckdb?.path;
+    if (!dbPath) {
+      let files = await fs.readdir(config.root);
+      dbPath = files.find((f) => f.endsWith(".duckdb"));
+      if (!dbPath) throw new Error("No .duckdb file found in current directory");
+    }
+    if (!path.isAbsolute(dbPath)) dbPath = path.resolve(config.root, dbPath);
+    let db = await DuckDBInstance.create(":memory:");
+    this.connection = await db.connect();
+    let escapedPath = dbPath.replace(/'/g, "''");
+    await this.connection.run(`attach '${escapedPath}' as graphene_cli (READ_ONLY);`);
+    await this.connection.run("use graphene_cli;");
+  }
+  async runQuery(sql, params) {
+    await this.ready;
+    let reader = params ? await this.connection.runAndReadAll(sql, params) : await this.connection.runAndReadAll(sql);
+    let rows = reader.getRowObjects().map((record) => {
+      let out = {};
+      for (let [k, v] of Object.entries(record)) {
+        if (typeof v === "bigint") out[k] = Number(v);
+        else if (v === null) out[k] = null;
+        else if (v instanceof DuckDBTimestampValue) out[k] = new Date(Number(v.micros / 1000n)).toUTCString();
+        else if (v instanceof DuckDBDateValue) out[k] = v.toString();
+        else if (v instanceof DuckDBDecimalValue) out[k] = v.toDouble();
+        else if (typeof v === "object") throw new Error(`Unsupported datatype ${v.constructor?.name}`);
+        else out[k] = v;
+      }
+      return out;
+    });
+    return { rows };
+  }
+  async listDatasets() {
+    return await Promise.resolve([]);
+  }
+  async listTables() {
+    let sql = `
+      select table_schema as table_schema, table_name as table_name
+      from information_schema.tables
+      where table_type in ('BASE TABLE', 'VIEW') and table_schema not in ('information_schema', 'pg_catalog')
+      order by table_schema, table_name
+    `.trim();
+    let res = await this.runQuery(sql);
+    return res.rows.map((row) => String(row["table_name"]).toLowerCase());
+  }
+  async describeTable(target) {
+    let parts = target.split(".");
+    let table = parts.pop() || "";
+    let schema = parts[0];
+    let schemaFilter = schema ? "lower(table_schema) = lower($2)" : "table_schema not in ('information_schema', 'pg_catalog')";
+    let sql = `
+      select column_name as column_name, data_type as data_type, ordinal_position as ordinal_position
+      from information_schema.columns
+      where lower(table_name) = lower($1) and ${schemaFilter}
+      order by ordinal_position
+    `.trim();
+    let params = schema ? [table, schema] : [table];
+    let res = await this.runQuery(sql, params);
+    return res.rows.map((row) => {
+      return { name: String(row["column_name"]).toLowerCase(), dataType: String(row["data_type"]) };
+    });
+  }
+  async close() {
+    await this.ready;
+    this.connection?.closeSync();
+  }
+};
+export {
+  DuckDBConnection
+};
+//# sourceMappingURL=duckdb-IYBIO5KJ.js.map

package/dist/cli/duckdb-IYBIO5KJ.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../connections/duckdb.ts"],
+  "sourcesContent": ["import {DuckDBTimestampValue, DuckDBInstance, DuckDBDateValue, DuckDBDecimalValue, type DuckDBConnection as InnerConnection} from '@duckdb/node-api'\nimport {promises as fs} from 'fs'\nimport path from 'path'\n\nimport {config} from '../../lang/config.ts'\nimport {type QueryResult, type QueryConnection, type SchemaColumn, type QueryParams} from './types.ts'\n\ninterface DuckDbOptions {\n  path?: string\n}\n\nexport class DuckDBConnection implements QueryConnection {\n  options: DuckDbOptions\n  ready: Promise<void>\n  connection: InnerConnection | null = null\n\n  constructor(options?: DuckDbOptions) {\n    this.options = options || {}\n    this.ready = this.initialize()\n  }\n\n  private async initialize() {\n    let dbPath = this.options.path || config.duckdb?.path\n    if (!dbPath) {\n      let files = await fs.readdir(config.root)\n      dbPath = files.find(f => f.endsWith('.duckdb'))\n      if (!dbPath) throw new Error('No .duckdb file found in current directory')\n    }\n    if (!path.isAbsolute(dbPath)) dbPath = path.resolve(config.root, dbPath)\n\n    let db = await DuckDBInstance.create(':memory:')\n    this.connection = await db.connect()\n    let escapedPath = dbPath.replace(/'/g, \"''\")\n    // Attach the project DuckDB file in read-only mode and make it the active schema\n    await this.connection.run(`attach '${escapedPath}' as graphene_cli (READ_ONLY);`)\n    await this.connection.run('use graphene_cli;')\n  }\n\n  async runQuery(sql: string, params?: QueryParams): Promise<QueryResult> {\n    await this.ready\n    let reader = params ? await this.connection!.runAndReadAll(sql, params as any) : await this.connection!.runAndReadAll(sql)\n    let rows = reader.getRowObjects().map(record => {\n      let out: Record<string, unknown> = {}\n      for (let [k, v] of Object.entries(record)) {\n        if (typeof v === 'bigint') out[k] = Number(v)\n        else if (v === null) out[k] = null\n        else if (v instanceof DuckDBTimestampValue) out[k] = new Date(Number(v.micros / 1000n)).toUTCString()\n        else if (v instanceof DuckDBDateValue) out[k] = v.toString()\n        else if (v instanceof DuckDBDecimalValue) out[k] = v.toDouble()\n        else if (typeof v === 'object') throw new Error(`Unsupported datatype ${v.constructor?.name}`)\n        else out[k] = v\n      }\n      return out\n    })\n    return {rows}\n  }\n\n  async listDatasets(): Promise<string[]> {\n    return await Promise.resolve([])\n  }\n\n  async listTables(): Promise<string[]> {\n    let sql = `\n      select table_schema as table_schema, table_name as table_name\n      from information_schema.tables\n      where table_type in ('BASE TABLE', 'VIEW') and table_schema not in ('information_schema', 'pg_catalog')\n      order by table_schema, table_name\n    `.trim()\n    let res = await this.runQuery(sql)\n    return res.rows.map(row => String(row['table_name']).toLowerCase())\n  }\n\n  async describeTable(target: string): Promise<SchemaColumn[]> {\n    let parts = target.split('.')\n    let table = parts.pop() || ''\n    let schema = parts[0]\n    let schemaFilter = schema ? 'lower(table_schema) = lower($2)' : \"table_schema not in ('information_schema', 'pg_catalog')\"\n    let sql = `\n      select column_name as column_name, data_type as data_type, ordinal_position as ordinal_position\n      from information_schema.columns\n      where lower(table_name) = lower($1) and ${schemaFilter}\n      order by ordinal_position\n    `.trim()\n    let params = schema ? [table, schema] : [table]\n    let res = await this.runQuery(sql, params)\n    return res.rows.map(row => {\n      return {name: String(row['column_name']).toLowerCase(), dataType: String(row['data_type'])}\n    })\n  }\n\n  async close(): Promise<void> {\n    await this.ready\n    this.connection?.closeSync()\n  }\n}\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/cli/serve2-TNN5EROW.js

@@ -0,0 +1,447 @@
+import {
+  analyzeWorkspace,
+  getWorkspaceScanCounts,
+  loadWorkspace,
+  mockFileMap,
+  runQuery,
+  runVitePlugin,
+  toSql
+} from "./chunk-OVWODUTJ.js";
+import {
+  config
+} from "./chunk-QAXEOZ43.js";
+
+// serve2.ts
+import { svelte, vitePreprocess } from "@sveltejs/vite-plugin-svelte";
+import crypto from "crypto";
+import fs2 from "fs-extra";
+import { mdsvex } from "mdsvex";
+import { createRequire } from "module";
+import path2 from "path";
+import { fileURLToPath } from "url";
+import { createServer, optimizeDeps, resolveConfig } from "vite";
+
+// mdCompile.ts
+import { decodeHTML } from "entities";
+import fs from "fs";
+import yaml from "js-yaml";
+import JSON5 from "json5";
+import path from "path";
+import sanitizeHtml from "sanitize-html";
+import { visit } from "unist-util-visit";
+function escapeHtml(str) {
+  return str.replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+function liftInlineEChartsConfig(content) {
+  return content.replace(/<ECharts\b([^>]*)>([\s\S]*?)<\/ECharts>/g, (match, attrs = "", body = "") => {
+    let inline = body.trim();
+    if (!inline) return match;
+    if (/\sconfig\s*=/.test(attrs)) return match;
+    let source = inline.startsWith("{") ? inline : `{${inline}}`;
+    let config2 = JSON.stringify(JSON5.parse(source), (_key, value) => typeof value == "string" ? decodeHTML(value) : value);
+    return `<ECharts${attrs} config={${config2}}></ECharts>`;
+  });
+}
+function extractQueries() {
+  return function transformer(tree) {
+    visit(tree, "code", (node, index, parent) => {
+      if (index === null) return;
+      let name = typeof node.meta === "string" ? node.meta : "";
+      let code = typeof node.value === "string" ? node.value.trim() : "";
+      parent.children[index] = { type: "html", value: `<GrapheneQuery name="${escapeHtml(name)}" code="${escapeHtml(code)}" />` };
+    });
+  };
+}
+function escapeAngles() {
+  return function transformer(tree) {
+    visit(tree, "text", (node) => {
+      if (!node.value || typeof node.value !== "string") return;
+      if (!node.value.includes("<")) return;
+      node.value = node.value.replace(/</g, "&lt;");
+    });
+  };
+}
+function mergeAdjacentHtml() {
+  return function transformer(tree) {
+    visit(tree, (parent) => {
+      if (!Array.isArray(parent?.children)) return;
+      for (let i = 0; i < parent.children.length; i++) {
+        if (parent.children[i]?.type !== "html") continue;
+        let j = i;
+        while (j + 1 < parent.children.length && parent.children[j + 1]?.type === "html") j++;
+        if (j == i) continue;
+        let value = parent.children.slice(i, j + 1).map((node) => node.value || "").join("\n");
+        parent.children.splice(i, j - i + 1, { type: "html", value });
+      }
+    });
+  };
+}
+function sanitizeMarkdown() {
+  return function transformer(tree) {
+    visit(tree, "raw", (node) => {
+      if (typeof node.value !== "string") return;
+      let expanded = node.value.replace(/<(\w+)((?:\s[^<>]*?)?)\s*\/>/gi, (_, name, attrs = "") => {
+        let spacing = attrs;
+        return `<${name}${spacing}></${name}>`;
+      });
+      let sanitized = sanitizeHtml(expanded, {
+        ...sanitizeHtml.defaults,
+        allowedTags: [...sanitizeHtml.defaults.allowedTags, ...componentNames()],
+        allowedAttributes: {
+          ...sanitizeHtml.defaults.allowedAttributes,
+          ...Object.fromEntries(componentNames().map((n) => [n, ["*"]]))
+        },
+        parser: {
+          ...sanitizeHtml.defaults.parser || {},
+          lowerCaseAttributeNames: false,
+          lowerCaseTags: false
+        }
+      });
+      node.value = sanitized;
+    });
+  };
+}
+function injectComponentImports() {
+  let imp = `const {${componentNames().join(", ")}} = window.$GRAPHENE.components`;
+  return {
+    markup: ({ content, filename }) => {
+      if (!filename.endsWith(".md")) return;
+      content = liftInlineEChartsConfig(content);
+      if (content.includes("<script>")) {
+        content = content.replace("<script>", `<script>
+${imp}`);
+      } else {
+        content = `<script>
+${imp}
+</script>
+${content}`;
+      }
+      return { code: content };
+    },
+    style: () => {
+    },
+    script: () => {
+    }
+  };
+}
+var cachedComponentNames = null;
+function componentNames() {
+  if (cachedComponentNames) return cachedComponentNames;
+  let files = fs.readdirSync(path.join(import.meta.dirname, "../ui/components"));
+  cachedComponentNames = files.map((f) => path.basename(f, ".svelte")).filter((f) => !f.startsWith("_"));
+  return cachedComponentNames || [];
+}
+var frontmatterRe = /^---\s*\n([\s\S]*?)\n---(?:\n|$)/;
+function extractFrontmatter(contents) {
+  let match = contents.trimStart().match(frontmatterRe);
+  if (!match) return {};
+  let raw = yaml.safeLoad(match[1]);
+  return { title: raw?.title ? String(raw.title) : void 0 };
+}
+var remarkPlugins = [extractQueries, escapeAngles, mergeAdjacentHtml];
+var rehypePlugins = [sanitizeMarkdown];
+
+// serve2.ts
+var svelteWarnings = [];
+function clearSvelteWarnings() {
+  svelteWarnings.length = 0;
+}
+var QUERY_VERSION = 1;
+var uiRoot;
+var nodeRequire = createRequire(import.meta.url);
+async function serve2(telemetry) {
+  let server = await createServer(await createConfig(telemetry));
+  await server.listen();
+  console.log(`Server running at http://localhost:${server.config.server.port}`);
+  return server;
+}
+async function createConfig(telemetry) {
+  uiRoot = path2.join(fileURLToPath(import.meta.url), "../../ui");
+  let port = Number(process.env.GRAPHENE_PORT) || 4e3;
+  let svelteRoot = path2.dirname(nodeRequire.resolve("svelte/package.json"));
+  let sveltePackage = nodeRequire("svelte/package.json");
+  let svelteDependencyRoot = path2.dirname(svelteRoot);
+  let svelteExport = (name) => path2.join(svelteRoot, sveltePackage.exports[name].browser || sveltePackage.exports[name].default);
+  let packaged = path2.basename(path2.dirname(uiRoot)) == "dist";
+  await fs2.ensureDir(path2.resolve(config.root, "node_modules/.graphene"));
+  let inContainer = fs2.existsSync("/.dockerenv");
+  let host = inContainer ? "0.0.0.0" : "127.0.0.1";
+  return {
+    root: config.root,
+    logLevel: process.env.NODE_ENV == "test" ? "silent" : "info",
+    plugins: [
+      svelte({
+        configFile: false,
+        extensions: [".svelte", ".md"],
+        preprocess: [
+          vitePreprocess(),
+          mdsvex({
+            extensions: [".md"],
+            remarkPlugins,
+            rehypePlugins
+          }),
+          injectComponentImports()
+        ],
+        onwarn(warning, defaultHandler) {
+          if (process.env.NODE_ENV === "test") {
+            svelteWarnings.push({ code: warning.code, message: warning.message, filename: warning.filename });
+          }
+          defaultHandler?.(warning);
+        }
+      }),
+      fixSvelteDepsInTests(),
+      fixHmrForFailedModules(),
+      runVitePlugin(),
+      handleRequestPlugin,
+      updateWorkspacePlugin(telemetry),
+      mockFilesForTests()
+    ],
+    publicDir: path2.resolve(uiRoot, "public"),
+    // on the fence about this one. This would make it less likely we need to optimize when alternating between dev and tests.
+    // cacheDir: process.env.NODE_ENV == 'test' ? 'node_modules/.vite-tests' : 'node_modules/.vite',
+    server: {
+      port,
+      host,
+      fs: { strict: false },
+      strictPort: true,
+      hmr: { overlay: false }
+      // we handle compilation errors ourselves (see LocalApp.svelte)
+    },
+    resolve: {
+      alias: [
+        { find: /^graphene$/, replacement: path2.resolve(uiRoot, "web.js") },
+        // Vite runs in a user project, but svelte is a direct dependency of the cli, and thus transitive to the user project.
+        // So when Vite tries to resolve `svelte` from a compiled md page, it can't find it without these aliases.
+        { find: /^svelte$/, replacement: svelteExport(".") },
+        { find: /^svelte\/animate$/, replacement: svelteExport("./animate") },
+        { find: /^svelte\/attachments$/, replacement: svelteExport("./attachments") },
+        { find: /^svelte\/easing$/, replacement: svelteExport("./easing") },
+        { find: /^svelte\/events$/, replacement: svelteExport("./events") },
+        { find: /^svelte\/internal$/, replacement: svelteExport("./internal") },
+        { find: /^svelte\/internal\/client$/, replacement: svelteExport("./internal/client") },
+        { find: /^svelte\/internal\/disclose-version$/, replacement: svelteExport("./internal/disclose-version") },
+        { find: /^svelte\/internal\/flags\/async$/, replacement: svelteExport("./internal/flags/async") },
+        { find: /^svelte\/internal\/flags\/legacy$/, replacement: svelteExport("./internal/flags/legacy") },
+        { find: /^svelte\/internal\/flags\/tracing$/, replacement: svelteExport("./internal/flags/tracing") },
+        { find: /^svelte\/legacy$/, replacement: svelteExport("./legacy") },
+        { find: /^svelte\/motion$/, replacement: svelteExport("./motion") },
+        { find: /^svelte\/reactivity$/, replacement: svelteExport("./reactivity") },
+        { find: /^svelte\/reactivity\/window$/, replacement: svelteExport("./reactivity/window") },
+        { find: /^svelte\/store$/, replacement: svelteExport("./store") },
+        { find: /^svelte\/transition$/, replacement: svelteExport("./transition") },
+        { find: /^clsx$/, replacement: path2.join(svelteDependencyRoot, "clsx/dist/clsx.mjs") }
+      ]
+    },
+    optimizeDeps: {
+      noDiscovery: process.env.NODE_ENV == "test",
+      // tests manually optimize before starting test workers
+      exclude: ["virtual:nav"],
+      // provided by a plugin, so don't try and optimize it
+      // Vite running in a user project will not naturally discover and optimize these transitive deps.
+      // When you launch the server, your first page load will automatically refresh after a second or two as Vite now sees and optimizes these.
+      // This line makes it do that up-front, avoiding that reload jank. The packaged CLI also pre-bundles the `graphene` alias itself;
+      // doing that from source causes trouble in examples/tests because the alias points outside node_modules.
+      // `graphene` here is a special case: when packaged up it is considered a dependency, but in examples/tests, including it would cause errors.
+      // oxfmt-ignore
+      include: [
+        ...packaged ? ["graphene"] : [],
+        "@graphenedata/cli > svelte",
+        "@graphenedata/cli > chroma-js",
+        "@graphenedata/cli > echarts",
+        "@graphenedata/cli > @graphenedata/html2canvas",
+        "@graphenedata/cli > @graphenedata/ui > svelte",
+        "@graphenedata/cli > @graphenedata/ui > chroma-js",
+        "@graphenedata/cli > @graphenedata/ui > echarts/dist/echarts.esm.js",
+        "@graphenedata/cli > @graphenedata/ui > @graphenedata/html2canvas"
+      ]
+    }
+  };
+}
+async function handleQuery(req, res) {
+  let chunks = [];
+  for await (let chunk of req) chunks.push(chunk);
+  let { gsql, params, hashes } = JSON.parse(Buffer.concat(chunks).toString());
+  res.setHeader("Content-Type", "application/json");
+  await workspaceLoadPromise;
+  let gsqlFiles = workspaceFiles.filter((file) => !file.path.endsWith(".md"));
+  let result = analyzeWorkspace({ config, files: [...gsqlFiles, { path: "input", contents: gsql }] });
+  updateParsedFiles(result);
+  let diagnostics = result.diagnostics;
+  if (diagnostics.length) {
+    res.statusCode = 400;
+    res.end(JSON.stringify(diagnostics[0]));
+    return;
+  }
+  let queries = result.files.find((file) => file.path == "input")?.queries || [];
+  if (queries.length > 1) throw new Error("Found multiple queries, which could be a parsing error");
+  let sql = toSql(queries[0], params);
+  let hash = crypto.createHash("SHA1").update(`query-v${QUERY_VERSION}|${sql}`).digest("hex");
+  res.setHeader("ETag", hash);
+  if (hashes.includes(hash) && req.headers["cache-control"] != "no-cache") {
+    res.statusCode = 304;
+    return res.end();
+  }
+  let queryResults = await runQuery(sql);
+  let totalRows = queryResults.totalRows ?? queryResults.rows.length;
+  if (totalRows > queryResults.rows.length) throw new Error("Query returns too many rows");
+  let fields = queries[0].fields.map((field) => ({ name: field.name, type: field.type, metadata: field.metadata || {} }));
+  res.end(JSON.stringify({ rows: queryResults.rows, hash, fields, sql }));
+}
+async function handlePage(server, res) {
+  res.setHeader("Content-Type", "text/html");
+  let html = await server.transformIndexHtml(
+    "/index.html",
+    `<!doctype html>
+  <html lang="en">
+    <head>
+      <meta charset="UTF-8" />
+      <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+      <title>Graphene</title>
+      <link rel="icon" href="/favicon.ico" />
+    </head>
+    <body>
+      <script type="module">
+        import 'graphene'
+      </script>
+    </body>
+  </html>`
+  );
+  return res.end(html);
+}
+async function prepareDeps() {
+  let cfg = await resolveConfig(await createConfig(), "serve");
+  await optimizeDeps(cfg, true);
+}
+function fixSvelteDepsInTests() {
+  let viteConfig;
+  function configResolved(cfg) {
+    viteConfig = cfg;
+  }
+  function buildStart() {
+    if (process.env.NODE_ENV != "test") return;
+    viteConfig.optimizeDeps.force = false;
+  }
+  buildStart.sequential = true;
+  return { name: "fix-svelte-deps", enforce: "post", configResolved, buildStart };
+}
+function fixHmrForFailedModules() {
+  return {
+    name: "fix-hmr-for-failed-modules",
+    hotUpdate({ modules }) {
+      let hasFailed = modules.some((m) => !m.transformResult);
+      if (hasFailed) {
+        this.environment.hot.send({ type: "full-reload", path: "*" });
+        return [];
+      }
+    }
+  };
+}
+var workspaceLoadPromise;
+var workspaceFiles = [];
+var mdFiles = [];
+function updateWorkspacePlugin(telemetry) {
+  return {
+    name: "updateWorkspace",
+    resolveId(id) {
+      if (id == "virtual:nav") return "\0virtual:nav";
+    },
+    load(id) {
+      if (id != "\0virtual:nav") return;
+      let res = [...mdFiles];
+      if (process.env.NODE_ENV == "test") {
+        for (let [path3, contents] of Object.entries(mockFileMap)) {
+          let mockFile = { path: path3, title: extractFrontmatter(contents).title };
+          let idx = res.findIndex((file) => file.path == path3);
+          if (idx >= 0) res.splice(idx, 1, mockFile);
+          else res.push(mockFile);
+        }
+      }
+      return `export default ${JSON.stringify(res)}`;
+    },
+    configureServer: (s) => {
+      let refresh = async () => {
+        workspaceLoadPromise = (async () => {
+          let loaded = await loadWorkspace(config.root, true, config.ignoredFiles);
+          telemetry?.event("workspace_scanned", { command: "serve", ...getWorkspaceScanCounts(loaded) });
+          workspaceFiles = loaded.map((file) => {
+            let existing = workspaceFiles.find((existing2) => existing2.path == file.path && existing2.contents == file.contents);
+            return existing?.parsed ? { ...file, parsed: existing.parsed } : file;
+          });
+        })();
+        await workspaceLoadPromise;
+        mdFiles = workspaceFiles.filter((file) => file.path.endsWith(".md")).map((f) => ({ path: f.path, title: extractFrontmatter(f.contents).title }));
+        let mod = s.moduleGraph.getModuleById("\0virtual:nav");
+        if (!mod) return;
+        s.reloadModule(mod);
+      };
+      s.watcher.add(["**/*.gsql", "**/*.md"]);
+      s.watcher.on("all", refresh);
+      refresh();
+    }
+  };
+}
+function updateParsedFiles(analysis) {
+  workspaceFiles = workspaceFiles.map((file) => {
+    let analyzed = analysis.files.find((next) => next.path == file.path);
+    if (!analyzed) return file;
+    return {
+      ...file,
+      parsed: {
+        tree: analyzed.tree,
+        virtualContents: analyzed.virtualContents,
+        virtualToMarkdownOffset: analyzed.virtualToMarkdownOffset
+      }
+    };
+  });
+}
+var handleRequestPlugin = {
+  name: "handleRequest",
+  configureServer: (s) => {
+    s.middlewares.use(async function handleRequest(req, res, next) {
+      try {
+        let [pathName] = (req.url || "").split("?");
+        if (pathName == "/_api/query") return await handleQuery(req, res);
+        if (pathName) {
+          if (pathName == "/__ct" || pathName == "/_charts" || pathName == "/_styles") return await handlePage(s, res);
+        }
+        if (!pathName || pathName == "/") pathName = "index";
+        let relativeMdPath = pathName.replace(/^\//, "") + ".md";
+        let mdPath = path2.join(config.root, relativeMdPath);
+        if (mockFileMap[relativeMdPath] || await fs2.exists(mdPath)) {
+          await handlePage(s, res);
+        } else {
+          next();
+        }
+      } catch (err) {
+        if (process.env.NODE_ENV != "test") console.error(err);
+        res.statusCode = 500;
+        res.end(JSON.stringify({ message: err.message, stack: err.stack }));
+      }
+    });
+  }
+};
+function mockFilesForTests() {
+  if (process.env.NODE_ENV !== "test") return null;
+  function toMockKey(id) {
+    return id.replace(config.root + "/", "").replace(/^\//, "");
+  }
+  return {
+    name: "mock-files-for-tests",
+    enforce: "pre",
+    resolveId(id) {
+      if (!mockFileMap[toMockKey(id)]) return;
+      return path2.join(config.root, toMockKey(id)) + "?mock";
+    },
+    load(id) {
+      if (!id.endsWith("?mock")) return null;
+      return mockFileMap[toMockKey(id.replace(/\?mock$/, ""))];
+    }
+  };
+}
+export {
+  clearSvelteWarnings,
+  prepareDeps,
+  serve2,
+  svelteWarnings
+};
+//# sourceMappingURL=serve2-TNN5EROW.js.map