@conduit-client/graphql-normalization 5.67.0-dev1

package/dist/types/v1/__tests__/utils.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/v1/__tests__/value-extraction.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/v1/base-object-repository.d.ts

@@ -0,0 +1,29 @@
+import { DenormalizeDataInput, ReadErrors, WriteErrors, NormalizeDataInput } from '@conduit-client/type-normalization/v1';
+import { AugmentSelectionsData, GraphQLData, GraphQLFragmentDefinitions, GraphQLInputExtension, GraphQLVariables } from './types';
+import { ReadonlyCache, Cache } from '@conduit-client/service-cache/v1';
+import { FieldNode, FragmentDefinitionNode, FragmentSpreadNode, InlineFragmentNode } from '@conduit-client/onestore-graphql-parser/v1';
+import { Result } from '@conduit-client/utils';
+import { FieldDef, FieldDefs } from './field-defs';
+export declare abstract class BaseGraphQLTypeRepository<Data extends GraphQLData = GraphQLData, NormalizedData extends GraphQLData = GraphQLData, ExtraInputExtension extends Record<string, any> = Record<string, unknown>> {
+    abstract readonly namespace: string;
+    abstract readonly typeName: string;
+    abstract readonly fields: FieldDefs<any, any, ExtraInputExtension>;
+    abstract readonly implementedInterfaces: string[];
+    equals(x: Data, y: Data): boolean;
+    augmentSelections(input: AugmentSelectionsData): AugmentSelectionsData;
+    augmentFieldSelection(selection: FieldNode, fragments: GraphQLFragmentDefinitions): AugmentSelectionsData;
+    augmentInlineFragmentSelection(fragment: InlineFragmentNode, fragments: GraphQLFragmentDefinitions): AugmentSelectionsData;
+    augmentFragmentSpreadSelection(selection: FragmentSpreadNode, fragments: GraphQLFragmentDefinitions): AugmentSelectionsData;
+    normalizeSelections(cache: Cache, input: NormalizeDataInput<Data, NormalizedData, GraphQLInputExtension & ExtraInputExtension>): Result<NormalizedData, WriteErrors>;
+    protected normalizeFieldSelection(cache: Cache, input: NormalizeDataInput<Data, NormalizedData, GraphQLInputExtension & ExtraInputExtension>, selection: FieldNode, errorCollector: WriteErrors): GraphQLData;
+    protected normalizeFragment(cache: Cache, input: NormalizeDataInput<Data, NormalizedData, GraphQLInputExtension & ExtraInputExtension>, fragment: InlineFragmentNode | FragmentDefinitionNode, errorCollector: WriteErrors): {};
+    denormalizeSelections(cache: ReadonlyCache, input: DenormalizeDataInput<NormalizedData, GraphQLInputExtension & ExtraInputExtension>): Result<Data, ReadErrors>;
+    protected getNormalizedFieldData(selection: FieldNode, input: NormalizeDataInput<Data, NormalizedData, GraphQLInputExtension & ExtraInputExtension> | DenormalizeDataInput<NormalizedData, GraphQLInputExtension & ExtraInputExtension>): Result<unknown, Error>;
+    protected denormalizeFieldSelection(cache: ReadonlyCache, input: DenormalizeDataInput<NormalizedData, GraphQLInputExtension & ExtraInputExtension>, selection: FieldNode, errorCollector: ReadErrors): GraphQLData;
+    protected denormalizeFragment(cache: ReadonlyCache, input: DenormalizeDataInput<NormalizedData, GraphQLInputExtension & ExtraInputExtension>, fragment: InlineFragmentNode | FragmentDefinitionNode, errorCollector: ReadErrors): {};
+    protected getFieldDef(input: NormalizeDataInput<Data, NormalizedData, GraphQLInputExtension & ExtraInputExtension> | DenormalizeDataInput<NormalizedData, GraphQLInputExtension & ExtraInputExtension> | undefined, selection: FieldNode): FieldDef<Data, NormalizedData> | undefined;
+    shouldProcessFragment(input: NormalizeDataInput<Data, NormalizedData, GraphQLInputExtension & ExtraInputExtension> | DenormalizeDataInput<NormalizedData, GraphQLInputExtension & ExtraInputExtension>, fragment: InlineFragmentNode | FragmentDefinitionNode): Result<boolean, Error>;
+    satisfiesFragmentTypeCondition(_input: NormalizeDataInput<Data, NormalizedData, GraphQLInputExtension & ExtraInputExtension> | DenormalizeDataInput<NormalizedData, GraphQLInputExtension & ExtraInputExtension> | undefined, fragment: InlineFragmentNode | FragmentDefinitionNode): Result<boolean, Error>;
+    protected getCacheKeyFieldArguments(selection: FieldNode): readonly import("@conduit-client/onestore-graphql-parser/v1").ArgumentNode[] | undefined;
+    buildFieldKey(selection: FieldNode, variables: GraphQLVariables): Result<string, Error>;
+}

