@lupinum/ginko-content 0.1.0

package/dist/runtime/query/unified.js

@@ -0,0 +1,473 @@
+import { compileQueryParams } from "../../core/query/filter";
+import { decorateLocalePathsWithFallbacks, localizePageResult } from "../../features/localization/results";
+import { normalizeRouteMounts } from "../../features/localization/path";
+import { normalizeReferenceValue } from "../../core/references/resolve";
+import { collectTopLevelReferenceFields } from "../../core/references/schema";
+import { MAX_PUBLIC_QUERY_LIMIT, MAX_PUBLIC_QUERY_SKIP } from "./public-limits.js";
+const NAVIGATION_INTERNAL_FIELDS = [
+  "_id",
+  "_path",
+  "_file",
+  "_canonicalKey",
+  "_locale",
+  "_draft",
+  "navigation",
+  "title"
+];
+const LOCALIZED_DOC_INTERNAL_FIELDS = [
+  "_id",
+  "_path",
+  "_file",
+  "_canonicalKey",
+  "_locale",
+  "_resolvedLocale",
+  "_requestedLocale",
+  "_fallback",
+  "_availableLocales",
+  "_variantPaths",
+  "_requestedPath",
+  "_requestedRoute",
+  "_requestedRef",
+  "_extension"
+];
+export const navigationSelectFields = (fields = []) => [
+  .../* @__PURE__ */ new Set([...NAVIGATION_INTERNAL_FIELDS, ...fields])
+];
+const isNotFoundError = (error) => {
+  const statusCode = error?.statusCode ?? error?.response?.status;
+  return statusCode === 404;
+};
+const isQueryEnvelope = (response) => Boolean(response && typeof response === "object" && "result" in response);
+const unwrapResponse = (response) => {
+  if (!response) return null;
+  if (isQueryEnvelope(response)) {
+    const result = response.result;
+    return result ?? null;
+  }
+  return response;
+};
+const unwrapFindResponse = (response) => {
+  if (!response) {
+    return { result: [], total: 0, skip: 0, limit: 0, hasTotal: false };
+  }
+  if (isQueryEnvelope(response)) {
+    const result2 = Array.isArray(response.result) ? response.result : response.result ? [response.result] : [];
+    const hasTotal = typeof response.total === "number";
+    return {
+      result: result2,
+      total: hasTotal ? response.total : result2.length,
+      skip: typeof response.skip === "number" ? response.skip : 0,
+      limit: typeof response.limit === "number" ? response.limit : result2.length,
+      hasTotal
+    };
+  }
+  const result = Array.isArray(response) ? response : [response];
+  return { result, total: result.length, skip: 0, limit: result.length, hasTotal: false };
+};
+const unwrapCountResponse = (response) => {
+  if (typeof response === "number") {
+    return response;
+  }
+  if (isQueryEnvelope(response) && typeof response.result === "number") {
+    return response.result;
+  }
+  return null;
+};
+const decorate = (doc, collection, runtime, requestedLocale) => {
+  if (!doc) return null;
+  const collectionI18n = runtime?.collections?.[collection]?.i18n;
+  const collectionLocales = collectionI18n && typeof collectionI18n === "object" ? collectionI18n.locales : void 0;
+  const collectionDefault = collectionI18n && typeof collectionI18n === "object" ? collectionI18n.defaultLocale : void 0;
+  const locales = collectionLocales?.length ? collectionLocales : runtime?.locales?.length ? runtime.locales : [];
+  const defaultLocale = collectionDefault || runtime?.defaultLocale;
+  const routeMounts = normalizeRouteMounts(runtime?.collections?.[collection]?.route, locales, defaultLocale);
+  const hasLocaleConfig = Boolean(locales.length || defaultLocale);
+  const page = hasLocaleConfig ? doc : {
+    ...doc,
+    _locale: "",
+    _resolvedLocale: void 0,
+    _requestedLocale: void 0,
+    _variantPaths: void 0,
+    _availableLocales: []
+  };
+  const result = localizePageResult(page, hasLocaleConfig ? requestedLocale : void 0, defaultLocale, locales, routeMounts);
+  const fallbackLocale = doc._resolvedLocale || requestedLocale || defaultLocale;
+  result.localePaths = decorateLocalePathsWithFallbacks(result.localePaths, locales, fallbackLocale, defaultLocale, routeMounts);
+  return result;
+};
+const collectionDefaultLocale = (collection, runtime) => {
+  const collectionI18n = runtime?.collections?.[collection]?.i18n;
+  const collectionDefault = collectionI18n && typeof collectionI18n === "object" ? collectionI18n.defaultLocale : void 0;
+  return collectionDefault || runtime?.defaultLocale;
+};
+const resolveFallback = (fallback, collection, runtime) => {
+  if (fallback !== "default") return fallback;
+  return collectionDefaultLocale(collection, runtime);
+};
+const explainResolution = (collection, requestedBy, normalizedBy, requestedLocale, requestedFallback, doc) => {
+  const resolvedLocale = doc?.resolved?.locale || doc?.locale;
+  return {
+    requested: {
+      collection,
+      by: requestedBy,
+      ...requestedLocale ? { locale: requestedLocale } : {},
+      ...requestedFallback !== void 0 ? { fallback: requestedFallback } : {}
+    },
+    normalized: {
+      by: normalizedBy
+    },
+    matched: {
+      found: Boolean(doc),
+      collection,
+      ...doc?.path ? { path: doc.path } : {},
+      ...doc?.canonicalPath ? { canonicalPath: doc.canonicalPath } : {},
+      ...doc?.ref ? { ref: doc.ref } : {},
+      ...resolvedLocale ? { locale: resolvedLocale } : {}
+    },
+    fallback: {
+      used: Boolean(requestedLocale && resolvedLocale && requestedLocale !== resolvedLocale),
+      ...requestedLocale && resolvedLocale && requestedLocale !== resolvedLocale ? { locale: resolvedLocale } : {}
+    }
+  };
+};
+const ensureCollectionName = (handle) => {
+  if (typeof handle === "string") return handle;
+  if (!handle || typeof handle !== "object" || typeof handle.name !== "string") {
+    throw new TypeError("query API: expected a collection handle from defineCollection(name, config) or a string collection name");
+  }
+  return handle.name;
+};
+const isRecord = (value) => {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+};
+const populateReferenceValue = async (context, target, value, locale, fallback) => {
+  if (typeof value !== "string" || !value) {
+    return null;
+  }
+  return one(context, target, {
+    by: { ref: value },
+    ...locale ? { locale } : {},
+    ...fallback !== void 0 ? { fallback } : {}
+  });
+};
+const populateDocument = async (context, doc, populate, locale, fallback) => {
+  if (!populate || !isRecord(populate)) {
+    return doc;
+  }
+  const populated = { ...doc };
+  await Promise.all(Object.entries(populate).map(async ([field, target]) => {
+    const value = doc[field];
+    if (Array.isArray(value)) {
+      const resolved = await Promise.all(value.map((item) => populateReferenceValue(context, target, item, locale, fallback)));
+      populated[field] = resolved.filter(Boolean);
+      return;
+    }
+    populated[field] = await populateReferenceValue(context, target, value, locale, fallback);
+  }));
+  return populated;
+};
+const selectWithPopulate = (select, populate) => {
+  if (!select) {
+    return void 0;
+  }
+  return [.../* @__PURE__ */ new Set([
+    ...select,
+    ...LOCALIZED_DOC_INTERNAL_FIELDS,
+    ...populate && isRecord(populate) ? Object.keys(populate) : []
+  ])];
+};
+export async function resolveOne(context, handle, options) {
+  const collection = ensureCollectionName(handle);
+  const runtime = context.runtime;
+  const by = options.by;
+  const fallback = resolveFallback(options.fallback, collection, runtime);
+  const params = compileQueryParams({
+    collection,
+    by,
+    locale: options.locale,
+    fallback,
+    select: selectWithPopulate(options.select, options.populate)
+  });
+  params.first = true;
+  let response;
+  try {
+    response = await context.transport("query", params);
+  } catch (error) {
+    if (isNotFoundError(error)) {
+      const explain2 = explainResolution(collection, options.by, by, options.locale, options.fallback, null);
+      return { doc: null, explain: explain2 };
+    }
+    throw error;
+  }
+  const unwrapped = unwrapResponse(response);
+  const doc = Array.isArray(unwrapped) ? unwrapped[0] ?? null : unwrapped ?? null;
+  const decorated = decorate(doc, collection, runtime, options.locale);
+  const populated = decorated ? await populateDocument(context, decorated, options.populate, options.locale, options.fallback) : null;
+  const explain = explainResolution(collection, options.by, by, options.locale, options.fallback, decorated);
+  return {
+    doc: populated,
+    explain
+  };
+}
+export async function one(context, handle, options) {
+  const result = await resolveOne(context, handle, options);
+  return result.doc;
+}
+export async function many(context, handle, options = {}) {
+  const collection = ensureCollectionName(handle);
+  const runtime = context.runtime;
+  const fallback = resolveFallback(options.fallback, collection, runtime);
+  const params = compileQueryParams({
+    collection,
+    where: options.where,
+    sort: options.sort,
+    limit: options.limit,
+    skip: options.skip,
+    locale: options.locale,
+    fallback,
+    select: selectWithPopulate(options.select, options.populate)
+  });
+  let response;
+  try {
+    response = await context.transport("query", params);
+  } catch (error) {
+    if (isNotFoundError(error)) return [];
+    throw error;
+  }
+  const unwrapped = unwrapResponse(response);
+  const list = Array.isArray(unwrapped) ? unwrapped : unwrapped ? [unwrapped] : [];
+  const decorated = list.map((doc) => decorate(doc, collection, runtime, options.locale)).filter((doc) => Boolean(doc));
+  const populated = await Promise.all(decorated.map((doc) => populateDocument(context, doc, options.populate, options.locale, options.fallback)));
+  return populated;
+}
+const normalizePositiveInteger = (value, fallback) => {
+  const number = typeof value === "number" && Number.isFinite(value) ? Math.floor(value) : fallback;
+  return Math.max(1, number);
+};
+export async function paginate(context, handle, options) {
+  const collection = ensureCollectionName(handle);
+  const runtime = context.runtime;
+  const requestedPage = normalizePositiveInteger(options.page, 1);
+  const limit = Math.min(normalizePositiveInteger(options.limit, 10), MAX_PUBLIC_QUERY_LIMIT);
+  const skip = Math.min((requestedPage - 1) * limit, MAX_PUBLIC_QUERY_SKIP);
+  const page = Math.floor(skip / limit) + 1;
+  const fallback = resolveFallback(options.fallback, collection, runtime);
+  const params = compileQueryParams({
+    collection,
+    where: options.where,
+    sort: options.sort,
+    limit,
+    skip,
+    locale: options.locale,
+    fallback,
+    select: selectWithPopulate(options.select, options.populate)
+  });
+  const countParams = compileQueryParams({
+    collection,
+    where: options.where,
+    locale: options.locale,
+    fallback
+  });
+  countParams.count = true;
+  let response;
+  try {
+    response = await context.transport("query", params);
+  } catch (error) {
+    if (isNotFoundError(error)) {
+      return {
+        data: [],
+        page,
+        limit,
+        total: 0,
+        pageCount: 0,
+        hasNext: false,
+        hasPrev: page > 1,
+        nextPage: null,
+        prevPage: page > 1 ? page - 1 : null
+      };
+    }
+    throw error;
+  }
+  const envelope = unwrapFindResponse(response);
+  let total = envelope.total;
+  if (!envelope.hasTotal) {
+    const countResponse = await context.transport("query", countParams);
+    total = unwrapCountResponse(countResponse) ?? envelope.total;
+  }
+  const decorated = envelope.result.map((doc) => decorate(doc, collection, runtime, options.locale)).filter((doc) => Boolean(doc));
+  const populated = await Promise.all(decorated.map((doc) => populateDocument(context, doc, options.populate, options.locale, options.fallback)));
+  const pageCount = total > 0 ? Math.ceil(total / limit) : 0;
+  return {
+    data: populated,
+    page,
+    limit,
+    total,
+    pageCount,
+    hasNext: page < pageCount,
+    hasPrev: page > 1,
+    nextPage: page < pageCount ? page + 1 : null,
+    prevPage: page > 1 ? page - 1 : null
+  };
+}
+const backlinkSources = (value) => Array.isArray(value) ? [...value] : [value];
+const isBacklinkFieldMap = (value) => {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+};
+const resolveExplicitBacklinkFields = (fields, sourceName) => {
+  if (Array.isArray(fields)) {
+    return fields.filter((field) => typeof field === "string" && field.length > 0);
+  }
+  if (!isBacklinkFieldMap(fields)) {
+    return [];
+  }
+  const sourceFields = fields?.[sourceName];
+  return Array.isArray(sourceFields) ? sourceFields.filter((field) => typeof field === "string" && field.length > 0) : [];
+};
+const inferBacklinkFields = (source, targetCollection) => {
+  if (typeof source === "string") {
+    return [];
+  }
+  return collectTopLevelReferenceFields(source.schema, targetCollection);
+};
+const targetReferenceCandidates = (doc) => {
+  const values = [
+    doc.ref,
+    doc.id,
+    doc._canonicalKey,
+    doc._path,
+    doc._path ? doc.path : void 0,
+    doc._path ? doc.canonicalPath : void 0
+  ].filter((value) => typeof value === "string" && value.length > 0).flatMap((value) => [value, normalizeReferenceValue(value)]).filter(Boolean);
+  return Array.from(new Set(values));
+};
+const backlinkWhere = (fields, candidates) => {
+  const clauses = fields.map((field) => ({
+    [field]: { $in: candidates }
+  }));
+  return clauses.length ? { $or: clauses } : void 0;
+};
+export async function backlinks(context, targetHandle, options) {
+  const targetCollection = ensureCollectionName(targetHandle);
+  const target = await one(context, targetHandle, {
+    by: options.by,
+    ...options.locale ? { locale: options.locale } : {},
+    ...options.fallback !== void 0 ? { fallback: options.fallback } : {}
+  });
+  if (!target) {
+    return [];
+  }
+  const candidates = targetReferenceCandidates(target);
+  if (!candidates.length) {
+    return [];
+  }
+  const sources = backlinkSources(options.from);
+  const results = await Promise.all(sources.map(async (source) => {
+    const sourceName = ensureCollectionName(source);
+    const fields = [
+      .../* @__PURE__ */ new Set([
+        ...resolveExplicitBacklinkFields(options.fields, sourceName),
+        ...inferBacklinkFields(source, targetCollection)
+      ])
+    ];
+    const where = backlinkWhere(fields, candidates);
+    if (!where) {
+      return [];
+    }
+    return await many(context, source, {
+      where,
+      sort: options.sort,
+      limit: options.limit,
+      skip: options.skip,
+      ...options.locale ? { locale: options.locale } : {},
+      ...options.fallback !== void 0 ? { fallback: options.fallback } : {},
+      select: options.select,
+      populate: options.populate
+    });
+  }));
+  return results.flat();
+}
+export async function variants(context, handle, options) {
+  const collection = ensureCollectionName(handle);
+  const runtime = context.runtime;
+  const collectionI18n = runtime?.collections?.[collection]?.i18n;
+  const collectionLocales = collectionI18n && typeof collectionI18n === "object" ? collectionI18n.locales : void 0;
+  const collectionDefault = collectionI18n && typeof collectionI18n === "object" ? collectionI18n.defaultLocale : void 0;
+  const locales = collectionLocales?.length ? collectionLocales : runtime?.locales || [];
+  const defaultLocale = collectionDefault || runtime?.defaultLocale;
+  const requestedLocales = options.locales?.length ? options.locales : locales;
+  if (!requestedLocales.length) {
+    return [];
+  }
+  const seed = await one(context, handle, {
+    by: options.by,
+    locale: options.locale || defaultLocale,
+    fallback: true
+  });
+  if (!seed) return [];
+  const variantPaths = seed._variantPaths || {};
+  const sourceLocale = seed.locale || defaultLocale || "";
+  return requestedLocales.map((locale) => {
+    const variantPath = variantPaths[locale];
+    if (variantPath) {
+      return {
+        locale,
+        path: seed.localePaths?.[locale]?.path || variantPath,
+        translated: true
+      };
+    }
+    return {
+      locale,
+      path: seed.path,
+      translated: false,
+      fallback: sourceLocale
+    };
+  });
+}
+export async function tree(context, handle, options = {}) {
+  const collection = ensureCollectionName(handle);
+  const runtime = context.runtime;
+  const fallback = resolveFallback(options.fallback, collection, runtime);
+  const params = compileQueryParams({
+    collection,
+    where: options.where,
+    sort: options.sort,
+    locale: options.locale,
+    fallback,
+    select: navigationSelectFields(options.fields),
+    exact: options.fallback === void 0 ? false : void 0
+  });
+  const response = await context.transport("navigation", params);
+  const list = Array.isArray(response) ? response : Array.isArray(response?.result) ? response.result : [];
+  return list;
+}
+export async function neighbors(context, handle, options) {
+  const seed = await one(context, handle, {
+    by: options.by,
+    locale: options.locale,
+    fallback: options.fallback ?? true
+  });
+  if (!seed) return { prev: null, next: null };
+  const fullTree = await tree(context, handle, {
+    locale: options.locale,
+    fallback: options.fallback,
+    fields: options.fields
+  });
+  const flat = [];
+  const walk = (nodes) => {
+    for (const node of nodes) {
+      const n = node;
+      if (n.path || n._path) {
+        flat.push({ path: n.path || n._path || "", item: node });
+      }
+      if (Array.isArray(n.children)) walk(n.children);
+    }
+  };
+  walk(fullTree);
+  const targetPath = seed.path;
+  const idx = flat.findIndex((entry) => entry.path === targetPath);
+  if (idx === -1) return { prev: null, next: null };
+  return {
+    prev: flat[idx - 1]?.item ?? null,
+    next: flat[idx + 1]?.item ?? null
+  };
+}

