@faststore/api 1.12.42 → 1.12.44

package/dist/api.cjs.development.js

@@ -11,9 +11,18 @@ var crypto = _interopDefault(require('crypto'));
 var graphql = require('graphql');
 var language = require('graphql/language');
 var utils = require('@graphql-tools/utils');
+var sdkTraceBase = require('@opentelemetry/sdk-trace-base');
+var resources = require('@opentelemetry/resources');
+var exporterTraceOtlpGrpc = require('@opentelemetry/exporter-trace-otlp-grpc');
+var sdkLogs = require('@opentelemetry/sdk-logs');
+var exporterLogsOtlpGrpc = require('@opentelemetry/exporter-logs-otlp-grpc');
+var core = require('@envelop/core');
+var onResolve = require('@envelop/on-resolve');
+var api = require('@opentelemetry/api');
+var apiLogs = require('@opentelemetry/api-logs');
 
 var name = "@faststore/api";
-var version = "1.12.41";
+var version = "1.12.43";
 var license = "MIT";
 var main = "dist/index.js";
 var typings = "dist/index.d.ts";
@@ -35,7 +44,12 @@ var scripts = {
 	generate: "graphql-codegen --config codegen.yml"
 };
 var dependencies = {
+	"@envelop/on-resolve": "^2.0.6",
 	"@graphql-tools/schema": "^8.2.0",
+	"@opentelemetry/exporter-logs-otlp-grpc": "^0.39.1",
+	"@opentelemetry/exporter-trace-otlp-grpc": "^0.39.1",
+	"@opentelemetry/sdk-logs": "^0.39.1",
+	"@opentelemetry/sdk-trace-base": "^1.13.0",
 	"@rollup/plugin-graphql": "^1.0.0",
 	dataloader: "^2.1.0",
 	"fast-deep-equal": "^3.1.3",
@@ -43,7 +57,8 @@ var dependencies = {
 	"p-limit": "^3.1.0"
 };
 var devDependencies = {
-	"@faststore/shared": "^1.12.37",
+	"@envelop/core": "^2.6.0",
+	"@faststore/shared": "^1.12.43",
 	"@graphql-codegen/cli": "2.2.0",
 	"@graphql-codegen/typescript": "2.2.2",
 	concurrently: "^6.2.1",
@@ -57,6 +72,7 @@ var devDependencies = {
 	typescript: "^4.4.2"
 };
 var peerDependencies = {
+	"@envelop/core": "^1 || ^2",
 	graphql: "^15.6.0"
 };
 var packageJson = {
@@ -2154,7 +2170,7 @@ const StoreSearchResult = {
   },
   products: async ({
     productSearchPromise
-  }) => {
+  }, _, ctx) => {
     const productSearchResult = await productSearchPromise;
     const skus = productSearchResult.products.map(product => {
       const [maybeSku] = product.items;
@@ -2168,7 +2184,14 @@ const StoreSearchResult = {
         endCursor: productSearchResult.recordsFiltered.toString(),
         totalCount: productSearchResult.recordsFiltered
       },
-      edges: skus.map((sku, index) => ({
+      edges: skus.filter(sku => {
+        if (ctx.hideUnavailableItems) {
+          return sku.sellers.some(item => inStock(item.commertialOffer));
+        } else {
+          return true;
+        }
+      }) // TODO: remove this filter when the IS returns correctly with hideUnavailableItems
+      .map((sku, index) => ({
         node: sku,
         cursor: index.toString()
       }))
@@ -2490,6 +2513,7 @@ const getContextFactory = options => ctx => {
   };
   ctx.clients = getClients(options, ctx);
   ctx.loaders = getLoaders(options, ctx);
+  ctx.hideUnavailableItems = options.hideUnavailableItems;
   return ctx;
 };
 const getResolvers = _ => Resolvers;
@@ -2640,6 +2664,268 @@ const directive = {
   })
 };
 
+var AttributeName;
+
+(function (AttributeName) {
+  AttributeName["EXECUTION_ERROR"] = "graphql.error";
+  AttributeName["EXECUTION_RESULT"] = "graphql.result";
+  AttributeName["RESOLVER_EXECUTION_ERROR"] = "graphql.resolver.error";
+  AttributeName["RESOLVER_EXCEPTION"] = "graphql.resolver.exception";
+  AttributeName["RESOLVER_FIELD_NAME"] = "graphql.resolver.fieldName";
+  AttributeName["RESOLVER_TYPE_NAME"] = "graphql.resolver.typeName";
+  AttributeName["RESOLVER_RESULT_TYPE"] = "graphql.resolver.resultType";
+  AttributeName["RESOLVER_ARGS"] = "graphql.resolver.args";
+  AttributeName["EXECUTION_OPERATION_NAME"] = "graphql.operation.name";
+  AttributeName["EXECUTION_OPERATION_TYPE"] = "graphql.operation.type";
+  AttributeName["EXECUTION_OPERATION_DOCUMENT"] = "graphql.document";
+  AttributeName["EXECUTION_VARIABLES"] = "graphql.variables";
+})(AttributeName || (AttributeName = {}));
+
+const tracingSpanSymbol = /*#__PURE__*/Symbol('OPEN_TELEMETRY_GRAPHQL');
+
+function getResolverSpanKey(path) {
+  const nodes = []; // If the first node (after reversed, it will be the last one) is an integer, that is, identifies a list,
+  // we don't want to include it in the key. Note that this will only happen when analysing .prev paths in
+  // a list of elements. We just want to remove the initial node that is a integer, not all of them.
+  //
+  // Nodes with keys 6bc73341b2a183fc::product::image::0::url would not be able to find
+  // parents with key 6bc73341b2a183fc::product::image because of the "0" list index -
+  // it would search for 6bc73341b2a183fc::product::image::0
+
+  let currentPath = nodes.length === 0 && Number.isInteger(path.key) ? path.prev : path;
+
+  while (currentPath) {
+    nodes.push(currentPath.key);
+    currentPath = currentPath.prev;
+  }
+
+  return [...nodes].reverse().join('.');
+}
+
+const getFaststoreTelemetryPlugin = (tracingProvider, loggerProvider, serviceName, experimentalSendLogs) => {
+  return function useFaststoreTelemetry() {
+    const tracer = tracingProvider.getTracer(serviceName);
+    const logger = loggerProvider.getLogger(serviceName);
+    const resolverContextsByRootSpans = {};
+    return {
+      onPluginInit({
+        addPlugin
+      }) {
+        addPlugin( // eslint-disable-next-line
+        onResolve.useOnResolve(({
+          info,
+          context
+        }) => {
+          if (context && typeof context === 'object' && context[tracingSpanSymbol]) {
+            var _path$prev, _path$prev2;
+
+            tracer.getActiveSpanProcessor();
+            const rootContextSpanId = context[tracingSpanSymbol].spanContext().spanId;
+            const {
+              fieldName,
+              returnType,
+              parentType,
+              path
+            } = info;
+            const previousResolverSpanKey = path.prev && getResolverSpanKey(path.prev);
+            let ctx = null;
+
+            if (previousResolverSpanKey && resolverContextsByRootSpans[rootContextSpanId][previousResolverSpanKey]) {
+              ctx = resolverContextsByRootSpans[rootContextSpanId][previousResolverSpanKey];
+            } else {
+              var _resolverContextsByRo;
+
+              ctx = api.trace.setSpan(api.context.active(), context[tracingSpanSymbol]);
+              resolverContextsByRootSpans[rootContextSpanId] = (_resolverContextsByRo = resolverContextsByRootSpans[rootContextSpanId]) != null ? _resolverContextsByRo : {};
+            }
+
+            const resolverIndexInList = Number.isInteger((_path$prev = path.prev) == null ? void 0 : _path$prev.key) ? `[${(_path$prev2 = path.prev) == null ? void 0 : _path$prev2.key}]` : '';
+            const resolverSpan = tracer.startSpan(`${parentType.toString()}.${fieldName}${resolverIndexInList}`, {
+              attributes: {
+                [AttributeName.RESOLVER_FIELD_NAME]: fieldName,
+                [AttributeName.RESOLVER_TYPE_NAME]: parentType.toString(),
+                [AttributeName.RESOLVER_RESULT_TYPE]: returnType.toString(),
+                'meta.span.path': getResolverSpanKey(path)
+              }
+            }, ctx);
+            const resolverCtx = api.trace.setSpan(ctx, resolverSpan);
+            resolverContextsByRootSpans[rootContextSpanId][getResolverSpanKey(path)] = resolverCtx;
+            return ({
+              result
+            }) => {
+              if (result instanceof Error) {
+                resolverSpan.setAttributes({
+                  error: true,
+                  'exception.category': AttributeName.RESOLVER_EXECUTION_ERROR,
+                  'exception.message': result.message,
+                  'exception.type': result.name
+                });
+                resolverSpan.recordException(result);
+              }
+
+              resolverSpan.end();
+            };
+          } // eslint-disable-next-line @typescript-eslint/no-empty-function
+
+
+          return () => {};
+        }));
+      },
+
+      onExecute({
+        args,
+        extendContext
+      }) {
+        var _args$document$defini, _args$operationName;
+
+        const operationType = (_args$document$defini = args.document.definitions.filter(def => def.kind === graphql.Kind.OPERATION_DEFINITION).map(def => def.operation)) == null ? void 0 : _args$document$defini[0]; // Span name according to Semantic Conventions
+        // https://github.com/open-telemetry/semantic-conventions
+
+        let spanName = 'GraphQL Operation';
+
+        if (operationType && args.operationName) {
+          spanName = `${operationType} ${args.operationName}`;
+        } else if (operationType && !args.operationName) {
+          spanName = operationType;
+        }
+
+        const executionSpan = tracer.startSpan(spanName, {
+          kind: api.SpanKind.SERVER,
+          attributes: {
+            [AttributeName.EXECUTION_OPERATION_NAME]: (_args$operationName = args.operationName) != null ? _args$operationName : undefined,
+            [AttributeName.EXECUTION_OPERATION_TYPE]: operationType != null ? operationType : undefined,
+            [AttributeName.EXECUTION_OPERATION_DOCUMENT]: graphql.print(args.document)
+          }
+        });
+        const executeContext = api.context.active();
+        const resultCbs = {
+          onExecuteDone({
+            result
+          }) {
+            var _args$operationName2, _args$variableValues;
+
+            if (core.isAsyncIterable(result)) {
+              executionSpan.end(); // eslint-disable-next-line no-console
+
+              console.warn(`Plugin "newrelic" encountered a AsyncIterator which is not supported yet, so tracing data is not available for the operation.`);
+              return;
+            }
+
+            const logRecord = {
+              context: executeContext,
+              attributes: {
+                'service.name': 'faststore-api',
+                'service.version': '1.12.38',
+                'service.name_and_version': 'faststore-api@1.12.38',
+                'vtex.search_index': 'faststore_beta_api',
+                [AttributeName.EXECUTION_OPERATION_NAME]: (_args$operationName2 = args.operationName) != null ? _args$operationName2 : undefined,
+                [AttributeName.EXECUTION_OPERATION_DOCUMENT]: graphql.print(args.document),
+                [AttributeName.EXECUTION_VARIABLES]: JSON.stringify((_args$variableValues = args.variableValues) != null ? _args$variableValues : {})
+              }
+            };
+
+            if (typeof result.data !== 'undefined' && !(result.errors && result.errors.length > 0)) {
+              logRecord.severityNumber = apiLogs.SeverityNumber.INFO;
+              logRecord.severityText = 'Info';
+              logRecord.attributes[AttributeName.EXECUTION_RESULT] = JSON.stringify(result);
+            }
+
+            if (result.errors && result.errors.length > 0) {
+              logRecord.severityNumber = apiLogs.SeverityNumber.ERROR;
+              logRecord.severityText = 'Error';
+              logRecord.attributes[AttributeName.EXECUTION_ERROR] = JSON.stringify(result.errors);
+              executionSpan.setAttributes({
+                error: true,
+                'exception.category': AttributeName.EXECUTION_ERROR,
+                'exception.message': JSON.stringify(result.errors)
+              });
+            }
+
+            if (experimentalSendLogs) {
+              logger.emit(logRecord);
+            }
+
+            executionSpan.end();
+          }
+
+        };
+        extendContext({
+          [tracingSpanSymbol]: executionSpan
+        });
+        return resultCbs;
+      }
+
+    };
+  };
+};
+
+const FASTSTORE_API_VERSION = packageJson.version; // TODO: These urls are hardcoded for now, but they should be configurable via ENV variables
+// They are only acessible from within the VTEX network, so they are not a security risk
+
+const TRACE_COLLECTOR_URL = 'opentelemetry-collector.vtex.systems';
+const TRACE_COLLECTOR_URL_DEV = 'opentelemetry-collector-beta.vtex.systems';
+const LOG_COLLECTOR_URL = 'opentelemetry-collector.vtex.systems';
+function getTelemetry(APIOptions, telemetryOptions) {
+  var _telemetryOptions$exp;
+
+  const honeycombCollectorOptions = {
+    url: (telemetryOptions == null ? void 0 : telemetryOptions.mode) === 'dev' ? TRACE_COLLECTOR_URL_DEV : TRACE_COLLECTOR_URL
+  };
+  const openSearchCollectorOptions = {
+    url: LOG_COLLECTOR_URL
+  }; // Create a new tracer provider
+
+  const tracerProvider = new sdkTraceBase.BasicTracerProvider({
+    resource: new resources.Resource({
+      'service.name': 'faststore-api',
+      'service.version': FASTSTORE_API_VERSION,
+      'service.name_and_version': `faststore-api@${FASTSTORE_API_VERSION}`,
+      platform: APIOptions.platform,
+      [`${APIOptions.platform}.account`]: APIOptions.account,
+      [`${APIOptions.platform}.environment`]: APIOptions.environment,
+      // TODO: include the following properties in the logs
+      // [`${APIOptions.platform}.options.hideUnavailableItems`]:
+      //   APIOptions.hideUnavailableItems,
+      // [`${APIOptions.platform}.flags.enableOrderFormSync`]:
+      //   APIOptions.flags?.enableOrderFormSync,
+      // channel: APIOptions.channel,
+      locale: APIOptions.locale
+    })
+  });
+  const loggerProvider = new sdkLogs.LoggerProvider(); // Create trace exporter
+
+  const honeycombExporter = new exporterTraceOtlpGrpc.OTLPTraceExporter(honeycombCollectorOptions); // Create log exporter
+
+  const openSearchExporter = new exporterLogsOtlpGrpc.OTLPLogsExporter(openSearchCollectorOptions); // Set up a span processor to export spans to Honeycomb
+
+  const honeyCombSpanProcessor = new sdkTraceBase.SimpleSpanProcessor(honeycombExporter); // Set up a log record processor to export spans to OpenSearch
+
+  const openSearchLogProcessor = new sdkLogs.SimpleLogRecordProcessor(openSearchExporter); // Register the span processor with the tracer provider
+
+  tracerProvider.addSpanProcessor(honeyCombSpanProcessor); // Register the log record processor with the log provider
+
+  loggerProvider.addLogRecordProcessor(openSearchLogProcessor);
+
+  if ((telemetryOptions == null ? void 0 : telemetryOptions.mode) === 'verbose' || (telemetryOptions == null ? void 0 : telemetryOptions.mode) === 'dev') {
+    // Set up a console exporter for verbose mode
+    const consoleExporter = new sdkTraceBase.ConsoleSpanExporter();
+    const verboseTraceProcessor = new sdkTraceBase.SimpleSpanProcessor(consoleExporter); // Set up processors for verbose mode
+
+    const consoleLogExporter = new sdkLogs.ConsoleLogRecordExporter();
+    const veboseLogRecordExporter = new sdkLogs.SimpleLogRecordProcessor(consoleLogExporter);
+    tracerProvider.addSpanProcessor(verboseTraceProcessor);
+    loggerProvider.addLogRecordProcessor(veboseLogRecordExporter);
+  }
+
+  const useFaststoreTelemetry = getFaststoreTelemetryPlugin( // The @opentelemetry/sdk-trace-base was renamed from @opentelemetry/tracing but the
+  // envelop plugin doesn't support this change yet. This causes the class type to be incompatible,
+  // even if they are the same. https://github.com/n1ru4l/envelop/issues/1610
+  tracerProvider, loggerProvider, 'faststore-api', (_telemetryOptions$exp = telemetryOptions == null ? void 0 : telemetryOptions.experimentalSendLogs) != null ? _telemetryOptions$exp : false);
+  return {
+    useFaststoreTelemetry
+  };
+}
+
 const platforms = {
   vtex: {
     getResolvers: getResolvers,
@@ -2663,6 +2949,7 @@ exports.NotFoundError = NotFoundError;
 exports.getContextFactory = getContextFactory$1;
 exports.getResolvers = getResolvers$1;
 exports.getSchema = getSchema;
+exports.getTelemetry = getTelemetry;
 exports.getTypeDefs = getTypeDefs;
 exports.isBadRequestError = isBadRequestError;
 exports.isFastStoreError = isFastStoreError;