@faststore/api 1.12.42 → 1.12.44

package/dist/index.d.ts

@@ -1,6 +1,7 @@
 import type { Options as OptionsVTEX } from './platforms/vtex';
 export * from './__generated__/schema';
 export * from './platforms/errors';
+export * from './telemetry';
 export { stringify as stringifyCacheControl } from './directives/cacheControl';
 export type { CacheControl } from './directives/cacheControl';
 export declare type Options = OptionsVTEX;

package/dist/platforms/vtex/index.d.ts

@@ -14,7 +14,7 @@ export interface Options {
 interface FeatureFlags {
     enableOrderFormSync?: boolean;
 }
-export interface Context {
+export interface Context extends Pick<Options, 'hideUnavailableItems'> {
     clients: Clients;
     loaders: Loaders;
     /**

package/dist/telemetry/index.d.ts

@@ -0,0 +1,8 @@
+import type { Options } from '../';
+export declare type GetTelemetryOptions = {
+    mode?: 'verbose' | 'dev';
+    experimentalSendLogs?: boolean;
+};
+export declare function getTelemetry(APIOptions: Options, telemetryOptions?: GetTelemetryOptions): {
+    useFaststoreTelemetry: () => import("@envelop/types").Plugin<import("./useFaststoreTelemetry").PluginContext>;
+};

package/dist/telemetry/useFaststoreTelemetry.d.ts

@@ -0,0 +1,24 @@
+import type { Plugin } from '@envelop/core';
+import { Span } from '@opentelemetry/api';
+import type { BasicTracerProvider } from '@opentelemetry/sdk-trace-base';
+import type { LoggerProvider } from '@opentelemetry/sdk-logs';
+export declare enum AttributeName {
+    EXECUTION_ERROR = "graphql.error",
+    EXECUTION_RESULT = "graphql.result",
+    RESOLVER_EXECUTION_ERROR = "graphql.resolver.error",
+    RESOLVER_EXCEPTION = "graphql.resolver.exception",
+    RESOLVER_FIELD_NAME = "graphql.resolver.fieldName",
+    RESOLVER_TYPE_NAME = "graphql.resolver.typeName",
+    RESOLVER_RESULT_TYPE = "graphql.resolver.resultType",
+    RESOLVER_ARGS = "graphql.resolver.args",
+    EXECUTION_OPERATION_NAME = "graphql.operation.name",
+    EXECUTION_OPERATION_TYPE = "graphql.operation.type",
+    EXECUTION_OPERATION_DOCUMENT = "graphql.document",
+    EXECUTION_VARIABLES = "graphql.variables"
+}
+declare const tracingSpanSymbol: unique symbol;
+export declare type PluginContext = {
+    [tracingSpanSymbol]: Span;
+};
+export declare const getFaststoreTelemetryPlugin: (tracingProvider: BasicTracerProvider, loggerProvider: LoggerProvider, serviceName: string, experimentalSendLogs: boolean) => (() => Plugin<PluginContext>);
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@faststore/api",
-  "version": "1.12.42",
+  "version": "1.12.44",
   "license": "MIT",
   "main": "dist/index.js",
   "typings": "dist/index.d.ts",
@@ -22,7 +22,12 @@
     "generate": "graphql-codegen --config codegen.yml"
   },
   "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",
@@ -30,7 +35,8 @@
     "p-limit": "^3.1.0"
   },
   "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",
@@ -44,7 +50,8 @@
     "typescript": "^4.4.2"
   },
   "peerDependencies": {
+    "@envelop/core": "^1 || ^2",
     "graphql": "^15.6.0"
   },
-  "gitHead": "65e4e781d2b4864373e4b50b37511a095c674382"
+  "gitHead": "47358f1f317a5fbbf57eaa3ec5d5691095f2264d"
 }

package/src/index.ts

@@ -11,6 +11,7 @@ import type { Options as OptionsVTEX } from './platforms/vtex'
 
 export * from './__generated__/schema'
 export * from './platforms/errors'
+export * from './telemetry'
 export { stringify as stringifyCacheControl } from './directives/cacheControl'
 export type { CacheControl } from './directives/cacheControl'
 

package/src/platforms/vtex/index.ts

@@ -42,7 +42,7 @@ interface FeatureFlags {
   enableOrderFormSync?: boolean
 }
 
-export interface Context {
+export interface Context extends Pick<Options, 'hideUnavailableItems'> {
   clients: Clients
   loaders: Loaders
   /**
@@ -99,6 +99,7 @@ export const getContextFactory =
     }
     ctx.clients = getClients(options, ctx)
     ctx.loaders = getLoaders(options, ctx)
+    ctx.hideUnavailableItems = options.hideUnavailableItems
 
     return ctx
   }

package/src/platforms/vtex/resolvers/searchResult.ts

@@ -3,6 +3,7 @@ import type { Resolver } from '..'
 import type { SearchArgs } from '../clients/search'
 import type { Facet } from '../clients/search/types/FacetSearchResult'
 import { ProductSearchResult } from '../clients/search/types/ProductSearchResult'
+import { inStock } from '../utils/productStock'
 
 type Root = {
   searchArgs: Omit<SearchArgs, 'type'>
@@ -53,7 +54,7 @@ export const StoreSearchResult: Record<string, Resolver<Root>> = {
       products: skus,
     }
   },
-  products: async ({ productSearchPromise }) => {
+  products: async ({ productSearchPromise }, _, ctx) => {
     const productSearchResult = await productSearchPromise
 
     const skus = productSearchResult.products
@@ -72,10 +73,18 @@ export const StoreSearchResult: Record<string, Resolver<Root>> = {
         endCursor: productSearchResult.recordsFiltered.toString(),
         totalCount: productSearchResult.recordsFiltered,
       },
-      edges: skus.map((sku, index) => ({
-        node: sku,
-        cursor: index.toString(),
-      })),
+      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(),
+        })),
     }
   },
   facets: async ({ searchArgs }, _, ctx) => {

package/src/telemetry/index.ts

@@ -0,0 +1,117 @@
+import {
+  BasicTracerProvider,
+  SimpleSpanProcessor,
+  ConsoleSpanExporter,
+} from '@opentelemetry/sdk-trace-base'
+import { Resource } from '@opentelemetry/resources'
+import { OTLPTraceExporter } from '@opentelemetry/exporter-trace-otlp-grpc'
+import {
+  LoggerProvider,
+  SimpleLogRecordProcessor,
+  ConsoleLogRecordExporter,
+} from '@opentelemetry/sdk-logs'
+import { OTLPLogsExporter } from '@opentelemetry/exporter-logs-otlp-grpc'
+
+import type { Options } from '../'
+import { getFaststoreTelemetryPlugin } from './useFaststoreTelemetry'
+import packageJson from '../../package.json'
+
+export type GetTelemetryOptions = {
+  mode?: 'verbose' | 'dev'
+  experimentalSendLogs?: boolean
+}
+
+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'
+
+export function getTelemetry(
+  APIOptions: Options,
+  telemetryOptions?: GetTelemetryOptions
+) {
+  const honeycombCollectorOptions = {
+    url:
+      telemetryOptions?.mode === 'dev'
+        ? TRACE_COLLECTOR_URL_DEV
+        : TRACE_COLLECTOR_URL,
+  }
+
+  const openSearchCollectorOptions = {
+    url: LOG_COLLECTOR_URL,
+  }
+
+  // Create a new tracer provider
+  const tracerProvider = new BasicTracerProvider({
+    resource: new 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 LoggerProvider()
+
+  // Create trace exporter
+  const honeycombExporter = new OTLPTraceExporter(honeycombCollectorOptions)
+
+  // Create log exporter
+  const openSearchExporter = new OTLPLogsExporter(openSearchCollectorOptions)
+
+  // Set up a span processor to export spans to Honeycomb
+  const honeyCombSpanProcessor = new SimpleSpanProcessor(honeycombExporter)
+
+  // Set up a log record processor to export spans to OpenSearch
+  const openSearchLogProcessor = new 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?.mode === 'verbose' ||
+    telemetryOptions?.mode === 'dev'
+  ) {
+    // Set up a console exporter for verbose mode
+    const consoleExporter = new ConsoleSpanExporter()
+    const verboseTraceProcessor = new SimpleSpanProcessor(consoleExporter)
+
+    // Set up processors for verbose mode
+    const consoleLogExporter = new ConsoleLogRecordExporter()
+    const veboseLogRecordExporter = new 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 as any,
+    loggerProvider,
+    'faststore-api',
+    telemetryOptions?.experimentalSendLogs ?? false
+  )
+
+  return { useFaststoreTelemetry }
+}

package/src/telemetry/useFaststoreTelemetry.ts

@@ -0,0 +1,256 @@
+import type { Plugin, OnExecuteHookResult } from '@envelop/core'
+import { isAsyncIterable } from '@envelop/core'
+import { useOnResolve } from '@envelop/on-resolve'
+import { SpanKind, Context, Span } from '@opentelemetry/api'
+import {
+  trace as openTelTrace,
+  context as openTelContext,
+} from '@opentelemetry/api'
+import type { BasicTracerProvider } from '@opentelemetry/sdk-trace-base'
+import type { Path } from 'graphql/jsutils/Path'
+import type { LoggerProvider } from '@opentelemetry/sdk-logs'
+import type { LogRecord } from '@opentelemetry/api-logs'
+import { SeverityNumber } from '@opentelemetry/api-logs'
+import { print, Kind, OperationDefinitionNode } from 'graphql'
+
+export enum AttributeName {
+  EXECUTION_ERROR = 'graphql.error',
+  EXECUTION_RESULT = 'graphql.result',
+  RESOLVER_EXECUTION_ERROR = 'graphql.resolver.error',
+  RESOLVER_EXCEPTION = 'graphql.resolver.exception',
+  RESOLVER_FIELD_NAME = 'graphql.resolver.fieldName',
+  RESOLVER_TYPE_NAME = 'graphql.resolver.typeName',
+  RESOLVER_RESULT_TYPE = 'graphql.resolver.resultType',
+  RESOLVER_ARGS = 'graphql.resolver.args',
+  EXECUTION_OPERATION_NAME = 'graphql.operation.name',
+  EXECUTION_OPERATION_TYPE = 'graphql.operation.type',
+  EXECUTION_OPERATION_DOCUMENT = 'graphql.document',
+  EXECUTION_VARIABLES = 'graphql.variables',
+}
+
+const tracingSpanSymbol = Symbol('OPEN_TELEMETRY_GRAPHQL')
+
+export type PluginContext = {
+  [tracingSpanSymbol]: Span
+}
+
+function getResolverSpanKey(path: 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: Path | undefined =
+    nodes.length === 0 && Number.isInteger(path.key) ? path.prev : path
+
+  while (currentPath) {
+    nodes.push(currentPath.key)
+
+    currentPath = currentPath.prev
+  }
+
+  return [...nodes].reverse().join('.')
+}
+
+export const getFaststoreTelemetryPlugin = (
+  tracingProvider: BasicTracerProvider,
+  loggerProvider: LoggerProvider,
+  serviceName: string,
+  experimentalSendLogs: boolean
+): (() => Plugin<PluginContext>) => {
+  return function useFaststoreTelemetry() {
+    const tracer = tracingProvider.getTracer(serviceName)
+    const logger = loggerProvider.getLogger(serviceName)
+
+    const resolverContextsByRootSpans: Record<
+      string,
+      Record<string, Context>
+    > = {}
+
+    return {
+      onPluginInit({ addPlugin }) {
+        addPlugin(
+          // eslint-disable-next-line
+          useOnResolve(({ info, context }) => {
+            if (
+              context &&
+              typeof context === 'object' &&
+              context[tracingSpanSymbol]
+            ) {
+              tracer.getActiveSpanProcessor()
+              const rootContextSpanId =
+                context[tracingSpanSymbol].spanContext().spanId
+
+              const { fieldName, returnType, parentType, path } = info
+
+              const previousResolverSpanKey =
+                path.prev && getResolverSpanKey(path.prev)
+
+              let ctx: Context | null = null
+
+              if (
+                previousResolverSpanKey &&
+                resolverContextsByRootSpans[rootContextSpanId][
+                  previousResolverSpanKey
+                ]
+              ) {
+                ctx =
+                  resolverContextsByRootSpans[rootContextSpanId][
+                    previousResolverSpanKey
+                  ]
+              } else {
+                ctx = openTelTrace.setSpan(
+                  openTelContext.active(),
+                  context[tracingSpanSymbol]
+                )
+
+                resolverContextsByRootSpans[rootContextSpanId] =
+                  resolverContextsByRootSpans[rootContextSpanId] ?? {}
+              }
+
+              const resolverIndexInList = Number.isInteger(path.prev?.key)
+                ? `[${path.prev?.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 = openTelTrace.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 }) {
+        const operationType = args.document.definitions
+          .filter((def) => def.kind === Kind.OPERATION_DEFINITION)
+          .map((def) => (def as OperationDefinitionNode).operation)?.[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: SpanKind.SERVER,
+          attributes: {
+            [AttributeName.EXECUTION_OPERATION_NAME]:
+              args.operationName ?? undefined,
+            [AttributeName.EXECUTION_OPERATION_TYPE]:
+              operationType ?? undefined,
+            [AttributeName.EXECUTION_OPERATION_DOCUMENT]: print(args.document),
+          },
+        })
+
+        const executeContext = openTelContext.active()
+
+        const resultCbs: OnExecuteHookResult<PluginContext> = {
+          onExecuteDone({ result }) {
+            if (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: 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.operationName ?? undefined,
+                [AttributeName.EXECUTION_OPERATION_DOCUMENT]: print(
+                  args.document
+                ),
+                [AttributeName.EXECUTION_VARIABLES]: JSON.stringify(
+                  args.variableValues ?? {}
+                ),
+              },
+            }
+
+            if (
+              typeof result.data !== 'undefined' &&
+              !(result.errors && result.errors.length > 0)
+            ) {
+              logRecord.severityNumber = SeverityNumber.INFO
+              logRecord.severityText = 'Info'
+              logRecord.attributes![AttributeName.EXECUTION_RESULT] =
+                JSON.stringify(result)
+            }
+
+            if (result.errors && result.errors.length > 0) {
+              logRecord.severityNumber = 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
+      },
+    }
+  }
+}