package/dist/runtime/server/api/cache

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

package/dist/runtime/server/api/cache.d.ts

@@ -0,0 +1,8 @@
+import type { NavItem } from '../../../types/content';
+declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<{
+    contents: unknown[];
+    navigation: NavItem[];
+    generatedAt: number;
+    generateTime: number;
+}>>;
+export default _default;

package/dist/runtime/server/api/cache.js

@@ -0,0 +1,26 @@
+import { defineEventHandler } from "h3";
+import { getContentProvider } from "../providers/index.js";
+import { createContentProviderError } from "../../../public/provider-errors";
+import { cacheStorage } from "../storage-access.js";
+export default defineEventHandler(async (event) => {
+  const now = Date.now();
+  const contents = [];
+  const provider = await getContentProvider(event);
+  if (!provider.navigationQuery) {
+    throw createContentProviderError("unsupported_provider_operation", `${provider.name} does not support navigation queries`, {
+      provider: provider.name
+    });
+  }
+  const navigation = await provider.navigationQuery(event, {});
+  await cacheStorage(event).setItem("_nav.json", navigation);
+  const meta = {
+    generatedAt: now,
+    generateTime: Date.now() - now
+  };
+  await cacheStorage(event).setItem("_meta.json", meta);
+  return {
+    ...meta,
+    contents,
+    navigation
+  };
+});

