@reactionary/source 0.0.52 → 0.2.16

package/providers/meilisearch/project.json

@@ -0,0 +1,34 @@
+{
+  "name": "provider-meilisearch",
+  "$schema": "../../node_modules/nx/schemas/project-schema.json",
+  "sourceRoot": "providers/meilisearch/src",
+  "projectType": "library",
+  "release": {
+    "version": {
+      "currentVersionResolver": "git-tag",
+      "fallbackCurrentVersionResolver": "disk",
+      "preserveLocalDependencyProtocols": false,
+      "manifestRootsToUpdate": ["dist/{projectRoot}"]
+    }
+  },
+  "tags": [],
+  "targets": {
+    "build": {
+      "executor": "@nx/esbuild:esbuild",
+      "outputs": ["{options.outputPath}"],
+      "options": {
+        "outputPath": "dist/providers/meilisearch",
+        "main": "providers/meilisearch/src/index.ts",
+        "tsConfig": "providers/meilisearch/tsconfig.lib.json",
+        "assets": ["providers/meilisearch/*.md"],
+        "format": ["esm"],
+        "bundle": false
+      }
+    },
+    "nx-release-publish": {
+      "options": {
+        "packageRoot": "dist/{projectRoot}"
+      }
+    }
+  }
+}

package/providers/meilisearch/src/core/initialize.ts

@@ -0,0 +1,21 @@
+import type { Cache, ClientFromCapabilities, RequestContext } from "@reactionary/core";
+import { MeilisearchSearchProvider } from "../providers/product-search.provider.js";
+import { MeilisearchOrderSearchProvider } from "../providers/order-search.provider.js";
+import type { MeilisearchCapabilities } from "../schema/capabilities.schema.js";
+import type { MeilisearchConfiguration } from "../schema/configuration.schema.js";
+
+export function withMeilisearchCapabilities<T extends MeilisearchCapabilities>(configuration: MeilisearchConfiguration, capabilities: T) {
+    return (cache: Cache, context: RequestContext): ClientFromCapabilities<T> => {
+        const client: any = {};
+
+        if (capabilities.productSearch) {
+            client.productSearch = new MeilisearchSearchProvider(configuration, cache, context);
+        }
+
+        if (capabilities.orderSearch) {
+            client.orderSearch = new MeilisearchOrderSearchProvider(configuration, cache, context);
+        }
+
+        return client;
+    };
+}

package/providers/meilisearch/src/index.ts

@@ -0,0 +1,6 @@
+export * from './core/initialize.js';
+export * from './providers/product-search.provider.js';
+export * from './providers/order-search.provider.js';
+
+export * from './schema/configuration.schema.js';
+export * from './schema/capabilities.schema.js';

package/providers/meilisearch/src/providers/index.ts

@@ -0,0 +1 @@
+export * from './product-search.provider.js';

package/providers/meilisearch/src/providers/order-search.provider.ts

