@reactionary/source 0.6.1 → 0.6.3

package/providers/commercetools/src/providers/product.provider.ts

@@ -1,312 +0,0 @@
-import {
-  ImageSchema,
-  ProductAttributeIdentifierSchema,
-  ProductAttributeSchema,
-  ProductAttributeValueIdentifierSchema,
-  ProductAttributeValueSchema,
-  ProductProvider,
-  ProductQueryByIdSchema,
-  ProductQueryBySKUSchema,
-  ProductQueryBySlugSchema,
-  ProductSchema,
-  Reactionary,
-  success,
-  error,
-} from '@reactionary/core';
-import type { CommercetoolsConfiguration } from '../schema/configuration.schema.js';
-import type {
-  ProductProjection,
-  ProductVariant as CTProductVariant,
-  Attribute as CTAttribute,
-} from '@commercetools/platform-sdk';
-import type {
-  Product,
-  ProductVariant,
-  ProductQueryById,
-  ProductQueryBySKU,
-  ProductQueryBySlug,
-  ProductVariantIdentifier,
-  RequestContext,
-  ProductAttribute,
-  ProductAttributeIdentifier,
-  ProductAttributeValue,
-  ProductAttributeValueIdentifier,
-  ProductIdentifier,
-  ProductVariantOption,
-  ProductOptionIdentifier,
-  Result,
-} from '@reactionary/core';
-import type { Cache, Image } from '@reactionary/core';
-import type { CommercetoolsAPI } from '../core/client.js';
-import type { NotFoundError } from '@reactionary/core';
-
-export class CommercetoolsProductProvider extends ProductProvider {
-  protected config: CommercetoolsConfiguration;
-  protected commercetools: CommercetoolsAPI;
-
-  constructor(
-    config: CommercetoolsConfiguration,
-    cache: Cache,
-    context: RequestContext,
-    commercetools: CommercetoolsAPI
-  ) {
-    super(cache, context);
-
-    this.config = config;
-    this.commercetools = commercetools;
-  }
-
-  protected async getClient() {
-    const client = await this.commercetools.getClient();
-    return client
-      .withProjectKey({ projectKey: this.config.projectKey })
-      .productProjections();
-  }
-
-  @Reactionary({
-    inputSchema: ProductQueryByIdSchema,
-    outputSchema: ProductSchema,
-    cache: true,
-    cacheTimeToLiveInSeconds: 300,
-    currencyDependentCaching: false,
-    localeDependentCaching: true
-  })
-  public override async getById(
-    payload: ProductQueryById
-  ): Promise<Result<Product>> {
-    const client = await this.getClient();
-    const remote = await client
-      .withKey({ key: payload.identifier.key })
-      .get()
-      .execute();
-    const value = this.parseSingle(remote.body);
-
-    return success(value);
-  }
-
-  @Reactionary({
-    inputSchema: ProductQueryBySlugSchema,
-    outputSchema: ProductSchema,
-    cache: true,
-    cacheTimeToLiveInSeconds: 300,
-    currencyDependentCaching: false,
-    localeDependentCaching: true
-  })
-  public override async getBySlug(
-    payload: ProductQueryBySlug
-  ): Promise<Result<Product, NotFoundError>> {
-    const client = await this.getClient();
-
-    const remote = await client
-      .get({
-        queryArgs: {
-          // FIXME: Hardcoded locale
-          where: 'slug(en = :slug)',
-          'var.slug': payload.slug,
-        },
-      })
-      .execute();
-
-    if (remote.body.count === 0) {
-      return error<NotFoundError>({
-        type: 'NotFound',
-        identifier: payload.slug,
-      });
-    }
-    const result = this.parseSingle(remote.body.results[0]);
-
-    return success(result);
-  }
-
-  @Reactionary({
-    inputSchema: ProductQueryBySKUSchema,
-    outputSchema: ProductSchema,
-    cache: true,
-    cacheTimeToLiveInSeconds: 300,
-    currencyDependentCaching: false,
-    localeDependentCaching: true
-  })
-  public override async getBySKU(
-    payload: ProductQueryBySKU
-  ): Promise<Result<Product>> {
-    const client = await this.getClient();
-
-    const remote = await client
-      .get({
-        queryArgs: {
-          staged: false,
-          limit: 1,
-          where: 'variants(sku in (:skus)) OR (masterVariant(sku in (:skus))) ',
-          'var.skus': [payload].map((p) => p.variant.sku),
-        },
-      })
-      .execute();
-
-    const result = this.parseSingle(remote.body.results[0]);
-
-    return success(result);
-  }
-
-  protected parseSingle(data: ProductProjection): Product {
-    const identifier = { key: data.key || data.id } satisfies ProductIdentifier;
-    const name = data.name[this.context.languageContext.locale];
-    const slug = data.slug[this.context.languageContext.locale];
-
-    let description = '';
-    if (data.description) {
-      description = data.description[this.context.languageContext.locale];
-    }
-
-    const variantLevelAttributes =
-      data.masterVariant.attributes?.map((x) => this.parseAttribute(x)) || [];
-
-
-    const specialAttributes = [
-      'reactionaryaccessories',
-      'reactionaryspareparts',
-      'reactionaryreplacements'
-    ]
-
-    const productLevelAttributes =
-      data.attributes.filter(x => !specialAttributes.includes(x.name)).map((x) => this.parseAttribute(x)) || [];
-
-    const sharedAttributes = [
-      ...productLevelAttributes,
-      ...variantLevelAttributes,
-    ];
-    const mainVariant = this.parseVariant(data.masterVariant, data);
-
-    const otherVariants = [];
-    for (const variant of data.variants || []) {
-      if (variant.id !== data.masterVariant.id) {
-        otherVariants.push(this.parseVariant(variant, data));
-      }
-    }
-
-    const result = {
-      identifier,
-      name,
-      slug,
-      description,
-      sharedAttributes,
-      mainVariant,
-      brand: '',
-      longDescription: '',
-      manufacturer: '',
-      options: [],
-      parentCategories: [],
-      published: true,
-      variants: otherVariants,
-    } satisfies Product;
-
-    return result;
-  }
-
-  /**
-   * Return true, if the attribute is a defining attribute (ie an option)
-   * @param attr a variant attribute
-   * @returns true if the attribute is an option
-   */
-  protected isVariantAttributeAnOption(attr: CTAttribute): boolean {
-    // for now, the assumption is that any variant attribute is a defining attribute (ie an option)
-    // ideally this should be verified with the product type.
-    return true;
-  }
-
-  protected parseVariant(
-    variant: CTProductVariant,
-    product: ProductProjection
-  ): ProductVariant {
-    const identifier = {
-      sku: variant.sku!,
-    } satisfies ProductVariantIdentifier;
-
-    const images = [
-      ...(variant.images || []).map((img) =>
-        ImageSchema.parse({
-          sourceUrl: img.url,
-          altText: img.label || '',
-          width: img.dimensions?.w,
-          height: img.dimensions?.h,
-        } satisfies Image)
-      ),
-    ];
-
-    const options =
-      (variant.attributes ?? [])
-        .filter((attr) => this.isVariantAttributeAnOption(attr))
-        .map((attr) => {
-          const attrVal = this.parseAttributeValue(attr);
-          const optionIdentifier: ProductOptionIdentifier = {
-            key: attr.name,
-          };
-          const option: ProductVariantOption = {
-            identifier: optionIdentifier,
-            name: attr.name,
-            value: {
-              identifier: {
-                key: attrVal.value,
-                option: optionIdentifier,
-              },
-              label: attrVal.label,
-            },
-          };
-          return option;
-        }) || [];
-
-    const result = {
-      identifier,
-      images,
-      barcode: '',
-      ean: '',
-      gtin: '',
-      name: product.name[this.context.languageContext.locale],
-      options,
-      upc: '',
-    } satisfies ProductVariant;
-
-    return result;
-  }
-
-  protected parseAttribute(attr: CTAttribute): ProductAttribute {
-    const result = ProductAttributeSchema.parse({
-      identifier: ProductAttributeIdentifierSchema.parse({
-        key: attr.name,
-      } satisfies Partial<ProductAttributeIdentifier>),
-      group: '',
-      name: attr.name,
-      values: [this.parseAttributeValue(attr)],
-    } satisfies Partial<ProductAttribute>);
-
-    return result;
-  }
-
-  protected parseAttributeValue(attr: CTAttribute): ProductAttributeValue {
-    let attrValue = '';
-    if (attr.value && Array.isArray(attr.value)) {
-      attrValue = attr.value[0];
-    }
-
-    if (attr.value && typeof attr.value === 'object') {
-      if (this.context.languageContext.locale in attr.value) {
-        attrValue = attr.value[this.context.languageContext.locale];
-      } else {
-        attrValue = '-';
-      }
-    }
-
-    if (typeof attr.value === 'string') {
-      attrValue = attr.value;
-    }
-
-    const attrVal = ProductAttributeValueSchema.parse({
-      identifier: ProductAttributeValueIdentifierSchema.parse({
-        key: attrValue,
-      } satisfies Partial<ProductAttributeValueIdentifier>),
-      value: String(attrValue),
-      label: String(attrValue),
-    } satisfies Partial<ProductAttributeValue>);
-
-    return attrVal;
-  }
-}

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

