@lde/search-api-graphql 0.25.1 → 0.26.0

package/dist/build-schema.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"build-schema.d.ts","sourceRoot":"","sources":["../src/build-schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAWL,aAAa,EAQd,MAAM,SAAS,CAAC;AACjB,OAAO,EAKL,KAAK,YAAY,EAGjB,KAAK,WAAW,EAChB,KAAK,YAAY,EAElB,MAAM,aAAa,CAAC;AAmBrB,OAAO,EAGL,KAAK,aAAa,EACnB,MAAM,eAAe,CAAC;AAIvB,8EAA8E;AAC9E,MAAM,WAAW,aAAa;IAC5B;;sDAEkD;IAClD,QAAQ,CAAC,MAAM,EAAE,YAAY,CAAC;IAC9B,mFAAmF;IACnF,QAAQ,CAAC,cAAc,EAAE,SAAS,MAAM,EAAE,CAAC;IAC3C;;;;;;OAMG;IACH,QAAQ,CAAC,YAAY,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,KAAK,IAAI,CAAC;CACjE;AAED;2EAC2E;AAC3E,MAAM,WAAW,iBAAiB;IAChC;yCACqC;IACrC,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC;IAC7B;uBACmB;IACnB,QAAQ,CAAC,aAAa,CAAC,EAAE,CACvB,KAAK,EAAE,WAAW,EAClB,OAAO,EAAE,aAAa,KACnB,WAAW,CAAC;CAClB;AAED,MAAM,WAAW,yBAAyB;IACxC;;kEAE8D;IAC9D,QAAQ,CAAC,KAAK,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,iBAAiB,CAAC,CAAC,CAAC;IAC7D,+EAA+E;IAC/E,QAAQ,CAAC,aAAa,CAAC,EAAE,aAAa,CAAC;IACvC;;gDAE4C;IAC5C,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC;CAC9B;AA4GD;;;;;;;;;GASG;AACH,wBAAgB,kBAAkB,CAChC,MAAM,EAAE,YAAY,EACpB,OAAO,GAAE,yBAA8B,GACtC,aAAa,CA0xBf;AAED;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAChC,MAAM,EAAE,YAAY,EACpB,OAAO,GAAE,yBAA8B,GACtC,MAAM,CAER"}
+{"version":3,"file":"build-schema.d.ts","sourceRoot":"","sources":["../src/build-schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAWL,aAAa,EAQd,MAAM,SAAS,CAAC;AACjB,OAAO,EAKL,KAAK,YAAY,EAIjB,KAAK,WAAW,EAChB,KAAK,YAAY,EAElB,MAAM,aAAa,CAAC;AAsBrB,OAAO,EAGL,KAAK,aAAa,EACnB,MAAM,eAAe,CAAC;AAIvB,8EAA8E;AAC9E,MAAM,WAAW,aAAa;IAC5B;;sDAEkD;IAClD,QAAQ,CAAC,MAAM,EAAE,YAAY,CAAC;IAC9B,mFAAmF;IACnF,QAAQ,CAAC,cAAc,EAAE,SAAS,MAAM,EAAE,CAAC;IAC3C;;;;;;OAMG;IACH,QAAQ,CAAC,YAAY,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,KAAK,IAAI,CAAC;CACjE;AAED;2EAC2E;AAC3E,MAAM,WAAW,iBAAiB;IAChC;yCACqC;IACrC,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC;IAC7B;uBACmB;IACnB,QAAQ,CAAC,aAAa,CAAC,EAAE,CACvB,KAAK,EAAE,WAAW,EAClB,OAAO,EAAE,aAAa,KACnB,WAAW,CAAC;CAClB;AAED,MAAM,WAAW,yBAAyB;IACxC;;kEAE8D;IAC9D,QAAQ,CAAC,KAAK,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,iBAAiB,CAAC,CAAC,CAAC;IAC7D,+EAA+E;IAC/E,QAAQ,CAAC,aAAa,CAAC,EAAE,aAAa,CAAC;IACvC;;gDAE4C;IAC5C,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC;CAC9B;AA4GD;;;;;;;;;GASG;AACH,wBAAgB,kBAAkB,CAChC,MAAM,EAAE,YAAY,EACpB,OAAO,GAAE,yBAA8B,GACtC,aAAa,CA85Bf;AAED;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAChC,MAAM,EAAE,YAAY,EACpB,OAAO,GAAE,yBAA8B,GACtC,MAAM,CAER"}

package/dist/build-schema.js

@@ -1,5 +1,5 @@
 import { GraphQLBoolean, GraphQLEnumType, GraphQLError, GraphQLFloat, GraphQLInputObjectType, GraphQLInt, GraphQLList, GraphQLNonNull, GraphQLObjectType, GraphQLScalarType, GraphQLSchema, GraphQLString, printSchema, } from 'graphql';
-import { AND_KEY, facetableFields, filterableFields, filterOn, filterOperatorFor, ID_FIELD, isAbsoluteIri, OR_KEY, isRangeFacet, joinGraph, nestedReferenceType, outputFields, pageForOffset, sortableFields, unixSecondsToIso, } from '@lde/search/adapter';
+import { AND_KEY, facetableFields, filterableFields, labelTargetNameOf, localLookupTypeOf, referenceFields, filterOn, filterOperatorFor, ID_FIELD, isAbsoluteIri, OR_KEY, isRangeFacet, joinGraph, nestedReferenceType, outputFields, pageForOffset, sortableFields, unixSecondsToIso, } from '@lde/search/adapter';
 import { defaultLanguageOrder, toLanguageStrings, } from './language.js';
 import { createFacetLoader } from './facet-batch.js';
 import { projectionFor } from './projection.js';
@@ -262,6 +262,45 @@ export function buildGraphQLSchema(schema, options = {}) {
     // collide: searchSchema resolves its typeName to a declared Reference Type
     // and rejects duplicate names schema-wide.
     const referenceTypes = new Map();
+    /**
+     * The lookup targets whose emitted type must carry a NULLABLE `id`: those
+     * some field reaches through a {@link ReferenceStrategy.local local} lookup,
+     * which stores what a document says about an endpoint whether or not the
+     * endpoint is identified.
+     *
+     * Computed over the whole schema before any type is registered, because one
+     * emitted type is SHARED by every field pointing at its target. Decided per
+     * field instead, the answer would depend on which field happened to register
+     * first: a plain `publisher` lookup registering before a `local` creator
+     * would make `id` non-null and then fail the response for every unidentified
+     * creator – exactly the endpoint `local` exists to serve.
+     *
+     * Nullability is therefore a property of the type, and takes the weakest
+     * guarantee any of its users can keep.
+     */
+    const nullableIdTargets = new Set();
+    {
+        const walked = new Set();
+        const collect = (searchType) => {
+            if (walked.has(searchType.name)) {
+                return;
+            }
+            walked.add(searchType.name);
+            for (const field of referenceFields(searchType)) {
+                if (field.ref?.strategy === 'lookup' && field.ref.local === true) {
+                    nullableIdTargets.add(field.ref.target);
+                }
+                const nested = nestedReferenceType(schema, field) ??
+                    localLookupTypeOf(field, schema);
+                if (nested !== undefined) {
+                    collect(nested);
+                }
+            }
+        };
+        for (const rootType of schema.values()) {
+            collect(rootType);
+        }
+    }
     // Seeded with the shared types every schema carries, not just the root type
     // names: a declaration is free to name a type `IRI` or `ValueBucket`, and
     // without this it would pass both collision checks and fail at
@@ -289,6 +328,7 @@ export function buildGraphQLSchema(schema, options = {}) {
     // same type queried in its own right meet exactly one `‹Name›Where`.
     const joins = joinGraph(schema);
     const whereInputs = new Map();
+    const nestedFilters = new Map();
     const referenceFilters = new Map();
     /** The name a reference’s emitted type is keyed under: a `lookup`’s target,
      *  an `inline`’s reference type, an `idOnly`’s declared name (which names a
@@ -321,8 +361,11 @@ export function buildGraphQLSchema(schema, options = {}) {
         const typeName = referencedTypeName(field.ref);
         if (referenceTypes.has(typeName)) {
             // Fields sharing a referent share one emitted type, and cannot disagree
-            // about it: a lookup's fields come from the target that names the type,
-            // an inline reference's from the Reference Type that does.
+            // about its FIELDS: a lookup's come from the target that names the type,
+            // an inline reference's from the Reference Type that does. They can
+            // disagree about `id` nullability, which is why that is settled over the
+            // whole schema up front ({@link nullableIdTargets}) rather than read off
+            // whichever field registers the type first.
             return;
         }
         const graphQLName = rootTypeNames.has(typeName)
@@ -349,14 +392,30 @@ export function buildGraphQLSchema(schema, options = {}) {
                 // An inline referent’s is nullable, and load-bearing: a referent
                 // needs no identity, so a blank-node one nests exactly like a named
                 // one, minus this.
+                //
+                // A `local` lookup is the exception among lookups, for that same
+                // reason: it stores what the referring document says about the
+                // endpoint whether or not the endpoint is identified, so an entry
+                // may legitimately arrive without one. Declared non-null, every such
+                // entry would fail the response instead of serving what it has.
                 id: {
-                    type: field.ref?.strategy === 'lookup'
+                    type: field.ref?.strategy === 'lookup' &&
+                        !nullableIdTargets.has(typeName)
                         ? new GraphQLNonNull(iriScalar)
                         : iriScalar,
                 },
                 ...Object.fromEntries(outputFields(nested).map((nestedField) => [
                     nestedField.name,
-                    outputFieldConfig(nestedField),
+                    // `required` is relaxed for the same reason `id` is above: a
+                    // `local` lookup carries what a document SAYS about an endpoint,
+                    // and a document that named one inline states no more than it
+                    // states. A field the target promises is non-null on the
+                    // target's own document, not on a referrer's account of it, so
+                    // holding this one to it fails the whole response for exactly
+                    // the endpoint `local` exists to serve.
+                    outputFieldConfig(nullableIdTargets.has(typeName)
+                        ? { ...nestedField, required: false }
+                        : nestedField),
                 ])),
             }),
         }));
@@ -450,6 +509,14 @@ export function buildGraphQLSchema(schema, options = {}) {
         }
     }
     function whereFieldType(field, owner) {
+        // An inline reference is filterable in two ways at once, exactly as a
+        // joinable one is: by the ids its entries hold (its identity companion),
+        // and by a condition on an entry. Same input shape, because it is the same
+        // question one hop out – only what the hop costs differs.
+        const nested = nestedReferenceType(schema, field);
+        if (nested !== undefined) {
+            return nestedFilterFor(nested, field);
+        }
         // A joinable reference is filterable in two ways at once – by the ids it
         // holds, and by a condition on the referent – so it earns a richer input
         // than the plain membership every other reference gets. Making the
@@ -461,6 +528,58 @@ export function buildGraphQLSchema(schema, options = {}) {
             ? referenceFilterFor(target)
             : plainWhereFieldType(field);
     }
+    /**
+     * The filter input an inline reference takes: the ids its entries hold, or a
+     * condition on one entry. `@oneOf`, so a criterion stays an atom.
+     *
+     * The `in` arm is typed by the target the reference’s
+     * {@link ReferenceStrategy.identity identity companion} names, so a bucket a
+     * consumer clicks feeds straight back in – the same round trip an ordinary
+     * facetable reference already guarantees. A reference declaring no identity
+     * has no ids to filter, so it offers the `where` arm alone.
+     */
+    function nestedFilterFor(referenceType, field) {
+        const existing = nestedFilters.get(referenceType.name);
+        if (existing !== undefined) {
+            return existing;
+        }
+        const identityTarget = labelTargetNameOf(field, schema);
+        const nestedWhere = nestedWhereInputFor(referenceType);
+        const created = new GraphQLInputObjectType({
+            name: `${referenceType.name}Filter`,
+            description: `A condition on ${referenceType.name}: the ids its entries reference, or a condition on one entry.`,
+            isOneOf: true,
+            fields: () => ({
+                ...(identityTarget !== undefined && {
+                    in: { type: new GraphQLList(new GraphQLNonNull(iriScalar)) },
+                }),
+                where: { type: nestedWhere },
+            }),
+        });
+        nestedFilters.set(referenceType.name, created);
+        return created;
+    }
+    /**
+     * The `where` input of a Reference Type – its filterable fields and nothing
+     * else. Deliberately without the `id` key every Root Type's `where` carries:
+     * an entry is read, not addressed, so it has no document key to filter on
+     * ({@link validateQuery} refuses one).
+     */
+    function nestedWhereInputFor(referenceType) {
+        // Memoized by its only caller, which is memoized itself – so this is built
+        // once per Reference Type however many fields nest it.
+        return new GraphQLInputObjectType({
+            name: `${referenceType.name}Where`,
+            description: 'Sibling keys are combined with AND, and all of them must hold of the SAME entry.',
+            fields: () => Object.fromEntries(filterableFields(referenceType).map((nestedField) => [
+                nestedField.name,
+                {
+                    type: whereFieldType(nestedField, referenceType),
+                    description: nestedField.description,
+                },
+            ])),
+        });
+    }
     /** The filter input one field accepts, fixed by what the field keys on: a
      *  `reference` keys on identity (its target’s filter, or `IRIFilter` when it
      *  names no target), a `keyword` on literals. */
@@ -688,10 +807,10 @@ export function buildGraphQLSchema(schema, options = {}) {
                 },
             },
             resolve: async (_source, args, context, info) => {
-                const built = argsToQuery(args, context, searchType, maxPerPage, joins);
+                const built = argsToQuery(args, context, searchType, maxPerPage, joins, schema);
                 // What the client selected decides what each lookup fetches, so the
                 // engine carries the referent fields this query asked for and no more.
-                const resolve = projectionFor(info, searchType, (target) => rootTypesByName.get(target));
+                const resolve = projectionFor(info, searchType, schema);
                 const finalQuery = typeOptions?.queryDefaults
                     ? typeOptions.queryDefaults(built, context)
                     : built;
@@ -790,7 +909,7 @@ export function printGraphQLSchema(schema, options = {}) {
 /** Pure args → {@link SearchQuery} mapping. Rejects out-of-bounds paging
  *  (`page < 1`, `perPage` outside `1..maxPerPage`) with a clear error – a
  *  negative offset or an unbounded page size must not reach the engine. */
-function argsToQuery(args, context, searchType, maxPerPage, joins) {
+function argsToQuery(args, context, searchType, maxPerPage, joins, schema) {
     const perPage = args.perPage ?? 20;
     const page = args.page ?? 1;
     if (page < 1) {
@@ -802,7 +921,7 @@ function argsToQuery(args, context, searchType, maxPerPage, joins) {
     }
     return {
         text: args.query,
-        where: whereToFilters(args.where, searchType, joins),
+        where: whereToFilters(args.where, searchType, joins, schema),
         orderBy: args.orderBy
             ? [{ field: args.orderBy.field, direction: args.orderBy.direction }]
             : [],
@@ -822,7 +941,7 @@ function argsToQuery(args, context, searchType, maxPerPage, joins) {
  * result is still flat: the nesting lives in each criterion’s `on` path, never
  * in the clause structure, so skip-own-filter (ADR 5) still scans one level.
  */
-function whereToFilters(where, searchType, joins, on = []) {
+function whereToFilters(where, searchType, joins, schema, on = []) {
     // `== null` deliberately: an explicit `where: null` is as absent as an omitted
     // one, and reading keys off it would throw.
     if (where == null) {
@@ -833,9 +952,22 @@ function whereToFilters(where, searchType, joins, on = []) {
     // while `or` becomes a SINGLE filter carrying every alternative. That is the
     // whole AND/OR mapping: which bucket a criterion lands in, never a combinator
     // inferred from how deeply it is nested.
-    for (const entry of keyEntriesOf(where, searchType, joins)) {
+    for (const entry of keyEntriesOf(where, searchType, joins, schema)) {
         if ('nested' in entry) {
-            filters.push(...whereToFilters(entry.nested, entry.target, joins, [
+            // A NESTING hop welds: every condition inside one edge's `where` must
+            // hold of the SAME entry, which is the whole point of indexing an edge.
+            // Written as separate criteria they would be satisfiable by different
+            // entries – the parallel-array answer, silently wider than what was
+            // asked. A JOIN hop keeps recursing: those conditions are about another
+            // document, where there is nothing to weld them to.
+            if (entry.target.class === undefined) {
+                const welded = weldedCriterionOf(entry, joins, schema, on);
+                if (welded !== undefined) {
+                    filters.push(filterOn(welded));
+                }
+                continue;
+            }
+            filters.push(...whereToFilters(entry.nested, entry.target, joins, schema, [
                 ...on,
                 entry.name,
             ]));
@@ -843,7 +975,7 @@ function whereToFilters(where, searchType, joins, on = []) {
         }
         filters.push(filterOn(withPath(entry.criterion, on)));
     }
-    const alternatives = (where[OR_KEY] ?? []).flatMap((criterion) => criteriaOf(criterion, searchType, joins, on));
+    const alternatives = (where[OR_KEY] ?? []).flatMap((criterion) => criteriaOf(criterion, searchType, joins, schema, on));
     if (alternatives.length > 0) {
         filters.push({ or: alternatives });
     }
@@ -852,10 +984,30 @@ function whereToFilters(where, searchType, joins, on = []) {
     // result flat: nested conjunctions collapse into this one list, and an `and`
     // can never sit inside an `or` (which holds only criteria).
     for (const nested of where[AND_KEY] ?? []) {
-        filters.push(...whereToFilters(nested, searchType, joins, on));
+        filters.push(...whereToFilters(nested, searchType, joins, schema, on));
     }
     return filters;
 }
+/**
+ * The one criterion an edge's `where` compiles to: its conditions welded to a
+ * single entry.
+ *
+ * Every key of that `where` becomes a condition. It carries no `or`/`and` of
+ * its own – `‹Edge›Where` declares neither, so the surface rejects them before
+ * a resolver runs: a disjunction inside a weld is not a weld, and the flat IR
+ * has nowhere to put one. `undefined` when the `where` states nothing, which
+ * constrains nothing and so contributes no clause.
+ */
+function weldedCriterionOf(entry, joins, schema, on) {
+    // Every entry here is a plain criterion, and can only be: a hop needs either
+    // a joinable reference (`joins.resolve` answers nothing from a Reference
+    // Type) or a filterable inline one (which needs an `identity`, refused inside
+    // a Reference Type). So there is nothing to skip.
+    const conditions = keyEntriesOf(entry.nested, entry.target, joins, schema).map((nested) => nested.criterion);
+    return conditions.length === 0
+        ? undefined
+        : withPath({ field: entry.name, entry: conditions }, on);
+}
 /** A criterion with its join path attached, or unchanged at the top level –
  *  so an ordinary query’s IR is byte-for-byte what it was. */
 function withPath(criterion, on) {
@@ -872,15 +1024,27 @@ function withPath(criterion, on) {
  * inside the `or` this feeds (ADR 18’s flat IR has nowhere to put it), so it is
  * rejected with the rewrite that expresses it instead.
  */
-function criteriaOf(keyed, searchType, joins, on = []) {
+function criteriaOf(keyed, searchType, joins, schema, on = []) {
     const criteria = [];
-    for (const entry of keyEntriesOf(keyed, searchType, joins)) {
+    for (const entry of keyEntriesOf(keyed, searchType, joins, schema)) {
         if (!('nested' in entry)) {
             criteria.push(withPath(entry.criterion, on));
             continue;
         }
+        // A NESTING hop welds, in an `or` alternative exactly as anywhere else –
+        // and it is the one place a weld belongs most naturally, since a welded
+        // criterion IS an atom. Compiled as separate joined criteria it would be
+        // rejected below as “a conjunction inside an or”, which is precisely the
+        // thing welding avoids.
+        if (entry.target.class === undefined) {
+            const welded = weldedCriterionOf(entry, joins, schema, on);
+            if (welded !== undefined) {
+                criteria.push(welded);
+            }
+            continue;
+        }
         const path = [...on, entry.name];
-        const nested = whereToFilters(entry.nested, entry.target, joins, path);
+        const nested = whereToFilters(entry.nested, entry.target, joins, schema, path);
         const [only] = nested;
         // An `or` alternative must be exactly one criterion. Empty and
         // more-than-one are opposite mistakes, so they are named separately rather
@@ -905,7 +1069,7 @@ function criteriaOf(keyed, searchType, joins, on = []) {
  * reference gets – while `where` states a condition on the referent and yields
  * a nested entry the caller walks into.
  */
-function keyEntriesOf(keyed, searchType, joins) {
+function keyEntriesOf(keyed, searchType, joins, schema) {
     const entries = [];
     const id = keyed[ID_FIELD];
     if (id !== undefined && id !== null) {
@@ -916,7 +1080,12 @@ function keyEntriesOf(keyed, searchType, joins) {
         if (value === undefined || value === null) {
             continue;
         }
-        const target = joins.resolve(searchType, [field.name]);
+        // Both hop kinds take the same `@oneOf` input – `in` (the ids this field
+        // holds) or `where` (a condition one hop out) – so both are read here, and
+        // only what they resolve to differs: another collection, or this
+        // document's own entries.
+        const target = nestedReferenceType(schema, field) ??
+            joins.resolve(searchType, [field.name]);
         if (target !== undefined) {
             const nested = value
                 .where;

package/dist/projection.d.ts

@@ -1,8 +1,5 @@
 import { type GraphQLResolveInfo } from 'graphql';
-import { type ReferenceProjection, type SearchType } from '@lde/search';
-/** How a `lookup` field’s `target` resolves to the Root Type it reads from –
- *  supplied by the caller, which holds the schema. */
-export type TargetResolver = (target: string) => SearchType | undefined;
+import { type ReferenceProjection, type SearchSchema, type SearchType } from '@lde/search';
 /**
  * Build the {@link ReferenceProjection} a query’s **selection set** asks for, so
  * the engine fetches each referent’s fields at the depth the client selected and
@@ -20,5 +17,5 @@ export type TargetResolver = (target: string) => SearchType | undefined;
  * omitted and then missing. Over-fetching a field is recoverable; a null where
  * the client asked for a value is not.
  */
-export declare function projectionFor(info: Pick<GraphQLResolveInfo, 'fieldNodes' | 'fragments'>, searchType: SearchType, targetOf: TargetResolver): ReferenceProjection | undefined;
+export declare function projectionFor(info: Pick<GraphQLResolveInfo, 'fieldNodes' | 'fragments'>, searchType: SearchType, schema: SearchSchema): ReferenceProjection | undefined;
 //# sourceMappingURL=projection.d.ts.map

package/dist/projection.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"projection.d.ts","sourceRoot":"","sources":["../src/projection.ts"],"names":[],"mappings":"AAAA,OAAO,EAIL,KAAK,kBAAkB,EAExB,MAAM,SAAS,CAAC;AACjB,OAAO,EAAE,KAAK,mBAAmB,EAAE,KAAK,UAAU,EAAE,MAAM,aAAa,CAAC;AAGxE;sDACsD;AACtD,MAAM,MAAM,cAAc,GAAG,CAAC,MAAM,EAAE,MAAM,KAAK,UAAU,GAAG,SAAS,CAAC;AAIxE;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,aAAa,CAC3B,IAAI,EAAE,IAAI,CAAC,kBAAkB,EAAE,YAAY,GAAG,WAAW,CAAC,EAC1D,UAAU,EAAE,UAAU,EACtB,QAAQ,EAAE,cAAc,GACvB,mBAAmB,GAAG,SAAS,CAajC"}
+{"version":3,"file":"projection.d.ts","sourceRoot":"","sources":["../src/projection.ts"],"names":[],"mappings":"AAAA,OAAO,EAIL,KAAK,kBAAkB,EAExB,MAAM,SAAS,CAAC;AACjB,OAAO,EACL,KAAK,mBAAmB,EACxB,KAAK,YAAY,EACjB,KAAK,UAAU,EAChB,MAAM,aAAa,CAAC;AASrB;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,aAAa,CAC3B,IAAI,EAAE,IAAI,CAAC,kBAAkB,EAAE,YAAY,GAAG,WAAW,CAAC,EAC1D,UAAU,EAAE,UAAU,EACtB,MAAM,EAAE,YAAY,GACnB,mBAAmB,GAAG,SAAS,CAQjC"}

package/dist/projection.js

@@ -1,5 +1,5 @@
 import { Kind, } from 'graphql';
-import { fieldNamed } from '@lde/search/adapter';
+import { fieldNamed, nestedReferenceType, rootTypeNamed, } from '@lde/search/adapter';
 /**
  * Build the {@link ReferenceProjection} a query’s **selection set** asks for, so
  * the engine fetches each referent’s fields at the depth the client selected and
@@ -17,11 +17,11 @@ import { fieldNamed } from '@lde/search/adapter';
  * omitted and then missing. Over-fetching a field is recoverable; a null where
  * the client asked for a value is not.
  */
-export function projectionFor(info, searchType, targetOf) {
+export function projectionFor(info, searchType, schema) {
     // `items` carries the hits; the root field’s other selections (pagination,
     // facets) are served without touching a referent.
     const items = info.fieldNodes.flatMap((node) => selectionsNamed(node.selectionSet, 'items', info.fragments));
-    const projection = fromSelections(items, searchType, info.fragments, targetOf);
+    const projection = fromSelections(items, searchType, info.fragments, schema);
     return Object.keys(projection).length === 0 ? undefined : projection;
 }
 /** The selection sets of every field named `name`, fragments followed. */
@@ -81,30 +81,50 @@ function mergeProjections(left, right) {
     return merged;
 }
 /** One level: which lookups were selected, and what each asked for. */
-function fromSelections(selectionSets, searchType, fragments, targetOf) {
+function fromSelections(selectionSets, searchType, fragments, schema) {
     const projection = {};
     for (const selectionSet of selectionSets) {
         for (const selected of fieldsOf(selectionSet, fragments)) {
             const field = fieldNamed(searchType, selected.name.value);
-            if (field === undefined ||
-                field.kind !== 'reference' ||
-                field.ref?.strategy !== 'lookup') {
+            if (field === undefined) {
+                continue;
+            }
+            // An INLINE reference is already carried by the hit, so it asks for
+            // nothing itself – but a lookup may sit inside it, and that one has to be
+            // reached. So the level is recorded with no `fields`, purely to carry
+            // what is selected below it.
+            const nested = nestedReferenceType(schema, field);
+            if (nested !== undefined) {
+                if (selected.selectionSet === undefined) {
+                    continue;
+                }
+                const below = fromSelections([selected.selectionSet], nested, fragments, schema);
+                if (Object.keys(below).length > 0) {
+                    const entry = (projection[selected.name.value] ??= {});
+                    entry.resolve = mergeProjections(entry.resolve, below);
+                }
+                continue;
+            }
+            if (field.kind !== 'reference' || field.ref?.strategy !== 'lookup') {
                 continue;
             }
             // The target's own declaration decides what its selections mean, so the
             // level below is read against it rather than against this type.
-            const target = targetOf(field.ref.target);
+            // `searchSchema` rejects a lookup whose target it cannot resolve, so a
+            // schema always resolves its own – which is why this reads the schema
+            // rather than taking a resolver that could answer nothing.
+            const target = rootTypeNamed(schema, field.ref.target);
             // Only what the target actually serves. A selection carries more than
             // that: `id` is on the referring document already, and every GraphQL
             // client worth the name injects `__typename` into every selection set –
             // asking the engine for either would fail the query at the port's guard.
             const wanted = fieldsOf(selected.selectionSet, fragments)
                 .map((node) => node.name.value)
-                .filter((name) => target === undefined ? false : servesField(target, name));
+                .filter((name) => servesField(target, name));
             const entry = (projection[selected.name.value] ??= {});
             entry.fields = [...new Set([...(entry.fields ?? []), ...wanted])];
-            if (target !== undefined && selected.selectionSet !== undefined) {
-                const below = fromSelections([selected.selectionSet], target, fragments, targetOf);
+            if (selected.selectionSet !== undefined) {
+                const below = fromSelections([selected.selectionSet], target, fragments, schema);
                 if (Object.keys(below).length > 0) {
                     // Merged level by level, not key by key: one lookup selected twice –
                     // two fragments each spreading it – must union what each asked for,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lde/search-api-graphql",
-  "version": "0.25.1",
+  "version": "0.26.0",
   "description": "Engine- and domain-agnostic GraphQL surface for @lde/search: builds an executable GraphQLSchema from a whole SearchSchema at runtime (no codegen) – one root query field per SearchType – served by generic resolvers over any SearchEngine – and serves it as a framework-agnostic fetch handler with a self-contained playground, SDL endpoint, CORS and depth/cost limits. You supply the schema and per-type typeNames; it names neither your domain nor your engine.",
   "repository": {
     "url": "git+https://github.com/ldelements/lde.git",
@@ -37,7 +37,7 @@
     "@escape.tech/graphql-armor-cost-limit": "^2.4.3",
     "@escape.tech/graphql-armor-max-depth": "^2.4.2",
     "@graphql-yoga/render-graphiql": "^5.21.3",
-    "@lde/search": "^0.23.1",
+    "@lde/search": "^0.24.0",
     "commander": "^15.0.0",
     "dataloader": "^2.2.3",
     "graphql": "^16.9.0",