@@ -0,0 +1,222 @@
+import {
+  type Cache,
+  type OrderSearchQueryByTerm,
+  OrderSearchQueryByTermSchema,
+  type OrderSearchResult,
+  type OrderSearchResultItem,
+  OrderSearchResultSchema,
+  OrderSearchProvider,
+  Reactionary,
+  type RequestContext,
+  type Result,
+  success,
+  type OrderStatus,
+  type Address,
+  type IdentityIdentifier,
+  type MonetaryAmount,
+  type Currency,
+  type OrderSearchIdentifier,
+  AddressIdentifierSchema,
+  type AddressIdentifier,
+  type OrderInventoryStatus,
+} from '@reactionary/core';
+import { MeiliSearch, type SearchParams, type SearchResponse } from 'meilisearch';
+import type { MeilisearchConfiguration } from '../schema/configuration.schema.js';
+
+interface MeilisearchNativeOrderAddress {
+  address1: string;
+  address2: string;
+  city: string;
+  postalCode: string;
+  country: string;
+}
+
+interface MeilisearchNativeOrderRecord {
+  orderIdentifier: string;
+  userIdentifier: string;
+  customerName: string;
+  shippingAddress: MeilisearchNativeOrderAddress;
+  orderDate: string;
+  orderStatus: string;
+  inventoryStatus: string;
+  totalAmount: number;
+  currency: string;
+}
+
+export class MeilisearchOrderSearchProvider extends OrderSearchProvider {
+  protected config: MeilisearchConfiguration;
+
+  constructor(config: MeilisearchConfiguration, cache: Cache, context: RequestContext) {
+    super(cache, context);
+    this.config = config;
+  }
+
+  @Reactionary({
+    inputSchema: OrderSearchQueryByTermSchema,
+    outputSchema: OrderSearchResultSchema,
+  })
+  public async queryByTerm(payload: OrderSearchQueryByTerm): Promise<Result<OrderSearchResult>> {
+    const client = new MeiliSearch({
+      host: this.config.apiUrl,
+      apiKey: this.config.apiKey,
+    });
+
+    const index = client.index(this.config.orderIndexName);
+
+    const filters: string[] = [];
+
+    // Add status filter
+    if (payload.search.orderStatus && payload.search.orderStatus.length > 0) {
+      const statusFilters = payload.search.orderStatus
+        .map((status) => `orderStatus = "${this.mapOrderStatus(status)}"`)
+        .join(' OR ');
+      filters.push(`(${statusFilters})`);
+    }
+
+    // Add user ID filter for B2B use cases with hierarchical order access
+    if (payload.search.user) {
+      filters.push(`userIdentifier = "${payload.search.user.userId}"`);
+    }
+
+    // Add date range filters
+    if (payload.search.startDate) {
+      filters.push(`orderDate >= ${new Date(payload.search.startDate).getTime()}`);
+    }
+    if (payload.search.endDate) {
+      filters.push(`orderDate <= ${new Date(payload.search.endDate).getTime()}`);
+    }
+
+
+    if (payload.search.partNumber && payload.search.partNumber.length > 0) {
+      const partNumberFilters = payload.search.partNumber
+        .map((partNumber) => `items.sku = "${partNumber}"`)
+        .join(' OR ');
+      filters.push(`(${partNumberFilters})`);
+    }
+
+    const searchOptions: SearchParams = {
+      offset:
+        (payload.search.paginationOptions.pageNumber - 1) *
+        payload.search.paginationOptions.pageSize,
+      limit: payload.search.paginationOptions.pageSize,
+      filter: filters.length > 0 ? filters.join(' AND ') : undefined,
+    };
+
+    const remote = await index.search<MeilisearchNativeOrderRecord>(
+      payload.search.term || '',
+      searchOptions
+    );
+
+    const result = this.parsePaginatedResult(remote, payload) as OrderSearchResult;
+
+    return success(result);
+  }
+
+  protected mapOrderStatus(status: OrderStatus): string {
+    // Map from Reactionary OrderStatus to Meilisearch native status
+    const statusMap: Record<OrderStatus, string> = {
+      AwaitingPayment: 'awaiting_payment',
+      ReleasedToFulfillment: 'released_to_fulfillment',
+      Shipped: 'shipped',
+      Cancelled: 'cancelled',
+    };
+    return statusMap[status] || status;
+  }
+
+  protected mapFromNativeOrderStatus(nativeStatus: string): OrderStatus {
+    // Map from Meilisearch native status to Reactionary OrderStatus
+    const statusMap: Record<string, OrderStatus> = {
+      awaiting_payment: 'AwaitingPayment',
+      released_to_fulfillment: 'ReleasedToFulfillment',
+      shipped: 'Shipped',
+      cancelled: 'Cancelled',
+    };
+    return statusMap[nativeStatus] || 'AwaitingPayment';
+  }
+
+  protected mapFromNativeInventoryStatus(nativeStatus: string): OrderInventoryStatus {
+    // Map from Meilisearch native status to Reactionary OrderInventoryStatus
+    const statusMap: Record<string, OrderInventoryStatus> = {
+      not_allocated: 'NotAllocated',
+      allocated: 'Allocated',
+      preordered: 'Preordered',
+      backordered: 'Backordered',
+    };
+    return statusMap[nativeStatus] || 'NotAllocated';
+  }
+
+  protected composeAddressFromNativeAddress(
+    nativeAddress: MeilisearchNativeOrderAddress
+  ): Address {
+    return {
+      identifier: AddressIdentifierSchema.parse({
+        nickName: 'shipping',
+      } satisfies AddressIdentifier),
+      firstName: '',
+      lastName: '',
+      streetAddress: nativeAddress.address1,
+      streetNumber: nativeAddress.address2,
+      city: nativeAddress.city,
+      postalCode: nativeAddress.postalCode,
+      countryCode: nativeAddress.country,
+      region: '',
+    };
+  }
+
+  protected parseSingle(body: MeilisearchNativeOrderRecord): OrderSearchResultItem {
+    const identifier = { key: body.orderIdentifier };
+    const userId: IdentityIdentifier = {
+      userId: body.userIdentifier,
+    };
+    const customerName = body.customerName;
+    const shippingAddress = this.composeAddressFromNativeAddress(body.shippingAddress);
+    const orderDate = body.orderDate;
+    const orderStatus = this.mapFromNativeOrderStatus(body.orderStatus);
+    const inventoryStatus = this.mapFromNativeInventoryStatus(body.inventoryStatus);
+
+    const totalAmount: MonetaryAmount = {
+      currency: (body.currency || this.context.languageContext.currencyCode)  as Currency,
+      value: body.totalAmount,
+    };
+
+    const order = {
+      identifier,
+      userId,
+      customerName,
+      shippingAddress,
+      orderDate,
+      orderStatus,
+      inventoryStatus,
+      totalAmount,
+    } satisfies OrderSearchResultItem;
+
+    return order;
+  }
+
+  protected parsePaginatedResult(
+    body: SearchResponse<MeilisearchNativeOrderRecord>,
+    query: OrderSearchQueryByTerm
+  ): OrderSearchResult {
+    const identifier = {
+      ...query.search,
+    } satisfies OrderSearchIdentifier;
+
+    const orders: OrderSearchResultItem[] = body.hits.map((hit) => {
+      return this.parseSingle(hit);
+    });
+
+    const totalCount = body.estimatedTotalHits || body.hits.length;
+    const totalPages = Math.ceil(totalCount / (body.limit || 1));
+
+    const result = {
+      identifier,
+      pageNumber: Math.floor((body.offset || 0) / (body.limit || 1)  ) + 1,
+      pageSize: body.limit || orders.length,
+      totalCount,
+      totalPages,
+      items: orders,
+    } satisfies OrderSearchResult;
+
+    return result;
+  }
+}

