@conduit-client/onestore-graphql-parser 3.8.0 → 3.9.0

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

@@ -1,17 +1,27 @@
 import { DocumentNode } from 'graphql/language';
+import { type Result } from '@conduit-client/utils';
+import type { GraphQLResponse } from './types';
 /**
- * Validates a GraphQL config and rejects operations not in the accepted list
- * @param config The GraphQL config containing query and operationName
- * @param options Options containing acceptedOperations array
- * @throws Error if the executable operation is not in acceptedOperations
+ * Resolves and validates a GraphQL query AST, handling parsing errors centrally.
+ * This function should be used in all GraphQL bindings to ensure consistent error handling.
+ *
+ * @param query The AST reference to resolve
+ * @param operationName Optional operation name for validation
+ * @param acceptedOperations Array of accepted operation types (default: ['query'])
+ * @returns Object with either:
+ *   - `error`: GraphQLResponse with errors if parsing/validation failed
+ *   - `document`: DocumentNode if successful
  */
-export declare function validateGraphQLOperations(config: {
-    query: DocumentNode;
-    operationName?: string;
-}, options: {
-    acceptedOperations: ('query' | 'mutation' | 'subscription')[];
-}): void;
-export declare function resolveAst(ast: any): DocumentNode | undefined;
-export declare function wrapConfigAndVerify(config: any, options?: {
+export type ResolveAndValidateOptions = {
     acceptedOperations?: ('query' | 'mutation' | 'subscription')[];
-}): any;
+};
+export type UnverifiedGraphQLConfig = {
+    query?: unknown;
+    operationName?: string;
+    variables?: Record<string, unknown>;
+};
+export type ValidGraphQLConfig<TConfig extends UnverifiedGraphQLConfig = UnverifiedGraphQLConfig> = Omit<TConfig, 'query'> & {
+    query: DocumentNode;
+};
+export type ResolveAndValidateConfigResult<TConfig extends UnverifiedGraphQLConfig> = Result<ValidGraphQLConfig<TConfig>, GraphQLResponse> | undefined;
+export declare function resolveAndValidateGraphQLConfig<TConfig extends UnverifiedGraphQLConfig>(config: TConfig, options?: ResolveAndValidateOptions): ResolveAndValidateConfigResult<TConfig>;

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

@@ -4,25 +4,33 @@
  * @module gql
  */
 import type { DefinitionNode, DocumentNode } from 'graphql/language';
-export type AstResolver = (astReference: any) => DocumentNode | undefined;
+import type { GraphQLResponse } from './types';
+export type AstResolution = {
+    type: 'document';
+    document: DocumentNode;
+} | {
+    type: 'error';
+    error: GraphQLResponse;
+};
+export type AstResolver = (astReference: unknown) => AstResolution | 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>;
+export declare const docMap: Map<string, AstResolution>;
 /**
  * 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>;
+export declare const referenceMap: WeakMap<Object, AstResolution>;
 /**
  * Returns document node if cached or else update the cache and return the document node
  * @param inputString - operation string
- * @returns DocumentNode
+ * @returns DocumentNode or GraphQLResponse with errors if parsing fails
  */
