forgepress 0.0.0 → 0.0.2

package/dist/_chunks/references.mjs

@@ -0,0 +1,56 @@
+import { isRecord, isTranslated, quote } from "./value.mjs";
+function entryKey(collection, id) {
+	return `${collection}/${id}`;
+}
+function isEntryRef(value) {
+	return isRecord(value) && typeof value.collection === "string" && typeof value.id === "string";
+}
+function localized(value, path, translated) {
+	if (!translated) return [[path, value]];
+	return isRecord(value) ? Object.entries(value).map(([locale, item]) => [[...path, locale], item]) : [];
+}
+function references(field, value, path) {
+	if (field.type === "relation" && !field.multiple) return typeof value === "string" ? [{
+		path,
+		collection: field.collection,
+		id: value
+	}] : [];
+	if (!Array.isArray(value)) return [];
+	if (field.type === "relation") return value.flatMap((id, index) => typeof id === "string" ? [{
+		path: [...path, index],
+		collection: field.collection,
+		id
+	}] : []);
+	if (field.type === "dynamic") return value.flatMap((block, index) => isEntryRef(block) && field.collections.includes(block.collection) ? [{
+		path: [...path, index],
+		collection: block.collection,
+		id: block.id
+	}] : []);
+	return [];
+}
+function entryReferences(schema, collection, row) {
+	const locales = schema.locales ?? [];
+	return Object.entries(schema.collections[collection]?.fields ?? {}).flatMap(([key, field]) => localized(row[key], [key], isTranslated(field, locales)).flatMap(([path, value]) => references(field, value, path)));
+}
+function validateReferences(schema, content) {
+	const issues = [];
+	for (const [collection, entries] of Object.entries(content)) for (const [id, row] of Object.entries(entries)) for (const reference of entryReferences(schema, collection, row)) {
+		const target = content[reference.collection]?.[reference.id];
+		const name = entryKey(reference.collection, reference.id);
+		const field = quote(reference.path[0]);
+		if (!target) issues.push({
+			collection,
+			id,
+			path: reference.path,
+			message: `Field ${field} references ${name}, which doesn't exist`
+		});
+		else if (row.status === "published" && target.status !== "published") issues.push({
+			collection,
+			id,
+			path: reference.path,
+			message: `Field ${field} references ${name}, which is unpublished; publish it or remove the reference`
+		});
+	}
+	return issues;
+}
+export { entryKey, isEntryRef, validateReferences };

package/dist/_chunks/resolve.d.mts

@@ -0,0 +1,2 @@
+import "./types.mjs";
+import "./types2.mjs";

package/dist/_chunks/response.mjs

@@ -0,0 +1,5 @@
+const OUTPUT_INDEX = "index.json";
+function isPage(response) {
+	return response.headers.get("content-type")?.includes("text/html") === true;
+}
+export { OUTPUT_INDEX, isPage };

package/dist/_chunks/routes.mjs

@@ -0,0 +1,9 @@
+const ENDPOINT = "/__forgepress";
+const EVENTS = `${ENDPOINT}/events`;
+const ROUTES = {
+	schema: "/schema",
+	content: "/content",
+	entry: "/entry",
+	media: "/media"
+};
+export { ENDPOINT, EVENTS, ROUTES };

package/dist/_chunks/serialize.mjs

