@lupinum/ginko-content 0.1.2 → 0.1.3

package/dist/runtime/query/populate.js

@@ -0,0 +1,106 @@
+import { collectTopLevelReferenceFieldsByTarget } from "../../core/references/schema";
+import { ensureCollectionName } from "./handles.js";
+const LOCALIZED_DOC_INTERNAL_FIELDS = [
+  "_id",
+  "_path",
+  "_file",
+  "_canonicalKey",
+  "_locale",
+  "_resolvedLocale",
+  "_requestedLocale",
+  "_fallback",
+  "_availableLocales",
+  "_variantPaths",
+  "_requestedPath",
+  "_requestedRoute",
+  "_requestedRef",
+  "_extension"
+];
+const wildcardReferenceTarget = "*";
+const isRecord = (value) => {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+};
+const collectReferenceFieldsByTarget = (source, sourceCollection, runtime) => {
+  if (typeof source !== "string") {
+    return collectTopLevelReferenceFieldsByTarget(source.schema);
+  }
+  return runtime?.collections?.[sourceCollection]?.references || {};
+};
+const invertReferenceFields = (references) => {
+  const fields = /* @__PURE__ */ new Map();
+  for (const [target, targetFields] of Object.entries(references)) {
+    for (const field of targetFields) {
+      const targets = fields.get(field) || [];
+      targets.push(target);
+      fields.set(field, targets);
+    }
+  }
+  return fields;
+};
+const createPopulateTargetMismatchError = (sourceCollection, field, expectedTargets, actualTarget) => new Error([
+  `Cannot populate "${sourceCollection}.${field}" from "${actualTarget}".`,
+  `Reference metadata declares "${sourceCollection}.${field}" points to ${expectedTargets.map((target) => `"${target}"`).join(" or ")}.`,
+  `Change populate.${field} to the declared target collection, or update ${sourceCollection}.schema relation metadata.`
+].join(" "));
+export const validatePopulateSpec = (source, sourceCollection, runtime, populate) => {
+  if (!populate || !isRecord(populate)) {
+    return;
+  }
+  const references = collectReferenceFieldsByTarget(source, sourceCollection, runtime);
+  const fieldTargets = invertReferenceFields(references);
+  if (!fieldTargets.size) {
+    return;
+  }
+  for (const [field, target] of Object.entries(populate)) {
+    const declaredTargets = fieldTargets.get(field);
+    if (!declaredTargets?.length) {
+      continue;
+    }
+    const actualTarget = ensureCollectionName(target);
+    if (declaredTargets.includes(actualTarget) || declaredTargets.includes(wildcardReferenceTarget)) {
+      continue;
+    }
+    throw createPopulateTargetMismatchError(
+      sourceCollection,
+      field,
+      declaredTargets.filter((target2) => target2 !== wildcardReferenceTarget),
+      actualTarget
+    );
+  }
+};
+const populateReferenceValue = async (context, resolveReference, target, value, locale, fallback) => {
+  if (typeof value !== "string" || !value) {
+    return null;
+  }
+  return resolveReference(context, target, {
+    by: { ref: value },
+    ...locale ? { locale } : {},
+    ...fallback !== void 0 ? { fallback } : {}
+  });
+};
+export const populateDocument = async (context, resolveReference, 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, resolveReference, target, item, locale, fallback)));
+      populated[field] = resolved.filter(Boolean);
+      return;
+    }
+    populated[field] = await populateReferenceValue(context, resolveReference, target, value, locale, fallback);
+  }));
+  return populated;
+};
+export const selectWithPopulate = (select, populate) => {
+  if (!select) {
+    return void 0;
+  }
+  return [.../* @__PURE__ */ new Set([
+    ...select,
+    ...LOCALIZED_DOC_INTERNAL_FIELDS,
+    ...populate && isRecord(populate) ? Object.keys(populate) : []
+  ])];
+};

package/dist/runtime/query/responses

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

package/dist/runtime/query/responses.d.ts