-export declare function parseDocument(inputString: string): DocumentNode | null;
-export declare function updateReferenceMapWithKnownKey(doc: DocumentNode, key: object): void;
-export declare function updateReferenceMapAndGetKey(doc: DocumentNode): object;
+export declare function parseDocument(inputString: string): AstResolution | null;
+export declare function updateReferenceMapWithKnownKey(doc: AstResolution, key: object): void;
+export declare function updateReferenceMapAndGetKey(doc: AstResolution): object;
 /**
  * Insert string and fragment substitutions with the actual nodes
  * @param inputString

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

@@ -2,6 +2,8 @@ export type { GraphQLObjectType, GraphQLInterfaceType, GraphQLDirective, GraphQL
 export type { ASTNode, ObjectValueNode, ListTypeNode, BooleanValueNode, EnumTypeDefinitionNode, FieldDefinitionNode, FloatValueNode, InterfaceTypeDefinitionNode, IntValueNode, NamedTypeNode, ObjectTypeDefinitionNode, StringValueNode, TypeNode, UnionTypeDefinitionNode, DocumentNode, OperationDefinitionNode, FieldNode, ArgumentNode, ValueNode, SelectionNode, SelectionSetNode, FragmentDefinitionNode, DirectiveNode, ObjectFieldNode, ScalarTypeDefinitionNode, InputObjectTypeDefinitionNode, InlineFragmentNode, FragmentSpreadNode, VariableDefinitionNode, ListValueNode, VariableNode, NullValueNode, } from 'graphql/language';
 export { Kind } from 'graphql/language';
 export { gql, astResolver } from './gql';
-export type { AstResolver } from './gql';
+export type { AstResolver, AstResolution } from './gql';
 export { parse, print, visit } from 'graphql/language';
-export { validateGraphQLOperations, resolveAst, wrapConfigAndVerify } from './bindings-utils';
+export type { ResolveAndValidateOptions, UnverifiedGraphQLConfig, ValidGraphQLConfig, } from './bindings-utils';
+export { resolveAndValidateGraphQLConfig } from './bindings-utils';
+export type { GraphQLResponse, GraphQLData } from './types';

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

@@ -0,0 +1,15 @@
+export interface GraphQLErrorShape {
+    message: string;
+    locations?: ReadonlyArray<{
+        line: number;
+        column: number;
+    }>;
+    path?: ReadonlyArray<string | number>;
+    extensions?: Record<string, any>;
+}
+export interface GraphQLResponse<TData = Record<string, any>> {
+    data?: TData | null;
+    errors?: ReadonlyArray<GraphQLErrorShape>;
+    extensions?: Record<string, any>;
+}
+export type GraphQLData = Record<string, any>;

package/dist/v1/index.js

@@ -3066,20 +3066,37 @@ function operationKeyBuilder(inputString) {
   return stripIgnoredCharacters(inputString);
 }
 function parseDocument(inputString) {
+  var _a;
   const operationKey = operationKeyBuilder(inputString);
   const cachedDoc = docMap.get(operationKey);
   if (cachedDoc !== void 0) {
     return cachedDoc;
   }
-  const parsedDoc = parse(inputString, { noLocation: true });
-  if (!parsedDoc || parsedDoc.kind !== "Document") {
-    if (process.env.NODE_ENV !== "production") {
-      throw new Error("Invalid graphql doc");
+  try {
+    const parsedDoc = parse(inputString, { noLocation: true });
+    const resolvedDoc = { type: "document", document: parsedDoc };
+    docMap.set(operationKey, resolvedDoc);
+    return resolvedDoc;
+  } catch (e) {
+    if (e instanceof GraphQLError) {
+      const errorDoc = {
+        errors: [
+          {
+            message: e.message || "Failed to parse GraphQL document",
+            locations: (_a = e.locations) == null ? void 0 : _a.map((loc) => ({
+              line: loc.line,
+              column: loc.column
+            })),
+            extensions: e.extensions
+          }
+        ]
+      };
+      const resolvedError = { type: "error", error: errorDoc };
+      docMap.set(operationKey, resolvedError);
+      return resolvedError;
     }
-    return null;
+    throw e;
   }
-  docMap.set(operationKey, parsedDoc);
-  return parsedDoc;
 }
 function insertFragments(doc, fragments) {
   fragments.forEach((fragment) => {
@@ -3105,15 +3122,17 @@ function processSubstitutions(inputString, substitutions) {
     if (typeof substitution === "string" || typeof substitution === "number") {
       outputString += substitution;
     } else if (typeof substitution === "object") {
-      const doc = referenceMap.get(substitution);
-      if (doc === void 0) {
+      const resolved = referenceMap.get(substitution);
+      if (resolved === void 0) {
         if (process.env.NODE_ENV !== "production") {
           throw new Error("Invalid substitution fragment");
         }
         return null;
       }
-      for (const def of doc.definitions) {
-        fragments.push(def);
+      if (resolved.type === "document") {
+        for (const def of resolved.document.definitions) {
+          fragments.push(def);
+        }
       }
     } else {
       if (process.env.NODE_ENV !== "production") {
@@ -3128,6 +3147,9 @@ function processSubstitutions(inputString, substitutions) {
   };
 }
 const astResolver = function(astReference) {
+  if (typeof astReference !== "object" || astReference === null) {
+    return void 0;
+  }
   return referenceMap.get(astReference);
 };
 function gql(literals, ...subs) {
@@ -3160,11 +3182,47 @@ function gql(literals, ...subs) {
   if (document === null) {
     return null;
   }
-  if (inputSubstitutionFragments.length === 0) {
+  if (document.type === "error") {
     return updateReferenceMapAndGetKey(document);
   }
-  return updateReferenceMapAndGetKey(insertFragments(document, inputSubstitutionFragments));
+  const docNode = document.document;
+  if (inputSubstitutionFragments.length === 0) {
+    return updateReferenceMapAndGetKey({ type: "document", document: docNode });
+  }
+  return updateReferenceMapAndGetKey({
+    type: "document",
+    document: insertFragments(docNode, inputSubstitutionFragments)
+  });
+}
+/*!
+ * Copyright (c) 2022, Salesforce, Inc.,
+ * All rights reserved.
+ * For full license text, see the LICENSE.txt file
+ */
+class Ok {
+  constructor(value) {
+    this.value = value;
+  }
+  isOk() {
+    return true;
+  }
+  isErr() {
+    return !this.isOk();
+  }
+}
+class Err {
+  constructor(error) {
+    this.error = error;
+  }
+  isOk() {
+    return false;
+  }
+  isErr() {
+    return !this.isOk();
+  }
 }
