@faststore/api 3.99.1 → 4.0.0-dev.4

package/src/directives/index.ts

@@ -1,6 +1,29 @@
+import { mergeTypeDefs } from '@graphql-tools/merge'
+import { makeExecutableSchema } from '@graphql-tools/schema'
+import type { IResolvers, TypeSource } from '@graphql-tools/utils'
 import type { GraphQLSchema } from 'graphql'
 
+export { default as AuthDirective } from './auth'
+export { default as CacheControlDirective } from './cacheControl'
+
 export type Directive = {
   typeDefs: string
   transformer: (schema: GraphQLSchema) => GraphQLSchema
 }
+
+export const withDirectives =
+  (directives?: Array<Directive>) =>
+  (resolvers: IResolvers<any, any>, typeDef: TypeSource) => {
+    const finalTypeDef = mergeTypeDefs([
+      ...(directives ?? []).map(({ typeDefs }) => typeDefs),
+      typeDef,
+    ])
+
+    return (directives ?? []).reduce(
+      (schema, { transformer }) => transformer?.(schema) ?? schema,
+      makeExecutableSchema({
+        typeDefs: finalTypeDef,
+        resolvers,
+      })
+    )
+  }

package/src/index.ts

@@ -1,61 +1,20 @@
-import { makeExecutableSchema } from '@graphql-tools/schema'
-
-import {
-  getContextFactory as getContextFactoryVTEX,
-  getResolvers as getResolversVTEX,
-} from './platforms/vtex'
-import { typeDefs } from './typeDefs'
-import authDirective from './directives/auth'
-import cacheControlDirective from './directives/cacheControl'
-import type { Directive } from './directives'
-import type { Options as OptionsVTEX } from './platforms/vtex'
-
 export * from './__generated__/schema'
-export * from './platforms/errors'
-export { default as authDirective } from './directives/auth'
+export * from './directives'
 export {
-  default as cacheControlDirective,
   stringify as stringifyCacheControl,
+  type CacheControl,
 } from './directives/cacheControl'
-export type { CacheControl } from './directives/cacheControl'
-
-export type Options = OptionsVTEX
-
-const platforms = {
-  vtex: {
-    getResolvers: getResolversVTEX,
-    getContextFactory: getContextFactoryVTEX,
-  },
-}
-
-const directives: Directive[] = [cacheControlDirective, authDirective]
-
-export const getTypeDefs = () => [
-  typeDefs,
-  ...directives.map((d) => d.typeDefs),
-]
-
-export const getResolvers = (options: Options) =>
-  platforms[options.platform].getResolvers(options)
-
-export const getContextFactory = (options: Options) =>
-  platforms[options.platform].getContextFactory(options)
-
-export const getSchema = async (options: Options) => {
-  const schema = makeExecutableSchema({
-    resolvers: getResolvers(options),
-    typeDefs: getTypeDefs(),
-  })
-
-  return directives.reduce((s, d) => d.transformer(s), schema)
-}
-
-export * from './platforms/vtex/resolvers/root'
-export type { Resolver } from './platforms/vtex'
+export { GraphqlVtexContextFactory, GraphqlVtexSchema } from './platforms/vtex'
+export { typeDefs } from './platforms/vtex/typeDefs'
 
+export * from './platforms/errors'
+export type { GraphqlResolver } from './platforms/vtex'
 export type {
   CommertialOffer,
   Item,
   ProductSearchResult,
   Seller,
 } from './platforms/vtex/clients/search/types/ProductSearchResult'
+export * from './platforms/vtex/resolvers/root'
+
+export type APIOptions = Options

package/src/observability/telemetry.ts