package/dist/types/v1/cursor-connection-graphql-type-repository.d.ts

@@ -0,0 +1,51 @@
+import { Cache, ReadonlyCache } from '@conduit-client/service-cache/v1';
+import { DenormalizeDataInput, NormalizeDataInput, WriteResult, ReadResult } from '@conduit-client/type-normalization/v1';
+import { RelayPaginationStrategy, ResponsePaginationMetadata, ManagedPaginationMetadata } from '@conduit-client/pagination';
+import { GraphQLData, AugmentSelectionsData, GraphQLInputExtension } from './types';
+import { UnidentifiableGraphQLTypeRepository } from '.';
+import { ArgumentNode, FieldNode } from '@conduit-client/onestore-graphql-parser/v1';
+import { FieldDef, FieldDefs } from './field-defs';
+/**
+ * Extended response type that includes both core pagination metadata and additional connection fields
+ */
+export type PaginatedResponse = ResponsePaginationMetadata<GraphQLData> & GraphQLData;
+export type ConnectionNormalizedData = {
+    pagination: ManagedPaginationMetadata<unknown>;
+} & GraphQLData;
+/**
+ * Constrains the GraphQL type fields for cursor connections to ensure:
+ * - edges is always an array of objects with repositories
+ * - pageInfo is always an object with a repository
+ * - other fields can be any valid GraphQL type
+ */
+export interface CursorConnectionTypeFields<Data, NormalizedData> extends FieldDefs<Data, NormalizedData> {
+    edges: FieldDef<Data, NormalizedData>;
+    pageInfo: FieldDef<Data, NormalizedData>;
+    [key: string]: FieldDef<Data, NormalizedData>;
+}
+export declare abstract class CursorConnectionGraphQLTypeRepository<Data extends PaginatedResponse = PaginatedResponse, NormalizedData extends ConnectionNormalizedData = ConnectionNormalizedData, ExtraInputExtension extends Record<string, any> = Record<string, unknown>> extends UnidentifiableGraphQLTypeRepository<Data, NormalizedData, ExtraInputExtension> {
+    abstract readonly fields: CursorConnectionTypeFields<Data, NormalizedData>;
+    abstract readonly defaultPageSize: number;
+    abstract readonly implementedInterfaces: string[];
+    protected paginationStrategy: RelayPaginationStrategy<unknown>;
+    augmentSelections(input: AugmentSelectionsData): AugmentSelectionsData;
+    write(cache: Cache, input: NormalizeDataInput<Data, NormalizedData, GraphQLInputExtension & ExtraInputExtension>): WriteResult<NormalizedData>;
+    read(cache: ReadonlyCache, input: DenormalizeDataInput<NormalizedData, GraphQLInputExtension & ExtraInputExtension>): ReadResult<Data>;
+    protected getCacheKeyFieldArguments(selection: FieldNode): ArgumentNode[] | undefined;
+    /**
+     * Helper method to extract fields from an object, excluding specified keys
+     */
+    private extractFieldsExcluding;
+    /**
+     * Builds incoming pagination data from response data.
+     */
+    private buildIncomingPaginationData;
+    private buildCanonicalManagedPaginationData;
+    private buildCacheManagedPaginationData;
+    private buildCacheResponsePaginationData;
+    /**
+     * Merges additional fields (non-pagination) from new and existing data
+     */
+    private mergeNonPaginationFields;
+    private mergeDefaultPageSize;
+}

