erdraft 0.0.0-stage → 0.0.1

package/dist/inspect/index.js

@@ -0,0 +1,373 @@
+'use client'
+
+// src/inspect/inspector.tsx
+import { z as z2 } from "zod";
+import {
+  useRef as useRef2,
+  useState,
+  useEffect as useEffect2,
+  useEffectEvent
+} from "react";
+
+// src/core/fields.ts
+import { z } from "zod";
+var STORAGE_AREAS = ["local", "session"];
+var destinationSchema = z.discriminatedUnion("kind", [
+  z.object({
+    kind: z.literal("column"),
+    table: z.string(),
+    column: z.string()
+  }),
+  z.object({
+    kind: z.literal("storage"),
+    area: z.enum(STORAGE_AREAS),
+    key: z.string()
+  }),
+  z.object({ kind: z.literal("none") })
+]);
+var fieldSchema = z.object({
+  page: z.string().min(1),
+  label: z.string().min(1),
+  destination: destinationSchema,
+  tracedAt: z.string()
+});
+function describeDestination(destination) {
+  if (destination.kind === "column") {
+    return `${destination.table}.${destination.column}`;
+  }
+  if (destination.kind === "storage") {
+    return `${destination.area}Storage "${destination.key}"`;
+  }
+  return "kept nowhere since it changed: not saved yet, or kept on the page only";
+}
+
+// src/inspect/use-field-changes.ts
+import { useRef, useEffect } from "react";
+
+// src/inspect/field-of.ts
+var FIELD = 'input, textarea, select, [role="radiogroup"]';
+var UNTRACED = /* @__PURE__ */ new Set([
+  "password",
+  "hidden",
+  "button",
+  "submit",
+  "reset",
+  "checkbox",
+  "radio",
+  "file",
+  "image"
+]);
+function fieldOf(element) {
+  if (!(element instanceof Element)) {
+    return null;
+  }
+  const field = element.closest(FIELD);
+  return field instanceof HTMLInputElement && UNTRACED.has(field.type) ? null : field;
+}
+function textOf(ids) {
+  return ids.split(/\s+/).map((id) => document.getElementById(id)?.textContent?.trim() ?? "").filter(Boolean).join(" ");
+}
+function labelOf(field) {
+  const labelled = field.getAttribute("aria-labelledby");
+  const own = field instanceof HTMLInputElement || field instanceof HTMLTextAreaElement || field instanceof HTMLSelectElement ? field.labels?.[0]?.textContent : null;
+  return field.getAttribute("aria-label") || (labelled ? textOf(labelled) : "") || own?.trim() || field.getAttribute("placeholder") || field.getAttribute("name") || "";
+}
+function valueIn(field) {
+  if (field instanceof HTMLInputElement || field instanceof HTMLTextAreaElement || field instanceof HTMLSelectElement) {
+    return field.value;
+  }
+  const checked = field.querySelector('[role="radio"][aria-checked="true"]');
+  return checked?.getAttribute("value") ?? "";
+}
+
+// src/inspect/listen-on-document.ts
+function listenOnDocument(listeners) {
+  for (const [type, listener] of listeners) {
+    document.addEventListener(type, listener, true);
+  }
+  return () => {
+    for (const [type, listener] of listeners) {
+      document.removeEventListener(type, listener, true);
+    }
+  };
+}
+
+// src/inspect/use-field-changes.ts
+function changeKey(label) {
+  return `${window.location.pathname}|${label}`;
+}
+function useFieldChanges() {
+  const changes = useRef(/* @__PURE__ */ new Map());
+  useEffect(() => {
+    let pressed = null;
+    const record = (field) => {
+      const label = labelOf(field);
+      if (label) {
+        changes.current.set(changeKey(label), {
+          value: valueIn(field),
+          at: Date.now()
+        });
+      }
+    };
+    const onInput = (event) => {
+      const field = fieldOf(event.target);
+      if (field) {
+        record(field);
+      }
+    };
+    const onPress = (event) => {
+      const field = fieldOf(event.target);
+      pressed = field?.getAttribute("role") === "radiogroup" ? { field, value: valueIn(field) } : null;
+    };
+    const onPressed = () => {
+      const before = pressed;
+      pressed = null;
+      if (before) {
+        setTimeout(() => {
+          if (valueIn(before.field) !== before.value) {
+            record(before.field);
+          }
+        });
+      }
+    };
+    return listenOnDocument([
+      ["input", onInput],
+      ["change", onInput],
+      ["pointerdown", onPress],
+      ["keydown", onPress],
+      ["click", onPressed],
+      ["keyup", onPressed]
+    ]);
+  }, []);
+  return changes;
+}
+
+// src/inspect/watch-storage.ts
+function watchStorage(onWrite) {
+  const prototype = Storage.prototype;
+  const setItem = prototype.setItem;
+  prototype.setItem = function watchedSetItem(key, value) {
+    setItem.call(this, key, value);
+    onWrite({
+      area: this === window.sessionStorage ? "session" : "local",
+      key,
+      value: String(value),
+      at: Date.now()
+    });
+  };
+  return () => {
+    prototype.setItem = setItem;
+  };
+}
+
+// src/inspect/holds-value.ts
+var SHORTEST = 2;
+var WITHIN = 4;
+var DIGITS = 4;
+function digitsOf(value) {
+  return value.replace(/\D/g, "");
+}
+function holdsValue(kept, typed) {
+  const value = typed.trim().toLowerCase();
+  if (value.length < SHORTEST || kept === null || kept === void 0) {
+    return false;
+  }
+  const text = (typeof kept === "string" ? kept : JSON.stringify(kept)).toLowerCase();
+  const digits = digitsOf(value);
+  return text.trim() === value || digits.length >= DIGITS && digits === digitsOf(text) || value.length >= WITHIN && text.includes(value);
+}
+
+// src/inspect/inspector.tsx
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+var KEPT_STORAGE = 200;
+var fieldsResponse = z2.object({ fields: z2.array(fieldSchema) });
+var columnsResponse = z2.object({
+  columns: z2.array(z2.object({ table: z2.string(), column: z2.string() }))
+});
+var keptResponse = z2.object({ field: fieldSchema });
+var LAYER = 2147483647;
+var INK = "#f5f5f4";
+var GROUND = "rgba(24, 24, 27, 0.94)";
+var FOCUS = "#3b82f6";
+var TEXT = {
+  font: "500 12px/16px ui-sans-serif, system-ui, sans-serif",
+  color: INK,
+  background: GROUND,
+  borderRadius: 6,
+  padding: "4px 8px",
+  boxShadow: "0 4px 16px rgba(0, 0, 0, 0.24)",
+  whiteSpace: "nowrap",
+  pointerEvents: "none",
+  position: "fixed",
+  zIndex: LAYER
+};
+function Inspector({ url }) {
+  const changes = useFieldChanges();
+  const storage = useRef2([]);
+  const hovered = useRef2(null);
+  const [active, setActive] = useState(false);
+  const [box, setBox] = useState(
+    null
+  );
+  const [said, setSaid] = useState(null);
+  const [known, setKnown] = useState([]);
+  useEffect2(
+    () => watchStorage((write) => {
+      storage.current = [...storage.current.slice(1 - KEPT_STORAGE), write];
+    }),
+    []
+  );
+  useEffect2(() => {
+    const onKey = (event) => {
+      if (event.code === "KeyD" && event.altKey && event.shiftKey) {
+        event.preventDefault();
+        setActive((was) => !was);
+      } else if (event.key === "Escape") {
+        setActive(false);
+      }
+    };
+    window.addEventListener("keydown", onKey);
+    return () => window.removeEventListener("keydown", onKey);
+  }, []);
+  const say = (field, text2) => setSaid({ field, text: text2 });
+  const trace = useEffectEvent(async (field) => {
+    const label2 = labelOf(field);
+    if (!label2) {
+      say(field, "This field has no label to be known by");
+      return;
+    }
+    const change = changes.current.get(changeKey(label2));
+    const value = change?.value ?? valueIn(field);
+    const since = change?.at ?? Math.floor(performance.timeOrigin);
+    if (value.trim().length < SHORTEST) {
+      say(field, `${label2}: type a longer value and save, then click it again`);
+      return;
+    }
+    say(field, `${label2}: tracing\u2026`);
+    try {
+      const found = columnsResponse.parse(
+        await (await fetch(
+          `${url}/api/inspect/find?value=${encodeURIComponent(value)}&since=${since}`
+        )).json()
+      ).columns;
+      const stored = storage.current.filter((write) => write.at >= since && holdsValue(write.value, value)).at(-1);
+      const [column] = found;
+      const destination = column ? { kind: "column", ...column } : stored ? { kind: "storage", area: stored.area, key: stored.key } : change ? { kind: "none" } : null;
+      if (!destination) {
+        say(field, `${label2}: change it and save, then click it again`);
+        return;
+      }
+      const kept = keptResponse.parse(
+        await (await fetch(`${url}/api/inspect/fields`, {
+          method: "POST",
+          headers: { "content-type": "application/json" },
+          body: JSON.stringify({
+            page: window.location.pathname,
+            label: label2,
+            destination
+          })
+        })).json()
+      ).field;
+      const more = found.length > 1 ? ` (and ${found.length - 1} more)` : "";
+      setKnown((before) => [
+        ...before.filter((each) => each.label !== label2),
+        kept
+      ]);
+      say(field, `${label2} \u2192 ${describeDestination(destination)}${more}`);
+    } catch {
+      say(field, "Erdraft's window is not open: run `erdraft studio`");
+    }
+  });
+  useEffect2(() => {
+    if (!active) {
+      hovered.current = null;
+      setBox(null);
+      setSaid(null);
+      return;
+    }
+    fetch(
+      `${url}/api/inspect/fields?page=${encodeURIComponent(window.location.pathname)}`
+    ).then(
+      async (response) => setKnown(fieldsResponse.parse(await response.json()).fields)
+    ).catch(() => setKnown([]));
+    const outline = (field) => {
+      hovered.current = field;
+      setBox(field ? { field, rect: field.getBoundingClientRect() } : null);
+    };
+    const onMove = (event) => outline(fieldOf(event.target));
+    const onScroll = () => outline(hovered.current);
+    const onPress = (event) => {
+      const field = fieldOf(event.target);
+      if (!field) {
+        return;
+      }
+      event.preventDefault();
+      event.stopPropagation();
+      if (event.type === "click") {
+        trace(field);
+      }
+    };
+    return listenOnDocument([
+      ["mousemove", onMove],
+      ["scroll", onScroll],
+      ["pointerdown", onPress],
+      ["mousedown", onPress],
+      ["click", onPress]
+    ]);
+  }, [active, url]);
+  if (!active) {
+    return null;
+  }
+  const label = box ? labelOf(box.field) : "";
+  const traced = known.find((field) => field.label === label);
+  const text = box && said?.field === box.field ? said.text : traced ? `${label} \u2192 ${describeDestination(traced.destination)}` : `${label || "This field"}: click to trace where it is kept`;
+  return /* @__PURE__ */ jsxs(Fragment, { children: [
+    /* @__PURE__ */ jsx(
+      "div",
+      {
+        style: {
+          ...TEXT,
+          bottom: 16,
+          left: "50%",
+          transform: "translateX(-50%)"
+        },
+        children: "Erdraft \xB7 click a field to see where it is kept \xB7 Esc to stop"
+      }
+    ),
+    box ? /* @__PURE__ */ jsxs(Fragment, { children: [
+      /* @__PURE__ */ jsx(
+        "div",
+        {
+          style: {
+            position: "fixed",
+            top: box.rect.top - 2,
+            left: box.rect.left - 2,
+            width: box.rect.width + 4,
+            height: box.rect.height + 4,
+            border: `2px solid ${FOCUS}`,
+            borderRadius: 6,
+            pointerEvents: "none",
+            zIndex: LAYER
+          }
+        }
+      ),
+      /* @__PURE__ */ jsx(
+        "div",
+        {
+          style: {
+            ...TEXT,
+            top: Math.max(4, box.rect.top - 30),
+            ...box.rect.left > window.innerWidth / 2 ? { right: window.innerWidth - box.rect.right } : { left: box.rect.left },
+            maxWidth: "calc(100vw - 16px)",
+            overflow: "hidden",
+            textOverflow: "ellipsis"
+          },
+          children: text
+        }
+      )
+    ] }) : null
+  ] });
+}
+export {
+  Inspector as default
+};