@@ -0,0 +1,82 @@
+import { META_KEYS } from "./value.mjs";
+const IDENTIFIER = /^[A-Z_$][\w$]*$/i;
+const WIDTH = 80;
+const ESCAPES = {
+	"\\": "\\\\",
+	"'": "\\'",
+	"\n": "\\n",
+	"\r": "\\r",
+	"	": "\\t"
+};
+function style(config) {
+	return {
+		indent: " ".repeat(config?.indent ?? 2),
+		semi: config?.semi ? ";" : ""
+	};
+}
+function unsafe(code) {
+	return code < 32 || code >= 127 && code <= 159 || code === 8232 || code === 8233;
+}
+function string(value) {
+	let out = "";
+	for (const char of value) {
+		const escaped = ESCAPES[char];
+		const code = char.charCodeAt(0);
+		if (escaped !== void 0) out += escaped;
+		else if (unsafe(code)) out += `\\u${code.toString(16).padStart(4, "0")}`;
+		else out += char;
+	}
+	return `'${out}'`;
+}
+function key(value) {
+	return IDENTIFIER.test(value) ? value : string(value);
+}
+function storable(input) {
+	return input !== void 0 && input !== null && !(typeof input === "number" && !Number.isFinite(input));
+}
+function value(input, style, depth) {
+	if (typeof input === "string") return string(input);
+	if (typeof input === "number") return String(input);
+	if (typeof input === "boolean") return String(input);
+	const pad = style.indent.repeat(depth + 1);
+	const close = style.indent.repeat(depth);
+	if (Array.isArray(input)) {
+		const kept = input.filter(storable);
+		if (kept.length === 0) return "[]";
+		const items = kept.map((item) => value(item, style, depth + 1));
+		const inline = `[${items.join(", ")}]`;
+		if (kept.every((item) => typeof item !== "object") && close.length + inline.length <= WIDTH) return inline;
+		return `[\n${items.map((item) => `${pad}${item},`).join("\n")}\n${close}]`;
+	}
+	const entries = Object.entries(input).filter(([, item]) => storable(item));
+	if (entries.length === 0) return "{}";
+	return `{\n${entries.map(([name, item]) => `${pad}${key(name)}: ${value(item, style, depth + 1)},`).join("\n")}\n${close}}`;
+}
+function serializeSchema(schema, config) {
+	const current = style(config);
+	return [
+		`import type { ForgePressSchema } from 'forgepress'${current.semi}`,
+		"",
+		`export default ${value(schema, current, 0)} as const satisfies ForgePressSchema${current.semi}`,
+		""
+	].join("\n");
+}
+function ordered(row) {
+	const entries = Object.entries(row).filter(([, item]) => storable(item));
+	const rank = (name) => {
+		const index = META_KEYS.indexOf(name);
+		return index === -1 ? META_KEYS.length : index;
+	};
+	return entries.sort(([left], [right]) => rank(left) - rank(right));
+}
+function serializeEntry(collection, row, config) {
+	const current = style(config);
+	const body = ordered(row).map(([name, item]) => `${current.indent}${key(name)}: ${value(item, current, 1)},`).join("\n");
+	return [
+		`import type { ForgePressEntry } from 'forgepress'${current.semi}`,
+		"",
+		`export default {\n${body}\n} satisfies ForgePressEntry<${string(collection)}>${current.semi}`,
+		""
+	].join("\n");
+}
+export { serializeEntry, serializeSchema };

package/dist/_chunks/settings.mjs

