vestrycms 0.0.0-stage → 0.1.0

package/dist/core/paths.js

@@ -0,0 +1,148 @@
+export function normalizePath(p) {
+    return p
+        .replace(/\\/g, "/")
+        .replace(/^\.\//, "")
+        .replace(/\/+/g, "/")
+        .replace(/^\//, "")
+        .replace(/\/$/, "");
+}
+export function extname(p) {
+    const i = p.lastIndexOf(".");
+    const s = p.lastIndexOf("/");
+    return i > s ? p.slice(i + 1).toLowerCase() : "";
+}
+export function basename(p) {
+    return p.slice(p.lastIndexOf("/") + 1);
+}
+export function dirname(p) {
+    const i = p.lastIndexOf("/");
+    return i === -1 ? "" : p.slice(0, i);
+}
+export function joinPath(...parts) {
+    return normalizePath(parts.filter(Boolean).join("/"));
+}
+/** Resolve `../x` style segments against a directory (repo-relative). */
+export function resolveRelative(fromDir, rel) {
+    const out = normalizePath(fromDir).split("/").filter(Boolean);
+    for (const seg of normalizePath(rel).split("/")) {
+        if (seg === "..")
+            out.pop();
+        else if (seg !== "." && seg !== "")
+            out.push(seg);
+    }
+    return out.join("/");
+}
+/** Relative path from one directory to a file (repo-relative, posix). */
+export function relativePath(fromDir, toFile) {
+    const a = normalizePath(fromDir).split("/").filter(Boolean);
+    const b = normalizePath(toFile).split("/").filter(Boolean);
+    let i = 0;
+    while (i < a.length && i < b.length && a[i] === b[i])
+        i++;
+    const ups = a.slice(i).map(() => "..");
+    const rest = b.slice(i);
+    const parts = [...ups, ...rest];
+    const rel = parts.join("/");
+    return rel.startsWith(".") ? rel : `./${rel}`;
+}
+export function formatFromPath(p) {
+    const ext = extname(p);
+    if (ext === "mdx")
+        return "mdx";
+    if (ext === "md" || ext === "markdown")
+        return "md";
+    if (ext === "yaml" || ext === "yml")
+        return "yaml";
+    if (ext === "json")
+        return "json";
+    throw new Error(`Cannot infer content format from path "${p}"`);
+}
+export function parsePathPattern(pattern) {
+    const p = normalizePath(pattern);
+    const deepIdx = p.indexOf("**");
+    const starIdx = p.indexOf("*");
+    if (starIdx === -1) {
+        return {
+            prefix: p,
+            suffix: "",
+            deep: false,
+            single: true,
+            directory: dirname(p),
+        };
+    }
+    const deep = deepIdx !== -1;
+    const prefix = p.slice(0, starIdx);
+    const after = deep ? p.slice(deepIdx + 2) : p.slice(starIdx + 1);
+    // `** /index.md` → suffix `/index.md`; `*.mdx` → suffix `.mdx`
+    if (after.includes("*")) {
+        throw new Error(`Path pattern "${pattern}" may contain only one wildcard`);
+    }
+    return {
+        prefix,
+        suffix: after,
+        deep,
+        single: false,
+        directory: prefix.replace(/\/$/, ""),
+    };
+}
+export function entryPath(pattern, slug) {
+    if (pattern.single)
+        return pattern.prefix;
+    return `${pattern.prefix}${slug}${pattern.suffix}`;
+}
+/** Returns the slug for a file path if it matches the pattern, else null. */
+export function slugFromPath(pattern, path) {
+    const p = normalizePath(path);
+    if (pattern.single)
+        return null;
+    if (!p.startsWith(pattern.prefix) || !p.endsWith(pattern.suffix))
+        return null;
+    const slug = p.slice(pattern.prefix.length, p.length - pattern.suffix.length);
+    if (!slug)
+        return null;
+    if (!pattern.deep && slug.includes("/"))
+        return null;
+    if (slug.startsWith("_") || slug.split("/").some((s) => s.startsWith("_"))) {
+        // Astro ignores underscore-prefixed content files.
+        return null;
+    }
+    return slug;
+}
+export function collectionFormat(c) {
+    return c.format ?? formatFromPath(c.path);
+}
+export function slugify(input) {
+    return input
+        .normalize("NFKD")
+        .replace(/[̀-ͯ]/g, "")
+        .toLowerCase()
+        .replace(/['’"]/g, "")
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/^-+|-+$/g, "");
+}
+/** Fill `{field}` placeholders from a record. Values are slugified when `slug` is true. */
+export function fillTemplate(template, values, opts = {}) {
+    return template.replace(/\{([\w.]+)\}/g, (_, key) => {
+        const raw = key.split(".").reduce((acc, k) => {
+            if (acc && typeof acc === "object")
+                return acc[k];
+            return undefined;
+        }, values);
+        if (raw === undefined || raw === null)
+            return "";
+        let s = raw instanceof Date ? raw.toISOString().slice(0, 10) : String(raw);
+        if (opts.slug)
+            s = slugify(s);
+        return s;
+    });
+}
+const SAFE_SLUG = /^[A-Za-z0-9][A-Za-z0-9._-]*(\/[A-Za-z0-9][A-Za-z0-9._-]*)*$/;
+export function isSafeSlug(slug) {
+    return SAFE_SLUG.test(slug) && !slug.includes("..");
+}
+export function isSafeRepoPath(path) {
+    const p = normalizePath(path);
+    return (p.length > 0 &&
+        !p.split("/").some((s) => s === ".." || s === "" || s === ".git") &&
+        !p.startsWith("/"));
+}

package/dist/core/roles.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Roles and the user shape the control panel works with. Kept free of
+ * server-only imports so the React bundle can share it.
+ */
+export type Role = "admin" | "editor";
+export declare const ROLES: {
+    value: Role;
+    label: string;
+    description: string;
+}[];
+export declare function isRole(value: unknown): value is Role;
+/** What the API sends to the browser about a user. */
+export interface PublicUser {
+    id: string;
+    email: string;
+    name: string;
+    role: Role;
+    /** `invited` until the first successful sign-in. */
+    status: "invited" | "active";
+    /** `config` for addresses listed in `auth.admins`; they cannot be removed or demoted. */
+    origin: "config" | "invite";
+    createdAt: string;
+    lastLoginAt?: string;
+}

package/dist/core/roles.js

@@ -0,0 +1,15 @@
+export const ROLES = [
+    {
+        value: "editor",
+        label: "Editor",
+        description: "Can create, edit and publish content and upload assets.",
+    },
+    {
+        value: "admin",
+        label: "Admin",
+        description: "Everything an editor can do, plus manage users.",
+    },
+];
+export function isRole(value) {
+    return value === "admin" || value === "editor";
+}

package/dist/core/service.d.ts

@@ -0,0 +1,102 @@
+import type { AssetContainerConfig, CollectionConfig, SingletonConfig, VestryConfig } from "../config/types.js";
+import { splitFrontmatter } from "./entries.js";
+import type { BuildIndex } from "./index-types.js";
+import { type ContentSource } from "./source.js";
+export interface EntrySummary {
+    slug: string;
+    path: string;
+    sha: string;
+    title: string;
+    data: Record<string, unknown>;
+    status: "published" | "draft" | null;
+    excerpt?: string;
+}
+export interface EntryDetail extends EntrySummary {
+    body: string;
+    /** Head commit when the entry was read, for conflict detection. */
+    head: string;
+}
+export interface Upload {
+    /** Repository path to write the file to. */
+    path: string;
+    /** Base64 file contents. */
+    base64: string;
+}
+export interface SaveEntryInput {
+    data: Record<string, unknown>;
+    body?: string;
+    /**
+     * Full file text composed (and formatted) by the client. When present it is
+     * written verbatim; `data`/`body` are still used for slugs and messages.
+     */
+    raw?: string;
+    /** Slug for a new entry (otherwise derived from the slug template / title). */
+    slug?: string;
+    /** Blob SHA the client last saw for this entry (omit for new entries). */
+    sha?: string | null;
+    uploads?: Upload[];
+    message?: string;
+}
+export interface AssetItem {
+    name: string;
+    path: string;
+    sha: string;
+    size?: number;
+    kind: "image" | "file";
+    ext: string;
+}
+export declare class ContentService {
+    config: VestryConfig;
+    source: ContentSource;
+    private index;
+    constructor(config: VestryConfig, source: ContentSource, index: BuildIndex);
+    collection(key: string): CollectionConfig;
+    singleton(key: string): SingletonConfig;
+    assetContainer(key: string): AssetContainerConfig;
+    listEntries(key: string): Promise<EntrySummary[]>;
+    /**
+     * Frontmatter for a file: served from the build-time index when the blob
+     * SHA still matches, otherwise read from the source.
+     */
+    private frontmatterFor;
+    getEntry(key: string, slug: string): Promise<EntryDetail | null>;
+    saveEntry(key: string, slug: string | null, input: SaveEntryInput): Promise<{
+        slug: string;
+        sha: string;
+        commit: string;
+        path: string;
+    }>;
+    deleteEntry(key: string, slug: string): Promise<{
+        commit: string;
+    }>;
+    getSingleton(key: string): Promise<EntryDetail>;
+    saveSingleton(key: string, input: SaveEntryInput): Promise<{
+        sha: string;
+        commit: string;
+    }>;
+    listAssets(containerKey: string, subdir?: string): Promise<{
+        items: AssetItem[];
+        folders: string[];
+    }>;
+    uploadAssets(containerKey: string, subdir: string, files: {
+        name: string;
+        base64: string;
+    }[]): Promise<{
+        commit: string;
+        paths: string[];
+    }>;
+    deleteAsset(containerKey: string, path: string): Promise<{
+        commit: string;
+    }>;
+    /** Raw file read restricted to configured asset containers and entry directories. */
+    readFile(path: string): Promise<{
+        bytes: Uint8Array;
+        sha: string;
+    } | null>;
+    allowedDirectories(): string[];
+    titleOf(col: CollectionConfig, data: Record<string, unknown>, slug: string): string;
+    newSlug(col: CollectionConfig, data: Record<string, unknown>): string;
+    commitMessage(col: CollectionConfig, action: string, slug: string, title: string, collection: string, override?: string): string;
+}
+export declare function safeFileName(name: string): string;
+export { splitFrontmatter };