package/providers/meilisearch/src/providers/product-search.provider.ts

@@ -0,0 +1,251 @@
+import {
+  type Cache,
+  type FacetIdentifier,
+  FacetIdentifierSchema,
+  type FacetValueIdentifier,
+  FacetValueIdentifierSchema,
+  ImageSchema,
+  ProductSearchProvider,
+  type ProductSearchQueryByTerm,
+  ProductSearchQueryByTermSchema,
+  type ProductSearchQueryCreateNavigationFilter,
+  type ProductSearchResult,
+  type ProductSearchResultFacet,
+  ProductSearchResultFacetSchema,
+  type ProductSearchResultFacetValue,
+  ProductSearchResultFacetValueSchema,
+  type ProductSearchResultItem,
+  type ProductSearchResultItemVariant,
+  ProductSearchResultItemVariantSchema,
+  ProductSearchResultSchema,
+  Reactionary,
+  type RequestContext,
+  type Result,
+  success
+} from '@reactionary/core';
+import { MeiliSearch, type SearchParams, type SearchResponse } from 'meilisearch';
+import type { MeilisearchConfiguration } from '../schema/configuration.schema.js';
+import type { MeilisearchProductSearchResult } from '../schema/search.schema.js';
+
+interface MeilisearchNativeVariant {
+  sku: string;
+  image: string;
+}
+
+interface MeilisearchNativeRecord {
+  objectID: string;
+  slug?: string;
+  name?: string;
+  variants: Array<MeilisearchNativeVariant>;
+}
+
+
+export class MeilisearchSearchProvider extends ProductSearchProvider {
+  protected config: MeilisearchConfiguration;
+
+  constructor(config: MeilisearchConfiguration, cache: Cache, context: RequestContext) {
+    super(cache, context);
+    this.config = config;
+  }
+
+  @Reactionary({
+    inputSchema: ProductSearchQueryByTermSchema,
+    outputSchema: ProductSearchResultSchema,
+    cache: true,
+    cacheTimeToLiveInSeconds: 300,
+    currencyDependentCaching: false,
+    localeDependentCaching: true
+  })
+  public override async queryByTerm(
+    payload: ProductSearchQueryByTerm
+  ): Promise<Result<ProductSearchResult>> {
+    const client = new MeiliSearch({
+      host: this.config.apiUrl,
+      apiKey: this.config.apiKey,
+    });
+
+    const index = client.index(this.config.indexName);
+
+    const facetsThatAreNotCategory = payload.search.facets.filter(x => x.facet.key !== 'categories');
+    const categoryFacet = payload.search.facets.find(x => x.facet.key === 'categories') || payload.search.categoryFilter;
+
+    const finalFilters: string[] = [...payload.search.filters || []];
+
+    const finalFacetFilters: string[] = [
+      ...facetsThatAreNotCategory.map(
+        (x) => `${x.facet.key}="${x.key}"`
+      ),
+    ];
+
+    if (categoryFacet) {
+      finalFilters.push(`categories = "${categoryFacet.key}"`);
+    }
+
+    // Combine all filters
+    let filterString: string | undefined;
+    if (finalFilters.length > 0 || finalFacetFilters.length > 0) {
+      const allFilters = [...finalFilters, ...finalFacetFilters];
+      filterString = allFilters.join(' AND ');
+    }
+
+    const searchOptions: SearchParams = {
+      offset: (payload.search.paginationOptions.pageNumber - 1) * payload.search.paginationOptions.pageSize,
+      limit: payload.search.paginationOptions.pageSize,
+      facets: ['*'],
+      filter: filterString,
+    };
+
+    if (this.config.useAIEmbedding) {
+      searchOptions.hybrid = {
+        embedder: this.config.useAIEmbedding
+      };
+    }
+
+    const remote = await index.search<MeilisearchNativeRecord>(payload.search.term, searchOptions);
+
+    const result = this.parsePaginatedResult(remote, payload) as MeilisearchProductSearchResult;
+
+    // mark selected facets as active
+    for (const selectedFacet of payload.search.facets) {
+      const facet = result.facets.find((f) => f.identifier.key === selectedFacet.facet.key);
+      if (facet) {
+        const value = facet.values.find((v) => v.identifier.key === selectedFacet.key);
+        if (value) {
+          value.active = true;
+        }
+      }
+    }
+
+    return success(result);
+  }
+
+  public override async createCategoryNavigationFilter(payload: ProductSearchQueryCreateNavigationFilter): Promise<Result<FacetValueIdentifier>> {
+
+    const facetIdentifier = FacetIdentifierSchema.parse({
+      key: 'categories'
+    });
+    const facetValueIdentifier = FacetValueIdentifierSchema.parse({
+      facet: facetIdentifier,
+      key: payload.categoryPath.map(c => c.name).join(' > ')
+    });
+    return success(facetValueIdentifier);
+  }
+
+
+  protected parseSingle(body: MeilisearchNativeRecord) {
+    const product = {
+      identifier: { key: body.objectID },
+      name: body.name || body.objectID,
+      slug: body.slug || body.objectID,
+      variants: [...(body.variants || [])].map(variant => this.parseVariant(variant, body)),
+    } satisfies ProductSearchResultItem;
+
+    return product;
+  }
+
+  protected override parseVariant(variant: MeilisearchNativeVariant, product: MeilisearchNativeRecord): ProductSearchResultItemVariant {
+    const result = ProductSearchResultItemVariantSchema.parse({
+      variant: {
+        sku: variant.sku
+      },
+      image: ImageSchema.parse({
+        sourceUrl: variant.image,
+        altText: product.name || '',
+      })
+    } satisfies Partial<ProductSearchResultItemVariant>);
+
+    return result;
+  }
+
+  protected parsePaginatedResult(body: SearchResponse<MeilisearchNativeRecord>, query: ProductSearchQueryByTerm) {
+    const items = body.hits.map((hit) => this.parseSingle(hit));
+    let facets: ProductSearchResultFacet[] = [];
+
+    if (body.facetDistribution) {
+      for (const id in body.facetDistribution) {
+        const f = body.facetDistribution[id];
+        const facetId = FacetIdentifierSchema.parse({
+          key: id
+        });
+        const facet = this.parseFacet(facetId, f);
+        if (facet.values.length > 0) {
+        facets.push(facet);
+        }
+      }
+    }
+
+    // Handle category hierarchy similar to Algolia
+    const selectedCategoryFacet = query.search.facets.find(x => x.facet.key === 'categories') || query.search.categoryFilter;
+    let subCategoryFacet;
+    if (selectedCategoryFacet) {
+      const valueDepth = selectedCategoryFacet.key.split(' > ').length;
+      subCategoryFacet = facets.find(f => f.identifier.key === `hierarchy.lvl${valueDepth}`);
+    } else {
+      subCategoryFacet = facets.find(f => f.identifier.key === 'hierarchy.lvl0');
+    }
+
+    if (subCategoryFacet) {
+      // remap to 'categories' facet
+      subCategoryFacet.identifier = FacetIdentifierSchema.parse({
+        key: 'categories'
+      });
+      subCategoryFacet.name = 'Categories';
+      for (const v of subCategoryFacet.values) {
+        const pathParts = v.identifier.key.split(' > ');
+        v.identifier.facet = subCategoryFacet.identifier;
+        v.name = pathParts[pathParts.length - 1];
+      }
+    }
+
+    // remove other hierarchy facets
+    facets = facets.filter(f => !f.identifier.key.startsWith('hierarchy.lvl'));
+
+    const totalPages = Math.ceil((body.estimatedTotalHits || 0) / query.search.paginationOptions.pageSize);
+
+    const result = {
+      identifier: {
+        term: query.search.term,
+        facets: query.search.facets,
+        filters: query.search.filters,
+        paginationOptions: query.search.paginationOptions,
+      },
+      pageNumber: query.search.paginationOptions.pageNumber,
+      pageSize: query.search.paginationOptions.pageSize,
+      totalCount: body.estimatedTotalHits || 0,
+      totalPages: totalPages,
+      items: items,
+      facets,
+    } satisfies ProductSearchResult;
+
+    return result;
+  }
+
+  protected parseFacet(facetIdentifier: FacetIdentifier, facetValues: Record<string, number>): ProductSearchResultFacet {
+    const result: ProductSearchResultFacet = ProductSearchResultFacetSchema.parse({
+      identifier: facetIdentifier,
+      name: facetIdentifier.key.replace(/_/g, ' '),
+      values: []
+    });
+
+    for (const vid in facetValues) {
+      const fv = facetValues[vid];
+
+      const facetValueIdentifier = FacetValueIdentifierSchema.parse({
+        facet: facetIdentifier,
+        key: vid
+      } satisfies Partial<FacetValueIdentifier>);
+
+      result.values.push(this.parseFacetValue(facetValueIdentifier, vid, fv));
+    }
+    return result;
+  }
+
+  protected parseFacetValue(facetValueIdentifier: FacetValueIdentifier, label: string, count: number): ProductSearchResultFacetValue {
+    return ProductSearchResultFacetValueSchema.parse({
+      identifier: facetValueIdentifier,
+      name: label,
+      count: count,
+      active: false,
+    } satisfies Partial<ProductSearchResultFacetValue>);
+  }
+}