package/dist/runtime/server/api/locales

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

package/dist/runtime/server/api/locales.d.ts

@@ -0,0 +1,6 @@
+declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<{
+    path?: any;
+    canonicalKey: any;
+    locale: string;
+}[]>>;
+export default _default;

package/dist/runtime/server/api/locales.js

@@ -0,0 +1,28 @@
+import { createError, defineEventHandler, getQuery } from "h3";
+import { resolveProviderContentVariants } from "../provider-query.js";
+export default defineEventHandler(async (event) => {
+  const identity = typeof getQuery(event).identity === "string" ? getQuery(event).identity : "";
+  const collection = event.context.params?.collection;
+  if (!collection || !identity) {
+    throw createError({
+      statusCode: 400,
+      statusMessage: "Missing collection or identity"
+    });
+  }
+  const resolved = await resolveProviderContentVariants(event, identity, {
+    collection,
+    exact: false
+  });
+  const locales = resolved ? resolved.variants.filter((doc) => doc._canonicalKey === resolved.canonicalKey && typeof doc._locale === "string").sort((left, right) => String(left._locale).localeCompare(String(right._locale))).map((doc) => ({
+    canonicalKey: resolved.canonicalKey,
+    locale: String(doc._locale),
+    ...typeof doc._path === "string" ? { path: doc._path } : {}
+  })) : [];
+  if (!locales.length) {
+    throw createError({
+      statusCode: 404,
+      statusMessage: "Locale variants not found"
+    });
+  }
+  return locales;
+});

