@capacms/sdk 1.0.0-next.0 → 1.0.0-next.10

package/dist/next/graphql/typed.d.ts

@@ -0,0 +1,261 @@
+/**
+ * typed.ts — the typed object builder behind `client.graphql.query()`.
+ *
+ * A selection is a plain object shaped like the response: `true` for a scalar,
+ * an object for anything with fields, and `args` beside the fields of a field
+ * that takes arguments.
+ *
+ *   capa.graphql.query({
+ *     articles: {
+ *       args: { first: 5, sort: ["publishedAt_DESC"] },
+ *       nodes: { title: true, author: { name: true } },
+ *     },
+ *   });
+ *
+ * The types come from `capa-codegen --graphql`, which writes the key's schema
+ * as TypeScript: pass its `CapaQuery` to `createClient<CapaQuery>()` and the
+ * selection is checked field by field (a misspelled field does not compile)
+ * while the result is typed from exactly what was selected.
+ *
+ * An alias reads a field again under another name, in the same request:
+ * `{ latest: { __aliasFor: "articles", args: { sort: ["publishedAt_DESC"] }, nodes: { title: true } } }`
+ * prints `latest: articles(sort: [publishedAt_DESC]) { ... }` and is typed as
+ * `articles` is, under `latest`. A scalar is aliased with `__aliasFor` alone:
+ * `{ headline: { __aliasFor: "title" } }`. `client.graphql.query` takes its
+ * selection as a `const` type parameter, so `__aliasFor` and every `sort`
+ * value keep their literal types inside an alias, which no field's type
+ * gives them there.
+ *
+ * Arguments are written inline as GraphQL literals. Every Capa argument is a
+ * scalar or an input object except `sort`, whose values are enum members, so
+ * `sort` is the one argument printed without quotes.
+ */
+/**
+ * A field that takes arguments, as codegen writes it: `R` is what it returns
+ * and `A` the arguments it takes. Never a runtime value.
+ */
+export interface CapaField<R, A> {
+    readonly __capaReturns: R;
+    readonly __capaArgs: A;
+}
+/**
+ * The key codegen writes each model type's `TreeLayout` under. A symbol, so it
+ * is never a field: a selection, a result and autocomplete see string keys only.
+ */
+declare const treeLayout: unique symbol;
+export type { treeLayout };
+/**
+ * How `toTree` lays a model's entries out in REST's shape, from what only the
+ * schema's descriptions say: each field's namespace, which is its key under
+ * `fields` (`hero_image` is `hero-image`, `status_field` is `status`), and
+ * which fields GraphQL types as ids because the key cannot read their model.
+ * Never a runtime value.
+ */
+export interface TreeLayout {
+    fields: {
+        [graphqlName: string]: string;
+    };
+    ids: string;
+}
+/** What a field returns, under its `CapaField` wrapper when it takes arguments. */
+export type Returns<F> = F extends CapaField<infer R, unknown> ? R : F;
+type ArgsOf<F> = F extends CapaField<unknown, infer A> ? A : never;
+/**
+ * Whether `R` admits `null`. Without `strictNullChecks`, `null extends R` holds
+ * for every `R`, so the check also asks that `R` changes without `null`: a
+ * type that stays itself is not nullable. That keeps the recursion on
+ * `NonNullable<R>` finite in a project compiled with `strict: false`.
+ */
+export type Nullable<R> = null extends R ? ([R] extends [NonNullable<R>] ? false : true) : false;
+/** The object type under nullability and lists. */
+export type Base<T> = NonNullable<T> extends ReadonlyArray<infer E> ? Base<E> : NonNullable<T>;
+type IsLeaf<T> = unknown extends T ? true : [Base<T>] extends [string | number | boolean | bigint] ? true : false;
+/**
+ * Arguments as a selection may write them: every list may be readonly, so a
+ * selection declared `as const` (which a selection kept in a variable for
+ * `toTree` needs, to keep its enum values) is accepted.
+ */
+export type ArgsInput<A> = A extends ReadonlyArray<infer E> ? ReadonlyArray<ArgsInput<E>> : A extends object ? {
+    [K in keyof A]: ArgsInput<A[K]>;
+} : A;
+/**
+ * Where a field's `args` go: optional when every argument is, and required
+ * when one is (`article` needs its `id`), so a read the API would refuse for
+ * a missing argument does not compile.
+ */
+type ArgsSlot<A> = {} extends ArgsInput<A> ? {
+    args?: ArgsInput<A>;
+} : {
+    args: ArgsInput<A>;
+};
+/**
+ * A scalar is selected with `true`. `boolean` is accepted too, because an
+ * object literal held in a variable widens `true` to `boolean`; such a field
+ * is typed as possibly absent, and `false` selects nothing.
+ */
+type FieldSelection<F> = IsLeaf<Returns<F>> extends true ? boolean : [ArgsOf<F>] extends [never] ? Selection<Base<Returns<F>>> : Selection<Base<Returns<F>>> & ArgsSlot<ArgsOf<F>>;
+/**
+ * What may be selected from an object type `T`: each of its fields, and any
+ * other key as an alias of one, which `ExactSelection` checks as the field it
+ * names. The index signature lets a level hold aliases only: an object type
+ * whose keys are all optional accepts no object that shares none of them.
+ */
+export type Selection<T> = {
+    [K in Extract<keyof T, string>]?: FieldSelection<T[K]>;
+} & {
+    readonly [alias: string]: unknown;
+};
+/** The key that makes a selection an alias of another field. */
+export type AliasKey = "__aliasFor";
+/** The field an alias selection `V` reads: its `__aliasFor`, or `never` when `V` is no alias. */
+export type AliasFor<V> = V extends {
+    readonly __aliasFor: infer F;
+} ? Extract<F, string> : never;
+/** The keys of selection `S` that alias a field of `T`, rather than name one. */
+export type AliasKeys<S, T> = {
+    [K in keyof S]-?: K extends keyof T ? never : [AliasFor<S[K]>] extends [never] ? never : AliasFor<S[K]> extends keyof T ? K : never;
+}[keyof S];
+/** The selection an alias stands for: `true` for a scalar, else its own fields and `args`. */
+type AliasedSelection<T, V> = IsLeaf<Returns<T[Extract<AliasFor<V>, keyof T>]>> extends true ? true : V;
+export type FieldResult<R, S> = S extends true ? R : Nullable<R> extends true ? FieldResult<NonNullable<R>, S> | null : R extends ReadonlyArray<infer E> ? Array<FieldResult<E, S>> : SelectionResult<R, S>;
+/** One object type from an intersection, so a result reads as the object it is. */
+export type Flatten<T> = {
+    [K in keyof T]: T[K];
+};
+/**
+ * The response for selection `S` on object type `T`: only the fields
+ * selected. A field selected with `true` or a sub-selection is always there,
+ * one selected with a `boolean` may be absent, one selected with `false` is not.
+ */
+export type SelectionResult<T, S> = Flatten<{
+    [K in Extract<keyof S, keyof T> as [S[K]] extends [false | undefined] ? never : boolean extends S[K] ? never : K]: FieldResult<Returns<T[K]>, S[K]>;
+} & {
+    [K in Extract<keyof S, keyof T> as boolean extends S[K] ? K : never]?: FieldResult<Returns<T[K]>, true>;
+} & {
+    [K in AliasKeys<S, T>]: FieldResult<Returns<T[Extract<AliasFor<S[K]>, keyof T>]>, AliasedSelection<T, S[K]>>;
+}>;
+/**
+ * What a key the schema does not take is checked against. Nothing satisfies
+ * it, and the compiler prints its message, which names the key and where it
+ * was written: `Type 'true' is not assignable to type 'true &
+ * SelectionError<"titel is not a field of articles.nodes">'`. A `never`, or a
+ * message as a string literal, which intersects with `true` to `never`,
+ * would print as `never` and name neither.
+ */
+export interface SelectionError<Message extends string> {
+    readonly __capaSelectionError: Message;
+}
+/**
+ * Where a key sits in a selection, as the compiler names it in a refusal:
+ * `articles.nodes`, from `P`, the path of the level holding `K`.
+ */
+type PathTo<P extends string, K extends string> = P extends "" ? K : `${P}.${K}`;
+/** The level a path names, for a refusal: the path, or `Query` at the root. */
+type LevelName<P extends string> = P extends "" ? "Query" : P;
+/**
+ * An argument value `S` checked against the input type `Shape`: every key an
+ * input object does not declare becomes a `SelectionError` naming it and where
+ * it was written (`"frist is not accepted in articles.args"`), through lists and
+ * nested inputs (`and`, `or`, `not`, a relation filter's hop), so a
+ * misspelled filter field or operator fails to compile even beside a valid
+ * one, and the compiler's error says which.
+ */
+type ExactInput<S, Shape, P extends string> = S extends ReadonlyArray<infer E> ? Shape extends ReadonlyArray<infer ShapeElement> ? ReadonlyArray<ExactInput<E, NonNullable<ShapeElement>, P>> : S : S extends object ? {
+    [K in keyof S]: K extends keyof Shape ? ExactInput<S[K], NonNullable<Shape[K]>, PathTo<P, K & string>> : SelectionError<`${K & string} is not accepted in ${P}`>;
+} : S;
+/**
+ * Selection `S` checked against object type `T`: every key that is neither a
+ * field of `T` nor an alias of one becomes a `SelectionError` naming it and
+ * the level it was written at (`"titel is not a field of articles.nodes"`), at
+ * every level, and so does an argument the field does not declare. A
+ * misspelling then fails to compile, instead of being accepted as an extra
+ * property, with an error that names it.
+ */
+export type Exact<S, T> = S extends object ? ExactLevel<S, T, never, ""> : S;
+/**
+ * One level of a selection, at path `P`: the fields of `T`, aliases of them,
+ * and `args` when the field takes arguments `A`.
+ */
+type ExactLevel<S, T, A, P extends string> = {
+    [K in keyof S]: K extends "args" ? [A] extends [never] ? SelectionError<`${LevelName<P>} takes no arguments`> : ExactInput<S[K], ArgsInput<A>, PathTo<P, "args">> : K extends Extract<keyof T, string> ? ExactField<S[K], T[K], PathTo<P, K>> : ExactAlias<S[K], T, P, K & string>;
+};
+/** The selection of field `F` at path `P`: `true` for a scalar, its fields and `args` otherwise. */
+type ExactField<V, F, P extends string> = V extends object ? ExactLevel<V, Base<Returns<F>>, ArgsOf<F>, P> : V;
+/**
+ * Key `K` at path `P` checked as an alias: as the field it names, its required
+ * arguments and their types included, or a `SelectionError` when it names no
+ * field of `T`, or is no alias and no field at all.
+ */
+type ExactAlias<V, T, P extends string, K extends string> = [AliasFor<V>] extends [never] ? SelectionError<`${K} is not a field of ${LevelName<P>}`> : AliasFor<V> extends Extract<keyof T, string> ? ExactField<Omit<V, AliasKey>, T[AliasFor<V>], PathTo<P, K>> & {
+    readonly __aliasFor: AliasFor<V>;
+} & AliasShape<FieldSelection<T[AliasFor<V>]>> : SelectionError<`${AliasFor<V>} is not a field of ${LevelName<P>}`>;
+/** What an alias of a field selected as `F` must also be: nothing more for a scalar, the field's own selection otherwise. */
+type AliasShape<F> = [F] extends [boolean] ? unknown : F;
+/**
+ * Stands in for the schema when a client was created without codegen types:
+ * any selection is accepted and the result is untyped.
+ */
+export interface UntypedQuery {
+    readonly __capaUntyped: true;
+}
+type AnySelection = {
+    [field: string]: boolean | AnySelection | Record<string, unknown>;
+};
+declare const runtimeSelection: unique symbol;
+/**
+ * A selection built at run time from a REST read (`selectToSelection`): its
+ * fields are known only once it runs, so any client runs it, untyped, and
+ * `toTree` reads it with any schema. A selection written in code is never one,
+ * so it is still checked field by field.
+ */
+export interface RuntimeSelection {
+    readonly [runtimeSelection]: true;
+    readonly [rootField: string]: Readonly<Record<string, unknown>>;
+}
+/** Whether `Q` carries no schema: a client created without codegen types, or a schema summary read without them. */
+export type IsUntyped<Q> = unknown extends Q ? true : [Q] extends [UntypedQuery] ? true : false;
+/** The selection accepted by a client typed with `Q`: its schema's fields, or a selection built at run time. */
+export type QuerySelection<Q> = (IsUntyped<Q> extends true ? AnySelection : Selection<Q>) | RuntimeSelection;
+/** `S` checked against `Q`: an unknown field becomes a `SelectionError` naming it. Untyped clients, and a selection built at run time, take it as it is. */
+export type ExactSelection<S, Q> = S extends RuntimeSelection ? S : IsUntyped<Q> extends true ? S : Exact<S, Q>;
+/** The data returned for selection `S` by a client typed with `Q`; untyped for a selection built at run time. */
+export type QueryResult<Q, S> = S extends RuntimeSelection ? Record<string, unknown> : IsUntyped<Q> extends true ? Record<string, unknown> : SelectionResult<Q, S>;
+/** The schema field root key `K` of selection `S` reads: `K` itself, or the field an alias names. */
+type RootFieldOf<Q, S, K extends keyof S> = K extends keyof Q ? K : Extract<AliasFor<S[K]>, keyof Q>;
+/** Whether a root field returns a connection (a list root), whose entries are its `nodes` or `edges`. */
+type IsConnection<T> = T extends {
+    nodes: unknown;
+    pageInfo: unknown;
+} ? true : false;
+/** One entry of root data `R`: an item of its `nodes` (or an `edges` node) for a list root, `R` itself for a single root. */
+type EntryOfRoot<R, Connection> = Connection extends true ? R extends {
+    nodes: ReadonlyArray<infer N>;
+} ? N : R extends {
+    edges: ReadonlyArray<{
+        node: infer N;
+    }>;
+} ? NonNullable<N> : never : R;
+/**
+ * One entry that root field `K` of selection `S` reads, as a client typed
+ * with `Q` returns it: a node of a list root (`articles`), or the entry of a
+ * single root (`article`). A component that renders one entry takes it as its
+ * props type, so the component and the query cannot drift:
+ *
+ *   const teasers = { articles: { args: { first: 5 }, nodes: { id: true, title: true } } } as const;
+ *   type Teaser = NodeOf<CapaQuery, typeof teasers, "articles">; // { id: string; title: string | null }
+ *
+ * `K` may be an alias. `unknown` for an untyped client.
+ */
+export type NodeOf<Q, S, K extends keyof S> = IsUntyped<Q> extends true ? unknown : EntryOfRoot<NonNullable<QueryResult<Q, S>[K & keyof QueryResult<Q, S>]>, IsConnection<Base<Returns<Q[RootFieldOf<Q, S, K>]>>>>;
+/**
+ * The field a selection reads when it is an alias (`{ __aliasFor: "articles" }`),
+ * or undefined when it is none.
+ */
+export declare function aliasedField(selection: unknown): string | undefined;
+/** The keys a selection level selects: not `args`, `__aliasFor` or `__typename`, and not `false`. */
+export declare function selectedKeys(selection: Readonly<Record<string, unknown>>): string[];
+/**
+ * The GraphQL document for a builder selection. Pure, exported so the text a
+ * selection sends can be logged, persisted or tested.
+ */
+export declare function selectionToDocument(selection: unknown, operationName?: string): string;