package/dist/types/v1/directives.d.ts

@@ -0,0 +1,5 @@
+import { FragmentDefinitionNode, InlineFragmentNode, FieldNode } from '@conduit-client/onestore-graphql-parser/v1';
+import { GraphQLVariables } from './types';
+import { Result } from '@conduit-client/utils';
+export type SkipableNode = FragmentDefinitionNode | InlineFragmentNode | FieldNode;
+export declare function shouldSkip(selection: SkipableNode, variables: GraphQLVariables): Result<boolean, Error>;

package/dist/types/v1/errors.d.ts

@@ -0,0 +1,7 @@
+import { GraphQLResponse } from './types';
+import { InternalError } from '@conduit-client/utils';
+export type GraphQLUserVisibleError = Error & {
+    type: 'user-visible';
+    data: GraphQLResponse;
+};
+export type GraphQLCommandError = InternalError | GraphQLUserVisibleError | Error;

package/dist/types/v1/field-defs.d.ts

@@ -0,0 +1,40 @@
+import type { AugmentSelectionsData, GraphQLFieldInputExtension, GraphQLVariables } from './types';
+import type { GraphQLTypeRepository } from './repository';
+import { FieldNode } from '@conduit-client/onestore-graphql-parser/v1';
+import { DenormalizeDataInput, NormalizeDataInput, ReadResult, WriteResult } from '@conduit-client/type-normalization/v1';
+import { Cache, ReadonlyCache } from '@conduit-client/service-cache/v1';
+import { Result } from '@conduit-client/utils';
+export type FieldDef<Data = unknown, NormalizedData = unknown, ExtraInputExtension extends Record<string, any> = Record<string, unknown>> = {
+    write(cache: Cache, input: NormalizeDataInput<Data, NormalizedData, ExtraInputExtension>): WriteResult<NormalizedData>;
+    read(cache: ReadonlyCache, input: DenormalizeDataInput<NormalizedData, ExtraInputExtension>): ReadResult<Data>;
+    buildFieldKey(selection: FieldNode, variables: GraphQLVariables): Result<string, Error>;
+    augmentSelections(input: AugmentSelectionsData): AugmentSelectionsData;
+};
+export type FieldDefs<Data = unknown, NormalizedData = unknown, ExtraInputExtension extends Record<string, any> = Record<string, unknown>> = Record<string, FieldDef<Data, NormalizedData, ExtraInputExtension>>;
+export declare class BaseScalarFieldDef<Data = unknown, NormalizedData = unknown, ExtraInputExtension extends Record<string, any> = Record<string, unknown>> implements FieldDef<Data, NormalizedData, ExtraInputExtension> {
+    readonly nullable: boolean;
+    constructor(nullable: boolean);
+    write(_cache: Cache, input: NormalizeDataInput<Data, NormalizedData, GraphQLFieldInputExtension & ExtraInputExtension>): WriteResult<NormalizedData>;
+    read(_cache: ReadonlyCache, input: DenormalizeDataInput<NormalizedData, GraphQLFieldInputExtension & ExtraInputExtension>): ReadResult<Data>;
+    augmentSelections(input: AugmentSelectionsData): AugmentSelectionsData;
+    buildFieldKey(selection: FieldNode, variables: GraphQLVariables): Result<string, Error>;
+}
+export declare class BaseArrayFieldDef<Data = unknown, NormalizedData = unknown, ExtraInputExtension extends Record<string, any> = Record<string, unknown>> implements FieldDef<Data, NormalizedData, ExtraInputExtension> {
+    readonly items: FieldDef<Data, NormalizedData, ExtraInputExtension>;
+    readonly nullable: boolean;
+    constructor(items: FieldDef<Data, NormalizedData, ExtraInputExtension>, nullable: boolean);
+    augmentSelections(input: AugmentSelectionsData): AugmentSelectionsData;
+    buildFieldKey(selection: FieldNode, variables: GraphQLVariables): Result<string, Error>;
+    write(cache: Cache, input: NormalizeDataInput<Data, NormalizedData, GraphQLFieldInputExtension & ExtraInputExtension>): WriteResult<NormalizedData>;
+    read(cache: ReadonlyCache, input: DenormalizeDataInput<NormalizedData, GraphQLFieldInputExtension & ExtraInputExtension>): ReadResult<Data>;
+}
+export declare class BaseObjectFieldDef<Data = unknown, NormalizedData = unknown, ExtraInputExtension extends Record<string, any> = Record<string, unknown>> implements FieldDef<Data, NormalizedData, ExtraInputExtension> {
+    readonly repository: GraphQLTypeRepository<Data, NormalizedData, ExtraInputExtension>;
+    readonly nullable: boolean;
+    constructor(repository: GraphQLTypeRepository<Data, NormalizedData, ExtraInputExtension>, nullable: boolean);
+    augmentSelections(input: AugmentSelectionsData): AugmentSelectionsData;
+    buildFieldKey(selection: FieldNode, variables: GraphQLVariables): Result<string, Error>;
+    write(cache: Cache, input: NormalizeDataInput<Data, NormalizedData, GraphQLFieldInputExtension & ExtraInputExtension>): WriteResult<NormalizedData>;
+    read(cache: ReadonlyCache, input: DenormalizeDataInput<NormalizedData, GraphQLFieldInputExtension & ExtraInputExtension>): ReadResult<Data>;
+}
+export declare const missingFieldDef: BaseScalarFieldDef<any, any, any>;