+const ok = (value) => new Ok(value);
+const err = (err2) => new Err(err2);
 function findExecutableOperation(document, operationName) {
   const operations = document.definitions.filter(
     (def) => def.kind === Kind.OPERATION_DEFINITION
@@ -3197,25 +3255,40 @@ function validateGraphQLOperations(config, options) {
 }
 function resolveAst(ast) {
   if (ast === null || ast === void 0) {
-    return;
+    return void 0;
   }
-  const result = astResolver(ast);
-  if (result === void 0) {
-    throw new Error("Could not resolve AST. Did you parse the query with gql?");
+  return astResolver(ast);
+}
+function resolveAndValidateGraphQLConfig(config, options) {
+  const query = config.query;
+  if (query === null || query === void 0) {
+    return void 0;
   }
-  return result;
+  const result = resolveAndValidateGraphQLDocument(query, config.operationName, options);
+  if (result.isErr()) {
+    return err(result.error);
+  }
+  return ok({
+    ...config,
+    query: result.value
+  });
 }
-function wrapConfigAndVerify(config, options) {
-  if (config == null ? void 0 : config.query) {
-    config = { ...config, query: resolveAst(config.query) };
-    if (config.query === void 0) {
-      throw new Error("Internal error in GraphQL adapter occurred: Unable to resolve query");
-    }
-    validateGraphQLOperations(config, {
-      acceptedOperations: (options == null ? void 0 : options.acceptedOperations) ?? ["query"]
-    });
+function resolveAndValidateGraphQLDocument(query, operationName, options) {
+  const resolved = resolveAst(query);
+  if (resolved === void 0) {
+    throw new Error("Could not resolve AST. Did you parse the query with gql?");
+  }
+  if (resolved.type === "error") {
+    return err(resolved.error);
   }
-  return config;
+  const document = resolved.document;
+  validateGraphQLOperations(
+    { query: document, operationName },
+    {
+      acceptedOperations: (options == null ? void 0 : options.acceptedOperations) ?? ["query"]
+    }
+  );
+  return ok(document);
 }
 export {
   Kind,
@@ -3223,9 +3296,7 @@ export {
   gql,
   parse,
   print,
-  resolveAst,
-  validateGraphQLOperations,
-  visit,
-  wrapConfigAndVerify
+  resolveAndValidateGraphQLConfig,
+  visit
 };
 //# sourceMappingURL=index.js.map