astro-dev-edit 0.11.0

package/src/server/zod-adapt.ts

@@ -0,0 +1,239 @@
+/**
+ * zod-major adapter for schema introspection.
+ *
+ * Astro 5/6 ship zod v3; Astro 7 ships zod v4 (`astro/zod` re-exports
+ * `zod/v4`), which renamed every internal this introspector reads:
+ *
+ * - `_def.typeName` (`'ZodString'`) → `_def.type` (`'string'`)
+ * - enum values `_def.values` (array) → `_def.entries` (object map)
+ * - array element `_def.type` → `_def.element` — in v4 `_def.type` is the
+ *   *string* `'array'`, so reading it as a schema silently yields nothing
+ * - literal `_def.value` → `_def.values[0]` (an array)
+ * - `.describe()` writes into `z.globalRegistry`, so `_def.description` is
+ *   empty and only the `.description` getter answers
+ * - `.brand()` / `.refine()` no longer wrap at all (the kind stays `'string'`),
+ *   while `.transform()` produces `pipe{in, out}` whose `out` is a `transform`
+ *   node no widget can render — v4 follows `in`, the shape a form must produce.
+ *   v3's `ZodPipeline` keeps following `out`, unchanged.
+ *
+ * Both majors are read **duck-typed** — we never import zod, so there is no
+ * dual-instance hazard and no peer dependency on it. Anything unrecognized
+ * yields `null` and the caller degrades to value inference rather than erroring.
+ */
+
+export interface ZodNode {
+  _def?: Record<string, unknown> & { typeName?: unknown; type?: unknown };
+  /** Getter on both majors; v4's reads from the global metadata registry. */
+  description?: string;
+  /** Enum options getter, present on both majors. */
+  options?: unknown;
+  /** Array element getter, present on both majors. */
+  element?: unknown;
+  safeParse?: (v: unknown) => { success: boolean; error?: { issues?: { message: string }[] } };
+}
+
+export interface Unwrapped {
+  /** The terminal schema, with every wrapper peeled off. */
+  inner: ZodNode;
+  /** False when a wrapper made the field optional (optional/nullable/default/catch). */
+  required: boolean;
+  /** Resolved schema default, when one was declared. */
+  defaultValue: unknown;
+}
+
+export interface ZodAdapter {
+  major: 3 | 4;
+  /** Kind of a node, normalized lowercase: `'string'`, `'object'`, `'optional'`… */
+  kind(node: ZodNode): string | null;
+  /** Peel wrapper types down to the terminal one. */
+  unwrap(node: ZodNode): Unwrapped;
+  /** The node's `.describe()` text, if any. Read *after* unwrapping. */
+  description(node: ZodNode): string | undefined;
+  /** All-string enum values, or null when the enum isn't all strings. */
+  enumOptions(node: ZodNode): string[] | null;
+  /** An array's element schema. */
+  arrayElement(node: ZodNode): ZodNode | null;
+  /** A literal's value. */
+  literalValue(node: ZodNode): unknown;
+  /** An object schema's shape record. */
+  shape(node: ZodNode): Record<string, ZodNode> | null;
+}
+
+/** A wrapper kind, and which `_def` key holds the schema it wraps. */
+interface Wrapper {
+  key: string;
+  /** This wrapper makes the field optional. */
+  optional?: true;
+  /** This wrapper makes the field required again, overriding inner optionality. */
+  pins?: true;
+}
+
+const V3_WRAPPERS: Record<string, Wrapper> = {
+  default: { key: 'innerType', optional: true },
+  optional: { key: 'innerType', optional: true },
+  nullable: { key: 'innerType', optional: true },
+  catch: { key: 'innerType', optional: true },
+  effects: { key: 'schema' },
+  // `ZodBranded` holds its inner schema on `_def.type`; `ZodReadonly` on
+  // `_def.innerType`. They are not interchangeable — reading `type` for
+  // readonly silently fails to unwrap and the field degrades to `json`.
+  branded: { key: 'type' },
+  readonly: { key: 'innerType' },
+  pipeline: { key: 'out' },
+};
+
+const V4_WRAPPERS: Record<string, Wrapper> = {
+  default: { key: 'innerType', optional: true },
+  prefault: { key: 'innerType', optional: true },
+  optional: { key: 'innerType', optional: true },
+  nullable: { key: 'innerType', optional: true },
+  catch: { key: 'innerType', optional: true },
+  readonly: { key: 'innerType' },
+  nonoptional: { key: 'innerType', pins: true },
+  pipe: { key: 'in' },
+};
+
+/** Kinds whose `_def.defaultValue` supplies the field's default. */
+const DEFAULT_KINDS = new Set(['default', 'prefault']);
+
+// --- accessors that read the same on both majors -----------------------------
+// Each tries the public getter first (both majors expose it), then the
+// major-specific `_def` keys, guarding shape so v4's `_def.type: 'array'`
+// string is never mistaken for a schema.
+
+function description(node: ZodNode): string | undefined {
+  const own = node.description;
+  if (typeof own === 'string') return own;
+  const fromDef = node._def?.description;
+  return typeof fromDef === 'string' ? fromDef : undefined;
+}
+
+function allStrings(value: unknown): string[] | null {
+  return Array.isArray(value) && value.every((v) => typeof v === 'string')
+    ? (value as string[])
+    : null;
+}
+
+function enumOptions(node: ZodNode): string[] | null {
+  const fromGetter = allStrings(node.options);
+  if (fromGetter) return fromGetter;
+  const def = node._def ?? {};
+  const fromValues = allStrings(def.values); // v3
+  if (fromValues) return fromValues;
+  const entries = def.entries; // v4 — an object map, not an array
+  if (entries && typeof entries === 'object') return allStrings(Object.values(entries));
+  return null;
+}
+
+function arrayElement(node: ZodNode): ZodNode | null {
+  const def = node._def ?? {};
+  for (const candidate of [node.element, def.element, def.type]) {
+    if (candidate && typeof candidate === 'object') return candidate as ZodNode;
+  }
+  return null;
+}
+
+function literalValue(node: ZodNode): unknown {
+  const def = node._def ?? {};
+  if (def.value !== undefined) return def.value; // v3
+  return Array.isArray(def.values) ? def.values[0] : undefined; // v4
+}
+
+function shape(node: ZodNode): Record<string, ZodNode> | null {
+  try {
+    const raw = node._def?.shape;
+    const resolved = typeof raw === 'function' ? (raw as () => unknown)() : raw;
+    return resolved && typeof resolved === 'object'
+      ? (resolved as Record<string, ZodNode>)
+      : null;
+  } catch {
+    return null;
+  }
+}
+
+/** Peel wrappers using this major's table. Bounded loop: wrapper chains are
+ *  short, and 20 guards against a cyclic definition. */
+function makeUnwrap(
+  wrappers: Record<string, Wrapper>,
+  kind: (node: ZodNode) => string | null,
+): (node: ZodNode) => Unwrapped {
+  return (schema) => {
+    let inner = schema;
+    let required = true;
+    let pinned = false;
+    let defaultValue: unknown;
+    for (let i = 0; i < 20; i++) {
+      const k = kind(inner);
+      const wrapper = k ? wrappers[k] : undefined;
+      if (!wrapper) break;
+      const def = inner._def ?? {};
+      if (wrapper.pins) {
+        required = true;
+        pinned = true;
+      } else if (wrapper.optional && !pinned) {
+        required = false;
+      }
+      if (k && DEFAULT_KINDS.has(k)) {
+        const declared = def.defaultValue;
+        try {
+          // v3 stores a thunk; v4 stores the value itself.
+          defaultValue = typeof declared === 'function'
+            ? (declared as () => unknown)()
+            : declared;
+        } catch {
+          /* a throwing default must never break introspection */
+        }
+      }
+      const next = def[wrapper.key];
+      if (!next || typeof next !== 'object') break;
+      inner = next as ZodNode;
+    }
+    return { inner, required, defaultValue };
+  };
+}
+
+function kindV3(node: ZodNode): string | null {
+  const typeName = node._def?.typeName;
+  // 'ZodString' → 'string', matching v4's own naming so callers switch once.
+  return typeof typeName === 'string' ? typeName.replace(/^Zod/, '').toLowerCase() : null;
+}
+
+function kindV4(node: ZodNode): string | null {
+  const type = node._def?.type;
+  return typeof type === 'string' ? type : null;
+}
+
+const V3: ZodAdapter = {
+  major: 3,
+  kind: kindV3,
+  unwrap: makeUnwrap(V3_WRAPPERS, kindV3),
+  description,
+  enumOptions,
+  arrayElement,
+  literalValue,
+  shape,
+};
+
+const V4: ZodAdapter = {
+  major: 4,
+  kind: kindV4,
+  unwrap: makeUnwrap(V4_WRAPPERS, kindV4),
+  description,
+  enumOptions,
+  arrayElement,
+  literalValue,
+  shape,
+};
+
+/**
+ * Pick the adapter for whatever zod instance produced this schema, or null when
+ * it isn't a recognizable zod schema at all (a function schema the provider
+ * couldn't call, a future major, a plain object).
+ */
+export function adapterFor(schema: unknown): ZodAdapter | null {
+  const def = (schema as ZodNode | null | undefined)?._def;
+  if (!def) return null;
+  if (typeof def.typeName === 'string') return V3;
+  if (typeof def.type === 'string') return V4;
+  return null;
+}