package/dist/types/v1/identifiable-object-repository.d.ts

@@ -0,0 +1,34 @@
+import { Cache, ReadonlyCache } from '@conduit-client/service-cache/v1';
+import { DenormalizeDataInput, IdentifiableTypeRepository, NormalizedLink, ReadResult, WriteInput, WriteResult } from '@conduit-client/type-normalization/v1';
+import { BaseGraphQLTypeRepository } from './base-object-repository';
+import { GraphQLData, GraphQLInputExtension, GraphQLRequestParams, AugmentSelectionsData, GraphQLVariables } from './types';
+import { Result } from '@conduit-client/utils';
+import { DocumentNode, FieldNode } from '@conduit-client/onestore-graphql-parser/v1';
+import { FieldDefs } from './field-defs';
+import { GraphQLTypeRepository } from './repository';
+export declare abstract class IdentifiableGraphQLTypeRepository<Data extends GraphQLData, NormalizedData extends GraphQLData, KeyParams extends Record<string, unknown> | null = Record<string, unknown>, ExtraInputExtension extends Record<string, any> = Record<string, unknown>> extends IdentifiableTypeRepository<Data, NormalizedData, KeyParams, GraphQLInputExtension & ExtraInputExtension, GraphQLInputExtension & ExtraInputExtension> implements GraphQLTypeRepository {
+    abstract readonly namespace: string;
+    abstract readonly typeName: string;
+    abstract readonly implementedInterfaces: string[];
+    abstract readonly fields: FieldDefs<any, any, ExtraInputExtension>;
+    readonly idField: string;
+    private _graphqlRepository;
+    protected get graphqlRepository(): BaseGraphQLTypeRepository<Data, NormalizedData, Record<string, unknown>>;
+    private LocalGraphQLRepository;
+    write(cache: Cache, input: WriteInput<Data, GraphQLInputExtension & ExtraInputExtension>): WriteResult<NormalizedLink>;
+    normalizeData(cache: Cache, input: WriteInput<Data, GraphQLInputExtension & ExtraInputExtension>): WriteResult<NormalizedData>;
+    denormalizeData(cache: ReadonlyCache, input: DenormalizeDataInput<NormalizedData, GraphQLInputExtension & ExtraInputExtension>): ReadResult<Data>;
+    augmentSelections(input: AugmentSelectionsData): AugmentSelectionsData;
+    buildFieldKey(selection: FieldNode, variables: GraphQLVariables): Result<string, Error>;
+    buildKeyParams(input: WriteInput<Data, GraphQLInputExtension & ExtraInputExtension>): KeyParams;
+}
+export declare abstract class GraphQLDocumentRootTypeRepository<Data extends GraphQLData, NormalizedData extends GraphQLData, ExtraInputExtension extends Record<string, any> = Record<string, unknown>> extends IdentifiableGraphQLTypeRepository<Data, NormalizedData, null, ExtraInputExtension> {
+    implementedInterfaces: never[];
+    private _rootGraphqlRepository;
+    protected get graphqlRepository(): BaseGraphQLTypeRepository<Data, NormalizedData, Record<string, unknown>>;
+    private LocalRootGraphQLRepository;
+    augmentSelections(input: AugmentSelectionsData): AugmentSelectionsData;
+    buildKeyParams(_input: WriteInput<Data, GraphQLInputExtension & ExtraInputExtension>): null;
+    denormalizeData(cache: ReadonlyCache, input: DenormalizeDataInput<NormalizedData, GraphQLInputExtension & ExtraInputExtension>): ReadResult<Data>;
+    buildAugmentedQuery(input: GraphQLRequestParams): Result<DocumentNode, Error>;
+}

