forgepress 0.0.1 → 0.0.2

package/dist/index.d.mts

@@ -1,6 +1,5 @@
-import { Entry, EntryMeta, EntryRef, EntryStatus, ForgePressEntry, ForgePressOutput, ForgePressSchema, ForgePressSchemaRegistry, OutputMeta, OutputOf, RegisteredSchema, SchemaLocale } from "./_chunks/entry.mjs";
-import { OutputCollection, OutputEntry, OutputIndex, OutputManifest } from "./_chunks/types.mjs";
-import { ForgePressConfig, OutputConfig } from "./_chunks/config.mjs";
+import { Entry, EntryMeta, EntryRef, EntryStatus, ForgePressConfig, ForgePressEntry, ForgePressOutput, ForgePressSchema, ForgePressSchemaRegistry, OutputConfig, OutputMeta, OutputOf, RegisteredSchema, SchemaLocale } from "./_chunks/types.mjs";
+import { OutputCollection, OutputEntry, OutputIndex, OutputManifest } from "./_chunks/types2.mjs";
 export declare function defineForgePressConfig(config: ForgePressConfig): ForgePressConfig;
 type Operator = 'eq' | 'ne' | 'gt' | 'gte' | 'lt' | 'lte' | 'in' | 'contains';
 type CollectionName<TSchema extends ForgePressSchema> = keyof TSchema['collections'] & string;

package/dist/index.mjs

@@ -1,6 +1,7 @@
-import { isRecord, quote } from "./_chunks/value.mjs";
-import { entryKey } from "./_chunks/references.mjs";
-import { OUTPUT_INDEX } from "./_chunks/types.mjs";
+import { OUTPUT_META_KEYS, pick, quote } from "./_chunks/value.mjs";
+import { entryKey, isEntryRef } from "./_chunks/references.mjs";
+import { OUTPUT_INDEX } from "./_chunks/response.mjs";
+import { keyed } from "./_chunks/once.mjs";
 import { fetchReader } from "./_chunks/fetch.mjs";
 import { overlaid } from "./_chunks/overlay.mjs";
 import { reader } from "#content-reader";
