@luvio/graphql-parser 0.126.0 → 0.126.2

package/dist/argument-node.d.ts

@@ -0,0 +1,4 @@
+import type { ArgumentNode } from 'graphql/language';
+import type { LuvioArgumentNode } from './ast';
+import type { TransformState } from './operation/query';
+export declare function transform(node: ArgumentNode, transformState: TransformState): LuvioArgumentNode;

package/dist/ast.d.ts

@@ -0,0 +1,95 @@
+import type { DocumentNode, OperationDefinitionNode, FieldNode, ArgumentNode, IntValueNode, ListValueNode, ObjectValueNode, FloatValueNode, StringValueNode, BooleanValueNode, NullValueNode, EnumValueNode, VariableNode, DirectiveNode, VariableDefinitionNode, NonNullTypeNode, ListTypeNode, NamedTypeNode, FragmentSpreadNode, InlineFragmentNode, FragmentDefinitionNode, DefinitionNode, TypeNode } from 'graphql/language';
+/**
+ * Luvio specific custom GraphQL AST
+ *
+ * - Omit Location
+ * - flatten NameNode for easier value access
+ * - Add luvioSelections for custom selections
+ * - LuvioSelectionCustomFieldNode for fields with custom client side directives
+ */
+export interface LuvioDocumentNode extends Omit<DocumentNode, 'loc' | 'definitions'> {
+    definitions: LuvioDefinitionNode[];
+}
+export declare type LuvioDefinitionNode = LuvioOperationDefinitionNode | LuvioFragmentDefinitionNode;
+export interface LuvioOperationDefinitionNode extends Omit<OperationDefinitionNode, 'loc' | 'name' | 'variableDefinitions' | 'directives' | 'selectionSet'> {
+    name?: string;
+    variableDefinitions?: LuvioVariableDefinitionNode[];
+    directives?: LuvioDirectiveNode[];
+    luvioSelections: LuvioSelectionNode[];
+}
+export interface LuvioVariableDefinitionNode extends Omit<VariableDefinitionNode, 'loc' | 'variable' | 'type' | 'defaultValue' | 'directives'> {
+    variable: LuvioVariableNode;
+    type: LuvioTypeNode;
+    defaultValue?: LuvioValueNode;
+    directives?: LuvioDirectiveNode[];
+}
+export interface LuvioVariableNode extends Omit<VariableNode, 'loc' | 'name'> {
+    name: string;
+}
+export declare type LuvioSelectionNode = LuvioFieldNode | LuvioFragmentSpreadNode | LuvioInlineFragmentNode;
+export declare type LuvioFieldNode = LuvioSelectionScalarFieldNode | LuvioSelectionObjectFieldNode | LuvioSelectionCustomFieldNode;
+export interface LuvioArgumentNode extends Omit<ArgumentNode, 'loc' | 'name' | 'value'> {
+    name: string;
+    value: LuvioValueNode;
+}
+export interface LuvioFragmentSpreadNode extends Omit<FragmentSpreadNode, 'loc' | 'name' | 'directives'> {
+    name: string;
+    directives?: LuvioDirectiveNode[];
+}
+export interface LuvioInlineFragmentNode extends Omit<InlineFragmentNode, 'loc' | 'typeCondition' | 'directives' | 'selectionSet'> {
+    typeCondition?: LuvioNamedTypeNode;
+    directives?: LuvioDirectiveNode[];
+    luvioSelections: LuvioSelectionNode[];
+}
+export interface LuvioFragmentDefinitionNode extends Omit<FragmentDefinitionNode, 'loc' | 'name' | 'variableDefinitions' | 'typeCondition' | 'directives' | 'selectionSet'> {
+    name: string;
+    variableDefinitions?: LuvioVariableDefinitionNode[];
+    typeCondition: LuvioNamedTypeNode;
+    directives?: LuvioDirectiveNode[];
+    luvioSelections: LuvioSelectionNode[];
+}
+export declare type LuvioValueNode = LuvioVariableNode | IntValueNode | FloatValueNode | StringValueNode | BooleanValueNode | NullValueNode | EnumValueNode | LuvioListValueNode | LuvioObjectValueNode;
+export interface LuvioListValueNode extends Omit<ListValueNode, 'loc' | 'values'> {
+    values: LuvioValueNode[];
+}
+export interface LuvioObjectValueNode extends Omit<ObjectValueNode, 'loc' | 'fields'> {
+    fields: {
+        [name: string]: LuvioValueNode;
+    };
+}
+export interface LuvioDirectiveNode extends Omit<DirectiveNode, 'loc' | 'name' | 'arguments'> {
+    name: string;
+    arguments?: LuvioArgumentNode[];
+}
+export declare type LuvioTypeNode = LuvioNamedTypeNode | LuvioListTypeNode | LuvioNonNullTypeNode;
+export interface LuvioNamedTypeNode extends Omit<NamedTypeNode, 'loc' | 'name'> {
+    name: string;
+}
+export interface LuvioListTypeNode extends Omit<ListTypeNode, 'loc' | 'type'> {
+    type: LuvioTypeNode;
+}
+export interface LuvioNonNullTypeNode extends Omit<NonNullTypeNode, 'loc' | 'type'> {
+    type: LuvioNamedTypeNode | LuvioListTypeNode;
+}
+export interface LuvioSelectionScalarFieldNode extends Omit<FieldNode, 'kind' | 'loc' | 'alias' | 'name' | 'arguments' | 'directives' | 'selectionSet'> {
+    kind: 'ScalarFieldSelection';
+    alias?: string;
+    name: string;
+}
+export interface LuvioSelectionObjectFieldNode extends Omit<FieldNode, 'kind' | 'loc' | 'alias' | 'name' | 'arguments' | 'directives' | 'selectionSet'> {
+    kind: 'ObjectFieldSelection';
+    alias?: string;
+    name: string;
+    arguments?: LuvioArgumentNode[];
+    directives?: LuvioDirectiveNode[];
+    luvioSelections?: LuvioSelectionNode[];
+}
+export interface LuvioSelectionCustomFieldNode extends Omit<LuvioSelectionObjectFieldNode, 'kind'> {
+    kind: 'CustomFieldSelection';
+    type: string;
+}
+export declare function isOperationDefinitionNode(input: DefinitionNode): input is OperationDefinitionNode;
+export declare function isFragmentDefinitionNode(input: DefinitionNode): input is FragmentDefinitionNode;
+export declare function isNamedTypeNode(input: TypeNode): input is NamedTypeNode;
+export declare function isListTypeNode(input: TypeNode): input is ListTypeNode;
+export declare function isNonNullTypeNode(input: TypeNode): input is NonNullTypeNode;