package/dist/runtime/server/api/navigation

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

package/dist/runtime/server/api/navigation.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<import("..").MaybeContentProviderResult<import("../../../types").NavItem[]>>>;
+export default _default;

package/dist/runtime/server/api/navigation.js

@@ -0,0 +1,21 @@
+import { defineEventHandler, getQuery } from "h3";
+import { getContentQuery } from "../../utils/query.js";
+import { getContentProvider } from "../providers/index.js";
+import { createContentProviderError } from "../../../public/provider-errors";
+export default defineEventHandler(async (event) => {
+  const query = getContentQuery(event);
+  const params = getQuery(event);
+  if (typeof params.collection === "string" && !query.collection) {
+    query.collection = params.collection;
+  }
+  if (typeof params.locale === "string" && !query.resolveLocale) {
+    query.resolveLocale = { locale: params.locale };
+  }
+  const provider = await getContentProvider(event);
+  if (!provider.navigationQuery) {
+    throw createContentProviderError("unsupported_provider_operation", `${provider.name} does not support navigation queries`, {
+      provider: provider.name
+    });
+  }
+  return await provider.navigationQuery(event, query);
+});

package/dist/runtime/server/api/query

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

package/dist/runtime/server/api/query.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<import("..").MaybeContentProviderResult<number | import("../../../types").ParsedContent | import("../../../types").ParsedContent[] | import("../../../types/api").ContentQueryResponse<import("../../../types").ParsedContent> | undefined>>>;
+export default _default;

package/dist/runtime/server/api/query.js

@@ -0,0 +1,6 @@
+import { defineEventHandler } from "h3";
+import { getContentQuery } from "../../utils/query.js";
+import { getContentProvider } from "../providers/index.js";
+export default defineEventHandler(async (event) => {
+  return await (await getContentProvider(event)).query(event, getContentQuery(event));
+});

package/dist/runtime/server/api/revalidate

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

package/dist/runtime/server/api/revalidate.d.ts

@@ -0,0 +1,6 @@
+declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<{
+    ok: boolean;
+    tags: string[];
+    paths: string[];
+}>>;
+export default _default;