package/dist/next/graphql/typed.js

@@ -0,0 +1,146 @@
+"use strict";
+/**
+ * typed.ts — the typed object builder behind `client.graphql.query()`.
+ *
+ * A selection is a plain object shaped like the response: `true` for a scalar,
+ * an object for anything with fields, and `args` beside the fields of a field
+ * that takes arguments.
+ *
+ *   capa.graphql.query({
+ *     articles: {
+ *       args: { first: 5, sort: ["publishedAt_DESC"] },
+ *       nodes: { title: true, author: { name: true } },
+ *     },
+ *   });
+ *
+ * The types come from `capa-codegen --graphql`, which writes the key's schema
+ * as TypeScript: pass its `CapaQuery` to `createClient<CapaQuery>()` and the
+ * selection is checked field by field (a misspelled field does not compile)
+ * while the result is typed from exactly what was selected.
+ *
+ * An alias reads a field again under another name, in the same request:
+ * `{ latest: { __aliasFor: "articles", args: { sort: ["publishedAt_DESC"] }, nodes: { title: true } } }`
+ * prints `latest: articles(sort: [publishedAt_DESC]) { ... }` and is typed as
+ * `articles` is, under `latest`. A scalar is aliased with `__aliasFor` alone:
+ * `{ headline: { __aliasFor: "title" } }`. `client.graphql.query` takes its
+ * selection as a `const` type parameter, so `__aliasFor` and every `sort`
+ * value keep their literal types inside an alias, which no field's type
+ * gives them there.
+ *
+ * Arguments are written inline as GraphQL literals. Every Capa argument is a
+ * scalar or an input object except `sort`, whose values are enum members, so
+ * `sort` is the one argument printed without quotes.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.aliasedField = aliasedField;
+exports.selectedKeys = selectedKeys;
+exports.selectionToDocument = selectionToDocument;
+const NAME = /^[_A-Za-z][_0-9A-Za-z]*$/;
+function checkName(name, where) {
+    if (!NAME.test(name))
+        throw new TypeError(`@capacms/sdk/next: ${JSON.stringify(name)} is not a GraphQL name (${where}).`);
+    return name;
+}
+function literal(value, enumValues) {
+    if (value === null)
+        return "null";
+    if (Array.isArray(value))
+        return `[${value.map((v) => literal(v, enumValues)).join(", ")}]`;
+    switch (typeof value) {
+        case "string":
+            return enumValues ? checkName(value, "sort value") : JSON.stringify(value);
+        case "number":
+            if (!Number.isFinite(value))
+                throw new TypeError("@capacms/sdk/next: an argument number must be finite.");
+            return String(value);
+        case "boolean":
+            return String(value);
+        case "object": {
+            // A date goes as the ISO text the DateTime scalar reads; any other
+            // object that is not plain would print as its enumerable keys, `{}`.
+            if (value instanceof Date) {
+                if (Number.isNaN(value.getTime()))
+                    throw new TypeError("@capacms/sdk/next: an argument date is not a valid date.");
+                return JSON.stringify(value.toISOString());
+            }
+            const prototype = Object.getPrototypeOf(value);
+            if (prototype !== Object.prototype && prototype !== null) {
+                throw new TypeError(`@capacms/sdk/next: an argument cannot be a ${prototype?.constructor?.name ?? "class instance"}; ` +
+                    "write a plain object, a list, text, a number, true, false or null.");
+            }
+            const fields = Object.entries(value)
+                .filter(([, inner]) => inner !== undefined)
+                .map(([key, inner]) => `${checkName(key, "argument field")}: ${literal(inner, false)}`);
+            return `{${fields.join(", ")}}`;
+        }
+        default:
+            throw new TypeError(`@capacms/sdk/next: an argument cannot be ${typeof value}.`);
+    }
+}
+function printArgs(args) {
+    if (args === undefined)
+        return "";
+    if (!args || typeof args !== "object" || Array.isArray(args)) {
+        throw new TypeError("@capacms/sdk/next: args must be an object.");
+    }
+    const parts = Object.entries(args)
+        .filter(([, value]) => value !== undefined)
+        .map(([name, value]) => `${checkName(name, "argument")}: ${literal(value, name === "sort")}`);
+    return parts.length ? `(${parts.join(", ")})` : "";
+}
+/** The key that makes a selection an alias of another field. */
+const ALIAS_KEY = "__aliasFor";
+/**
+ * The field a selection reads when it is an alias (`{ __aliasFor: "articles" }`),
+ * or undefined when it is none.
+ */
+function aliasedField(selection) {
+    if (!selection || typeof selection !== "object" || !(ALIAS_KEY in selection))
+        return undefined;
+    const field = selection[ALIAS_KEY];
+    if (typeof field !== "string")
+        throw new TypeError(`@capacms/sdk/next: ${ALIAS_KEY} names the field an alias reads, as text.`);
+    return checkName(field, "aliased field");
+}
+/** The keys a selection level selects: not `args`, `__aliasFor` or `__typename`, and not `false`. */
+function selectedKeys(selection) {
+    return Object.keys(selection).filter((key) => key !== "args" && key !== ALIAS_KEY && key !== "__typename" && selection[key] !== false && selection[key] !== undefined);
+}
+function printSelection(selection, depth) {
+    if (!selection || typeof selection !== "object" || Array.isArray(selection)) {
+        throw new TypeError("@capacms/sdk/next: a selection must be an object of fields.");
+    }
+    const pad = "  ".repeat(depth);
+    const lines = [];
+    for (const [name, value] of Object.entries(selection)) {
+        if (name === "args" || name === ALIAS_KEY || value === undefined || value === false)
+            continue;
+        checkName(name, "field");
+        if (value === true) {
+            lines.push(`${pad}${name}`);
+            continue;
+        }
+        const field = aliasedField(value);
+        const head = `${pad}${field === undefined ? name : `${name}: ${field}`}${printArgs(value.args)}`;
+        const inner = printSelection(value, depth + 1);
+        // An alias of a scalar selects nothing below it.
+        if (inner.length === 0 && field !== undefined)
+            lines.push(head);
+        else if (inner.length === 0)
+            throw new TypeError(`@capacms/sdk/next: ${name} selects no fields.`);
+        else
+            lines.push(`${head} {`, ...inner, `${pad}}`);
+    }
+    return lines;
+}
+/**
+ * The GraphQL document for a builder selection. Pure, exported so the text a
+ * selection sends can be logged, persisted or tested.
+ */
+function selectionToDocument(selection, operationName) {
+    const name = operationName === undefined ? "" : ` ${checkName(operationName, "operation name")}`;
+    const body = printSelection(selection, 1);
+    if (body.length === 0)
+        throw new TypeError("@capacms/sdk/next: a query must select at least one field.");
+    return [`query${name} {`, ...body, "}"].join("\n");
+}