@@ -1,22 +0,0 @@
-import { CapabilitiesSchema } from "@reactionary/core";
-import type * as z from 'zod';
-
-export const CommercetoolsCapabilitiesSchema = CapabilitiesSchema.pick({
-    product: true,
-    productSearch: true,
-    productAssociations: true,
-    productReviews: true,
-    productList: true,
-    identity: true,
-    cart: true,
-    checkout: true,
-    order: true,
-    orderSearch: true,
-    inventory: true,
-    price: true,
-    category: true,
-    store: true,
-    profile: true
-}).partial();
-
-export type CommercetoolsCapabilities = z.infer<typeof CommercetoolsCapabilitiesSchema>;

package/providers/commercetools/tsconfig.lib.json

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

package/providers/commercetools/tsconfig.spec.json

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

package/providers/commercetools/vitest.config.ts

@@ -1,15 +0,0 @@
-/// <reference types="vitest" />
-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,js}', 'src/**/*.test.ts'],
-  },
-});

package/providers/fake/README.md

@@ -1,23 +0,0 @@
-# Fake provider for Reactionary
-
-## Supports
-
-
-
-| Feature | Support | Notes |
-| -----------   | ----------- | --------- |
-| product       | Full      |          |
-| productSearch | Full     |  |
-| identity | Full     | |
-| cart | Full     |  |
-| checkout | Planned     |  |
-| order | Planned     |  |
-| inventory | Full     |  |
-| price | Full   |  |
-| category | Full     |  |
-| store | Full    |  |
-
-
-## Notes
-
-Not as many different product names as we would have liked. Maybe we need to create our own faker test data.

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