@@ -8,7 +9,7 @@ function defineForgePressConfig(config) {
 	return config;
 }
 function comparable(value) {
-	return isRecord(value) && typeof value.collection === "string" && typeof value.id === "string" ? value.id : value;
+	return isEntryRef(value) ? value.id : value;
 }
 function compare(left, right) {
 	const first = comparable(left);
@@ -47,13 +48,8 @@ function evaluate(entries, plan) {
 	if (plan.limit !== void 0) result = result.slice(0, plan.limit);
 	return result;
 }
-const META = [
-	"id",
-	"createdAt",
-	"updatedAt"
-];
 function refsOf(value) {
-	return (Array.isArray(value) ? value : [value]).filter((item) => isRecord(item) && typeof item.collection === "string" && typeof item.id === "string");
+	return (Array.isArray(value) ? value : [value]).filter(isEntryRef);
 }
 function listing(names) {
 	return names.map(quote).join(", ");
@@ -125,7 +121,7 @@ var Builder = class {
 		const manifest = await snapshot.manifest(collection, locale);
 		const unlinked = plan.with.filter((field) => manifest.links[field] === void 0);
 		if (unlinked.length > 0) throw new Error(`[forgepress] .with() loads relation and dynamic fields, and ${listing(unlinked)} ${unlinked.length === 1 ? "is not one" : "are not"} in ${quote(collection)}`);
-		const listed = /* @__PURE__ */ new Set([...META, ...manifest.indexed]);
+		const listed = /* @__PURE__ */ new Set([...OUTPUT_META_KEYS, ...manifest.indexed]);
 		const unindexed = [...new Set([...plan.where, ...plan.sort].map((clause) => clause.field))].filter((field) => !listed.has(field));
 		if (unindexed.length > 0 && index.dev) console.warn(`[forgepress] query(${quote(collection)}) filters or sorts by ${listing(unindexed)}, which ${unindexed.length === 1 ? "is" : "are"} not indexed, so every entry is loaded. Add index: true to ${unindexed.length === 1 ? "the field" : "the fields"} in the schema`);
 		const selected = evaluate(unindexed.length > 0 ? await snapshot.entries(collection, locale, manifest.entries.map((entry) => entry.id)) : manifest.entries, limit === void 0 ? plan : {
@@ -135,8 +131,8 @@ var Builder = class {
 		const listedOnly = plan.pick !== void 0 && [...plan.pick, ...plan.with].every((field) => listed.has(field));
 		const rows = unindexed.length > 0 || listedOnly ? selected : await snapshot.entries(collection, locale, selected.map((entry) => entry.id));
 		const linked = plan.with.length > 0 ? await this.link(snapshot, manifest, rows) : rows;
-		const { pick } = plan;
-		const picked = pick === void 0 ? linked : linked.map((row) => Object.fromEntries(pick.filter((field) => row[field] !== void 0).map((field) => [field, row[field]])));
+		const fields = plan.pick;
+		const picked = fields === void 0 ? linked : linked.map((row) => pick(row, fields));
 		return structuredClone(picked);
 	}
 	async link(snapshot, manifest, rows) {
@@ -197,18 +193,12 @@ function manifestPath(index, collection, locale) {
 	return path;
 }
 function createLoader(read) {
-	const files = /* @__PURE__ */ new Map();
+	const files = keyed();
 	function file(path) {
-		let pending = files.get(path);
-		if (!pending) {
-			pending = read(path).then((value) => {
-				if (value === void 0) throw new MissingFile(path);
-				return value;
-			});
-			pending.catch(() => files.delete(path));
-			files.set(path, pending);
-		}
-		return pending;
+		return files(path, () => read(path).then((value) => {
+			if (value === void 0) throw new MissingFile(path);
+			return value;
+		}));
 	}
 	async function snapshot() {
 		const index = await read(OUTPUT_INDEX);

package/dist/next/preview.d.mts

@@ -0,0 +1 @@
+export {}

package/dist/next/preview.mjs

@@ -0,0 +1,3 @@
+import { enablePreview } from "../_chunks/preview.mjs";
+enablePreview();
+export {};

package/dist/next/reload.d.mts

@@ -0,0 +1 @@
+export {}

package/dist/next/reload.mjs

@@ -0,0 +1,20 @@
+import { EVENTS } from "../_chunks/routes.mjs";
+import { settings_default } from "../_chunks/settings2.mjs";
+const RETRY = 1e3;
+const LONGEST_RETRY = 3e4;
+function connect(delay) {
+	const socket = new WebSocket(`${settings_default.devServer.replace(/^http/, "ws")}${EVENTS}`);
+	let opened = false;
+	socket.addEventListener("open", () => {
+		opened = true;
+	});
+	socket.addEventListener("message", (event) => {
+		if (event.data === "reload") location.reload();
+	});
+	socket.addEventListener("close", () => {
+		const next = opened ? RETRY : Math.min(delay * 2, LONGEST_RETRY);
+		setTimeout(connect, next, next);
+	});
+}
+connect(RETRY);
+export {};

package/dist/next/settings.d.mts

@@ -0,0 +1,12 @@
+import { ContentConfig, ProviderConfig, ResolvedMedia } from "../_chunks/types.mjs";
+import "../_chunks/resolve.mjs";
+interface EditorSettings {
+  local: boolean;
+  devServer: string;
+  provider?: ProviderConfig | undefined;
+  format?: ContentConfig | undefined;
+  contentPath: string;
+  media: ResolvedMedia;
+}
+declare const _default: EditorSettings;
+export { _default as default };

package/dist/next/settings.mjs

@@ -0,0 +1,2 @@
+import { settings_default } from "../_chunks/settings2.mjs";
+export { settings_default as default };

package/dist/plugin/next.d.mts

@@ -0,0 +1,11 @@
+import { Options } from "../_chunks/project.mjs";
+import { NextConfig } from "next";
+export interface NextOptions extends Options {
+  preview?: boolean;
+}
+export type NextConfigFunction = (phase: string, context: {
+  defaultConfig: NextConfig;
+}) => NextConfig | Promise<NextConfig>;
+export declare function withForgePress(nextConfig: NextConfig | NextConfigFunction, options?: NextOptions): (phase: string, context: {
+  defaultConfig: NextConfig;
+}) => Promise<NextConfig>;

package/dist/plugin/next.mjs

@@ -0,0 +1,213 @@
+import { isRecord } from "../_chunks/value.mjs";
+import { keyed } from "../_chunks/once.mjs";
+import { errorMessage } from "../_chunks/error.mjs";
+import { buildOutput } from "../_chunks/output.mjs";
+import { toPosix } from "../_chunks/files.mjs";
+import { EVENTS } from "../_chunks/routes.mjs";
+import { SETTINGS_ID, createDevContent, editorSettings, loadProject, syncTypes } from "../_chunks/settings.mjs";
+import { basename, dirname, extname, join, relative, resolve, sep } from "node:path";
+import process from "node:process";
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+import { createServer } from "node:http";
+import { Worker, isMainThread } from "node:worker_threads";
+import { applyEdits, modify, parse } from "jsonc-parser";
+import { WebSocketServer } from "ws";
+const DEVELOPMENT = "phase-development-server";
+const BUILD = "phase-production-build";
+const SETTINGS_MODULE = "forgepress/next/settings";
+const SETTINGS_VARIABLE = "__FORGEPRESS_SETTINGS__";
+const PREVIEW_MODULE = "forgepress/next/preview";
+const RELOAD_MODULE = "forgepress/next/reload";
+const VUE_FLAGS = {
+	__VUE_OPTIONS_API__: true,
+	__VUE_PROD_DEVTOOLS__: false,
+	__VUE_PROD_HYDRATION_MISMATCH_DETAILS__: false
+};
+const SERVERS = Symbol.for("forgepress:next:servers");
+const LOCAL_ORIGIN = /^https?:\/\/(?:(?:[^/:]+\.)?localhost|127\.0\.0\.1|\[::1\])(?::\d+)?$/;
+const PREFLIGHT = {
+	"access-control-allow-methods": "GET, POST, DELETE",
+	"access-control-allow-headers": "content-type",
+	"access-control-max-age": "600"
+};
+const INDENT = /^[ \t]+(?=\S)/m;
+const DIST = `${dirname(dirname(fileURLToPath(import.meta.url)))}${sep}`;
+const WATCHER = new URL(`./watcher${extname(fileURLToPath(import.meta.url))}`, import.meta.url);
+function dynamicConfigImport(warning) {
+	return Boolean(warning.module?.resource?.startsWith(DIST) && warning.message?.includes("the request of a dependency is an expression"));
+}
+const logger = {
+	info: (message) => process.stdout.write(`${message}\n`),
+	warn: (message) => console.warn(message),
+	error: (message) => console.error(message)
+};
+function localPage(request) {
+	const { origin } = request.headers;
+	const site = request.headers["sec-fetch-site"];
+	if (origin !== void 0) return LOCAL_ORIGIN.test(origin);
+	return site === void 0 || site === "none" || site === "same-origin";
+}
+const LOCAL_PAGES = {
+	accepts: localPage,
+	refusal: "the dev endpoint only accepts requests from pages opened on localhost"
+};
+function end(response, status, text) {
+	response.statusCode = status;
+	response.end(text);
+}
+function servers() {
+	const scope = globalThis;
+	scope[SERVERS] ??= keyed();
+	return scope[SERVERS];
+}
+function formatting(text) {
+	const indent = INDENT.exec(text)?.[0] ?? "  ";
+	return {
+		insertSpaces: !indent.startsWith("	"),
+		tabSize: indent.length,
+		eol: text.includes("\r\n") ? "\r\n" : "\n"
+	};
+}
+function includeContent(root, config, tsconfig) {
+	const file = resolve(root, tsconfig);
+	if (!existsSync(file)) return;
+	const folder = toPosix(relative(dirname(file), join(root, config.paths.dir)));
+	const pattern = `${folder}/**/*.ts`;
+	if (!folder.split("/").some((segment) => segment.startsWith("."))) return;
+	const text = readFileSync(file, "utf8");
+	const errors = [];
+	const parsed = parse(text, errors, { allowTrailingComma: true });
+	if (errors.length > 0 || !isRecord(parsed) || !Array.isArray(parsed.include)) {
+		logger.warn(`[forgepress] add ${JSON.stringify(pattern)} to "include" in ${basename(file)}, so TypeScript knows the schema`);
+		return;
+	}
+	if (parsed.include.includes(pattern)) return;
+	writeFileSync(file, applyEdits(text, modify(text, ["include", parsed.include.length], pattern, {
+		isArrayInsertion: true,
+		formattingOptions: formatting(text)
+	})));
+	logger.info(`[forgepress] added ${JSON.stringify(pattern)} to "include" in ${basename(file)}, so TypeScript knows the schema`);
+}
+function watchContent(dir, schema, changed) {
+	const watcher = new Worker(WATCHER, { workerData: {
+		dir,
+		schema
+	} });
+	let watching = false;
+	return new Promise((ready, fail) => {
+		watcher.on("message", (file) => {
+			if (file !== null) return changed(file);
+			watching = true;
+			watcher.unref();
+			ready();
+		});
+		watcher.on("error", (error) => {
+			if (watching) logger.error(`[forgepress] stopped watching the content folder: ${errorMessage(error)}`);
+			else fail(error);
+		});
+	});
+}
+function listen(server) {
+	return new Promise((done, fail) => {
+		server.once("error", fail);
+		server.listen(0, "127.0.0.1", () => done(`127.0.0.1:${server.address().port}`));
+	});
+}
+async function startDevServer(root, config, write) {
+	const pages = new WebSocketServer({ noServer: true });
+	const dev = createDevContent(root, config, logger, () => {
+		for (const page of pages.clients) page.send("reload");
+	}, LOCAL_PAGES);
+	await watchContent(join(root, config.paths.dir), join(root, config.paths.schema), dev.changed);
+	await dev.refresh();
+	const server = createServer();
+	const host = await listen(server);
+	server.on("request", (request, response) => {
+		const { origin } = request.headers;
+		if (request.headers.host !== host) return end(response, 403);
+		if (origin !== void 0) {
+			response.setHeader("access-control-allow-origin", origin);
+			response.setHeader("vary", "origin");
+		}
+		if (request.method === "OPTIONS") {
+			if (!LOCAL_PAGES.accepts(request)) return end(response, 403, LOCAL_PAGES.refusal);
+			for (const [name, value] of Object.entries(PREFLIGHT)) response.setHeader(name, value);
+			return end(response, 204);
+		}
+		if (!write) return end(response, 404);
+		dev.endpoint(request, response, () => end(response, 404));
+	});
+	server.on("upgrade", (request, socket, head) => {
+		if (request.headers.host !== host || request.url !== EVENTS || !LOCAL_PAGES.accepts(request)) {
+			socket.destroy();
+			return;
+		}
+		socket.unref();
+		pages.handleUpgrade(request, socket, head, (page) => page.on("error", () => page.terminate()));
+	});
+	server.unref();
+	return `http://${host}`;
+}
+function devServer(root, config, write) {
+	return servers()(root, () => startDevServer(root, config, write));
+}
+async function prepare(phase, next, options) {
+	const project = await loadProject(process.cwd(), options);
+	const { root, config } = project;
+	const serving = phase === DEVELOPMENT && isMainThread;
+	if (isMainThread && (phase === DEVELOPMENT || phase === BUILD)) {
+		syncTypes(root, config);
+		includeContent(root, config, next.typescript?.tsconfigPath ?? "tsconfig.json");
+	}
+	return {
+		...project,
+		local: phase === DEVELOPMENT && options.write !== false,
+		server: serving ? await devServer(root, config, options.write !== false) : void 0
+	};
+}
+function extend(next, project, options) {
+	const extended = {
+		compiler: {
+			...next.compiler,
+			define: {
+				...VUE_FLAGS,
+				...next.compiler?.define,
+				[SETTINGS_VARIABLE]: JSON.stringify(editorSettings(project.local, project.config, project.server))
+			},
+			runAfterProductionCompile: async (metadata) => {
+				await buildOutput(project.root, project.config);
+				await next.compiler?.runAfterProductionCompile?.(metadata);
+			}
+		},
+		turbopack: {
+			...next.turbopack,
+			resolveAlias: {
+				...next.turbopack?.resolveAlias,
+				[SETTINGS_ID]: SETTINGS_MODULE
+			}
+		},
+		webpack: (config, context) => {
+			const result = next.webpack ? next.webpack(config, context) : config;
+			result.plugins = [...result.plugins ?? [], new context.webpack.NormalModuleReplacementPlugin(/^virtual:forgepress\/settings$/, SETTINGS_MODULE)];
+			result.ignoreWarnings = [...result.ignoreWarnings ?? [], dynamicConfigImport];
+			return result;
+		},
+		instrumentationClientInject: [
+			...next.instrumentationClientInject ?? [],
+			...options.preview === false ? [] : [PREVIEW_MODULE],
+			...project.server ? [RELOAD_MODULE] : []
+		]
+	};
+	return {
+		...next,
+		...extended
+	};
+}
+function withForgePress(nextConfig, options = {}) {
+	return async (phase, context) => {
+		const found = typeof nextConfig === "function" ? await nextConfig(phase, context) : nextConfig;
+		return extend(found, await prepare(phase, found, options), options);
+	};
+}
+export { withForgePress };

package/dist/plugin/nuxt.d.mts

@@ -0,0 +1,7 @@
+import { Options } from "../_chunks/project.mjs";
+import { NuxtModule } from "@nuxt/schema";
+export interface ModuleOptions extends Options {
+  preview?: boolean;
+}
+declare const forgepress: NuxtModule<ModuleOptions>;
+export { forgepress as default };

package/dist/plugin/nuxt.mjs

@@ -0,0 +1,52 @@
+import { toPosix } from "../_chunks/files.mjs";
+import { loadProject } from "../_chunks/settings.mjs";
+import { configFile } from "../_chunks/config.mjs";
+import { vitePlugin } from "../_chunks/plugin.mjs";
+import { join, relative } from "node:path";
+import { addPluginTemplate, addVitePlugin, defineNuxtModule } from "@nuxt/kit";
+const PREVIEW_PLUGIN = `import { defineNuxtPlugin, refreshNuxtData, usePreviewMode } from '#app'
+import { enablePreview, onPreviewChange, previewing } from 'forgepress/preview'
+
+export default defineNuxtPlugin({
+  name: 'forgepress:preview',
+  setup(nuxtApp) {
+    enablePreview()
+
+    const { enabled } = usePreviewMode({ shouldEnable: previewing })
+
+    onPreviewChange(() => nuxtApp.runWithContext(() => {
+      enabled.value = previewing()
+
+      return refreshNuxtData()
+    }))
+  },
+})
+`;
+const forgepress = defineNuxtModule({
+	meta: {
+		name: "forgepress",
+		configKey: "forgepress"
+	},
+	async setup(options, nuxt) {
+		const { root, config } = await loadProject(nuxt.options.rootDir, options);
+		addVitePlugin(vitePlugin({
+			...options,
+			root
+		}));
+		nuxt.hook("prepare:types", ({ tsConfig, nodeTsConfig }) => {
+			tsConfig.include ??= [];
+			tsConfig.include.push(toPosix(relative(nuxt.options.buildDir, join(root, config.paths.dir, "**/*.ts"))));
+			const file = configFile(root);
+			if (file) {
+				nodeTsConfig.include ??= [];
+				nodeTsConfig.include.push(toPosix(relative(nuxt.options.buildDir, join(root, file))));
+			}
+		});
+		if (options.preview !== false) addPluginTemplate({
+			filename: "forgepress/preview.client.mjs",
+			getContents: () => PREVIEW_PLUGIN,
+			mode: "client"
+		});
+	}
+});
+export { forgepress as default };

package/dist/plugin/watcher.d.mts

@@ -0,0 +1 @@
+export {}

package/dist/plugin/watcher.mjs

@@ -0,0 +1,23 @@
+import { basename, dirname, join } from "node:path";
+import { existsSync, watch } from "node:fs";
+import { parentPort, workerData } from "node:worker_threads";
+const { dir, schema } = workerData;
+function changed(file) {
+	parentPort?.postMessage(file);
+}
+function start() {
+	if (!existsSync(dir)) return false;
+	watch(dir, { recursive: true }, (_, name) => {
+		if (name) changed(join(dir, name));
+	});
+	return true;
+}
+if (!start() && existsSync(dirname(dir))) {
+	const parent = watch(dirname(dir), (_, name) => {
+		if (name !== basename(dir) || !start()) return;
+		parent.close();
+		changed(schema);
+	});
+}
+parentPort?.postMessage(null);
+export {};

package/dist/preview/index.d.mts

@@ -1,5 +1,4 @@
-import "../_chunks/entry.mjs";
-import "../_chunks/config.mjs";
+import "../_chunks/types.mjs";
 export declare function previewing(): boolean;
 export declare function onPreviewChange(listener: () => void): () => void;
 export declare function enablePreview(): boolean;