package/providers/meilisearch/src/schema/capabilities.schema.ts

@@ -0,0 +1,10 @@
+import { CapabilitiesSchema } from "@reactionary/core";
+import type { z } from 'zod';
+
+export const MeilisearchCapabilitiesSchema = CapabilitiesSchema.pick({
+    productSearch: true,
+    orderSearch: true,
+    analytics: true
+}).partial();
+
+export type MeilisearchCapabilities = z.infer<typeof MeilisearchCapabilitiesSchema>;

package/providers/meilisearch/src/schema/configuration.schema.ts

@@ -0,0 +1,11 @@
+import { z } from 'zod';
+
+export const MeilisearchConfigurationSchema = z.looseObject({
+    apiUrl: z.string(),
+    apiKey: z.string(),
+    indexName: z.string(),
+    orderIndexName: z.string(),
+    useAIEmbedding: z.string().optional()
+});
+
+export type MeilisearchConfiguration = z.infer<typeof MeilisearchConfigurationSchema>;

package/providers/meilisearch/src/schema/index.ts

@@ -0,0 +1,3 @@
+export * from './configuration.schema.js';
+export * from './capabilities.schema.js';
+export * from './search.schema.js';

package/providers/meilisearch/src/schema/search.schema.ts

@@ -0,0 +1,14 @@
+import { ProductSearchIdentifierSchema, ProductSearchResultSchema } from '@reactionary/core';
+import { z } from 'zod';
+
+export const MeilisearchProductSearchIdentifierSchema = ProductSearchIdentifierSchema.extend({
+   key: z.string(),
+   index: z.string(),
+});
+
+export const MeilisearchProductSearchResultSchema = ProductSearchResultSchema.extend({
+    identifier: MeilisearchProductSearchIdentifierSchema.default(() => MeilisearchProductSearchIdentifierSchema.parse({}))
+});
+
+export type MeilisearchProductSearchResult = z.infer<typeof MeilisearchProductSearchResultSchema>;
+export type MeilisearchProductSearchIdentifier = z.infer<typeof MeilisearchProductSearchIdentifierSchema>;