@@ -1,105 +0,0 @@
-import type {
-  Cache as ReactinaryCache,
-  RequestContext,
-  ClientFromCapabilities,
-} from '@reactionary/core';
-import { FakeProductProvider } from '../providers/product.provider.js';
-import { FakeSearchProvider } from '../providers/product-search.provider.js';
-import type { FakeConfiguration } from '../schema/configuration.schema.js';
-import type { FakeCapabilities } from '../schema/capabilities.schema.js';
-import { FakeCategoryProvider } from '../providers/category.provider.js';
-import {
-  FakeCartProvider,
-  FakeIdentityProvider,
-  FakeInventoryProvider,
-  FakePriceProvider,
-  FakeStoreProvider,
-} from '../providers/index.js';
-import { FakeCheckoutProvider } from '../providers/checkout.provider.js';
-import { FakeOrderSearchProvider } from '../providers/order-search.provider.js';
-import { FakeOrderProvider } from '../providers/order.provider.js';
-import { FakeProfileProvider } from '../providers/profile.provider.js';
-import { FakeProductReviewsProvider } from '../providers/product-reviews.provider.js';
-import { FakeProductAssociationsProvider } from '../providers/product-associations.provider.js';
-
-export function withFakeCapabilities<T extends FakeCapabilities>(
-  configuration: FakeConfiguration,
-  capabilities: T
-) {
-  return (
-    cache: ReactinaryCache,
-    context: RequestContext
-  ): ClientFromCapabilities<T> => {
-    const client: any = {};
-
-    if (capabilities.product) {
-      client.product = new FakeProductProvider(configuration, cache, context);
-    }
-
-    if (capabilities.productSearch) {
-      client.productSearch = new FakeSearchProvider(
-        configuration,
-        cache,
-        context
-      );
-    }
-
-    if (capabilities.category) {
-      client.category = new FakeCategoryProvider(configuration, cache, context);
-    }
-
-    if (capabilities.cart) {
-      client.cart = new FakeCartProvider(configuration, cache, context);
-    }
-
-    if (capabilities.inventory) {
-      client.inventory = new FakeInventoryProvider(
-        configuration,
-        cache,
-        context
-      );
-    }
-
-    if (capabilities.store) {
-      client.store = new FakeStoreProvider(configuration, cache, context);
-    }
-
-    if (capabilities.price) {
-      client.price = new FakePriceProvider(configuration, cache, context);
-    }
-
-    if (capabilities.identity) {
-      client.identity = new FakeIdentityProvider(configuration, cache, context);
-    }
-
-    if (capabilities.checkout) {
-      client.checkout = new FakeCheckoutProvider(configuration, cache, context);
-    }
-
-    if (capabilities.orderSearch) {
-      client.orderSearch = new FakeOrderSearchProvider(
-        configuration,
-        cache,
-        context
-      );
-    }
-
-    if (capabilities.order) {
-      client.order = new FakeOrderProvider(configuration, cache, context);
-    }
-
-    if (capabilities.profile) {
-      client.profile = new FakeProfileProvider(configuration, cache, context);
-    }
-
-    if (capabilities.productReviews) {
-      client.productReviews = new FakeProductReviewsProvider(configuration, cache, context);
-    }
-
-    if (capabilities.productAssociations) {
-      client.productAssociations = new FakeProductAssociationsProvider(configuration, cache, context);
-    }
-
-    return client;
-  };
-}