@@ -0,0 +1,66 @@
+import { OTELAPI } from '@faststore/diagnostics'
+import { name, version } from '../../package.json' with { type: 'json' }
+
+export const ResolverTrace = <
+  TContext extends {
+    OTEL: Record<string, any>
+    account: string
+    discoveryConfig: Record<string, any>
+  },
+  TSource = any,
+  TVars = any,
+  TReturn = any,
+>(
+  fn: (source: TSource, vars: TVars, context: TContext, info: any) => TReturn,
+  resolverName?: string
+) => {
+  return (
+    source: TSource,
+    vars: TVars,
+    graphqlContext: TContext,
+    info: any
+  ): TReturn => {
+    if ((graphqlContext?.OTEL?.enabled ?? false) === false) {
+      return fn(source, vars, graphqlContext, info)
+    }
+
+    const trace = OTELAPI.trace.getTracer(name, version)
+    const activeContext = OTELAPI.propagation.extract(
+      OTELAPI.context.active(),
+      graphqlContext.OTEL
+    )
+
+    return OTELAPI.context.with(activeContext, () => {
+      const span = trace.startSpan(resolverName ?? 'Unknown Graphql Resolver', {
+        startTime: Date.now(),
+        kind: OTELAPI.SpanKind.INTERNAL,
+        attributes: {
+          timestamp: Date.now(),
+          '@faststore_version': version,
+          '@faststore_package_name': name,
+          '@faststore_account_name': graphqlContext.account,
+          '@faststore_environment': process.env.NODE_ENV,
+        },
+      })
+
+      if (!span) return fn(source, vars, graphqlContext, info)
+      try {
+        const returnedValue = fn(source, vars, graphqlContext, info)
+
+        if (!(returnedValue instanceof Promise)) {
+          span.end()
+          return returnedValue
+        }
+
+        return returnedValue.then((value) => {
+          span.end()
+          return value
+        }) as TReturn
+      } catch (error) {
+        span.end()
+        console.error(`Error when executing resolver: ${resolverName}`, error)
+        throw error
+      }
+    })
+  }
+}

package/src/platforms/vtex/clients/commerce/index.ts

@@ -14,13 +14,11 @@ import {
   type UserOrderCancel,
   type UserOrderListResult,
 } from '../../../..'
-import type { Context, Options } from '../../index'
+import type { GraphqlContext } from '../../index'
 import { getWithAppKeyAndToken } from '../../utils/auth'
 import type { Channel } from '../../utils/channel'
 import {
-  getAuthCookie,
   getStoreCookie,
-  getUpdatedCookie,
   getWithAutCookie,
   getWithCookie,
 } from '../../utils/cookies'
@@ -29,7 +27,11 @@ import type { Address, AddressInput } from './types/Address'
 import type { Brand } from './types/Brand'
 import type { CategoryTree } from './types/CategoryTree'
 import type { MasterDataResponse } from './types/Newsletter'
-import type { OrderForm, OrderFormInputItem } from './types/OrderForm'
+import type {
+  ClientPreferencesData,
+  OrderForm,
+  OrderFormInputItem,
+} from './types/OrderForm'
 import type { PickupPoints, PickupPointsInput } from './types/PickupPoints'
 import type { PortalPagetype } from './types/Portal'
 import type { PortalProduct } from './types/Product'