package/dist/constants.d.ts

@@ -0,0 +1,12 @@
+export declare const CUSTOM_DIRECTIVE_CONNECTION = "connection";
+export declare const CUSTOM_DIRECTIVE_RESOURCE = "resource";
+export declare const NODE_KIND_CUSTOM_FIELD_SELECTION = "CustomFieldSelection";
+export declare const NODE_KIND_FIELD = "Field";
+export declare const NODE_KIND_FRAGMENT_SPREAD = "FragmentSpread";
+export declare const NODE_KIND_INLINE_FRAGMENT = "InlineFragment";
+export declare const NODE_KIND_LIST_TYPE = "ListType";
+export declare const NODE_KIND_NAMED_TYPE = "NamedType";
+export declare const NODE_KIND_NON_NULL_TYPE = "NonNullType";
+export declare const NODE_KIND_OBJECT_FIELD_SELECTION = "ObjectFieldSelection";
+export declare const NODE_KIND_SCALAR_FIELD_SELECTION = "ScalarFieldSelection";
+export declare const NODE_TYPE_CONNECTION = "Connection";

package/dist/directive-node.d.ts

@@ -0,0 +1,5 @@
+import type { DirectiveNode } from 'graphql/language';
+import type { LuvioDirectiveNode } from './ast';
+import type { TransformState } from './operation/query';
+export declare function transform(node: DirectiveNode, transformState: TransformState): LuvioDirectiveNode;
+export declare function isCustomDirective(node: DirectiveNode): boolean;