package/dist/next/index.d.ts

@@ -1,3 +1,30 @@
-export { CapaError, createClient, isCapaError, resolveNextConfig, serializeSelect, } from "./client";
-export type { CallOptions, CapaNextClient, CapaNextConfig, EntriesResource, Entry, Filter, FilterOperator, FilterScalar, FilterValue, GetOptions, ListOptions, Page, PageDetail, PageInfo, PageSummary, PagesListOptions, PagesResource, PreviewClaim, ResponseMeta, Single, } from "./client";
-export type { CapaRelation, CapaRelationList, RelationSelectOptions, Select, SelectItem, SelectSort, } from "./select-types";
+export { CapaError, createClient, isCapaError, LAYOUT_PAGE, resolveNextConfig, serializeSelect, } from "./client";
+export { CAPA_EDIT, capaAttrs, fieldAttrs, isEditEntry, markEditEntries, markGraphQLEntries } from "./attrs";
+export { inflate } from "./inflate";
+export { isCapaGraphQLError } from "./errors";
+export type { CapaGraphQLError, GraphQLErrorItem } from "./errors";
+export { INTROSPECTION_QUERY } from "./graphql/introspection";
+export type { CapaIntrospection } from "./graphql/introspection";
+export { PERSISTED_QUERY_NOT_FOUND } from "./graphql/request";
+export { gql } from "./graphql/documents";
+export type { CapaDocumentResult, CapaDocuments, CapaDocumentVariables, NotARecordedDocument, RunCapaCodegen } from "./graphql/documents";
+export type { CapaGraphQLCost, CapaGraphQLExtensions, GraphQLCallOptions, GraphQLDeprecation, GraphQLQueryCost, GraphQLResult, TypedDocument, VariablesThenOptions, } from "./graphql/request";
+export { summarizeIntrospection } from "./graphql/summary";
+export type { GraphQLFieldKind, GraphQLFieldSummary, GraphQLModelSummary, GraphQLSchemaSummary, GraphQLSystemFilterSummary, } from "./graphql/summary";
+export { CapaBuildError } from "./graphql/plan";
+export type { GraphQLFieldSpec, GraphQLFieldSpecSort, GraphQLQuerySpec } from "./graphql/plan";
+export { buildGraphQLQuery } from "./graphql/build";
+export type { BuiltGraphQLQuery } from "./graphql/build";
+export { selectToGraphQL } from "./graphql/rest";
+export type { RestReadOptions, RestRequest } from "./graphql/rest";
+export { graphqlToSelect, selectToSelection } from "./graphql/selection";
+export { toTree } from "./graphql/tree";
+export type { TreeData, TreeEntry, TreeRoot, TreeSelection } from "./graphql/tree";
+export type { CapaTreeLayout, TreeLayoutField, TreeLayoutModel } from "./graphql/tree-layout";
+export { selectionToDocument } from "./graphql/typed";
+export type { ArgsInput, CapaField, Exact, ExactSelection, NodeOf, QueryResult, QuerySelection, RuntimeSelection, Selection, SelectionError, SelectionResult, TreeLayout, treeLayout, UntypedQuery, } from "./graphql/typed";
+export type { FlatResponse, Inflated } from "./inflate";
+export type { EntryFields, EntryMedia, EntryReference, FlatFields, IncludedFields, MissingEntry, RelationItems, } from "./entry-fields";
+export type { CapaAttrs, FieldAttrs, TaggableField } from "./attrs";
+export type { BuilderCallOptions, CallOptions, CapaNextClient, CapaNextConfig, EntriesResource, Entry, GraphQLClient, Filter, FilterOperator, FlatGetOptions, FlatListOptions, FlatPage, FlatSingle, Included, FilterScalar, FilterValue, GetOptions, ListOptions, Page, PageDetail, PageInfo, PageSummary, PagesListOptions, PagesResource, PreviewClaim, ResponseMeta, ResponseShape, Single, } from "./client";
+export type { ExpandedTargets, CapaRelation, CapaRelationList, RelationSelectOptions, Select, SelectItem, SelectSort, SortableSystemKey, SystemKey, } from "./select-types";

