@lupinum/ginko-content 0.1.6 → 0.2.0

package/dist/runtime/server/search.js

@@ -39,7 +39,7 @@ const rememberSearchRecords = (cacheKey, records) => {
   }
 };
 const mergeSearchFilter = (filterQuery, locale) => {
-  const localeFilter = locale ? { _locale: locale } : void 0;
+  const localeFilter = locale ? { locale } : void 0;
   if (filterQuery && localeFilter) {
     return { $and: [filterQuery, localeFilter] };
   }
@@ -50,7 +50,7 @@ export async function serverSearchContent(event, filterQuery, locale, collection
   const collections = resolveSearchCollections(runtimeConfig.content, collectionsOverride);
   const results = await Promise.all(collections.map(async (collection) => {
     const loadPages = async (queryLocale) => {
-      const query = serverQueryCollection(event, collection).select("_path", "_locale", "title", "description", "body");
+      const query = serverQueryCollection(event, collection).select("path", "locale", "title", "description", "body");
       const mergedFilter = mergeSearchFilter(filterQuery, queryLocale);
       if (mergedFilter) {
         return await query.where(mergedFilter).find();
@@ -84,7 +84,7 @@ const toSearchRecord = (section) => {
     content: section.content,
     headings: section.titles,
     anchor: anchor || void 0,
-    locale: typeof section._locale === "string" ? section._locale : void 0
+    locale: typeof section.locale === "string" ? section.locale : void 0
   };
 };
 const buildProviderSearchSections = async (event, collections, provider, opts) => {
@@ -92,7 +92,7 @@ const buildProviderSearchSections = async (event, collections, provider, opts) =
   const sections = await Promise.all(collections.map(async (collection) => {
     const loadCollectionLocale = async (locale) => (await provider.searchSections(event, collection, {
       ignoredTags: opts.ignoredTags || [],
-      extraFields: unique(["_locale", ...opts.extraFields || []]),
+      extraFields: unique(["locale", ...opts.extraFields || []]),
       filterQuery: opts.filterQuery,
       locale
     })).map((section) => ({

package/dist/runtime/server/sitemap.js

@@ -6,11 +6,11 @@ import { serverQueryCollection } from "./storage.js";
 import { contentConfig } from "./storage-access.js";
 import { resolveCollectionI18n } from "../../features/localization/path";
 const sitemapPageFields = [
-  "_path",
-  "_file",
-  "_locale",
-  "_draft",
-  "_canonicalKey",
+  "path",
+  "file",
+  "locale",
+  "draft",
+  "canonicalKey",
   "sitemap",
   "image",
   "seo",

package/dist/runtime/server/storage-access.d.ts

@@ -1 +1,4 @@
-export { cacheParsedStorage, cacheStorage, contentConfig, contentIgnorePredicate, getContentsIds, resolveStorageId, sourceStorage } from '../../integrations/nitro/storage';
+import type { H3Event } from 'h3';
+import { cacheParsedStorage, cacheStorage, contentConfig, contentIgnorePredicate, getSourceContentIds, resolveStorageId, sourceStorage } from '../../integrations/nitro/storage';
+export declare const getContentsIds: (event: H3Event, prefix?: string) => Promise<string[]>;
+export { cacheParsedStorage, cacheStorage, contentConfig, contentIgnorePredicate, getSourceContentIds, resolveStorageId, sourceStorage };

package/dist/runtime/server/storage-access.js

@@ -1,9 +1,34 @@
-export {
+import { splitInlineLocaleVariantId } from "../../core/content/locale";
+import {
   cacheParsedStorage,
   cacheStorage,
   contentConfig,
   contentIgnorePredicate,
-  getContentsIds,
+  getContentsIds as getStorageContentsIds,
+  getSourceContentIds,
   resolveStorageId,
   sourceStorage
 } from "../../integrations/nitro/storage";
+import { getProcessDocuments, usesProcessSnapshot } from "../../storage/snapshot-runtime";
+export const getContentsIds = async (event, prefix) => {
+  if (!usesProcessSnapshot) {
+    return getStorageContentsIds(event, prefix);
+  }
+  const ids = /* @__PURE__ */ new Set();
+  for (const document of await getProcessDocuments(event)) {
+    const { sourceId } = splitInlineLocaleVariantId(document.id);
+    if (!prefix || sourceId.startsWith(prefix)) {
+      ids.add(sourceId);
+    }
+  }
+  return [...ids];
+};
+export {
+  cacheParsedStorage,
+  cacheStorage,
+  contentConfig,
+  contentIgnorePredicate,
+  getSourceContentIds,
+  resolveStorageId,
+  sourceStorage
+};

package/dist/runtime/transformers/component-resolver.d.ts

@@ -6,5 +6,5 @@ export declare function loadComponents(node: ParsedContent['body'] | {
     props?: Record<string, unknown>;
     children?: Array<ParsedContent['body']>;
 } | null, tags: Record<string, string>): [string, unknown][];
-declare const _default: import("../../types").ContentTransformer;
+declare const _default: import("../../types/content").ContentTransformer;
 export default _default;

package/dist/storage/content.d.ts

@@ -1,5 +1,5 @@
 import type { H3Event } from 'h3';
-import type { ParsedContent } from '../types/content';
+import type { ContentDocumentResolution, ParsedContent } from '../types/content';
 import type { ContentCollectionMap, ContentLocaleEntry, ContentQueryBuilderParams, ContentQueryFetcher, CollectionQueryBuilder, ResolveContentReferenceOptions } from '../types/query';
 export declare const createServerQueryFetch: <T = ParsedContent>(event: H3Event) => ContentQueryFetcher<T>;
 /**
@@ -19,11 +19,7 @@ export declare const createServerQueryFetch: <T = ParsedContent>(event: H3Event)
  * ```
  */
 export declare const resolveContentReference: <T = ParsedContent>(event: H3Event, reference: string, options?: ResolveContentReferenceOptions) => Promise<(T & {
-    _requestedLocale?: string;
-    _resolvedLocale?: string;
-    _fallback?: boolean;
-    _availableLocales?: string[];
-    _variantPaths?: Record<string, string>;
+    resolved?: ContentDocumentResolution;
 }) | null>;
 export declare const createServerContentQuery: <T = ParsedContent>(event: H3Event, query?: string | ContentQueryBuilderParams, ...pathParts: string[]) => import("../types/query").ContentQueryBuilder<T>;
 export declare function serverQueryCollection<K extends keyof ContentCollectionMap & string>(event: H3Event, collection: K): CollectionQueryBuilder<ContentCollectionMap[K]>;

package/dist/storage/content.js

@@ -1,6 +1,7 @@
 import { joinURL, withLeadingSlash } from "ufo";
 import { createQuery, wrapQueryBuilder } from "../core/query/builder";
 import { resolveGraphCanonicalKey, resolveGraphCollectionLocales, resolveGraphVariant } from "../core/content/graph";
+import { sortLocalesCanonically } from "../core/content/locale";
 import { normalizeReferenceValue } from "../core/references/resolve";
 import { executeQueryPlan } from "../core/query/execute";
 import { lowerQueryPlan } from "../core/query/lower";
@@ -27,7 +28,7 @@ export const resolveContentReference = async (event, reference, options = {}) =>
   if (!canonicalId) {
     return null;
   }
-  const variants = Object.values(graph.byCanonical[canonicalId] || {}).map((entry) => entry.document).filter((document) => !options.collection || document._collection === options.collection);
+  const variants = Object.values(graph.byCanonical[canonicalId] || {}).map((entry) => entry.document).filter((document) => !options.collection || document.collection === options.collection);
   if (!variants.length) {
     return null;
   }
@@ -41,17 +42,27 @@ export const resolveContentReference = async (event, reference, options = {}) =>
   if (!resolved || !resolvedVariant) {
     return null;
   }
-  const availableLocales = Array.from(new Set(variants.map((document) => document._locale).filter(Boolean)));
+  const collectionI18n = getServerCollectionI18n(options.collection);
+  const availableLocales = sortLocalesCanonically(
+    Array.from(new Set(variants.map((document) => document.locale).filter(Boolean))),
+    {
+      defaultLocale: collectionI18n?.defaultLocale || config.defaultLocale,
+      locales: collectionI18n?.locales
+    }
+  );
   const variantPaths = Object.fromEntries(
-    variants.filter((document) => document._locale && document._path).map((document) => [document._locale, document._path])
+    variants.filter((document) => document.locale && document.path).map((document) => [document.locale, document.path])
   );
   return {
     ...resolved,
-    _requestedLocale: resolvedVariant.requestedLocale,
-    _resolvedLocale: resolvedVariant.resolvedLocale,
-    _fallback: resolvedVariant.fallback,
-    _availableLocales: availableLocales,
-    _variantPaths: variantPaths
+    resolved: {
+      ...resolved.resolved || {},
+      requestedLocale: resolvedVariant.requestedLocale,
+      locale: resolvedVariant.resolvedLocale,
+      fallback: resolvedVariant.fallback,
+      availableLocales,
+      variantPaths
+    }
   };
 };
 const getServerCollectionI18n = (collection) => {

package/dist/storage/contents.d.ts

@@ -1,5 +1,13 @@
 import type { H3Event } from 'h3';
-import type { ParsedContent } from '../types/content';
+import type { MissingDocument, ParsedContent } from '../types/content';
 export declare function chunksFromArray<T>(arr: T[], n: number): Generator<T[], void>;
+/**
+ * Load every locale variant for a single content id.
+ *
+ * Cache strategy:
+ *  1. Dev/prerender validate source metadata before reusing an artifact.
+ *  2. Concurrent misses for the same `(storageId, hash)` share one parse.
+ */
+export declare const loadContentVariants: (event: H3Event, id: string) => Promise<Array<ParsedContent | MissingDocument>>;
 export declare const getContentsList: (event: H3Event, prefix?: string) => Promise<ParsedContent[]>;
 export declare const getContent: (event: H3Event, id: string) => Promise<ParsedContent>;

package/dist/storage/contents.js

@@ -1,11 +1,12 @@
 import { hash as ohash } from "ohash";
+import { isRealDocument } from "../core/content/document";
 import { splitInlineLocaleVariantId } from "../core/content/locale";
 import { memoizeRuntimeValue } from "../integrations/nitro/context";
 import { parseContentVariants } from "../integrations/nitro/ingest";
 import { cacheStoreFor, getCachedContents, setCachedContents } from "./cache.js";
 import { contentConfig, contentIgnorePredicate, getContentStorageRuntime, getContentsIds, resolveStorageId } from "./driver.js";
+import { getProcessDocuments, usesProcessSnapshot } from "./snapshot-runtime.js";
 import { validateContentGraph } from "./validation.js";
-const isProduction = process.env.NODE_ENV === "production";
 const isPrerendering = import.meta.prerender;
 const shouldValidateAtRuntime = import.meta.dev || isPrerendering;
 const isContentCacheArtifact = (value) => {
@@ -16,23 +17,22 @@ export function* chunksFromArray(arr, n) {
     yield arr.slice(i, i + n);
   }
 }
-const loadContentVariants = async (event, id) => {
+export const loadContentVariants = async (event, id) => {
   const runtime = getContentStorageRuntime(event);
   const config = contentConfig();
   const { sourceId: contentId } = splitInlineLocaleVariantId(id);
   if (!contentIgnorePredicate(contentId)) {
-    return [{ _id: contentId, body: null }];
+    return [{ id: contentId, body: null, missing: true }];
   }
   const storageId = await resolveStorageId(event, contentId);
   const cachedValue = await runtime.parsedCache.getItem(storageId);
   const cached = isContentCacheArtifact(cachedValue) ? cachedValue : null;
-  if (isProduction && !isPrerendering && cached) {
-    return cached.parsed;
+  const body = await runtime.source.getItem(storageId);
+  if (body === null) {
+    return [{ id: contentId, body: null, missing: true }];
   }
-  const meta = await runtime.source.getMeta(storageId);
   const hash = ohash({
-    mtime: meta.mtime,
-    size: meta.size || 0,
+    body: ohash(body),
     version: runtime.config.cacheVersion,
     integrity: runtime.config.cacheIntegrity,
     collections: runtime.config.collections,
@@ -46,10 +46,6 @@ const loadContentVariants = async (event, id) => {
     return cached.parsed;
   }
   return cacheStoreFor(event).inflightContents.run(`${storageId}${hash}`, async () => {
-    const body = await runtime.source.getItem(storageId);
-    if (body === null) {
-      return [{ _id: contentId, body: null }];
-    }
     const parsed = await parseContentVariants(contentId, body, config, { validate: true });
     try {
       await runtime.parsedCache.setItem(storageId, { parsed, hash });
@@ -68,7 +64,7 @@ const loadContents = async (event, prefix) => {
     const result = await Promise.all(chunk.map((key) => loadContentVariants(event, key)));
     contents.push(...result.flat());
   }
-  const filtered = contents.filter((document) => document && document._path);
+  const filtered = contents.filter(isRealDocument).filter((document) => document.path);
   if (shouldValidateAtRuntime) {
     const outcome = validateContentGraph(filtered, contentConfig());
     if (!outcome.ok) {
@@ -77,7 +73,20 @@ const loadContents = async (event, prefix) => {
   }
   return filtered;
 };
+const snapshotDocumentsFor = async (event, prefix) => {
+  const documents = await getProcessDocuments(event);
+  if (!prefix) {
+    return documents;
+  }
+  return documents.filter((document) => {
+    const { sourceId } = splitInlineLocaleVariantId(document.id);
+    return sourceId.startsWith(prefix);
+  });
+};
 export const getContentsList = (event, prefix) => {
+  if (usesProcessSnapshot) {
+    return snapshotDocumentsFor(event, prefix);
+  }
   const runtime = getContentStorageRuntime(event);
   const cacheKey = JSON.stringify({
     prefix,
@@ -90,25 +99,23 @@ export const getContentsList = (event, prefix) => {
   });
   return memoizeRuntimeValue(event, `contents:${cacheKey}`, async () => {
     const cached = getCachedContents(event, cacheKey);
-    if ((isPrerendering || !isProduction) && cached?.length) {
+    if (cached?.length) {
       return cached;
     }
     return await cacheStoreFor(event).inflightContentsList.run(cacheKey, async () => {
       const result = await loadContents(event, prefix);
-      if (isPrerendering || !isProduction) {
-        setCachedContents(event, cacheKey, result);
-      }
+      setCachedContents(event, cacheKey, result);
       return result;
     });
   });
 };
 export const getContent = async (event, id) => {
   const { sourceId, locale } = splitInlineLocaleVariantId(id);
-  const parsed = await loadContentVariants(event, sourceId);
+  const parsed = usesProcessSnapshot ? (await getProcessDocuments(event)).filter((document) => splitInlineLocaleVariantId(document.id).sourceId === sourceId) : (await loadContentVariants(event, sourceId)).filter(isRealDocument);
   if (!locale) {
     return parsed[0];
   }
-  const match = parsed.find((document) => document._locale === locale);
+  const match = parsed.find((document) => document.locale === locale);
   if (!match) {
     console.warn(`[content] Locale variant "${locale}" not found for "${sourceId}", falling back to default`);
   }

package/dist/storage/driver.d.ts

@@ -1,6 +1,6 @@
 import type { H3Event } from 'h3';
 import type { Storage, StorageValue } from 'unstorage';
-import { sourceStorage, cacheStorage, cacheParsedStorage, contentConfig, contentIgnorePredicate, getContentsIds, resolveStorageId } from '../integrations/nitro/storage';
+import { sourceStorage, cacheStorage, cacheParsedStorage, contentConfig, contentIgnorePredicate, getContentsIds, getSourceContentIds, resolveStorageId } from '../integrations/nitro/storage';
 export interface ContentSourceDriver {
     getKeys: (prefix?: string) => Promise<string[]>;
     getItem: (key: string) => Promise<StorageValue | null>;
@@ -25,4 +25,4 @@ export interface ContentStorageRuntime {
     now: () => Date;
 }
 export declare const getContentStorageRuntime: (event: H3Event) => ContentStorageRuntime;
-export { cacheParsedStorage, cacheStorage, contentConfig, contentIgnorePredicate, getContentsIds, resolveStorageId, sourceStorage };
+export { cacheParsedStorage, cacheStorage, contentConfig, contentIgnorePredicate, getContentsIds, getSourceContentIds, resolveStorageId, sourceStorage };

package/dist/storage/driver.js

@@ -1,4 +1,4 @@
-import { sourceStorage, cacheStorage, cacheParsedStorage, contentConfig, contentIgnorePredicate, getContentsIds, resolveStorageId } from "../integrations/nitro/storage";
+import { sourceStorage, cacheStorage, cacheParsedStorage, contentConfig, contentIgnorePredicate, getContentsIds, getSourceContentIds, resolveStorageId } from "../integrations/nitro/storage";
 import { getContentRuntimeContext } from "../integrations/nitro/context";
 export const getContentStorageRuntime = (event) => {
   const runtime = getContentRuntimeContext(event);
@@ -17,6 +17,7 @@ export {
   contentConfig,
   contentIgnorePredicate,
   getContentsIds,
+  getSourceContentIds,
   resolveStorageId,
   sourceStorage
 };

package/dist/storage/graph.js

@@ -2,7 +2,11 @@ import { buildContentGraph } from "../core/content/graph";
 import { memoizeRuntimeValue } from "../integrations/nitro/context";
 import { contentConfig } from "./driver.js";
 import { getContentsList } from "./contents.js";
+import { getProcessGraph, usesProcessSnapshot } from "./snapshot-runtime.js";
 export const getContentGraph = async (event) => {
+  if (usesProcessSnapshot) {
+    return getProcessGraph(event);
+  }
   return await memoizeRuntimeValue(event, "graph", async () => {
     const config = contentConfig();
     const contents = await getContentsList(event);

package/dist/storage/manifest.js

@@ -31,6 +31,7 @@ export async function resolveVariant(event, canonicalKey, requestedLocale, optio
   const config = getContentRuntimeConfig().content;
   return resolveGraphVariant(await getContentGraph(event), canonicalKey, requestedLocale, {
     defaultLocale: config.defaultLocale,
+    locales: config.locales,
     fallback: options.fallback,
     exact: options.exact,
     localeFallback: config.localeFallback
@@ -40,6 +41,7 @@ export async function resolveRouteVariant(event, routePath, requestedLocale, opt
   const config = getContentRuntimeConfig().content;
   return resolveGraphRouteVariant(await getContentGraph(event), routePath, requestedLocale, {
     defaultLocale: config.defaultLocale,
+    locales: config.locales,
     fallback: options.fallback,
     exact: options.exact,
     localeFallback: config.localeFallback
@@ -56,7 +58,7 @@ export async function getIndexedContentsList(event, query) {
     return await getContentsList(event);
   }
   const params = query.params();
-  const paths = collectQueryWhere(params?.where, (where) => typeof where._path !== "undefined").map((where) => where._path).filter((path) => typeof path === "string" || path instanceof RegExp);
+  const paths = collectQueryWhere(params?.where, (where) => typeof where.path !== "undefined").map((where) => where.path).filter((path) => typeof path === "string" || path instanceof RegExp);
   const graph = await getContentGraph(event);
   if (!paths.length && !params?.collection) {
     return graph.documents;

package/dist/storage/references.js

@@ -17,7 +17,7 @@ const isConfiguredQuickLink = (href) => {
   return Boolean(links?.[namespace]?.[key]);
 };
 const resolveDocumentRefLinks = async (event, content, requestedLocale) => {
-  if (!content || content._type !== "markdown" || !content.body) {
+  if (!content || content.type !== "markdown" || !content.body) {
     return void 0;
   }
   const hrefs = collectMarkdownRefLinks(content.body);
@@ -35,19 +35,19 @@ const resolveDocumentRefLinks = async (event, content, requestedLocale) => {
         return [href, href];
       }
       if (import.meta.dev) {
-        console.warn(`[content] Could not resolve markdown ref "${href}" in "${content._file || content._id}"`);
+        console.warn(`[content] Could not resolve markdown ref "${href}" in "${content.file?.path || content.id}"`);
       }
       return [href, href];
     }
     const variant = await resolveVariant(event, canonicalKey, requestedLocale);
     if (!variant?.path) {
       if (import.meta.dev) {
-        console.warn(`[content] Could not resolve markdown ref "${href}" in "${content._file || content._id}"`);
+        console.warn(`[content] Could not resolve markdown ref "${href}" in "${content.file?.path || content.id}"`);
       }
       return [href, href];
     }
     if (import.meta.dev && requestedLocale && variant.resolvedLocale && variant.resolvedLocale !== requestedLocale) {
-      console.warn(`[content] Markdown ref "${href}" in "${content._file || content._id}" fell back from locale "${requestedLocale}" to "${variant.resolvedLocale}"`);
+      console.warn(`[content] Markdown ref "${href}" in "${content.file?.path || content.id}" fell back from locale "${requestedLocale}" to "${variant.resolvedLocale}"`);
     }
     const routeLocale = variant.fallback && requestedLocale ? requestedLocale : variant.resolvedLocale;
     return [href, `${projectContentPathToLocale(variant.path, routeLocale, contentConfig().defaultLocale)}${parsed.hash}`];
@@ -63,9 +63,13 @@ export const withResolvedRefs = async (event, content, requestedLocale) => {
   if (!resolvedRefs) {
     return content;
   }
+  const existingResolution = content.resolved;
   return {
     ...content,
-    _resolvedRefs: resolvedRefs
+    resolved: {
+      ...existingResolution || {},
+      resolvedRefs
+    }
   };
 };
 export const withResolvedRefsList = async (event, items, requestedLocale) => {

package/dist/storage/snapshot-runtime

@@ -0,0 +1 @@
+export * from './snapshot-runtime.js'

package/dist/storage/snapshot-runtime.d.ts

@@ -0,0 +1,11 @@
+import type { H3Event } from 'h3';
+import type { ParsedContent } from '../types/content';
+import type { ContentGraph } from '../core/content/graph';
+/**
+ * Single source of truth for "serve from the process-scoped snapshot".
+ * Prerender must stay on the request-scoped dev path — it is the phase that
+ * produces the snapshot in the first place.
+ */
+export declare const usesProcessSnapshot: boolean;
+export declare const getProcessGraph: (event: H3Event) => Promise<ContentGraph>;
+export declare const getProcessDocuments: (event: H3Event) => Promise<ParsedContent[]>;

package/dist/storage/snapshot-runtime.js

@@ -0,0 +1,46 @@
+import { buildContentGraph } from "../core/content/graph";
+import { isContentSnapshot } from "../core/content/snapshot";
+import { cacheStorage, contentConfig } from "./driver.js";
+export const usesProcessSnapshot = process.env.NODE_ENV === "production" && !import.meta.prerender;
+let state = null;
+export const getProcessGraph = async (event) => {
+  const snapshotState = await getProcessSnapshotState(event);
+  return snapshotState.graph;
+};
+export const getProcessDocuments = async (event) => {
+  const snapshotState = await getProcessSnapshotState(event);
+  return snapshotState.documents;
+};
+const getProcessSnapshotState = (event) => {
+  const config = contentConfig();
+  const integrity = config.cacheIntegrity;
+  if (state && state.integrity === integrity) {
+    return state.promise;
+  }
+  const promise = loadSnapshotState(event, integrity);
+  promise.catch(() => {
+    if (state?.promise === promise) {
+      state = null;
+    }
+  });
+  state = { integrity, promise };
+  return promise;
+};
+const loadSnapshotState = async (event, integrity) => {
+  const raw = await cacheStorage(event).getItem("snapshot.json");
+  if (!isContentSnapshot(raw)) {
+    throw new Error("[content] production snapshot missing or invalid \u2014 the site was built without a content snapshot. Rebuild with this package version.");
+  }
+  if (raw.integrity !== integrity) {
+    throw new Error(`[content] snapshot integrity mismatch (built: ${raw.integrity}, runtime: ${integrity}) \u2014 stale build artifact.`);
+  }
+  const config = contentConfig();
+  const graph = buildContentGraph(raw.documents, {
+    locales: config.locales,
+    defaultLocale: config.defaultLocale
+  });
+  return {
+    graph,
+    documents: raw.documents
+  };
+};

package/dist/storage/validation.d.ts

@@ -16,7 +16,7 @@ export declare const getCanonicalContentId: (document: ParsedContent, locales?:
  * - Strict collections (default): schema errors produce a `SCHEMA_VALIDATION_FAILED`
  *   failure.
  *
- * Also chains into `validateNavigationDocument` for `_navigation: true` files,
+ * Also chains into `validateNavigationDocument` for `navigationFile: true` files,
  * which can fail with `INVALID_NAVIGATION_YAML`.
  */
 export declare const validateCollectionDocument: (document: ParsedContent, collections?: Record<string, ContentCollectionConfig>) => Result<ParsedContent, ContentError>;