package/dist/document.d.ts

@@ -0,0 +1,3 @@
+import type { DocumentNode } from 'graphql/language';
+import type { LuvioDocumentNode } from './ast';
+export declare function transform(root: DocumentNode): LuvioDocumentNode;

package/dist/field-node.d.ts

@@ -0,0 +1,4 @@
+import type { FieldNode } from 'graphql/language';
+import type { LuvioFieldNode } from './ast';
+import type { TransformState } from './operation/query';
+export declare function transform(node: FieldNode, transformState: TransformState): LuvioFieldNode;

package/dist/fragment-spread-node.d.ts

@@ -0,0 +1,4 @@
+import type { FragmentSpreadNode } from 'graphql/language';
+import type { LuvioFragmentSpreadNode } from './ast';
+import type { TransformState } from './operation/query';
+export declare function transform(node: FragmentSpreadNode, transformState: TransformState): LuvioFragmentSpreadNode;

package/dist/fragment.d.ts

@@ -0,0 +1,3 @@
+import type { FragmentDefinitionNode } from 'graphql/language';
+import type { LuvioFragmentDefinitionNode } from './ast';
+export declare function transform(node: FragmentDefinitionNode): LuvioFragmentDefinitionNode;

package/dist/gql.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Exposes a tagged template literal to parse graphql operation string
+ * "gql" is the only publicly exposed method
+ * @module gql
+ */
+import type { DefinitionNode, DocumentNode } from 'graphql/language';
+export declare type AstResolver = (astReference: any) => DocumentNode | undefined;
+/**
+ * we should look into optimizing this before it turns into a memory hog
+ * weakmaps, or limiting the size of the cache, or something
+ */
+export declare const docMap: Map<string, DocumentNode>;
+/**
+ * Opaque reference map to return keys to userland
+ * As a user shouldn't have access to the Document
+ */
+export declare const referenceMap: WeakMap<Object, DocumentNode>;
+/**
+ * Returns document node if cached or else update the cache and return the document node
+ * @param inputString - operation string
+ * @returns DocumentNode
+ */
+export declare function parseDocument(inputString: string): DocumentNode | null;
+export declare function updateReferenceMapWithKnownKey(doc: DocumentNode, key: object): void;
+export declare function updateReferenceMapAndGetKey(doc: DocumentNode): object;
+/**
+ * Insert string and fragment substitutions with the actual nodes
+ * @param inputString
+ * @param substitutions - string | fragment DocumentNode
+ * @returns { operation string, fragment docs [] }
+ */
+export declare function processSubstitutions(inputString: ReadonlyArray<string>, substitutions: (string | object)[]): {
+    operationString: string;
+    fragments: DefinitionNode[];
+} | null;
+/**
+ * strips Document node and nested definitions of location references
+ */
+export declare function stripLocation(node: any): any;
+/**
+ *
+ * @param astReference - ast reference passed from user land
+ */
+export declare const astResolver: AstResolver;
+/**
+ *
+ * @param literals - operation query string
+ * @param subs - all other substitutions
+ * @returns an opaque reference to the parsed document
+ */
+export declare function gql(literals: ReadonlyArray<string> | string, ...subs: (string | object)[]): object | null;

package/dist/inline-fragment-node.d.ts

@@ -0,0 +1,4 @@
+import type { InlineFragmentNode } from 'graphql/language';
+import type { LuvioInlineFragmentNode } from './ast';
+import type { TransformState } from './operation/query';
+export declare function transform(node: InlineFragmentNode, transformState: TransformState): LuvioInlineFragmentNode;