package/dist/inspect/logger.js

@@ -0,0 +1,64 @@
+// src/inspect/read-write.ts
+var UPDATE = /^update (?:"[^"]+"\.)?"([^"]+)" set (.+?)(?: from | where | returning |$)/s;
+var INSERT = /^insert into (?:"[^"]+"\.)?"([^"]+)" \(([^)]*)\) values (.+?)(?: on conflict | returning |$)/s;
+var ASSIGNMENT = /^"([^"]+)" = \$(\d+)$/;
+var PLACEHOLDER = /^\$(\d+)$/;
+var ROW = /\(([^()]*)\)/g;
+function paramOf(params, placeholder) {
+  return params[Number(placeholder) - 1];
+}
+function readWrite(sql, params) {
+  const update = UPDATE.exec(sql);
+  if (update) {
+    const values = {};
+    for (const part of String(update[2]).split(", ")) {
+      const assignment = ASSIGNMENT.exec(part);
+      if (assignment) {
+        values[String(assignment[1])] = paramOf(params, String(assignment[2]));
+      }
+    }
+    return [{ table: String(update[1]), values }];
+  }
+  const insert = INSERT.exec(sql);
+  if (!insert) {
+    return [];
+  }
+  const table = String(insert[1]);
+  const columns = String(insert[2]).split(", ").map((column) => column.slice(1, -1));
+  return [...String(insert[3]).matchAll(ROW)].map((row) => {
+    const values = {};
+    String(row[1]).split(", ").forEach((token, at) => {
+      const placeholder = PLACEHOLDER.exec(token);
+      if (placeholder) {
+        values[String(columns[at])] = paramOf(params, String(placeholder[1]));
+      }
+    });
+    return { table, values };
+  });
+}
+
+// src/inspect/inspect-logger.ts
+function jsonable(_key, value) {
+  return typeof value === "bigint" ? value.toString() : value;
+}
+function inspectLogger(url, send = fetch) {
+  return {
+    logQuery(query, params) {
+      try {
+        const writes = readWrite(query, params);
+        if (writes.length === 0) {
+          return;
+        }
+        send(`${url}/api/inspect/writes`, {
+          method: "POST",
+          headers: { "content-type": "application/json" },
+          body: JSON.stringify({ writes }, jsonable)
+        }).catch(() => void 0);
+      } catch {
+      }
+    }
+  };
+}
+export {
+  inspectLogger as default
+};

package/dist/read-schema-child.js

@@ -0,0 +1,238 @@
+import {
+  indexName
+} from "./chunk-VSN3XJPO.js";
+
+// src/core/read-schema-child.ts
+import { pathToFileURL } from "url";
+
+// src/core/read-drizzle-schema.ts
+import { is, SQL, StringChunk } from "drizzle-orm";
+import {
+  PgTable,
+  getTableConfig,
+  PgDialect,
+  isPgEnum
+} from "drizzle-orm/pg-core";
+import { z } from "zod";
+
+// src/core/type-of-json-schema.ts
+var PRIMITIVES = {
+  string: "string",
+  number: "number",
+  integer: "number",
+  boolean: "boolean",
+  null: "null"
+};
+function literal(value) {
+  return typeof value === "string" ? `'${value.replaceAll("'", "\\'")}'` : JSON.stringify(value);
+}
+function element(type) {
+  let depth = 0;
+  let quote = null;
+  let joined = false;
+  for (const char of type) {
+    if (quote) {
+      quote = char === quote ? null : quote;
+    } else if (char === "'" || char === '"') {
+      quote = char;
+    } else if ("{[(<".includes(char)) {
+      depth += 1;
+    } else if ("}])>".includes(char)) {
+      depth -= 1;
+    } else if (depth === 0 && (char === "|" || char === "&")) {
+      joined = true;
+    }
+  }
+  return joined ? `(${type})[]` : `${type}[]`;
+}
+function objectOf(node, of) {
+  const required = new Set(node.required);
+  const fields = Object.entries(node.properties ?? {}).map(
+    ([name, child]) => `${name}${required.has(name) ? "" : "?"}: ${of(child)}`
+  );
+  const rest = node.additionalProperties;
+  if (fields.length === 0 && typeof rest === "object") {
+    return `Record<string, ${of(rest)}>`;
+  }
+  return fields.length === 0 ? "{}" : `{ ${fields.join("; ")} }`;
+}
+function arrayOf(node, of) {
+  const { prefixItems, items } = node;
+  if (Array.isArray(items)) {
+    return `[${items.map(of).join(", ")}]`;
+  }
+  if (prefixItems) {
+    return `[${prefixItems.map(of).join(", ")}]`;
+  }
+  return element(items === void 0 ? "unknown" : of(items));
+}
+function typeOfJsonSchema(node, root = typeof node === "object" ? node : {}, followed = /* @__PURE__ */ new Set()) {
+  if (typeof node === "boolean") {
+    return node ? "unknown" : "never";
+  }
+  const of = (child) => typeOfJsonSchema(child, root, followed);
+  if (node.$ref !== void 0) {
+    const name = node.$ref.slice(node.$ref.lastIndexOf("/") + 1);
+    const definition = root.$defs?.[name];
+    if (definition === void 0) {
+      return "unknown";
+    }
+    return followed.has(name) ? name : typeOfJsonSchema(definition, root, /* @__PURE__ */ new Set([...followed, name]));
+  }
+  if (node.const !== void 0) {
+    return literal(node.const);
+  }
+  if (node.enum) {
+    return node.enum.map(literal).join(" | ");
+  }
+  const union = node.anyOf ?? node.oneOf;
+  if (union) {
+    return union.map(of).join(" | ");
+  }
+  if (node.allOf) {
+    return node.allOf.map(of).join(" & ");
+  }
+  if (Array.isArray(node.type)) {
+    return node.type.map((type) => of({ ...node, type })).join(" | ");
+  }
+  if (node.type === "object") {
+    return objectOf(node, of);
+  }
+  if (node.type === "array") {
+    return arrayOf(node, of);
+  }
+  return PRIMITIVES[node.type ?? ""] ?? "unknown";
+}
+
+// src/core/read-drizzle-schema.ts
+var dialect = new PgDialect();
+function sqlOf(value) {
+  return dialect.sqlToQuery(value, "indexes").sql;
+}
+function defaultOf(column) {
+  if (column.generatedIdentity) {
+    return "identity";
+  }
+  if (column.generated || column.defaultFn) {
+    return "generated";
+  }
+  const value = column.default;
+  if (value === void 0) {
+    return void 0;
+  }
+  if (is(value, SQL)) {
+    const words = value.queryChunks.flatMap(
+      (chunk) => is(chunk, StringChunk) ? chunk.value : []
+    );
+    return words.length === value.queryChunks.length ? words.join("") : "sql";
+  }
+  return JSON.stringify(value);
+}
+function namedIndex(table, name, columns, unique) {
+  return {
+    name: name ?? indexName(table, { columns, unique }),
+    columns,
+    unique
+  };
+}
+function nameOf(table) {
+  const { schema, name } = getTableConfig(table);
+  return schema ? `${schema}.${name}` : name;
+}
+function shapeName(table, column) {
+  const words = `${table}_${column}`.split(/[_.]/).filter(Boolean);
+  return `${words.map(
+    (word, index) => index === 0 ? word : `${word.charAt(0).toUpperCase()}${word.slice(1)}`
+  ).join("")}Shape`;
+}
+function tableOf(table, shapeOf) {
+  const config = getTableConfig(table);
+  const primary = new Set(
+    config.primaryKeys.flatMap((key) => key.columns.map((each) => each.name))
+  );
+  const unique = new Set(
+    config.uniqueConstraints.filter((constraint) => constraint.columns.length === 1).flatMap((constraint) => constraint.columns.map((each) => each.name))
+  );
+  return {
+    name: nameOf(table),
+    columns: config.columns.map((column) => {
+      const shape = shapeOf(nameOf(table), column.name);
+      return {
+        name: column.name,
+        type: column.getSQLType(),
+        nullable: !column.notNull,
+        primaryKey: column.primary || primary.has(column.name),
+        unique: column.isUnique || unique.has(column.name),
+        default: defaultOf(column),
+        ...shape === void 0 ? {} : { shape }
+      };
+    }),
+    foreignKeys: config.foreignKeys.map((foreignKey) => {
+      const reference = foreignKey.reference();
+      return {
+        name: foreignKey.getName(),
+        columns: reference.columns.map((each) => each.name),
+        table: nameOf(reference.foreignTable),
+        foreignColumns: reference.foreignColumns.map((each) => each.name),
+        onDelete: foreignKey.onDelete
+      };
+    }),
+    // Its indexes, and its unique constraints of several columns (one of a single column is its column's `unique`)
+    indexes: [
+      ...config.indexes.map(
+        ({ config: index }) => namedIndex(
+          config.name,
+          index.name,
+          index.columns.map(
+            (column) => (
+              // Else an indexed column, the only other kind, by its name
+              is(column, SQL) ? sqlOf(column) : String(Reflect.get(column, "name"))
+            )
+          ),
+          index.unique
+        )
+      ),
+      ...config.uniqueConstraints.filter((constraint) => constraint.columns.length > 1).map(
+        (constraint) => namedIndex(
+          config.name,
+          constraint.getName(),
+          constraint.columns.map((each) => each.name),
+          true
+        )
+      )
+    ],
+    checks: config.checks.map((check) => ({
+      name: check.name,
+      expression: sqlOf(check.value)
+    }))
+  };
+}
+function readDrizzleSchema(module) {
+  const values = [...new Set(Object.values(module))];
+  const shapeOf = (table, column) => {
+    const exported = module[shapeName(table, column)];
+    return exported instanceof z.core.$ZodType ? typeOfJsonSchema(
+      z.toJSONSchema(exported, { io: "output", unrepresentable: "any" })
+    ) : void 0;
+  };
+  return {
+    tables: values.filter((value) => is(value, PgTable)).map((table) => tableOf(table, shapeOf)),
+    enums: values.filter(isPgEnum).map((each) => ({
+      name: each.enumName,
+      values: [...each.enumValues]
+    }))
+  };
+}
+
+// src/core/read-schema-child.ts
+var [path = ""] = process.argv.slice(2);
+try {
+  const module = await import(pathToFileURL(path).href);
+  const { default: exported } = module;
+  const exports = typeof exported === "object" && exported !== null ? { ...exported, ...module } : module;
+  process.send?.({ schema: readDrizzleSchema(exports) });
+} catch (error) {
+  process.send?.({
+    error: error instanceof Error ? error.message : String(error)
+  });
+}

package/dist/studio-config-TIVT4MNY.js

@@ -0,0 +1,32 @@
+import {
+  createApi
+} from "./chunk-SSLBX2OF.js";
+import "./chunk-VSN3XJPO.js";
+
+// src/server/studio-config.ts
+import { fileURLToPath } from "url";
+import react from "@vitejs/plugin-react";
+import tailwind from "@tailwindcss/vite";
+function studioConfig(config) {
+  return {
+    configFile: false,
+    root: fileURLToPath(new URL("../..", import.meta.url)),
+    plugins: [
+      react(),
+      tailwind(),
+      {
+        name: "erdraft-api",
+        configureServer(server) {
+          const api = createApi(config);
+          server.middlewares.use(api.middleware);
+          server.httpServer?.on("close", api.close);
+        }
+      }
+    ],
+    server: { host: "127.0.0.1", port: config.port, strictPort: true },
+    logLevel: "warn"
+  };
+}
+export {
+  studioConfig as default
+};