package/dist/next/index.js

@@ -1,9 +1,42 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.serializeSelect = exports.resolveNextConfig = exports.isCapaError = exports.createClient = exports.CapaError = void 0;
+exports.selectionToDocument = exports.toTree = exports.selectToSelection = exports.graphqlToSelect = exports.selectToGraphQL = exports.buildGraphQLQuery = exports.CapaBuildError = exports.summarizeIntrospection = exports.gql = exports.PERSISTED_QUERY_NOT_FOUND = exports.INTROSPECTION_QUERY = exports.isCapaGraphQLError = exports.inflate = exports.markGraphQLEntries = exports.markEditEntries = exports.isEditEntry = exports.fieldAttrs = exports.capaAttrs = exports.CAPA_EDIT = exports.serializeSelect = exports.resolveNextConfig = exports.LAYOUT_PAGE = exports.isCapaError = exports.createClient = exports.CapaError = void 0;
 var client_1 = require("./client");
 Object.defineProperty(exports, "CapaError", { enumerable: true, get: function () { return client_1.CapaError; } });
 Object.defineProperty(exports, "createClient", { enumerable: true, get: function () { return client_1.createClient; } });
 Object.defineProperty(exports, "isCapaError", { enumerable: true, get: function () { return client_1.isCapaError; } });