package/dist/types/v1/index.d.ts

@@ -0,0 +1,11 @@
+export { IdentifiableGraphQLTypeRepository, GraphQLDocumentRootTypeRepository, } from './identifiable-object-repository';
+export { UnidentifiableGraphQLTypeRepository } from './unidentifiable-object-repository';
+export { BaseInterfaceRepository, BaseUnionRepository } from './union-interface-repositories';
+export { BaseGraphQLTypeRepository } from './base-object-repository';
+export * from './field-defs';
+export * from './types';
+export { BaseScalarFieldDef, BaseObjectFieldDef } from './field-defs';
+export { findExecutableOperation, buildGraphQLInputExtension, buildFieldKey, buildAugmentedFieldSelection, deepMerge, addTypenameToDocument, } from './utils';
+export { GraphQLQueryJsonSchema } from './json-schema';
+export * from './errors';
+export { shouldSkip } from './directives';

package/dist/types/v1/json-schema.d.ts

@@ -0,0 +1,2 @@
+import { JSONSchema } from '@conduit-client/jsonschema-validate';
+export declare const GraphQLQueryJsonSchema: JSONSchema;

package/dist/types/v1/repository.d.ts

@@ -0,0 +1,8 @@
+import { DenormalizeDataInput, NormalizeDataInput, TypeRepository } from '@conduit-client/type-normalization/v1';
+import { AugmentSelectionsData, GraphQLInputExtension, GraphQLVariables } from './types';
+import { FieldNode } from '@conduit-client/onestore-graphql-parser/v1';
+import { Result } from '@conduit-client/utils';
+export type GraphQLTypeRepository<Data = unknown, NormalizedData = unknown, ExtraInputExtension extends Record<string, any> = Record<string, unknown>> = TypeRepository<Data, DenormalizeDataInput<NormalizedData, GraphQLInputExtension & ExtraInputExtension>, NormalizedData, NormalizeDataInput<Data, NormalizedData, GraphQLInputExtension & ExtraInputExtension>> & {
+    augmentSelections(input: AugmentSelectionsData): AugmentSelectionsData;
+    buildFieldKey(selection: FieldNode, variables: GraphQLVariables): Result<string, Error>;
+};

package/dist/types/v1/type-registry.d.ts

@@ -0,0 +1,2 @@
+import { GraphQLTypeRepository } from './repository';
+export type GraphQLTypeRegistry = Record<string, GraphQLTypeRepository>;

package/dist/types/v1/types.d.ts