@@ -0,0 +1,10 @@
+export declare const unwrapOneResponse: <T>(response: unknown) => T | T[] | null;
+export declare const unwrapListResponse: <T>(response: unknown) => T[];
+export declare const unwrapFindResponse: <T>(response: unknown) => {
+    result: T[];
+    total: number;
+    skip: number;
+    limit: number;
+    hasTotal: boolean;
+};
+export declare const unwrapCountResponse: (response: unknown) => number | null;

package/dist/runtime/query/responses.js

@@ -0,0 +1,47 @@
+const isObject = (value) => Boolean(value) && typeof value === "object" && !Array.isArray(value);
+const isFindResponseEnvelope = (response) => isObject(response) && Array.isArray(response.result) && typeof response.total === "number" && (typeof response.skip === "undefined" || typeof response.skip === "number") && (typeof response.limit === "undefined" || typeof response.limit === "number");
+const isResultOnlyEnvelope = (response) => isObject(response) && "result" in response && Object.keys(response).length === 1;
+const isSingleQueryEnvelope = (response) => isFindResponseEnvelope(response) || isResultOnlyEnvelope(response);
+const isListQueryEnvelope = (response) => isFindResponseEnvelope(response);
+export const unwrapOneResponse = (response) => {
+  if (!response) return null;
+  if (isSingleQueryEnvelope(response)) {
+    const result = response.result;
+    return result ?? null;
+  }
+  return response;
+};
+export const unwrapListResponse = (response) => {
+  if (!response) return [];
+  if (isListQueryEnvelope(response)) {
+    return response.result;
+  }
+  return Array.isArray(response) ? response : [response];
+};
+export const unwrapFindResponse = (response) => {
+  if (!response) {
+    return { result: [], total: 0, skip: 0, limit: 0, hasTotal: false };
+  }
+  if (isListQueryEnvelope(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 };
+};
+export const unwrapCountResponse = (response) => {
+  if (typeof response === "number") {
+    return response;
+  }
+  if (isSingleQueryEnvelope(response) && typeof response.result === "number") {
+    return response.result;
+  }
+  return null;
+};

package/dist/runtime/query/unified.d.ts

@@ -16,26 +16,10 @@
  */
 import type { ParsedContent } from '../../types/content';
 import type { ContentCollectionHandle } from '../../types/config';
-import type { BacklinkSource, BacklinksOptions, BacklinksResult, ContentTreeItem, DocumentFromHandle, ManyOptions, LocalizedDoc, NeighborsOptions, NeighborsResult, OneOptions, PopulateSpec, PopulateFromOptions, PopulatedDocument, PaginationOptions, PaginationResult, ResolveOneOptions, ResolveOneResult, TreeOptions, ContentVariant, ContentQueryBuilderParams, VariantsOptions } from '../../types/query';
-import type { ContentQueryResponse } from '../../types/api';
-export interface RuntimeContentConfig {
-    locales?: string[];
-    defaultLocale?: string;
-    collections?: Record<string, {
-        i18n?: boolean | {
-            locales?: string[];
-            defaultLocale?: string;
-        };
-        route?: string | Record<string, string>;
-        references?: Record<string, string[]>;
-    }>;
-}
-export type ContentQueryEndpoint = 'query' | 'navigation';
-export interface ContentQueryContext {
-    runtime: RuntimeContentConfig;
-    transport: <T>(endpoint: ContentQueryEndpoint, params: ContentQueryBuilderParams) => Promise<ContentQueryResponse<T> | T | T[] | null>;
-}
-export declare const navigationSelectFields: (fields?: ReadonlyArray<string> | undefined) => string[];
+import type { BacklinkSource, BacklinksOptions, BacklinksResult, ContentTreeItem, DocumentFromHandle, ManyOptions, LocalizedDoc, NeighborsOptions, NeighborsResult, OneOptions, PopulateSpec, PopulateFromOptions, PopulatedDocument, PaginationOptions, PaginationResult, ResolveOneOptions, ResolveOneResult, TreeOptions, ContentVariant, VariantsOptions } from '../../types/query';
+import type { ContentQueryContext } from './context';
+export type { ContentQueryContext, ContentQueryEndpoint, RuntimeContentConfig } from './context';
+export { navigationSelectFields } from './navigation';
 /**
  * Resolve exactly one document and return an explanation of how it matched.
  */