package/src/shared/asset-path.ts

@@ -0,0 +1,132 @@
+/**
+ * Conversions between the universes an asset path lives in — the two the entry
+ * drawer straddles, plus the URL form any of them takes once it is written into
+ * markup (`webPathToUrl`).
+ *
+ * Two path universes meet in the entry drawer. A plain `<img src>` in a
+ * `.astro` file needs a **web-servable, root-relative** path (`/images/hero.png`)
+ * that still resolves in the built site. A field backed by Astro's `image()`
+ * schema helper needs an **entry-file-relative** path (`../../assets/hero.png`)
+ * that Vite can import at build time. This module is the only place that
+ * converts between them.
+ *
+ * Runtime-shared (client + server), like `slug.ts` — so it is pure posix string
+ * math with no `node:path` import and no DOM. Every function returns `null`
+ * rather than throwing, and refuses anything that would escape the project root.
+ */
+
+/** Only assets under `src/` can back an `image()` field: Astro imports them
+ *  through Vite, and files in `public/` are copied verbatim, never importable. */
+const IMPORTABLE_PREFIX = 'src';
+
+/** Split a path into segments, tolerating Windows separators and dropping the
+ *  no-op `.` and empty parts. */
+function segmentsOf(path: string): string[] {
+  return path.replace(/\\/g, '/').split('/').filter((s) => s !== '' && s !== '.');
+}
+
+/** Resolve `..` segments, or null when they climb past the root. */
+function normalize(parts: string[]): string[] | null {
+  const out: string[] = [];
+  for (const part of parts) {
+    if (part === '..') {
+      if (out.length === 0) return null; // escapes the project root
+      out.pop();
+      continue;
+    }
+    out.push(part);
+  }
+  return out;
+}
+
+/** The directory segments of a repo-relative file path. */
+function dirSegments(file: string): string[] {
+  const parts = segmentsOf(file);
+  return parts.slice(0, -1);
+}
+
+/**
+ * An entry-relative asset value → the path the dev server serves it at.
+ *
+ * `('src/content/blog/post.md', '../../assets/blog/hero.png')`
+ *   → `'/src/assets/blog/hero.png'`
+ *
+ * A value that is already root-relative is returned unchanged: it is the wrong
+ * shape for the field, but previewing what it actually points at is more useful
+ * than showing nothing. Returns null for an empty value or one that climbs out
+ * of the project root.
+ */
+export function entryRelativeToWeb(entryFile: string, value: string): string | null {
+  const trimmed = value.trim();
+  if (!trimmed) return null;
+  if (trimmed.startsWith('/')) return trimmed;
+  // A bare URL or data: value is not a file path at all — hand it back for the
+  // preview to attempt, and let the caller decide it isn't a valid field value.
+  if (/^[a-z][a-z0-9+.-]*:/i.test(trimmed)) return trimmed;
+  const resolved = normalize([...dirSegments(entryFile), ...segmentsOf(trimmed)]);
+  return resolved && resolved.length ? '/' + resolved.join('/') : null;
+}
+
+/**
+ * A served asset path → the entry-relative value to store in frontmatter.
+ *
+ * `('src/content/blog/post.md', '/src/assets/blog/hero.png')`
+ *   → `'../../assets/blog/hero.png'`
+ *
+ * Returns null when the asset can't back an `image()` field — anything outside
+ * `src/`, which covers every `public/` asset, since Astro cannot import those.
+ */
+export function webToEntryRelative(entryFile: string, webPath: string): string | null {
+  if (!webPath.startsWith('/')) return null;
+  const target = normalize(segmentsOf(webPath));
+  if (!target || target[0] !== IMPORTABLE_PREFIX) return null;
+  const from = normalize(dirSegments(entryFile));
+  if (!from) return null;
+
+  let common = 0;
+  while (common < from.length && common < target.length && from[common] === target[common]) {
+    common++;
+  }
+  const up = new Array(from.length - common).fill('..');
+  const down = target.slice(common);
+  if (down.length === 0) return null; // the asset *is* the directory
+  // A bare `hero.png` reads as a bare module specifier to Vite; `./hero.png`
+  // is unambiguously a sibling file.
+  return up.length ? [...up, ...down].join('/') : './' + down.join('/');
+}
+
+/**
+ * The root-relative directory an `image()` field's current value lives in, for
+ * uploads that should land beside their siblings rather than in a shared root.
+ *
+ * `('src/content/blog/post.md', '../../assets/blog/hero.png')` → `'src/assets/blog'`
+ *
+ * Returns null when there is no value, or when it doesn't resolve to an
+ * importable `src/` asset — the caller then falls back to its configured dir.
+ */
+export function entryAssetDir(entryFile: string, value: string): string | null {
+  const web = entryRelativeToWeb(entryFile, value);
+  if (!web || !web.startsWith('/')) return null;
+  const parts = normalize(segmentsOf(web));
+  if (!parts || parts[0] !== IMPORTABLE_PREFIX) return null;
+  const dir = parts.slice(0, -1);
+  return dir.length ? dir.join('/') : null;
+}
+
+/**
+ * A web path as it must be written into markup: every segment
+ * percent-encoded.
+ *
+ * A filesystem name may hold characters a URL path may not — a space above
+ * all — and the paths this module and `toWebPath` deal in are descriptions of
+ * files, so they carry those characters raw. A browser forgives a raw space
+ * when it fetches one, which is why this is easy to miss, but `src="/a b.png"`
+ * is not a valid URI and is not how anyone writes that path by hand.
+ *
+ * Only for a path that is **not yet** encoded — one this tool composed from a
+ * filename. Running it over a value a person typed would turn their `%20` into
+ * `%2520`, so a hand-edited field keeps what it was given.
+ */
+export function webPathToUrl(webPath: string): string {
+  return webPath.split('/').map(encodeURIComponent).join('/');
+}