@@ -56,7 +58,7 @@ const BASE_INIT = {
 
 export const VtexCommerce = (
   { account, environment, incrementAddress, subDomainPrefix }: Options,
-  ctx: Context
+  ctx: GraphqlContext
 ) => {
   const base = `https://${account}.${environment}.com.br`
   const storeCookies = getStoreCookie(ctx)
@@ -221,6 +223,28 @@ export const VtexCommerce = (
           { storeCookies }
         )
       },
+      clientPreferencesData: ({
+        id,
+        clientPreferencesData,
+      }: {
+        id: string
+        clientPreferencesData: ClientPreferencesData
+      }): Promise<OrderForm> => {
+        const headers: HeadersInit = withCookie({
+          'content-type': 'application/json',
+          'X-FORWARDED-HOST': forwardedHost,
+        })
+
+        return fetchAPI(
+          `${base}/api/checkout/pub/orderForm/${id}/attachments/clientPreferencesData`,
+          {
+            headers,
+            body: JSON.stringify(clientPreferencesData),
+            method: 'POST',
+          },
+          { storeCookies }
+        )
+      },
       orderForm: ({
         id,
         refreshOutdatedData = true,
@@ -739,15 +763,14 @@ export const VtexCommerce = (
     vtexid: {
       validate: (): Promise<VtexIdResponse> => {
         const headers: HeadersInit = withAutCookie(forwardedHost, account)
-        // Read from the merged cookie set so the body token stays in sync with
-        // the `cookie` header (both pull from request + storage updates).
-        const token = getAuthCookie(getUpdatedCookie(ctx) ?? '', account)
 
         return fetchAPI(
           `${base}/api/vtexid/credential/validate`,
           {
             headers,
-            body: JSON.stringify({ token }),
+            body: JSON.stringify({
+              token: headers['VtexIdclientAutCookie'],
+            }),
             method: 'POST',
           },
           { storeCookies }

package/src/platforms/vtex/clients/commerce/types/OrderForm.ts

@@ -120,10 +120,7 @@ export interface OrderForm {
     name: string
     logo: string
   }>
-  clientPreferencesData: {
-    locale: string
-    optinNewsLetter: any | null
-  }
+  clientPreferencesData: ClientPreferencesData | null
   commercialConditionData: any | null
   storePreferencesData: {
     countryCode: string
@@ -156,6 +153,11 @@ export interface OrderForm {
   itemsOrdination: any | null
 }
 
+export interface ClientPreferencesData {
+  locale: string
+  optinNewsLetter?: boolean | null
+}
+
 export interface OrderFormCustomData {
   customApps: Array<{
     fields: Record<string, string>

package/src/platforms/vtex/clients/fetch.ts

@@ -1,5 +1,5 @@
 import fetch from 'isomorphic-unfetch'
-import packageJson from '../../../../package.json'
+import packageJson from '../../../../package.json' with { type: 'json' }
 import {
   BadRequestError,
   FastStoreError,

package/src/platforms/vtex/clients/index.ts

@@ -1,10 +1,10 @@
-import type { Context, Options } from '..'
+import type { GraphqlContext } from '..'
 import { VtexCommerce } from './commerce'
 import { IntelligentSearch } from './search'
 
 export type Clients = ReturnType<typeof getClients>
 
-export const getClients = (options: Options, ctx: Context) => {
+export const getClients = (options: Options, ctx: GraphqlContext) => {
   const search = IntelligentSearch(options, ctx)
   const commerce = VtexCommerce(options, ctx)
 

package/src/platforms/vtex/clients/search/index.ts

@@ -1,4 +1,4 @@
-import type { Context, Options } from '../../'
+import type { GraphqlContext } from '../../'
 import type { IStoreSelectedFacet } from '../../../../__generated__/schema'
 import { getWithCookie } from '../../utils/cookies'
 import type {
@@ -94,7 +94,7 @@ export const IntelligentSearch = (
     showSponsored,
     subDomainPrefix,
   }: Options,
-  ctx: Context
+  ctx: GraphqlContext
 ) => {
   const base = `https://${account}.${environment}.com.br/api/io`
   const withCookie = getWithCookie(ctx)

package/src/platforms/vtex/index.ts

@@ -1,54 +1,23 @@
+import { OTELAPI } from '@faststore/diagnostics'
+import { mergeSchemas } from '@graphql-tools/schema'
+import { type GraphQLSchema, isSchema } from 'graphql'
+import { withDirectives } from '../../directives'
+import authDirective from '../../directives/auth'
+import cacheControlDirective from '../../directives/cacheControl'
+import { ResolverTrace } from '../../observability/telemetry'
 import type { Clients } from './clients'
 import { getClients } from './clients'
 import type { SearchArgs } from './clients/search'
 import type { Loaders } from './loaders'
 import { getLoaders } from './loaders'
-import { StoreAggregateOffer } from './resolvers/aggregateOffer'
-import { StoreAggregateRating } from './resolvers/aggregateRating'
-import { StoreCollection } from './resolvers/collection'
-import {
-  StoreFacet,
-  StoreFacetBoolean,
-  StoreFacetRange,
-} from './resolvers/facet'
-import { StoreFacetValueBoolean } from './resolvers/faceValue'
-import { Mutation } from './resolvers/mutation'
-import { ObjectOrString } from './resolvers/objectOrString'
-import { StoreOffer } from './resolvers/offer'
-import { StoreProduct } from './resolvers/product'
-import { StoreProductGroup } from './resolvers/productGroup'
-import { StorePropertyValue } from './resolvers/propertyValue'
-import { Query } from './resolvers/query'
-import { StoreReview } from './resolvers/review'
-import { StoreSearchResult } from './resolvers/searchResult'
-import { StoreSeo } from './resolvers/seo'
-import { ShippingSLA } from './resolvers/shippingSLA'
-import { SkuVariants } from './resolvers/skuVariations'
-import { UserOrderResult } from './resolvers/userOrder'
+import { getResolvers as nativeGetResolvers } from './resolvers'
+import typeDefs from './typeDefs'
 import type { Channel } from './utils/channel'
 import ChannelMarshal from './utils/channel'
 
-export interface Options {
-  platform: 'vtex'
-  account: string
-  environment: 'vtexcommercestable' | 'vtexcommercebeta'
-  // Default sales channel to use for fetching products
-  subDomainPrefix: string[]
-  channel: string
-  locale: string
-  hideUnavailableItems: boolean
-  simulationBehavior?: 'default' | 'skip' | 'only1P'
-  showSponsored: boolean
-  incrementAddress: boolean
-  flags?: FeatureFlags
-}
-
-interface FeatureFlags {
-  enableOrderFormSync?: boolean
-  enableUnavailableItemsOnCart?: boolean
-}
-
-export interface Context {
+export interface GraphqlContext {
+  /** Request scope ID */
+  id: string
   clients: Clients
   loaders: Loaders
   /**
@@ -66,52 +35,69 @@ export interface Context {
   }
   headers: Record<string, string>
   account: string
+  OTEL: Record<string, unknown>
+}
+
+export const GraphqlVtexContextFactory = async (options: Options) => {
+  return OTELAPI.context.with(
+    OTELAPI.propagation.extract(OTELAPI.context.active(), options.OTEL),
+    () =>
+      (ctx: any): GraphqlContext => {
+        ctx.storage = {
+          channel: ChannelMarshal.parse(options.channel),
+          flags: options.flags ?? {},
+          locale: options.locale,
+          cookies: new Map<string, Record<string, string>>(),
+        }
+        ctx.clients = getClients(options, ctx)
+        ctx.loaders = getLoaders(options, ctx)
+        ctx.account = options.account
+        ctx.OTEL = options.OTEL
+        ctx.discoveryConfig = options.discoveryConfig
+
+        return ctx
+      }
+  )
 }
 
-export type Resolver<R = unknown, A = unknown, Return = any> = (
-  root: R,
-  args: A,
-  ctx: Context,
-  info: any
-) => Return
+export type GraphqlResolver<S = any, V = any, R = any> = Resolver<
+  GraphqlContext,
+  S,
+  V,
+  R
+>
+
+export function getResolvers() {
+  const resolvers = nativeGetResolvers()
 
-const Resolvers = {
-  StoreCollection,
-  StoreAggregateOffer,
-  StoreProduct,
-  StoreSeo,
-  StoreFacet,
-  StoreFacetBoolean,
-  StoreFacetRange,
-  StoreFacetValueBoolean,
-  StoreOffer,
-  StoreAggregateRating,
-  StoreReview,
-  StoreProductGroup,
-  StoreSearchResult,
-  StorePropertyValue,
-  SkuVariants,
-  ShippingSLA,
-  UserOrderResult,
-  ObjectOrString,
-  Query,
-  Mutation,
+  const finalResolvers: any = {}
+  for (const [key, resolver] of Object.entries(resolvers)) {
+    finalResolvers[key] = Object.fromEntries(
+      Object.entries(resolver).map(([name, resolverFunction]) => {
+        if (typeof resolverFunction !== 'function')
+          return [name, resolverFunction]
+
+        return [name, ResolverTrace(resolverFunction, `${key}(${name})`)]
+      })
+    )
+  }
+
+  return finalResolvers as typeof resolvers
 }
 
-export const getContextFactory =
-  (options: Options) =>
-  (ctx: any): Context => {
-    ctx.storage = {
-      channel: ChannelMarshal.parse(options.channel),
-      flags: options.flags ?? {},
-      locale: options.locale,
-      cookies: new Map<string, Record<string, string>>(),
-    }
-    ctx.clients = getClients(options, ctx)
-    ctx.loaders = getLoaders(options, ctx)
-    ctx.account = options.account
+export function GraphqlVtexSchema(mergeSchema?: GraphQLSchema) {
+  const withCacheControl = withDirectives([
+    cacheControlDirective,
+    authDirective,
+  ])
+
+  const platformSchema = withCacheControl(getResolvers(), typeDefs)
 
-    return ctx
+  if (mergeSchema && isSchema(mergeSchema)) {
+    return mergeSchemas({
+      schemas: [platformSchema, mergeSchema],
+    })
   }
 
-export const getResolvers = (_: Options) => Resolvers
+  return platformSchema
+}

package/src/platforms/vtex/loaders/collection.ts

@@ -2,9 +2,8 @@ import DataLoader from 'dataloader'
 import pLimit from 'p-limit'
 
 import { NotFoundError } from '../../errors'
-import type { CollectionPageType } from '../clients/commerce/types/Portal'
-import type { Options } from '..'
 import type { Clients } from '../clients'
+import type { CollectionPageType } from '../clients/commerce/types/Portal'
 
 // Limits concurrent requests to 20 so that they don't timeout
 const CONCURRENT_REQUESTS_MAX = 20

package/src/platforms/vtex/loaders/index.ts

@@ -1,12 +1,12 @@
+import type { GraphqlContext } from '..'
+import { getCollectionLoader } from './collection'
 import { getSalesChannelLoader } from './salesChannel'
 import { getSimulationLoader } from './simulation'
 import { getSkuLoader } from './sku'
-import { getCollectionLoader } from './collection'
-import type { Context, Options } from '..'
 
 export type Loaders = ReturnType<typeof getLoaders>
 
-export const getLoaders = (options: Options, { clients }: Context) => {
+export const getLoaders = (options: Options, { clients }: GraphqlContext) => {
   const skuLoader = getSkuLoader(options, clients)
   const simulationLoader = getSimulationLoader(options, clients)
   const collectionLoader = getCollectionLoader(options, clients)

package/src/platforms/vtex/loaders/salesChannel.ts

@@ -1,6 +1,5 @@
 import DataLoader from 'dataloader'
 
-import type { Options } from '..'
 import type { Clients } from '../clients'
 
 import type { SalesChannel } from './../clients/commerce/types/SalesChannel'

package/src/platforms/vtex/loaders/simulation.ts

@@ -1,7 +1,6 @@
 import DataLoader from 'dataloader'
 import pLimit from 'p-limit'
 
-import type { Options } from '..'
 import type { Clients } from '../clients'
 import type {
   ShippingItem,

package/src/platforms/vtex/loaders/sku.ts

@@ -1,10 +1,9 @@
 import DataLoader from 'dataloader'
 
-import { enhanceSku } from '../utils/enhanceSku'
 import { NotFoundError } from '../../errors'
-import type { EnhancedSku } from '../utils/enhanceSku'
-import type { Options } from '..'
 import type { Clients } from '../clients'
+import type { EnhancedSku } from '../utils/enhanceSku'
+import { enhanceSku } from '../utils/enhanceSku'
 
 export const getSkuLoader = ({ flags }: Options, clients: Clients) => {
   const loader = async (keys: readonly string[]) => {

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

@@ -1,8 +1,7 @@
+import type { GraphqlResolver } from '..'
 import { inStock, price } from '../utils/productStock'
-import type { StoreProduct } from './product'
-import type { PromiseType } from '../../../typings'
-import type { Resolver } from '..'
 import { withTax } from '../utils/taxes'
+import type { StoreProduct } from './product'
 
 export type Root = PromiseType<ReturnType<typeof StoreProduct.offers>>
 
@@ -35,8 +34,8 @@ const getLowPrice = (
   return withTax(lowPrice, lowOffer?.Tax, lowOffer?.product?.unitMultiplier)
 }
 
-export const StoreAggregateOffer: Record<string, Resolver<Root>> & {
-  offers: Resolver<Root, any, Root>
+export const StoreAggregateOffer: Record<string, GraphqlResolver<Root>> & {
+  offers: GraphqlResolver<Root, any, Root>
 } = {
   highPrice: (offers) => getHighPrice(offers),
   lowPrice: (offers) => getLowPrice(offers),

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

@@ -1,7 +1,7 @@
-import type { Resolver } from '..'
+import type { GraphqlResolver } from '..'
 
 // TODO: Add a review system integration
-export const StoreAggregateRating: Record<string, Resolver> = {
+export const StoreAggregateRating: Record<string, GraphqlResolver> = {
   ratingValue: () => 5,
   reviewCount: () => 0,
 }

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

@@ -1,4 +1,4 @@
-import type { Context } from '..'
+import type { GraphqlContext } from '..'
 import type {
   MutationCancelOrderArgs,
   UserOrderCancel,
@@ -8,7 +8,7 @@ import { BadRequestError } from '../../errors'
 export const cancelOrder = async (
   _: any,
   { data }: MutationCancelOrderArgs,
-  { clients: { commerce } }: Context
+  { clients: { commerce } }: GraphqlContext
 ): Promise<UserOrderCancel | null> => {
   if (!data?.orderId) {
     throw new BadRequestError('Missing orderId')

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

@@ -1,4 +1,4 @@
-import type { Resolver } from '..'
+import type { GraphqlResolver } from '..'
 import type { Brand } from '../clients/commerce/types/Brand'
 import type { CategoryTree } from '../clients/commerce/types/CategoryTree'
 import type { CollectionPageType } from '../clients/commerce/types/Portal'
@@ -29,7 +29,7 @@ const slugifyRoot = (root: Root) => {
   return new URL(root.url).pathname.slice(1).toLowerCase()
 }
 
-export const StoreCollection: Record<string, Resolver<Root>> = {
+export const StoreCollection: Record<string, GraphqlResolver<Root>> = {
   id: ({ id }) => id.toString(),
   slug: (root) => slugifyRoot(root),
   seo: (root) =>

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

@@ -1,9 +1,9 @@
-import type { Resolver } from '..'
+import type { GraphqlResolver } from '..'
 import type { FacetValueBoolean } from '../clients/search/types/FacetSearchResult'
 
 export const StoreFacetValueBoolean: Record<
   string,
-  Resolver<FacetValueBoolean>
+  GraphqlResolver<FacetValueBoolean>
 > = {
   value: ({ value }) => value,
   label: ({ name }) => name || 'unknown',

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

@@ -1,4 +1,4 @@
-import type { Resolver } from '..'
+import type { GraphqlResolver } from '..'
 import type {
   Facet,
   FacetValueBoolean,
@@ -9,7 +9,7 @@ import { min } from '../utils/orderStatistics'
 
 export type Root = Facet
 
-export const StoreFacet: Record<string, Resolver<Root>> = {
+export const StoreFacet: Record<string, GraphqlResolver<Root>> = {
   __resolveType: ({ type, values }) => {
     if (type !== 'TEXT' && type !== 'DELIVERY') {
       return 'StoreFacetRange'
@@ -29,7 +29,7 @@ export const StoreFacet: Record<string, Resolver<Root>> = {
 
 export const StoreFacetBoolean: Record<
   string,
-  Resolver<Facet<FacetValueBoolean>>
+  GraphqlResolver<Facet<FacetValueBoolean>>
 > = {
   key: ({ key }) => key,
   label: ({ name }) => name,
@@ -38,7 +38,7 @@ export const StoreFacetBoolean: Record<
 
 export const StoreFacetRange: Record<
   string,
-  Resolver<Facet<FacetValueRange>>
+  GraphqlResolver<Facet<FacetValueRange>>
 > = {
   key: ({ key }) => key,
   label: ({ name }) => name,