package/providers/meilisearch/tsconfig.json

@@ -0,0 +1,24 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": {
+    "module": "NodeNext",
+    "moduleResolution": "nodenext",
+    "forceConsistentCasingInFileNames": true,
+    "strict": true,
+    "importHelpers": true,
+    "noImplicitOverride": true,
+    "noImplicitReturns": true,
+    "noFallthroughCasesInSwitch": true,
+    "noPropertyAccessFromIndexSignature": true
+  },
+  "files": [],
+  "include": [],
+  "references": [
+    {
+      "path": "./tsconfig.lib.json"
+    },
+    {
+      "path": "./tsconfig.spec.json"
+    }
+  ]
+}

package/providers/meilisearch/tsconfig.lib.json

@@ -0,0 +1,10 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "outDir": "../../dist/out-tsc",
+    "declaration": true,
+    "types": ["node"]
+  },
+  "include": ["src/**/*.ts"],
+  "exclude": ["src/**/*.spec.ts", "vitest.config.ts"]
+}

package/providers/meilisearch/tsconfig.spec.json

@@ -0,0 +1,4 @@
+{
+  "extends": "./tsconfig.lib.json",
+  "exclude": []
+}

package/providers/meilisearch/vitest.config.ts

@@ -0,0 +1,14 @@
+import { defineConfig, defineProject } from 'vitest/config';
+import tsconfigPaths from 'vite-tsconfig-paths';
+import { resolve } from 'path';
+import { nxViteTsPaths } from '@nx/vite/plugins/nx-tsconfig-paths.plugin';
+
+export default defineProject({
+  plugins: [nxViteTsPaths()],
+  test: {
+    root: resolve(__dirname),
+    globals: true,
+    environment: 'node',
+    include: ['src/**/*.spec.ts'],
+  },
+});