@@ -0,0 +1,52 @@
+import { DocumentNode, FieldNode, FragmentDefinitionNode, SelectionNode, VariableDefinitionNode } from '@conduit-client/onestore-graphql-parser/v1';
+import { QueryParams } from '@conduit-client/pagination';
+export interface GraphQLRequestParams {
+    query: DocumentNode;
+    variables?: Record<string, any>;
+    operationName?: string;
+}
+export type AugmentSelectionsData = {
+    selections: SelectionNode[];
+    fragments: GraphQLFragmentDefinitions;
+};
+export type GraphQLInputExtension = {
+    readonly selections: SelectionNode[];
+    request: {
+        definitions: {
+            variables: GraphQLVariables;
+            fragments: GraphQLFragmentDefinitions;
+        };
+    };
+    readonly parentFieldSelection: FieldNode | undefined;
+};
+export type GraphQLFieldInputExtension = {
+    readonly selection: FieldNode;
+    request: {
+        definitions: {
+            variables: GraphQLVariables;
+            fragments: GraphQLFragmentDefinitions;
+        };
+    };
+};
+export type GraphQLConnectionRepositoryInputExtension = {
+    connectionQueryParams: QueryParams;
+} & GraphQLInputExtension;
+export interface GraphQLResponse<T extends GraphQLData = GraphQLData> {
+    data?: T;
+    errors?: Array<{
+        message?: string;
+        locations?: Array<{
+            line: number;
+            column: number;
+        }>;
+        path?: Array<string | number>;
+        extensions?: Record<string, any>;
+    }>;
+    extensions?: Record<string, any>;
+}
+export type GraphQLData<T extends Record<string, any> = Record<string, any>> = T;
+export type GraphQLVariables = Record<string, {
+    definition: VariableDefinitionNode;
+    value: unknown;
+}>;
+export type GraphQLFragmentDefinitions = Record<string, FragmentDefinitionNode>;

package/dist/types/v1/unidentifiable-object-repository.d.ts

@@ -0,0 +1,11 @@
+import { Cache, ReadonlyCache } from '@conduit-client/service-cache/v1';
+import { DenormalizeDataInput, NormalizeDataInput, ReadResult, WriteResult } from '@conduit-client/type-normalization/v1';
+import { BaseGraphQLTypeRepository } from './base-object-repository';
+import { GraphQLData, GraphQLInputExtension } from './types';
+import { GraphQLTypeRepository } from './repository';
+export declare abstract class UnidentifiableGraphQLTypeRepository<Data extends GraphQLData, NormalizedData extends GraphQLData, ExtraInputExtension extends Record<string, any> = Record<string, unknown>> extends BaseGraphQLTypeRepository<Data, NormalizedData, ExtraInputExtension> implements GraphQLTypeRepository {
+    protected services: {};
+    constructor(services: {});
+    write(cache: Cache, input: NormalizeDataInput<Data, NormalizedData, GraphQLInputExtension & ExtraInputExtension>): WriteResult<NormalizedData>;
+    read(cache: ReadonlyCache, input: DenormalizeDataInput<NormalizedData, GraphQLInputExtension & ExtraInputExtension>): ReadResult<Data>;
+}

package/dist/types/v1/union-interface-repositories.d.ts

