@ubean/content 0.6.0 → 0.6.1-beta.2

package/dist/index.d.ts

@@ -170,5 +170,28 @@ interface LiveCollection extends Omit<ContentCollection, 'documents' | 'list' |
   /** Invalidate the cache, forcing the next fetch to call the loader. */
   invalidate(): void;
 }
+/**
+ * Define a live collection that fetches content at request time.
+ *
+ * The loader is called on every request (unless caching is enabled).
+ * Entries are converted to `ContentDocument` shape and can be queried
+ * using the standard query builder.
+ *
+ * @param options Collection definition
+ * @returns LiveCollection instance
+ */
+export declare function defineLiveCollection(options: LiveCollectionOptions): LiveCollection;
+/**
+ * Get a registered live collection by name.
+ */
+export declare function getLiveCollection(name: string): LiveCollection | undefined;
+/**
+ * List all registered live collection names.
+ */
+export declare function listLiveCollections(): string[];
+/**
+ * Clear all registered live collections (useful for testing).
+ */
+export declare function clearLiveCollections(): void;
 //#endregion
 export { type ContentBody, type ContentCollection, type ContentDocument, type ContentFieldSchema, type ContentModuleOptions, type ContentNavigationItem, type ContentPageRouteOptions, type ContentQueryBuilder, type ContentSchema, type ContentSearchOptions, type ContentSourceConfig, type ContentSourceScanConfig, type ContentTocItem, type ContentType, type DiscoverContentPageRoutesOptions, type GenerateSearchSectionsOptions, type LiveCollection, type LiveCollectionCacheOptions, type LiveCollectionEntry, type LiveCollectionLoader, type LiveCollectionLoaderParams, type LiveCollectionOptions, type MarkdownNode, type PagefindIndexOptions, type PagefindIndexResult, type ParsedContentMeta, type ResolvedContentSearchConfig, type ScanContentSourcesOptions, type SearchHit, type SearchSection, type SectionQueryOptions, type SectionSearchEngine, type SectionSearchOptions, type UbeanContentOptions, bootstrapContentFromDisk, buildNavigation, configureContentRuntime, createContentCollection, createQueryBuilder, defineCollection, defineContentCollection, fetchContentNavigation, fetchContentNavigation as fetchNavigation, generateId, getCollection, getContentItem, listCollections, parseContent, parseContentFile, parseFrontmatter, parseMarkdown, queryCollection, queryCollection as queryContent, queryCollectionSearchSections, registerContent, scanContentSources, ubeanContentPlugin };

package/dist/index.js

@@ -32,4 +32,235 @@ function discoverContentPageRoutes(rootDir, options = {}) {
 	return extractContentPageRoutes(Object.values(collections).flat(), { includeDrafts });
 }
 //#endregion