@@ -0,0 +1,328 @@
+import { isRecord } from "./value.mjs";
+import { errorMessage } from "./error.mjs";
+import { assetName, checkUpload, defaultPaths, isAssetName, isCollectionName, isEntryFile, isEntryId, isMediaFile, mediaType, resolveMedia, sortAssets, storedAsset, toEntryId } from "./media.mjs";
+import { ContentError, createFileSource, validateSchema } from "./content.mjs";
+import { buildOutput, outputDir } from "./output.mjs";
+import { diskFiles, listFiles } from "./files.mjs";
+import { ENDPOINT, ROUTES } from "./routes.mjs";
+import { serializeEntry, serializeSchema } from "./serialize.mjs";
+import { findRoot, loadConfig, resolveConfig } from "./config.mjs";
+import { OUTPUT_VARIABLE } from "./reader.mjs";
+import { mkdir, readdir, rm, stat, writeFile } from "node:fs/promises";
+import { dirname, join, resolve, sep } from "node:path";
+import process from "node:process";
+import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { debounce } from "perfect-debounce";
+import { Buffer } from "node:buffer";
+function createMediaStore(root, config) {
+	const media = resolveMedia(config);
+	const dir = join(root, media.dir);
+	async function describe(name) {
+		const info = await stat(join(dir, name));
+		return {
+			...storedAsset(name, media.url),
+			size: info.size,
+			modifiedAt: info.mtime.toISOString()
+		};
+	}
+	return {
+		async list() {
+			if (!existsSync(dir)) return [];
+			const files = (await readdir(dir)).filter(isMediaFile);
+			return sortAssets(await Promise.all(files.map(describe)));
+		},
+		async write({ name, data }) {
+			checkUpload(name, data.byteLength, media.maxSize);
+			const file = await assetName(name, data);
+			await mkdir(dir, { recursive: true });
+			await writeFile(join(dir, file), data);
+			return describe(file);
+		},
+		async remove(name) {
+			if (!isAssetName(name)) throw new Error(`[forgepress] "${name}" is not a valid asset name`);
+			await rm(join(dir, name), { force: true });
+		}
+	};
+}
+function collectionName$1(collection) {
+	if (!isCollectionName(collection)) throw new Error(`[forgepress] ${JSON.stringify(collection)} is not a collection name`);
+	return collection;
+}
+function entryId$1(id) {
+	if (typeof id !== "string" || !isEntryId(id)) throw new Error(`[forgepress] ${JSON.stringify(id)} is not an entry id`);
+	return id;
+}
+function createWriter(root, paths = defaultPaths, config) {
+	const directory = (collection) => join(root, paths.collection(collectionName$1(collection)));
+	const file = (collection, id) => join(root, paths.entry(collectionName$1(collection), entryId$1(id)));
+	return {
+		async writeSchema(schema) {
+			await mkdir(join(root, paths.dir), { recursive: true });
+			await writeFile(join(root, paths.schema), serializeSchema(schema, config));
+		},
+		async writeEntry(collection, row) {
+			const target = file(collection, row.id);
+			await mkdir(directory(collection), { recursive: true });
+			await writeFile(target, serializeEntry(collection, row, config));
+		},
+		async removeEntry(collection, id) {
+			await rm(file(collection, id), { force: true });
+		},
+		async writeContent(collection, rows) {
+			const targets = rows.map((row) => [file(collection, row.id), serializeEntry(collection, row, config)]);
+			const kept = new Set(rows.map((row) => row.id));
+			await mkdir(directory(collection), { recursive: true });
+			const stale = (await listFiles(directory(collection))).filter(isEntryFile).map(toEntryId).filter((id) => !kept.has(id));
+			await Promise.all(stale.map((id) => rm(file(collection, id), { force: true })));
+			await Promise.all(targets.map(([target, text]) => writeFile(target, text)));
+		},
+		async removeCollection(collection) {
+			await rm(directory(collection), {
+				recursive: true,
+				force: true
+			});
+		}
+	};
+}
+var EndpointError = class extends Error {
+	status;
+	constructor(status, message) {
+		super(message);
+		this.name = "EndpointError";
+		this.status = status;
+	}
+};
+function sameOrigin(request) {
+	const site = request.headers["sec-fetch-site"];
+	if (site !== void 0) return site === "same-origin" || site === "none";
+	const { origin, host } = request.headers;
+	if (origin === void 0) return true;
+	try {
+		return new URL(origin).host === host;
+	} catch {
+		return false;
+	}
+}
+const SAME_ORIGIN = {
+	accepts: sameOrigin,
+	refusal: "the dev endpoint only accepts requests from pages on its own origin"
+};
+function missing(path) {
+	return new EndpointError(404, `there is no endpoint ${JSON.stringify(path)}`);
+}
+async function bytes(request) {
+	const chunks = [];
+	for await (const chunk of request) chunks.push(chunk);
+	return Buffer.concat(chunks);
+}
+async function body(request) {
+	const text = (await bytes(request)).toString("utf8");
+	try {
+		return JSON.parse(text);
+	} catch {
+		throw new EndpointError(400, "the request body is not valid JSON");
+	}
+}
+function json(response, payload) {
+	response.statusCode = 200;
+	response.setHeader("content-type", "application/json");
+	response.end(JSON.stringify(payload));
+}
+function done(response) {
+	response.statusCode = 204;
+	response.end();
+}
+function decode(value, path) {
+	try {
+		return decodeURIComponent(value);
+	} catch {
+		throw new EndpointError(400, `${JSON.stringify(path)} is not a valid path`);
+	}
+}
+function under(path, route) {
+	return path.startsWith(`${route}/`);
+}
+function segments(path, route, count) {
+	const found = path.slice(route.length + 1).split("/").filter(Boolean).map((segment) => decode(segment, path));
+	if (found.length > count) throw missing(path);
+	return found;
+}
+function collectionName(name) {
+	if (name === void 0 || !isCollectionName(name)) throw new EndpointError(400, `${JSON.stringify(name ?? "")} is not a collection name`);
+	return name;
+}
+function entryId(id) {
+	if (typeof id !== "string" || !isEntryId(id)) throw new EndpointError(400, `${JSON.stringify(id ?? "")} is not an entry id`);
+	return id;
+}
+function entry(value) {
+	if (!isRecord(value)) throw new EndpointError(400, "an entry has to be an object");
+	entryId(value.id);
+	return value;
+}
+async function media(config, root, path, request, response) {
+	const store = createMediaStore(root, config.media);
+	if (request.method === "GET") return json(response, await store.list());
+	const name = decode(path.slice(ROUTES.media.length + 1), path);
+	if (request.method === "DELETE") {
+		if (!isAssetName(name)) throw new EndpointError(400, `${JSON.stringify(name)} is not an asset name`);
+		await store.remove(name);
+		return done(response);
+	}
+	if (!mediaType(name)) throw new EndpointError(400, `${JSON.stringify(name)} is not a supported media file`);
+	return json(response, await store.write({
+		name,
+		data: await bytes(request)
+	}));
+}
+async function read(config, root, path, response) {
+	const source = createFileSource(diskFiles(root), config.paths);
+	if (path === ROUTES.schema) return json(response, await source.schema());
+	if (under(path, ROUTES.content)) {
+		const [collection = ""] = segments(path, ROUTES.content, 1);
+		const schema = await source.schema();
+		return json(response, Object.hasOwn(schema.collections, collection) ? await source.list(collection) : []);
+	}
+	if (!under(path, ROUTES.entry)) throw missing(path);
+	const [collection = "", id = ""] = segments(path, ROUTES.entry, 2);
+	const schema = await source.schema();
+	const row = Object.hasOwn(schema.collections, collection) && isEntryId(id) ? await source.entry(collection, id) : void 0;
+	if (row) return json(response, row);
+	response.statusCode = 404;
+	response.end();
+}
+async function write(config, root, path, request, response) {
+	const writer = createWriter(root, config.paths, config.content);
+	const removing = request.method === "DELETE";
+	if (path === ROUTES.schema && !removing) {
+		const schema = await body(request);
+		const issues = validateSchema(schema);
+		if (issues.length > 0) throw new EndpointError(400, `the schema is not valid:\n${issues.map((issue) => issue.message).join("\n")}`);
+		await writer.writeSchema(schema);
+	} else if (under(path, ROUTES.entry)) {
+		const [name, id] = segments(path, ROUTES.entry, 2);
+		const collection = collectionName(name);
+		if (removing) await writer.removeEntry(collection, entryId(id));
+		else {
+			const row = entry(await body(request));
+			if (row.id !== entryId(id)) throw new EndpointError(400, `the entry id ${JSON.stringify(row.id)} doesn't match the path`);
+			await writer.writeEntry(collection, row);
+		}
+	} else if (under(path, ROUTES.content)) {
+		const [name] = segments(path, ROUTES.content, 1);
+		const collection = collectionName(name);
+		if (removing) await writer.removeCollection(collection);
+		else {
+			const rows = await body(request);
+			if (!Array.isArray(rows)) throw new EndpointError(400, "the entries have to be a list");
+			await writer.writeContent(collection, rows.map(entry));
+		}
+	} else throw missing(path);
+	done(response);
+}
+async function handle(config, root, request, response, origins = SAME_ORIGIN) {
+	if (!origins.accepts(request)) throw new EndpointError(403, origins.refusal);
+	const path = (request.url ?? "").slice(ENDPOINT.length);
+	if (path === ROUTES.media || under(path, ROUTES.media)) return media(config, root, path, request, response);
+	if (request.method === "GET") return read(config, root, path, response);
+	return write(config, root, path, request, response);
+}
+const TYPES = `// Generated by ForgePress. Do not edit.
+import type schema from './schema'
+
+declare module 'forgepress' {
+  interface ForgePressSchemaRegistry {
+    schema: typeof schema
+  }
+}
+
+export {}
+`;
+async function loadProject(base, options) {
+	const root = options?.root ? resolve(base, options.root) : findRoot(base);
+	const loaded = await loadConfig(root);
+	const config = resolveConfig({
+		...loaded,
+		media: {
+			...loaded?.media,
+			...options?.media
+		}
+	});
+	const output = outputDir(root, config);
+	process.env[OUTPUT_VARIABLE] = output;
+	return {
+		root,
+		config,
+		output
+	};
+}
+function syncTypes(root, config) {
+	const path = join(root, config.paths.types);
+	if (!existsSync(join(root, config.paths.schema))) {
+		rmSync(path, { force: true });
+		return;
+	}
+	if (existsSync(path) && readFileSync(path, "utf8") === TYPES) return;
+	mkdirSync(dirname(path), { recursive: true });
+	writeFileSync(path, TYPES);
+}
+function createDevContent(root, config, logger, reload, origins = SAME_ORIGIN) {
+	const schemaFile = join(root, config.paths.schema);
+	const contentDir = join(root, config.paths.content);
+	let reported = "";
+	function report(issues) {
+		const message = issues.length > 0 ? new ContentError(issues).message : "";
+		if (message === reported) return;
+		if (message) logger.warn(`${message}\n[forgepress] the build fails until ${issues.length === 1 ? "this problem is" : "these problems are"} fixed`);
+		else logger.info("[forgepress] content problems are fixed");
+		reported = message;
+	}
+	async function write() {
+		syncTypes(root, config);
+		try {
+			report((await buildOutput(root, config, { dev: true })).issues);
+		} catch (error) {
+			if (!(error instanceof ContentError)) throw error;
+			report(error.issues);
+		}
+	}
+	const rebuild = debounce(async (after) => {
+		await write().catch((error) => logger.error(`[forgepress] could not write the content output: ${errorMessage(error)}`));
+		after?.();
+	}, 100);
+	return {
+		watched: [schemaFile, contentDir],
+		changed: (file) => {
+			if (file === schemaFile || file.startsWith(`${contentDir}${sep}`)) rebuild(reload);
+		},
+		refresh: () => rebuild(),
+		endpoint: (request, response, next) => {
+			const method = request.method ?? "";
+			if (!(method === "POST" || method === "DELETE" || method === "GET") || !request.url?.startsWith(`/__forgepress/`)) return next();
+			handle(config, root, request, response, origins).then(() => {
+				if (method !== "GET") rebuild(reload);
+			}).catch((error) => {
+				response.statusCode = error instanceof EndpointError ? error.status : 500;
+				response.end(errorMessage(error));
+			});
+		}
+	};
+}
+function editorSettings(local, config, devServer = "") {
+	return {
+		local,
+		devServer,
+		provider: config.provider,
+		format: config.content,
+		contentPath: config.paths.dir,
+		media: config.media
+	};
+}
+const SETTINGS_ID = "virtual:forgepress/settings";
+function resolved(id) {
+	return `\0${id}`;
+}
+function generateSettings(local, config) {
+	return `export default ${JSON.stringify(editorSettings(local, config))}\n`;
+}
+export { SETTINGS_ID, createDevContent, editorSettings, generateSettings, loadProject, resolved, syncTypes };

package/dist/_chunks/settings2.mjs

@@ -0,0 +1,2 @@
+var settings_default = JSON.parse(__FORGEPRESS_SETTINGS__);
+export { settings_default };