vestrycms 0.0.0-stage → 0.1.0

package/dist/core/values.js

@@ -0,0 +1,123 @@
+import { basename, dirname, joinPath, normalizePath, relativePath, resolveRelative, } from "./paths.js";
+export function walkValues(schema, data, fn) {
+    const out = { ...data };
+    for (const [key, field] of Object.entries(schema)) {
+        if (!(key in out))
+            continue;
+        out[key] = walkValue(field, out[key], fn);
+    }
+    return out;
+}
+function walkValue(field, value, fn) {
+    if (field.type === "object" &&
+        value &&
+        typeof value === "object" &&
+        !Array.isArray(value)) {
+        return walkValues(field.fields, value, fn);
+    }
+    if (field.type === "array" && Array.isArray(value)) {
+        return value.map((v) => walkValue(field.of, v, fn));
+    }
+    if (field.type === "tree" && Array.isArray(value)) {
+        const key = field.childrenKey ?? "children";
+        const walkNodes = (nodes) => nodes.map((n) => {
+            if (!n || typeof n !== "object")
+                return n;
+            const node = walkValues(field.fields, n, fn);
+            const children = n[key];
+            if (Array.isArray(children))
+                node[key] = walkNodes(children);
+            return node;
+        });
+        return walkNodes(value);
+    }
+    return fn(field, value);
+}
+export function defaultStorage(field) {
+    if (field.storeAs)
+        return field.storeAs;
+    return normalizePath(field.directory).startsWith("public/")
+        ? "public"
+        : "relative";
+}
+/** Stored reference (relative path, bare filename, public URL) → repository path. */
+export function assetToRepoPath(field, value, filePath) {
+    const dir = normalizePath(field.directory);
+    if (/^https?:\/\//.test(value))
+        return value;
+    if (value.startsWith("/")) {
+        if (dir.startsWith("public/")) {
+            const publicRoot = dir.slice("public/".length);
+            const rel = value.replace(/^\//, "");
+            return rel.startsWith(publicRoot)
+                ? `public/${rel}`
+                : joinPath(dir, basename(rel));
+        }
+        return normalizePath(value);
+    }
+    if (value.startsWith("."))
+        return resolveRelative(dirname(filePath), value);
+    if (value.startsWith(dir))
+        return normalizePath(value);
+    if (value.includes("/") &&
+        (value.startsWith("src/") || value.startsWith("public/"))) {
+        return normalizePath(value);
+    }
+    return joinPath(dir, value);
+}
+/** Repository path → the reference written into the content file. */
+export function repoPathToAsset(field, repoPath, filePath) {
+    if (/^https?:\/\//.test(repoPath))
+        return repoPath;
+    const n = normalizePath(repoPath);
+    switch (defaultStorage(field)) {
+        case "filename":
+            return basename(n);
+        case "public":
+            return n.startsWith("public/")
+                ? `/${n.slice("public/".length)}`
+                : `/${n}`;
+        case "repo":
+            return n;
+        case "relative":
+        default:
+            return relativePath(dirname(filePath), n);
+    }
+}
+/** Convert stored values to the editor's canonical representation (repo paths, ISO strings). */
+export function toEditorValues(schema, data, filePath) {
+    return walkValues(schema, data, (field, value) => {
+        if ((field.type === "image" || field.type === "file") &&
+            typeof value === "string" &&
+            value) {
+            return assetToRepoPath(field, value, filePath);
+        }
+        if (field.type === "date" && value instanceof Date)
+            return value.toISOString().slice(0, 10);
+        if (field.type === "datetime" && value instanceof Date)
+            return value.toISOString();
+        return value;
+    });
+}
+export function toStoredValues(schema, data, filePath) {
+    return walkValues(schema, data, (field, value) => {
+        if ((field.type === "image" || field.type === "file") &&
+            typeof value === "string" &&
+            value) {
+            return repoPathToAsset(field, value, filePath);
+        }
+        return value;
+    });
+}
+export function applyAutoFields(schema, data, now = new Date()) {
+    const out = { ...data };
+    for (const [key, field] of Object.entries(schema)) {
+        if (field.type === "datetime" && field.autoUpdate) {
+            out[key] =
+                field.storage === "local"
+                    ? now.toISOString().slice(0, 16)
+                    : now.toISOString();
+        }
+    }
+    return out;
+}

package/dist/env.d.ts

@@ -0,0 +1,19 @@
+declare module "virtual:vestry/config" {
+  const config: import("./config/types.js").VestryConfig;
+  export default config;
+}
+
+declare module "virtual:vestry/index" {
+  const index: import("./core/index-types.js").BuildIndex;
+  export default index;
+}
+
+declare module "virtual:vestry/runtime" {
+  export const basePath: string;
+  export const name: string;
+}
+
+declare module "virtual:vestry/formatter" {
+  export const available: boolean;
+  export function formatFile(text: string, filepath: string): Promise<string>;
+}

package/dist/index.d.ts

@@ -0,0 +1,18 @@
+import type { AstroIntegration } from "astro";
+import type { VestryConfig } from "./config/types.js";
+export type { VestryConfig } from "./config/types.js";
+export { defineConfig, collection, singleton, component, assetContainer, fields, } from "./config/index.js";
+export interface VestryIntegrationOptions {
+    /** URL path the control panel is served from. Defaults to `/admin`. */
+    base?: string;
+    /**
+     * What `astro dev` does. `local` (the default) edits the project directory
+     * with no sign-in. `auth` edits the project directory but requires sign-in,
+     * with users and sessions kept in `.vestry/auth.sqlite` and emails printed to
+     * the terminal, for working on the sign-in flow itself. `github` goes
+     * through the repository with the GitHub App credentials, as production
+     * does. `VESTRY_MODE` in the environment sets this too.
+     */
+    mode?: "local" | "auth" | "github";
+}
+export default function vestry(config: VestryConfig, options?: VestryIntegrationOptions): AstroIntegration;

package/dist/index.js

@@ -0,0 +1,167 @@
+import { existsSync, mkdirSync } from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { createRequire } from "node:module";
+import { loadEnv } from "vite";
+import { createApi } from "./core/api.js";
+import { buildIndex } from "./integration/build-index.js";
+import { formatterModule } from "./integration/formatter.js";
+import { nodeToFetchHandler } from "./integration/dev-middleware.js";
+import { LocalSource } from "./core/sources/local.js";
+import { consoleMailer } from "./core/mail.js";
+import { clientDependencies } from "./integration/client-deps.js";
+export { defineConfig, collection, singleton, component, assetContainer, fields, } from "./config/index.js";
+const VIRTUAL = {
+    config: "virtual:vestry/config",
+    index: "virtual:vestry/index",
+    runtime: "virtual:vestry/runtime",
+    formatter: "virtual:vestry/formatter",
+};
+export default function vestry(config, options = {}) {
+    const basePath = `/${(options.base ?? "/admin").replace(/^\/+|\/+$/g, "")}`;
+    validateConfig(config);
+    return {
+        name: "vestry",
+        hooks: {
+            "astro:config:setup": ({ command, config: astroConfig, injectRoute, updateConfig, addWatchFile, logger, }) => {
+                const root = fileURLToPath(astroConfig.root);
+                // The config arrives as an object, so Astro can't know which file it
+                // came from. Watch the conventional file name so edits restart dev.
+                for (const name of [
+                    "vestry.config.ts",
+                    "vestry.config.mts",
+                    "vestry.config.js",
+                    "vestry.config.mjs",
+                ]) {
+                    const candidate = path.join(root, name);
+                    if (existsSync(candidate))
+                        addWatchFile(candidate);
+                }
+                const isDev = command === "dev";
+                const fileEnv = loadEnv(isDev ? "development" : "production", root, "");
+                const readEnv = (key) => process.env[key] ?? fileEnv[key];
+                const envMode = readEnv("VESTRY_MODE");
+                const mode = options.mode ??
+                    (envMode === "github" || envMode === "auth"
+                        ? envMode
+                        : isDev
+                            ? "local"
+                            : "github");
+                let indexPromise = null;
+                const getIndex = () => (indexPromise ??= buildIndex(root, config));
+                const plugin = {
+                    name: "vestry",
+                    resolveId(id) {
+                        if (Object.values(VIRTUAL).includes(id))
+                            return `\0${id}`;
+                        return null;
+                    },
+                    async load(id) {
+                        if (id === `\0${VIRTUAL.config}`)
+                            return `export default ${JSON.stringify(config)};`;
+                        if (id === `\0${VIRTUAL.runtime}`) {
+                            return `export const basePath = ${JSON.stringify(basePath)};\nexport const name = ${JSON.stringify(config.name ?? "Vestry")};`;
+                        }
+                        if (id === `\0${VIRTUAL.formatter}`)
+                            return formatterModule(root);
+                        if (id === `\0${VIRTUAL.index}`) {
+                            // Dev edits bypass the index (the local source reads disk), so
+                            // an empty index keeps dev startup instant.
+                            const index = isDev
+                                ? { builtAt: "", files: {} }
+                                : await getIndex();
+                            return `export default ${JSON.stringify(index)};`;
+                        }
+                        return null;
+                    },
+                    configureServer(server) {
+                        if (!isDev)
+                            return;
+                        const localSource = mode === "github" ? undefined : new LocalSource(root);
+                        // Dev keeps users and sessions in a SQLite file and, unless a real
+                        // mail provider is configured, prints sign-in codes to the terminal.
+                        let auth;
+                        if (mode !== "local") {
+                            const dir = path.join(root, ".vestry");
+                            mkdirSync(dir, { recursive: true });
+                            // Loaded only here, so builds and plain local dev never touch
+                            // node:sqlite. A CJS require rather than import(): Astro runs
+                            // this file through Vite's module runner, which intercepts
+                            // dynamic imports and has already closed by the time this runs.
+                            const { DatabaseSync } = createRequire(import.meta.url)("node:sqlite");
+                            auth = {
+                                database: new DatabaseSync(path.join(dir, "auth.sqlite")),
+                                mailer: config.mail?.provider === "resend" &&
+                                    readEnv("VESTRY_RESEND_API_KEY")
+                                    ? undefined
+                                    : consoleMailer((line) => logger.info(line)),
+                                required: true,
+                                dev: true,
+                            };
+                        }
+                        const api = createApi({
+                            config,
+                            index: { builtAt: "", files: {} },
+                            basePath,
+                            env: readEnv,
+                            localSource,
+                            auth,
+                        });
+                        const handler = nodeToFetchHandler(api.handle);
+                        server.middlewares.use((req, res, next) => {
+                            if (!req.url?.startsWith(`${api.apiPrefix}/`) &&
+                                req.url !== api.apiPrefix)
+                                return next();
+                            return handler(req, res, next);
+                        });
+                        logger.info(`Control panel at ${basePath} (${mode === "local"
+                            ? "editing local files, no sign-in"
+                            : mode === "auth"
+                                ? "editing local files, sign-in required"
+                                : `GitHub ${config.repo.owner}/${config.repo.name}`})`);
+                    },
+                };
+                updateConfig({
+                    vite: {
+                        plugins: [plugin],
+                        optimizeDeps: {
+                            include: clientDependencies.map((dep) => `vestrycms > ${dep}`),
+                        },
+                    },
+                });
+                injectRoute({
+                    pattern: `${basePath}/api/[...path]`,
+                    entrypoint: "vestrycms/pages/api",
+                    prerender: false,
+                });
+                injectRoute({
+                    pattern: `${basePath}/[...path]`,
+                    entrypoint: "vestrycms/pages/admin.astro",
+                    prerender: false,
+                });
+            },
+        },
+    };
+}
+function validateConfig(config) {
+    if (!config.repo?.owner || !config.repo?.name) {
+        throw new Error("[vestry] config.repo.owner and config.repo.name are required");
+    }
+    for (const [key, col] of Object.entries(config.collections ?? {})) {
+        if (!col.path)
+            throw new Error(`[vestry] collection "${key}" needs a path`);
+        if (col.body) {
+            for (const name of col.body.components ?? []) {
+                if (!config.components?.[name]) {
+                    throw new Error(`[vestry] collection "${key}" references unknown component "${name}"`);
+                }
+            }
+        }
+    }
+    try {
+        JSON.stringify(config);
+    }
+    catch {
+        throw new Error("[vestry] config must be JSON-serializable (no functions)");
+    }
+}

package/dist/integration/build-index.d.ts

@@ -0,0 +1,8 @@
+import type { VestryConfig } from "../config/types.js";
+import type { BuildIndex } from "../core/index-types.js";
+/**
+ * Scan every file-per-entry collection and record blob SHA + frontmatter.
+ * Runs at build time inside the integration (Node), so it can read the
+ * checked-out repository directly.
+ */
+export declare function buildIndex(root: string, config: VestryConfig): Promise<BuildIndex>;

package/dist/integration/build-index.js

@@ -0,0 +1,67 @@
+import { promises as fs } from "node:fs";
+import path from "node:path";
+import { parseEntry } from "../core/entries.js";
+import { collectionFormat, normalizePath, parsePathPattern, slugFromPath, } from "../core/paths.js";
+import { gitBlobSha } from "../core/source.js";
+/**
+ * Scan every file-per-entry collection and record blob SHA + frontmatter.
+ * Runs at build time inside the integration (Node), so it can read the
+ * checked-out repository directly.
+ */
+export async function buildIndex(root, config) {
+    const files = {};
+    for (const col of Object.values(config.collections ?? {})) {
+        const pattern = parsePathPattern(col.path);
+        if (pattern.single)
+            continue;
+        const format = collectionFormat(col);
+        const dir = path.join(root, pattern.directory);
+        for (const rel of await walk(dir)) {
+            const repoPath = normalizePath(`${pattern.directory}/${rel}`);
+            if (slugFromPath(pattern, repoPath) === null)
+                continue;
+            try {
+                const buf = await fs.readFile(path.join(dir, rel));
+                const text = buf.toString("utf8");
+                const parsed = parseEntry(format, text);
+                files[repoPath] = {
+                    sha: await gitBlobSha(new Uint8Array(buf)),
+                    data: JSON.parse(JSON.stringify(parsed.data)),
+                    excerpt: excerpt(parsed.body),
+                    hasBody: parsed.body.trim().length > 0,
+                };
+            }
+            catch (e) {
+                console.warn(`[vestry] Could not index ${repoPath}: ${e.message}`);
+            }
+        }
+    }
+    return { builtAt: new Date().toISOString(), files };
+}
+async function walk(dir, rel = "") {
+    let entries;
+    try {
+        entries = await fs.readdir(dir, { withFileTypes: true });
+    }
+    catch {
+        return [];
+    }
+    const out = [];
+    for (const e of entries) {
+        const r = rel ? `${rel}/${e.name}` : e.name;
+        if (e.isDirectory())
+            out.push(...(await walk(path.join(dir, e.name), r)));
+        else if (e.isFile())
+            out.push(r);
+    }
+    return out;
+}
+function excerpt(body) {
+    const text = body
+        .replace(/^import .*$/gm, "")
+        .replace(/<[^>]+>/g, " ")
+        .replace(/[#*_>`[\]]/g, "")
+        .replace(/\s+/g, " ")
+        .trim();
+    return text ? text.slice(0, 200) : undefined;
+}

package/dist/integration/client-deps.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Every package the control panel imports in the browser (from `ui/main`,
+ * following relative imports). An installed integration is excluded from
+ * Vite's dependency optimizer, and the optimizer then skips its imports too,
+ * so dev would serve these raw: CommonJS ones such as `react/jsx-runtime`
+ * fail to load. The integration pre-bundles them explicitly as
+ * `vestrycms > dep`, which resolves each from this package. `pnpm build`
+ * checks this list against the compiled UI's imports.
+ */
+export declare const clientDependencies: readonly ["@codemirror/lang-markdown", "@codemirror/lang-yaml", "@codemirror/view", "@dnd-kit/core", "@dnd-kit/modifiers", "@dnd-kit/sortable", "@dnd-kit/utilities", "@tanstack/react-query", "@tiptap/core", "@tiptap/extension-image", "@tiptap/extension-subscript", "@tiptap/extension-superscript", "@tiptap/extension-table", "@tiptap/extensions", "@tiptap/react", "@tiptap/starter-kit", "@uiw/react-codemirror", "better-auth/client", "better-auth/client/plugins", "lucide-react", "mdast-util-from-markdown", "mdast-util-gfm", "mdast-util-mdx", "mdast-util-to-markdown", "micromark-extension-gfm", "micromark-extension-mdxjs", "react", "react-dom", "react-dom/client", "react-router", "react/jsx-runtime", "yaml"];

package/dist/integration/client-deps.js

@@ -0,0 +1,43 @@
+/**
+ * Every package the control panel imports in the browser (from `ui/main`,
+ * following relative imports). An installed integration is excluded from
+ * Vite's dependency optimizer, and the optimizer then skips its imports too,
+ * so dev would serve these raw: CommonJS ones such as `react/jsx-runtime`
+ * fail to load. The integration pre-bundles them explicitly as
+ * `vestrycms > dep`, which resolves each from this package. `pnpm build`
+ * checks this list against the compiled UI's imports.
+ */
+export const clientDependencies = [
+    "@codemirror/lang-markdown",
+    "@codemirror/lang-yaml",
+    "@codemirror/view",
+    "@dnd-kit/core",
+    "@dnd-kit/modifiers",
+    "@dnd-kit/sortable",
+    "@dnd-kit/utilities",
+    "@tanstack/react-query",
+    "@tiptap/core",
+    "@tiptap/extension-image",
+    "@tiptap/extension-subscript",
+    "@tiptap/extension-superscript",
+    "@tiptap/extension-table",
+    "@tiptap/extensions",
+    "@tiptap/react",
+    "@tiptap/starter-kit",
+    "@uiw/react-codemirror",
+    "better-auth/client",
+    "better-auth/client/plugins",
+    "lucide-react",
+    "mdast-util-from-markdown",
+    "mdast-util-gfm",
+    "mdast-util-mdx",
+    "mdast-util-to-markdown",
+    "micromark-extension-gfm",
+    "micromark-extension-mdxjs",
+    "react",
+    "react-dom",
+    "react-dom/client",
+    "react-router",
+    "react/jsx-runtime",
+    "yaml",
+];

package/dist/integration/dev-middleware.d.ts

@@ -0,0 +1,6 @@
+import type { IncomingMessage, ServerResponse } from "node:http";
+/**
+ * Bridge a Node HTTP request to the Fetch API handler and write the Response
+ * back. Used by the Vite dev server middleware.
+ */
+export declare function nodeToFetchHandler(handle: (request: Request) => Promise<Response>): (req: IncomingMessage, res: ServerResponse, next: (err?: unknown) => void) => Promise<void>;

package/dist/integration/dev-middleware.js

@@ -0,0 +1,48 @@
+import { Readable } from "node:stream";
+/**
+ * Bridge a Node HTTP request to the Fetch API handler and write the Response
+ * back. Used by the Vite dev server middleware.
+ */
+export function nodeToFetchHandler(handle) {
+    return async (req, res, next) => {
+        try {
+            const host = req.headers.host ?? "localhost";
+            const proto = req.headers["x-forwarded-proto"] ?? "http";
+            const url = new URL(req.url ?? "/", `${proto}://${host}`);
+            const headers = new Headers();
+            for (const [k, v] of Object.entries(req.headers)) {
+                if (Array.isArray(v))
+                    v.forEach((x) => headers.append(k, x));
+                else if (typeof v === "string")
+                    headers.set(k, v);
+            }
+            const method = req.method ?? "GET";
+            let body;
+            if (method !== "GET" && method !== "HEAD") {
+                const chunks = [];
+                for await (const chunk of req)
+                    chunks.push(Buffer.from(chunk));
+                body = new Uint8Array(Buffer.concat(chunks));
+            }
+            const response = await handle(new Request(url, { method, headers, body }));
+            res.statusCode = response.status;
+            response.headers.forEach((value, key) => {
+                if (key.toLowerCase() === "set-cookie")
+                    return;
+                res.setHeader(key, value);
+            });
+            const cookies = response.headers.getSetCookie?.() ?? [];
+            if (cookies.length)
+                res.setHeader("Set-Cookie", cookies);
+            if (response.body) {
+                Readable.fromWeb(response.body).pipe(res);
+            }
+            else {
+                res.end();
+            }
+        }
+        catch (e) {
+            next(e);
+        }
+    };
+}

package/dist/integration/formatter.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Generates the `virtual:vestry/formatter` module. When the project has
+ * Prettier installed, the control panel formats files with it before saving
+ * (using the project's own Prettier config), so commits made through Vestry
+ * match what `prettier --check` expects. Otherwise the module is a no-op.
+ */
+export declare function formatterModule(root: string): Promise<string>;

package/dist/integration/formatter.js

@@ -0,0 +1,56 @@
+import { existsSync } from "node:fs";
+import { createRequire } from "node:module";
+import path from "node:path";
+import { pathToFileURL } from "node:url";
+/**
+ * Generates the `virtual:vestry/formatter` module. When the project has
+ * Prettier installed, the control panel formats files with it before saving
+ * (using the project's own Prettier config), so commits made through Vestry
+ * match what `prettier --check` expects. Otherwise the module is a no-op.
+ */
+export async function formatterModule(root) {
+    const require = createRequire(path.join(root, "package.json"));
+    let standalone;
+    let plugins;
+    try {
+        // Resolve the ESM builds explicitly: `require.resolve` would pick the
+        // CommonJS entry, which doesn't load as a module in the browser.
+        const pkgDir = path.dirname(require.resolve("prettier/package.json"));
+        standalone = path.join(pkgDir, "standalone.mjs");
+        plugins = {
+            markdown: path.join(pkgDir, "plugins/markdown.mjs"),
+            yaml: path.join(pkgDir, "plugins/yaml.mjs"),
+            babel: path.join(pkgDir, "plugins/babel.mjs"),
+            estree: path.join(pkgDir, "plugins/estree.mjs"),
+        };
+        if (![standalone, ...Object.values(plugins)].every((p) => existsSync(p)))
+            throw new Error("prettier layout");
+    }
+    catch {
+        return `export const available = false;\nexport async function formatFile(text) { return text; }\n`;
+    }
+    let options = {};
+    try {
+        const prettier = await import(
+        /* @vite-ignore */ pathToFileURL(require.resolve("prettier")).href);
+        const resolved = await prettier.resolveConfig(path.join(root, "README.md"), { editorconfig: true });
+        if (resolved) {
+            options = { ...resolved };
+            // Plugins from the config are resolved in Node; the browser gets the fixed set above.
+            delete options.plugins;
+        }
+    }
+    catch {
+        /* fall back to defaults */
+    }
+    return [
+        `import * as prettier from ${JSON.stringify(standalone)};`,
+        ...Object.entries(plugins).map(([name, p]) => `import * as ${name} from ${JSON.stringify(p)};`),
+        `export const available = true;`,
+        `const options = ${JSON.stringify(options)};`,
+        `export async function formatFile(text, filepath) {`,
+        `  return prettier.format(text, { ...options, filepath, plugins: [markdown, yaml, babel, estree] });`,
+        `}`,
+        "",
+    ].join("\n");
+}

package/dist/mdx/expressions.d.ts

@@ -0,0 +1,14 @@
+import type * as ES from "estree";
+/**
+ * Convert a parsed JSX attribute expression to a plain JSON value when it is
+ * made only of literals; otherwise return a RawExpression holding the source.
+ */
+export declare function estreeToValue(node: ES.Node | undefined, source: string): unknown;
+/**
+ * Serialize a JSON value (or RawExpression) to JS source for a JSX attribute,
+ * in the shape Prettier produces: multi-line objects and arrays with trailing
+ * commas, bare identifier keys, double-quoted strings.
+ */
+export declare function valueToSource(value: unknown, indent?: string): string;
+/** Whether a value can be written as a plain string attribute (`a="b"`) rather than an expression. */
+export declare function isPlainString(value: unknown): value is string;