package/providers/fake/src/providers/category.provider.ts

@@ -1,184 +0,0 @@
-import type { Result, NotFoundError, Category, CategoryPaginatedResult, CategoryQueryById, CategoryQueryBySlug, CategoryQueryForBreadcrumb, CategoryQueryForChildCategories, CategoryQueryForTopCategories, RequestContext} from "@reactionary/core";
-import { success, error, CategoryPaginatedResultSchema, CategoryProvider, CategoryQueryByIdSchema, CategoryQueryBySlugSchema, CategoryQueryForBreadcrumbSchema, CategoryQueryForChildCategoriesSchema, CategoryQueryForTopCategoriesSchema, CategorySchema, Reactionary } from "@reactionary/core";
-import type { FakeConfiguration } from "../schema/configuration.schema.js";
-import type { Cache as ReactionaryCache } from "@reactionary/core";
-import * as z from "zod";
-import { Faker, en, base } from '@faker-js/faker';
-
-export class FakeCategoryProvider extends CategoryProvider {
-
-  protected config: FakeConfiguration;
-
-  protected topCategories = new Array<Category>();
-  protected childCategories = new Map<string, Array<Category>>();
-  protected allCategories = new Map<string, Category>();
-
-  protected categoryGenerator: Faker;
-
-  protected generateFakeCategory(parent: Category | undefined, index: number): Category {
-    let name: string;
-    if (!parent) {
-      name = this.categoryGenerator.commerce.department();
-    } else {
-      name = `${parent.name}-${index}`;
-    }
-
-    const identifier = { key: name.toLowerCase().replace(/\s+/g, '-') };
-    const text = this.categoryGenerator.lorem.sentences(3);
-    const slug = identifier.key + '-slug';
-
-    let parentCategory;
-    if (parent) {
-      parentCategory = parent.identifier;
-    }
-
-    const category = {
-      identifier,
-      images: [],
-      name,
-      slug,
-      text,
-      parentCategory
-    } satisfies Category;
-
-    this.allCategories.set(identifier.key, category);
-    return category;
-  }
-
-
-  constructor(config: FakeConfiguration, cache: ReactionaryCache, context: RequestContext) {
-    super(cache, context);
-    this.config = config;
-    this.categoryGenerator = new Faker({
-      seed: this.config.seeds.category,
-      locale: [en, base],
-    });
-
-    // Generate some top-level categories
-    for (let i = 0; i < 6; i++) {
-      const category = this.generateFakeCategory(undefined, i);
-      this.topCategories.push(category);
-    }
-
-    // Generate two levels of child categories
-    this.topCategories.forEach((parentCategory) => {
-      const children = new Array<Category>();
-      for (let j = 0; j < 5; j++) {
-        const childCategory = this.generateFakeCategory(parentCategory, j);
-        children.push(childCategory);
-
-
-        const subCategoryChildren = new Array<Category>();
-        for(let k = 0; k < 5; k++) {
-          const subChildCategory = this.generateFakeCategory(childCategory, k);
-          subCategoryChildren.push(subChildCategory);
-        }
-        this.childCategories.set(childCategory.identifier.key, subCategoryChildren);
-      }
-      this.childCategories.set(parentCategory.identifier.key, children);
-    });
-  }
-
-  @Reactionary({
-    inputSchema: CategoryQueryByIdSchema,
-    outputSchema: CategorySchema
-  })
-  public override async getById(payload: CategoryQueryById): Promise<Result<Category, NotFoundError>> {
-    const category = this.allCategories.get(payload.id.key);
-
-    if(!category) {
-      return error<NotFoundError>({
-        type: 'NotFound',
-        identifier: payload
-      });
-    }
-
-    return success(category);
-  }
-
-  @Reactionary({
-    inputSchema: CategoryQueryBySlugSchema,
-    outputSchema: CategorySchema
-  })
-  public override async getBySlug(payload: CategoryQueryBySlug): Promise<Result<Category, NotFoundError>> {
-    for(const p of this.allCategories.values()) {
-      if(p.slug === payload.slug) {
-        return success(p);
-      }
-    }
-    return error<NotFoundError>({
-      type: 'NotFound',
-      identifier: payload
-    });
-  }
-
-  @Reactionary({
-    inputSchema: CategoryQueryForBreadcrumbSchema,
-    outputSchema: z.array(CategorySchema)
-  })
-  public override async getBreadcrumbPathToCategory(payload: CategoryQueryForBreadcrumb): Promise<Result<Category[]>> {
-    const path = new Array<Category>();
-    let category = this.allCategories.get(payload.id.key);
-    path.push(category!);
-    while(category?.parentCategory) {
-      category = this.allCategories.get(category.parentCategory.key);
-      if(category) {
-        path.unshift(category);
-      }
-    }
-    return success(path);
-  }
-
-  @Reactionary({
-    inputSchema: CategoryQueryForChildCategoriesSchema,
-    outputSchema: CategoryPaginatedResultSchema
-  })
-  public override async findChildCategories(payload: CategoryQueryForChildCategories): Promise<Result<CategoryPaginatedResult>> {
-    const children = this.childCategories.get(payload.parentId.key);
-    const page = children?.slice((payload.paginationOptions.pageNumber - 1) * payload.paginationOptions.pageSize, payload.paginationOptions.pageNumber * payload.paginationOptions.pageSize);
-
-    const res = {
-      meta: {
-        placeholder: false,
-        cache: {
-          hit: false,
-          key: 'child-categories-' + payload.parentId.key + '-' + payload.paginationOptions.pageNumber + '-' + payload.paginationOptions.pageSize,
-        },
-      },
-      items: page ? page : [],
-      totalCount: children ? children.length : 0,
-      pageNumber: payload.paginationOptions.pageNumber,
-      pageSize: payload.paginationOptions.pageSize,
-      totalPages: children ? Math.ceil(children.length / payload.paginationOptions.pageSize) : 1,
-    };
-
-    return success(res);
-  }
-
-  @Reactionary({
-    inputSchema: CategoryQueryForTopCategoriesSchema,
-    outputSchema: CategoryPaginatedResultSchema
-  })
-  public override async findTopCategories(payload: CategoryQueryForTopCategories): Promise<Result<CategoryPaginatedResult>> {
-    const children = this.topCategories;
-    const page = children?.slice((payload.paginationOptions.pageNumber - 1) * payload.paginationOptions.pageSize, payload.paginationOptions.pageNumber * payload.paginationOptions.pageSize);
-
-    const res = {
-      meta: {
-        placeholder: false,
-        cache: {
-          hit: false,
-          key: 'top' + '-' + payload.paginationOptions.pageNumber + '-' + payload.paginationOptions.pageSize,
-        },
-      },
-      items: page ? page : [],
-      totalCount: children ? children.length : 0,
-      pageNumber: payload.paginationOptions.pageNumber,
-      pageSize: payload.paginationOptions.pageSize,
-      totalPages: children ? Math.ceil(children.length / payload.paginationOptions.pageSize) : 1,
-    };
-
-    return success(res);
-  }
-
-}

package/providers/fake/src/providers/index.ts

@@ -1,15 +0,0 @@
-export * from './analytics.provider.js';
-export * from './cart.provider.js';
-export * from './category.provider.js';
-export * from './checkout.provider.js';
-export * from './identity.provider.js';
-export * from './inventory.provider.js';
-export * from './order-search.provider.js';
-export * from './order.provider.js';
-export * from './price.provider.js';
-export * from './product.provider.js';
-export * from './product-associations.provider.js';
-export * from './product-reviews.provider.js';
-export * from './product-search.provider.js';
-export * from './profile.provider.js';
-export * from './store.provider.js';