package/providers/posthog/package.json

@@ -7,5 +7,6 @@
     "@reactionary/core": "0.0.1",
     "zod": "4.1.9"
   },
-  "type": "module"
+  "type": "module",
+  "sideEffects": false
 }

package/providers/posthog/tsconfig.json

@@ -1,7 +1,7 @@
 {
   "extends": "../../tsconfig.base.json",
   "compilerOptions": {
-    "module": "nodenext",
+    "module": "NodeNext",
     "moduleResolution": "nodenext",
     "forceConsistentCasingInFileNames": true,
     "strict": true,

package/tsconfig.base.json

@@ -17,7 +17,12 @@
     "paths": {
       "@reactionary/core": ["core/src/index.ts"],
       "@reactionary/examples-node": ["examples/node/src/index.ts"],
+      "@reactionary/provider-medusa": ["providers/medusa/src/index.ts"],
+      "@reactionary/otel": ["otel/src/index.ts"],
       "@reactionary/provider-algolia": ["providers/algolia/src/index.ts"],
+      "@reactionary/provider-meilisearch": [
+        "providers/meilisearch/src/index.ts"
+      ],
       "@reactionary/provider-commercetools": [
         "providers/commercetools/src/index.ts"
       ],

package/vitest.config.ts

@@ -0,0 +1,10 @@
+import { resolve } from 'path'
+import { defineConfig } from 'vitest/config'
+
+export default defineConfig({
+  test: {
+    projects: ['providers/*', 'examples/*', 'core'],
+    reporters: ['default', 'verbose', 'github-actions'],
+
+  },
+})