@@ -0,0 +1,38 @@
+import { AugmentSelectionsData, GraphQLInputExtension, GraphQLVariables } from './types';
+import { GraphQLTypeRepository } from './repository';
+import { FieldDefs } from './field-defs';
+import { FieldNode, SelectionNode } from '@conduit-client/onestore-graphql-parser/v1';
+import { Cache, ReadonlyCache } from '@conduit-client/service-cache/v1';
+import { DenormalizeDataInput, NormalizeDataInput, ReadErrors, ReadResult, WriteErrors, WriteResult } from '@conduit-client/type-normalization/v1';
+import { Result } from '@conduit-client/utils';
+export declare abstract class BaseInterfaceRepository<Data = unknown, NormalizedData = unknown, ExtraInputExtension extends Record<string, any> = Record<string, unknown>> implements GraphQLTypeRepository<Data, NormalizedData, ExtraInputExtension> {
+    protected services: {};
+    abstract namespace: string;
+    abstract typeName: string;
+    abstract get possibleTypes(): Record<string, GraphQLTypeRepository<any, any, ExtraInputExtension>>;
+    abstract fields: FieldDefs<Data, NormalizedData, ExtraInputExtension>;
+    constructor(services: {});
+    equals(x: unknown, y: unknown): boolean;
+    write(cache: Cache, input: NormalizeDataInput<Data, NormalizedData, GraphQLInputExtension & ExtraInputExtension>): WriteResult<NormalizedData>;
+    read(cache: ReadonlyCache, input: DenormalizeDataInput<NormalizedData, GraphQLInputExtension & ExtraInputExtension>): ReadResult<Data>;
+    augmentSelections(input: AugmentSelectionsData): AugmentSelectionsData;
+    protected getTypeDiscriminator(data: any, selections: SelectionNode[]): any;
+    protected verifyInterfaceFields(selections: readonly SelectionNode[]): (ReadErrors & WriteErrors) | void;
+    buildFieldKey(selection: FieldNode, variables: GraphQLVariables): Result<string, Error>;
+    protected getCacheKeyFieldArguments(selection: FieldNode): readonly import("@conduit-client/onestore-graphql-parser/v1").ArgumentNode[] | undefined;
+}
+export declare abstract class BaseUnionRepository<Data = unknown, NormalizedData = unknown, ExtraInputExtension extends Record<string, any> = Record<string, unknown>> implements GraphQLTypeRepository<Data, NormalizedData, ExtraInputExtension> {
+    protected services: {};
+    abstract namespace: string;
+    abstract typeName: string;
+    abstract get possibleTypes(): Record<string, GraphQLTypeRepository<any, any, ExtraInputExtension>>;
+    constructor(services: {});
+    equals(x: unknown, y: unknown): boolean;
+    write(cache: Cache, input: NormalizeDataInput<Data, NormalizedData, GraphQLInputExtension & ExtraInputExtension>): WriteResult<NormalizedData>;
+    read(cache: ReadonlyCache, input: DenormalizeDataInput<NormalizedData, GraphQLInputExtension & ExtraInputExtension>): ReadResult<Data>;
+    augmentSelections(input: AugmentSelectionsData): AugmentSelectionsData;
+    protected getTypeDiscriminator(data: any, selections: SelectionNode[]): any;
+    protected verifyUnionFields(selections: readonly SelectionNode[]): (ReadErrors & WriteErrors) | void;
+    buildFieldKey(selection: FieldNode, variables: GraphQLVariables): Result<string, Error>;
+    protected getCacheKeyFieldArguments(selection: FieldNode): readonly import("@conduit-client/onestore-graphql-parser/v1").ArgumentNode[] | undefined;
+}

package/dist/types/v1/utils.d.ts

@@ -0,0 +1,21 @@
+import { Result } from '@conduit-client/utils';
+import { GraphQLFragmentDefinitions, GraphQLRequestParams, GraphQLVariables, GraphQLInputExtension } from './types';
+import { ArgumentNode, FieldNode, FragmentDefinitionNode, OperationDefinitionNode, SelectionNode, ASTNode, DocumentNode, InlineFragmentNode, FragmentSpreadNode, DirectiveNode, ValueNode } from '@conduit-client/onestore-graphql-parser/v1';
+export declare function deepMerge(target: Record<string, unknown>, ...sources: Record<string, unknown>[]): Record<string, unknown>;
+export declare function findExecutableOperation(input: GraphQLRequestParams): Result<OperationDefinitionNode, Error>;
+export declare function buildGraphQLInputExtension(input: GraphQLRequestParams): Result<GraphQLInputExtension, Error>;
+export declare function buildAugmentedFieldSelection(newSelection: FieldNode, selections: SelectionNode[], fragments: GraphQLFragmentDefinitions): FieldNode | undefined;
+export declare function selectionExists(selection: FieldNode, selections: SelectionNode[]): boolean;
+export declare function selectionEquals(a: SelectionNode, b: SelectionNode): boolean;
+export declare function argumentValueEquals(a: ValueNode, b: ValueNode): boolean;
+export declare function directivesEqual(a: readonly DirectiveNode[] | undefined, b: readonly DirectiveNode[] | undefined): boolean;
+export declare function argumentsEqual(a: readonly ArgumentNode[] | undefined, b: readonly ArgumentNode[] | undefined): boolean;
+export declare function selectionSetsEqual(a: readonly SelectionNode[] | undefined, b: readonly SelectionNode[] | undefined): boolean;
+export declare function getUniqueSelectionName(fieldName: string, selections: SelectionNode[], fragments: GraphQLFragmentDefinitions): string;
+export declare function collectFieldNames(selections: SelectionNode[], fragments: GraphQLFragmentDefinitions): string[];
+export declare function buildFieldKey(canonicalFieldName: string, fieldArguments: readonly ArgumentNode[] | undefined, variables: GraphQLVariables): Result<string, Error>;
+export declare function addTypenameToDocument(doc: DocumentNode): DocumentNode;
+export declare function isField(node: ASTNode): node is FieldNode;
+export declare function isFragmentSpread(node: ASTNode): node is FragmentSpreadNode;
+export declare function isInlineFragment(node: ASTNode): node is InlineFragmentNode;
+export declare function isFragmentDefinition(node: ASTNode): node is FragmentDefinitionNode;