+Object.defineProperty(exports, "LAYOUT_PAGE", { enumerable: true, get: function () { return client_1.LAYOUT_PAGE; } });
 Object.defineProperty(exports, "resolveNextConfig", { enumerable: true, get: function () { return client_1.resolveNextConfig; } });
 Object.defineProperty(exports, "serializeSelect", { enumerable: true, get: function () { return client_1.serializeSelect; } });
+var attrs_1 = require("./attrs");
+Object.defineProperty(exports, "CAPA_EDIT", { enumerable: true, get: function () { return attrs_1.CAPA_EDIT; } });
+Object.defineProperty(exports, "capaAttrs", { enumerable: true, get: function () { return attrs_1.capaAttrs; } });
+Object.defineProperty(exports, "fieldAttrs", { enumerable: true, get: function () { return attrs_1.fieldAttrs; } });
+Object.defineProperty(exports, "isEditEntry", { enumerable: true, get: function () { return attrs_1.isEditEntry; } });
+Object.defineProperty(exports, "markEditEntries", { enumerable: true, get: function () { return attrs_1.markEditEntries; } });
+Object.defineProperty(exports, "markGraphQLEntries", { enumerable: true, get: function () { return attrs_1.markGraphQLEntries; } });
+var inflate_1 = require("./inflate");
+Object.defineProperty(exports, "inflate", { enumerable: true, get: function () { return inflate_1.inflate; } });
+var errors_1 = require("./errors");
+Object.defineProperty(exports, "isCapaGraphQLError", { enumerable: true, get: function () { return errors_1.isCapaGraphQLError; } });
+var introspection_1 = require("./graphql/introspection");
+Object.defineProperty(exports, "INTROSPECTION_QUERY", { enumerable: true, get: function () { return introspection_1.INTROSPECTION_QUERY; } });
+var request_1 = require("./graphql/request");
+Object.defineProperty(exports, "PERSISTED_QUERY_NOT_FOUND", { enumerable: true, get: function () { return request_1.PERSISTED_QUERY_NOT_FOUND; } });
+var documents_1 = require("./graphql/documents");
+Object.defineProperty(exports, "gql", { enumerable: true, get: function () { return documents_1.gql; } });
+var summary_1 = require("./graphql/summary");
+Object.defineProperty(exports, "summarizeIntrospection", { enumerable: true, get: function () { return summary_1.summarizeIntrospection; } });
+var plan_1 = require("./graphql/plan");
+Object.defineProperty(exports, "CapaBuildError", { enumerable: true, get: function () { return plan_1.CapaBuildError; } });
+var build_1 = require("./graphql/build");
+Object.defineProperty(exports, "buildGraphQLQuery", { enumerable: true, get: function () { return build_1.buildGraphQLQuery; } });
+var rest_1 = require("./graphql/rest");
+Object.defineProperty(exports, "selectToGraphQL", { enumerable: true, get: function () { return rest_1.selectToGraphQL; } });
+var selection_1 = require("./graphql/selection");
+Object.defineProperty(exports, "graphqlToSelect", { enumerable: true, get: function () { return selection_1.graphqlToSelect; } });
+Object.defineProperty(exports, "selectToSelection", { enumerable: true, get: function () { return selection_1.selectToSelection; } });
+var tree_1 = require("./graphql/tree");
+Object.defineProperty(exports, "toTree", { enumerable: true, get: function () { return tree_1.toTree; } });
+var typed_1 = require("./graphql/typed");
+Object.defineProperty(exports, "selectionToDocument", { enumerable: true, get: function () { return typed_1.selectionToDocument; } });