-export { bootstrapContentFromDisk, buildNavigation, configureContentRuntime, createContentCollection, createQueryBuilder, createSectionSearch, defineCollection, defineContentCollection, discoverContentPageRoutes, extractContentPageRoutes, fetchContentNavigation, fetchContentNavigation as fetchNavigation, generateId, generateSearchSections, generateSearchSectionsSnapshot, getCollection, getContentItem, listCollections, parseContent, parseContentFile, parseFrontmatter, parseMarkdown, queryCollection, queryCollection as queryContent, queryCollectionSearchSections, registerContent, resolveContentSearchConfig, runPagefindIndex, scanContentSources, searchSections, splitDocumentIntoSearchSections, tokenizeText, ubeanContentPlugin };
+//#region src/live.ts
+const liveCollections = /* @__PURE__ */ new Map();
+/**
+* Validate an entry against a schema. Only checks required fields and basic
+* types — does not perform full JSON Schema validation. Invalid entries
+* are logged to console.warn and still returned (lenient validation).
+*/
+function validateEntry(entry, schema, collectionName) {
+	if (!schema) return entry;
+	const doc = {
+		_type: "json",
+		_extension: "json",
+		_dir: "",
+		_file: "",
+		_draft: false,
+		_partial: false,
+		_empty: false,
+		...entry
+	};
+	if (schema.required) {
+		for (const field of schema.required) if (entry[field] === void 0) console.warn(`[ubean/content] Live collection "${collectionName}": entry "${entry._id}" is missing required field "${field}"`);
+	}
+	if (schema.properties) for (const [field, fieldSchema] of Object.entries(schema.properties)) {
+		const value = entry[field];
+		if (value === void 0) continue;
+		const expectedType = fieldSchema.type;
+		const actualType = Array.isArray(value) ? "array" : typeof value;
+		if (expectedType && actualType !== expectedType && !(expectedType === "date" && value instanceof Date)) console.warn(`[ubean/content] Live collection "${collectionName}": field "${field}" expected "${expectedType}" but got "${actualType}" in entry "${entry._id}"`);
+	}
+	return doc;
+}
+/**
+* Define a live collection that fetches content at request time.
+*
+* The loader is called on every request (unless caching is enabled).
+* Entries are converted to `ContentDocument` shape and can be queried
+* using the standard query builder.
+*
+* @param options Collection definition
+* @returns LiveCollection instance
+*/
+function defineLiveCollection(options) {
+	const cacheStore = /* @__PURE__ */ new Map();
+	const fetchEntries = async (params = {}) => {
+		const cacheKey = options.cache?.key ? options.cache.key(params) : JSON.stringify(params);
+		const now = Date.now();
+		if (options.cache && options.cache.ttl > 0) {
+			const cached = cacheStore.get(cacheKey);
+			if (cached && cached.expiresAt > now) return cached.data;
+		}
+		const docs = (await options.loader(params)).map((e) => validateEntry(e, options.schema, options.name));
+		if (options.cache && options.cache.ttl > 0) cacheStore.set(cacheKey, {
+			data: docs,
+			expiresAt: now + options.cache.ttl * 1e3
+		});
+		return docs;
+	};
+	const collection = {
+		name: options.name,
+		source: "live",
+		type: "json",
+		isLive: true,
+		loader: options.loader,
+		schema: options.schema,
+		cache: options.cache,
+		async list(params = {}) {
+			return fetchEntries(params);
+		},
+		async getItem(path) {
+			const found = (await fetchEntries({ path })).find((d) => d._path === path);
+			if (found) return found;
+			return (await fetchEntries({})).find((d) => d._path === path) || null;
+		},
+		query(params = {}) {
+			let docsPromise = null;
+			const getDocs = () => {
+				if (!docsPromise) docsPromise = fetchEntries(params);
+				return docsPromise;
+			};
+			const deferredBuilder = {
+				where(fieldOrQuery, operator, value) {
+					pendingWhere.push({
+						fieldOrQuery,
+						operator,
+						value
+					});
+					return deferredBuilder;
+				},
+				sort(field, direction = "asc") {
+					pendingSort.push({
+						field,
+						direction
+					});
+					return deferredBuilder;
+				},
+				limit(count) {
+					limitCount = count;
+					return deferredBuilder;
+				},
+				skip(count) {
+					skipCount = count;
+					return deferredBuilder;
+				},
+				only(fields) {
+					selectedFields = fields;
+					return deferredBuilder;
+				},
+				without(fields) {
+					excludedFields = fields;
+					return deferredBuilder;
+				},
+				async find() {
+					return applySelection(applyFilters(await getDocs()));
+				},
+				async findOne() {
+					limitCount = 1;
+					return applyFilters(await getDocs())[0] || null;
+				},
+				async findSurround(path, surroundOptions = {}) {
+					const before = surroundOptions.before ?? 1;
+					const after = surroundOptions.after ?? 1;
+					const filtered = applyFilters(await getDocs());
+					const index = filtered.findIndex((d) => d._path === path);
+					if (index === -1) return [];
+					const start = Math.max(0, index - before);
+					const end = Math.min(filtered.length, index + after + 1);
+					return applySelection(filtered.slice(start, end).filter((_, i) => i !== before));
+				},
+				async count() {
+					return applyFilters(await getDocs()).length;
+				}
+			};
+			let pendingWhere = [];
+			let pendingSort = [];
+			let limitCount = null;
+			let skipCount = 0;
+			let selectedFields = null;
+			let excludedFields = null;
+			function applyFilters(docs) {
+				let result = [...docs];
+				for (const w of pendingWhere) if (typeof w.fieldOrQuery === "object") for (const [key, val] of Object.entries(w.fieldOrQuery)) result = result.filter((d) => getNested(d, key) === val);
+				else {
+					const field = w.fieldOrQuery;
+					let op = w.operator;
+					let val = w.value;
+					if (val === void 0 && w.operator !== void 0) {
+						op = "==";
+						val = w.operator;
+					}
+					result = result.filter((d) => {
+						const dv = getNested(d, field);
+						switch (op) {
+							case "=":
+							case "==":
+							case void 0: return dv === val;
+							case "!=": return dv !== val;
+							case ">": return dv > val;
+							case ">=": return dv >= val;
+							case "<": return dv < val;
+							case "<=": return dv <= val;
+							case "contains": return String(dv).includes(val);
+							case "in": return Array.isArray(val) && val.includes(dv);
+							case "exists": return val ? dv !== void 0 : dv === void 0;
+							default: return dv === val;
+						}
+					});
+				}
+				if (pendingSort.length === 0) pendingSort = [{
+					field: "_path",
+					direction: "asc"
+				}];
+				result.sort((a, b) => {
+					for (const { field, direction } of pendingSort) {
+						const av = getNested(a, field);
+						const bv = getNested(b, field);
+						if (av === bv) continue;
+						const cmp = av < bv ? -1 : 1;
+						return direction === "desc" ? -cmp : cmp;
+					}
+					return 0;
+				});
+				if (skipCount > 0) result = result.slice(skipCount);
+				if (limitCount !== null) result = result.slice(0, limitCount);
+				return result;
+			}
+			function applySelection(docs) {
+				if (!selectedFields && !excludedFields) return docs;
+				return docs.map((doc) => {
+					const newDoc = { ...doc };
+					if (excludedFields) for (const f of excludedFields) delete newDoc[f];
+					if (selectedFields) {
+						const kept = {};
+						for (const f of selectedFields) kept[f] = doc[f];
+						kept._id = doc._id;
+						kept._path = doc._path;
+						return kept;
+					}
+					return newDoc;
+				});
+			}
+			return deferredBuilder;
+		},
+		invalidate() {
+			cacheStore.clear();
+		}
+	};
+	liveCollections.set(options.name, collection);
+	return collection;
+}
+/**
+* Get a registered live collection by name.
+*/
+function getLiveCollection(name) {
+	return liveCollections.get(name);
+}
+/**
+* List all registered live collection names.
+*/
+function listLiveCollections() {
+	return Array.from(liveCollections.keys());
+}
+/**
+* Clear all registered live collections (useful for testing).
+*/
+function clearLiveCollections() {
+	liveCollections.clear();
+}
+function getNested(obj, path) {
+	return path.split(".").reduce((o, key) => o?.[key], obj);
+}
+//#endregion
+export { bootstrapContentFromDisk, buildNavigation, clearLiveCollections, configureContentRuntime, createContentCollection, createQueryBuilder, createSectionSearch, defineCollection, defineContentCollection, defineLiveCollection, discoverContentPageRoutes, extractContentPageRoutes, fetchContentNavigation, fetchContentNavigation as fetchNavigation, generateId, generateSearchSections, generateSearchSectionsSnapshot, getCollection, getContentItem, getLiveCollection, listCollections, listLiveCollections, parseContent, parseContentFile, parseFrontmatter, parseMarkdown, queryCollection, queryCollection as queryContent, queryCollectionSearchSections, registerContent, resolveContentSearchConfig, runPagefindIndex, scanContentSources, searchSections, splitDocumentIntoSearchSections, tokenizeText, ubeanContentPlugin };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ubean/content",
-  "version": "0.6.0",
+  "version": "0.6.1-beta.2",
   "description": "File-based content module for ubean (markdown/MDX/YAML/JSON)",
   "files": [
     "dist"
@@ -28,7 +28,7 @@
     }
   },
   "dependencies": {
-    "@ubean/shared": "0.6.0",
+    "@ubean/shared": "0.6.1-beta.2",
     "defu": "6.1.7",
     "pathe": "^2.0.3",
     "scule": "^1.3.0"
@@ -36,15 +36,19 @@
   "devDependencies": {
     "@types/node": "^26.6.4",
     "typescript": "npm:typescript-native-bridge@latest",
-    "vite": "npm:@voidzero-dev/vite-plus-core@1.0.0",
-    "vite-plus": "1.0.0",
+    "vite": "npm:@voidzero-dev/vite-plus-core@1.1.0",
+    "vite-plus": "1.1.0",
     "vue": "^3.5.43"
   },
   "peerDependencies": {
+    "pagefind": "^1.0.0",
     "vite": "^5.0.0 || ^6.0.0",
     "vue": "^3.5.0"
   },
   "peerDependenciesMeta": {
+    "pagefind": {
+      "optional": true
+    },
     "vite": {
       "optional": true
     },