package/dist/types/v1/value-extraction.d.ts

@@ -0,0 +1,61 @@
+import { ArgumentNode, ValueNode } from '@conduit-client/onestore-graphql-parser/v1';
+import { GraphQLVariables } from './types';
+import { QueryParams } from '@conduit-client/pagination';
+import { Result } from '@conduit-client/utils';
+export type ExpectedType = {
+    type: 'string';
+    nullable?: false;
+} | {
+    type: 'string';
+    nullable: true;
+} | {
+    type: 'number';
+    nullable?: false;
+} | {
+    type: 'number';
+    nullable: true;
+} | {
+    type: 'boolean';
+    nullable?: false;
+} | {
+    type: 'boolean';
+    nullable: true;
+};
+export declare function extractValue(valueNode: ValueNode, variableDefinitions: GraphQLVariables, expectedType: {
+    type: 'string';
+    nullable?: false;
+}): Result<string, Error>;
+export declare function extractValue(valueNode: ValueNode, variableDefinitions: GraphQLVariables, expectedType: {
+    type: 'string';
+    nullable: true;
+}): Result<string | null, Error>;
+export declare function extractValue(valueNode: ValueNode, variableDefinitions: GraphQLVariables, expectedType: {
+    type: 'number';
+    nullable?: false;
+}): Result<number, Error>;
+export declare function extractValue(valueNode: ValueNode, variableDefinitions: GraphQLVariables, expectedType: {
+    type: 'number';
+    nullable: true;
+}): Result<number | null, Error>;
+export declare function extractValue(valueNode: ValueNode, variableDefinitions: GraphQLVariables, expectedType: {
+    type: 'boolean';
+    nullable?: false;
+}): Result<boolean, Error>;
+export declare function extractValue(valueNode: ValueNode, variableDefinitions: GraphQLVariables, expectedType: {
+    type: 'boolean';
+    nullable: true;
+}): Result<boolean | null, Error>;
+export declare function extractValue(valueNode: ValueNode, variableDefinitions: GraphQLVariables): Result<unknown, Error>;
+/**
+ * Helper function to extract and validate a pagination argument from GraphQL arguments
+ */
+export declare function findArgumentNode(argName: string, args: readonly ArgumentNode[] | undefined): ArgumentNode | undefined;
+/**
+ * Extracts and validates GraphQL connection pagination parameters into a standardized QueryParams object.
+ * Implements the Relay Cursor Pagination specification.
+ *
+ * @param args - The GraphQL arguments array from the query
+ * @param variables - The GraphQL variables object
+ * @returns QueryParams object with validated pagination parameters
+ */
+export declare function extractConnectionQueryParams(args: readonly ArgumentNode[] | undefined, variables: GraphQLVariables): Result<QueryParams, Error>;