package/dist/next/inflate.d.ts

@@ -0,0 +1,51 @@
+import type { Entry } from "./client";
+import type { EntryFields, FlatRead, flatRead } from "./entry-fields";
+/** The flat body, or an SDK result wrapping one. */
+export interface FlatResponse {
+    data: unknown;
+    included: Record<string, Record<string, unknown>>;
+    /** The select the request sent, when the SDK made it. */
+    select?: string;
+}
+/**
+ * One level of a select: `*` or not, and the names it wrote, in order, each
+ * read back from its quotes. A quoted name is always a field (`"tags"`),
+ * never a system key, and is marked `quoted`.
+ */
+interface Level {
+    star: boolean;
+    items: Array<{
+        name: string;
+        expand: Level | null;
+        quoted?: true;
+    }>;
+}
+/**
+ * The select grammar, read only as far as `inflate` needs it: names, bare or
+ * quoted (`"price.usd"`, spec 17 amendment 121), nesting and `*`. Modifiers
+ * (`limit:`, `sort:`, `after:`) decide which rows the API returned, which the
+ * response already reflects, so they are skipped. The API validated the
+ * select before answering, so this parser trusts its shape and throws a
+ * `TypeError` only on text it cannot split at all.
+ */
+export declare function parseSelectLevels(select: string): Level;
+/**
+ * What `inflate` returns for `R`: `R` without `included` and `select`. For a
+ * flat read of this SDK, `data` is typed as the tree read of the same model
+ * and select returns it (`EntryFields`).
+ */
+export type Inflated<R> = typeof flatRead extends keyof R ? R extends FlatRead<infer T, infer S> ? Omit<R, "included" | "select" | "data" | typeof flatRead> & {
+    data: R extends {
+        data: ReadonlyArray<unknown>;
+    } ? Array<Entry<EntryFields<T, S>>> : Entry<EntryFields<T, S>>;
+} : Omit<R, "included" | "select"> : Omit<R, "included" | "select">;
+/**
+ * The tree shape of a flat response: `data` with every expansion nested back
+ * in, `included` and `select` removed, everything else (`page`, `meta`,
+ * `cacheTags`) carried over as it was.
+ *
+ * `select` is what the request sent; it defaults to `response.select`, which
+ * an SDK flat read fills in. A request with no select expanded nothing.
+ */
+export declare function inflate<R extends FlatResponse>(response: R, select?: string): Inflated<R>;
+export {};