@mframework/layer-commerce 0.0.3

package/app/utils/Validator/Validator.type.ts

@@ -0,0 +1,47 @@
+/**
+ * M Framework - Flexible backend agnostic framework.
+ *
+ * Copyright © Meeovi, LTD. All rights reserved.
+ * See LICENSE for license details.
+ *
+ * @license OSL-3.0 (Open Software License ("OSL") v. 3.0)
+ * @package mframework/mframework-theme
+ * @link https://github.com/meeovi/mframework
+ */
+
+import { FieldType } from 'Component/Field/Field.config';
+
+export interface ValidationRule {
+    isRequired?: boolean;
+    inputType?: string;
+    selector?: string;
+    match?: string
+    | ((value: string | Record<string, string | boolean>[] | undefined) => boolean)
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    | ((...args: any[]) => boolean | string);
+    range?: { min?: number; max?: number; showLengthError?: boolean };
+    fileExtension?: Record<string, string>;
+    customErrorMessages?: Record<string, string>;
+}
+
+export interface ValidationOutput {
+    value: string | boolean;
+    errorMessages: string[];
+}
+
+export interface ValidationDOMOutput {
+    values?: {
+        name: string;
+        value: string | boolean;
+        type: string;
+    }[];
+    errorFields?: unknown[];
+    errorMessages?: string[];
+}
+
+export interface FieldValidationOutput {
+    errorMessages?: string[];
+    name?: string;
+    type: any;
+    value?: string | boolean;
+}

package/app/utils/Validator/index.ts

@@ -0,0 +1,12 @@
+/**
+ * M Framework - Flexible backend agnostic framework.
+ *
+ * Copyright © Meeovi, LTD. All rights reserved.
+ * See LICENSE for license details.
+ *
+ * @license OSL-3.0 (Open Software License ("OSL") v. 3.0)
+ * @package mframework/mframework
+ * @link https://github.com/meeovi/mframework
+ */
+
+export * from './Validator';

package/app/utils/Wishlist/Wishlist.ts

@@ -0,0 +1,65 @@
+/**
+* M Framework - Flexible backend agnostic framework.
+*
+* Copyright © Meeovi, LTD. All rights reserved.
+* See LICENSE for license details.
+*
+* @license OSL-3.0 (Open Software License ("OSL") v. 3.0)
+* @package mframework/mframework
+* @link https://github.com/meeovi/mframework
+*/
+
+import {
+    PriceRange,
+    ProductDiscount,
+    ProductItem,
+    ProductPrice,
+} from '../../normalizers/ProductList.type';
+import { Product as DomainProduct } from '../../types/domain';
+
+/**
+ * Updates wishlist item price for option based products
+ * @param {Object} product
+ * @namespace ../../utils/Wishlist/getPriceRange
+ */
+export const getPriceRange = (
+    product: ProductItem | DomainProduct,
+    price: number,
+    priceWithoutTax: number,
+    discount: ProductDiscount | number = 0,
+): { price_range?: PriceRange } => {
+    if (!price) {
+        return {};
+    }
+
+    const {
+        price_range: {
+            minimum_price: {
+                regular_price: {
+                    currency,
+                } = {},
+            },
+        },
+    } = product;
+
+    const priceCurrencyValue = { value: price, currency };
+    const priceCurrencyValueExclTax = { value: priceWithoutTax, currency };
+
+    const priceSection = {
+        final_price: priceCurrencyValue,
+        regular_price: priceCurrencyValue,
+        final_price_excl_tax: priceCurrencyValueExclTax,
+        regular_price_excl_tax: priceCurrencyValueExclTax,
+        default_final_price_excl_tax: priceCurrencyValueExclTax,
+        discount,
+    } as ProductPrice;
+
+    return {
+        price_range: {
+            minimum_price: priceSection,
+            maximum_price: priceSection,
+        },
+    };
+};
+
+export default getPriceRange;

package/app/utils/Wishlist/index.ts

@@ -0,0 +1,12 @@
+/**
+ * M Framework - Flexible backend agnostic framework.
+ *
+ * Copyright © Meeovi, LTD. All rights reserved.
+ * See LICENSE for license details.
+ *
+ * @license OSL-3.0 (Open Software License ("OSL") v. 3.0)
+ * @package mframework/mframework
+ * @link https://github.com/meeovi/mframework
+ */
+
+export * from './Wishlist';

package/app/utils/client.ts

@@ -0,0 +1,280 @@
+import * as CommercePkg from '~/types';
+import { sdk } from '@mframework/sdk';
+import imports from '../types';
+import { normalizeProductsQueryOutput, normalizeProduct } from '../normalizers/ProductList.type';
+import { normalizeCart } from '../normalizers/Cart.type';
+import { normalizeOrder } from '../normalizers/Order.type';
+import { normalizeReview } from '../normalizers/Review.type';
+import { normalizeGiftCard, normalizeGiftCards } from '../normalizers/GiftCard.type';
+import { normalizeSubscription, normalizeSubscriptions } from '../normalizers/Subscription.type';
+import { normalizeReturn, normalizeReturns } from '../normalizers/Return.type';
+import { normalizeCreditMemo, normalizeCreditMemos } from '../normalizers/CreditMemo.type';
+import { normalizeInvoice, normalizeInvoices } from '../normalizers/Invoice.type';
+import { normalizeTransaction, normalizeTransactions } from '../normalizers/Transaction.type';
+import { normalizePayment, normalizePayments } from '../normalizers/Payment.type';
+
+function getRawCommerceClient(provider?: string, config?: any): any {
+  try {
+    if (typeof (imports as any)?.createClient === 'function') {
+      return (imports as any).createClient(provider, config);
+    }
+    if (typeof (imports as any)?.init === 'function') {
+      return (imports as any).init(config);
+    }
+    if ((imports as any).commerce) return (imports as any).commerce;
+  } catch (e) {
+    // ignore and continue to other fallbacks
+  }
+
+  try {
+    const CommerceAny: any = CommercePkg as any;
+    if (typeof CommerceAny?.createClient === 'function') return CommerceAny.createClient(provider, config);
+    if (typeof CommerceAny?.init === 'function') return CommerceAny.init(config);
+    if (CommerceAny?.commerce) return CommerceAny.commerce;
+  } catch (e) {
+    // ignore and fallback to sdk
+  }
+
+  return (sdk as any)?.commerce || null;
+}
+
+function createNormalizedClient(client: any) {
+  if (!client) return client;
+  if ((client as any).__normalized) return client;
+
+  const wrapped: any = Object.create(client);
+
+  if (typeof client.listProducts === 'function') {
+    wrapped.listProducts = async (...args: any[]) => {
+      const res = await client.listProducts(...args);
+      try {
+        return normalizeProductsQueryOutput(res);
+      } catch (e) {
+        return res;
+      }
+    };
+  }
+
+  if (typeof client.getProductById === 'function') {
+    wrapped.getProductById = async (...args: any[]) => {
+      const res = await client.getProductById(...args);
+      try {
+        return normalizeProduct(res);
+      } catch (e) {
+        return res;
+      }
+    };
+  }
+
+  if (typeof client.getProductBySlug === 'function') {
+    wrapped.getProductBySlug = async (...args: any[]) => {
+      const res = await client.getProductBySlug(...args);
+      try {
+        return normalizeProduct(res);
+      } catch (e) {
+        return res;
+      }
+    };
+  }
+
+  if (typeof client.getProduct === 'function') {
+    wrapped.getProduct = async (...args: any[]) => {
+      const res = await client.getProduct(...args);
+      try {
+        return normalizeProduct(res);
+      } catch (e) {
+        return res;
+      }
+    };
+  }
+
+  const cartMethods = ['getCart', 'createCart', 'addToCart', 'updateCart', 'removeFromCart', 'applyCoupon', 'setShippingAddress'];
+  for (const m of cartMethods) {
+    if (typeof client[m] === 'function') {
+      wrapped[m] = async (...args: any[]) => {
+        const res = await client[m](...args);
+        try {
+          return normalizeCart(res);
+        } catch (e) {
+          return res;
+        }
+      };
+    }
+  }
+
+  // Order methods: normalize single orders and lists of orders
+  if (typeof client.listOrders === 'function') {
+    wrapped.listOrders = async (...args: any[]) => {
+      const res = await client.listOrders(...args);
+      try {
+        if (Array.isArray(res)) return res.map(normalizeOrder);
+        if (res && Array.isArray(res.items)) return res.items.map(normalizeOrder);
+        return res;
+      } catch (e) {
+        return res;
+      }
+    };
+  }
+
+  const orderSingles = ['getOrder', 'getOrderById', 'getOrders'];
+  for (const m of orderSingles) {
+    if (typeof client[m] === 'function') {
+      wrapped[m] = async (...args: any[]) => {
+        const res = await client[m](...args);
+        try {
+          return normalizeOrder(res);
+        } catch (e) {
+          return res;
+        }
+      };
+    }
+  }
+
+  // Returns
+  if (typeof client.listReturns === 'function') {
+    wrapped.listReturns = async (...args: any[]) => {
+      const res = await client.listReturns(...args);
+      try { if (Array.isArray(res)) return normalizeReturns(res); if (res && Array.isArray(res.items)) return normalizeReturns(res.items); return res; } catch (e) { return res; }
+    };
+  }
+  if (typeof client.getReturn === 'function') {
+    wrapped.getReturn = async (...args: any[]) => { const res = await client.getReturn(...args); try { return normalizeReturn(res); } catch (e) { return res; } };
+  }
+  if (typeof client.createReturn === 'function') {
+    wrapped.createReturn = async (...args: any[]) => { const res = await client.createReturn(...args); try { return normalizeReturn(res); } catch (e) { return res; } };
+  }
+
+  // Credit memos
+  if (typeof client.listCreditMemos === 'function') {
+    wrapped.listCreditMemos = async (...args: any[]) => {
+      const res = await client.listCreditMemos(...args);
+      try { if (Array.isArray(res)) return normalizeCreditMemos(res); if (res && Array.isArray(res.items)) return normalizeCreditMemos(res.items); return res; } catch (e) { return res; }
+    };
+  }
+  if (typeof client.getCreditMemo === 'function') {
+    wrapped.getCreditMemo = async (...args: any[]) => { const res = await client.getCreditMemo(...args); try { return normalizeCreditMemo(res); } catch (e) { return res; } };
+  }
+
+  // Invoices
+  if (typeof client.listInvoices === 'function') {
+    wrapped.listInvoices = async (...args: any[]) => {
+      const res = await client.listInvoices(...args);
+      try { if (Array.isArray(res)) return normalizeInvoices(res); if (res && Array.isArray(res.items)) return normalizeInvoices(res.items); return res; } catch (e) { return res; }
+    };
+  }
+  if (typeof client.getInvoice === 'function') {
+    wrapped.getInvoice = async (...args: any[]) => { const res = await client.getInvoice(...args); try { return normalizeInvoice(res); } catch (e) { return res; } };
+  }
+
+  // Transactions
+  if (typeof client.listTransactions === 'function') {
+    wrapped.listTransactions = async (...args: any[]) => {
+      const res = await client.listTransactions(...args);
+      try { if (Array.isArray(res)) return normalizeTransactions(res); if (res && Array.isArray(res.items)) return normalizeTransactions(res.items); return res; } catch (e) { return res; }
+    };
+  }
+  if (typeof client.getTransaction === 'function') {
+    wrapped.getTransaction = async (...args: any[]) => { const res = await client.getTransaction(...args); try { return normalizeTransaction(res); } catch (e) { return res; } };
+  }
+
+  // Payments
+  if (typeof client.listPayments === 'function') {
+    wrapped.listPayments = async (...args: any[]) => {
+      const res = await client.listPayments(...args);
+      try { if (Array.isArray(res)) return normalizePayments(res); if (res && Array.isArray(res.items)) return normalizePayments(res.items); return res; } catch (e) { return res; }
+    };
+  }
+  if (typeof client.getPayment === 'function') {
+    wrapped.getPayment = async (...args: any[]) => { const res = await client.getPayment(...args); try { return normalizePayment(res); } catch (e) { return res; } };
+  }
+  if (typeof client.createPaymentIntent === 'function') {
+    wrapped.createPaymentIntent = async (...args: any[]) => { const res = await client.createPaymentIntent(...args); try { return normalizePayment(res); } catch (e) { return res; } };
+  }
+  if (typeof client.createPayment === 'function') {
+    wrapped.createPayment = async (...args: any[]) => { const res = await client.createPayment(...args); try { return normalizePayment(res); } catch (e) { return res; } };
+  }
+  if (typeof client.capturePayment === 'function') {
+    wrapped.capturePayment = async (...args: any[]) => { const res = await client.capturePayment(...args); try { return normalizePayment(res); } catch (e) { return res; } };
+  }
+  if (typeof client.refundPayment === 'function') {
+    wrapped.refundPayment = async (...args: any[]) => { const res = await client.refundPayment(...args); try { return normalizePayment(res); } catch (e) { return res; } };
+  }
+
+  // Reviews
+  if (typeof client.listReviews === 'function') {
+    wrapped.listReviews = async (...args: any[]) => {
+      const res = await client.listReviews(...args);
+      try {
+        if (Array.isArray(res)) return res.map(normalizeReview);
+        if (res && Array.isArray(res.items)) return res.items.map(normalizeReview);
+        return res;
+      } catch (e) {
+        return res;
+      }
+    };
+  }
+
+  if (typeof client.getReview === 'function') {
+    wrapped.getReview = async (...args: any[]) => {
+      const res = await client.getReview(...args);
+      try { return normalizeReview(res); } catch (e) { return res; }
+    };
+  }
+
+  // Gift cards
+  if (typeof client.listGiftCards === 'function') {
+    wrapped.listGiftCards = async (...args: any[]) => {
+      const res = await client.listGiftCards(...args);
+      try { return normalizeGiftCards(res); } catch (e) { return res; }
+    };
+  }
+  if (typeof client.getGiftCard === 'function') {
+    wrapped.getGiftCard = async (...args: any[]) => {
+      const res = await client.getGiftCard(...args);
+      try { return normalizeGiftCard(res); } catch (e) { return res; }
+    };
+  }
+
+  if (typeof client.redeemGiftCard === 'function') {
+    wrapped.redeemGiftCard = async (...args: any[]) => {
+      const res = await client.redeemGiftCard(...args);
+      try { return normalizeGiftCard(res); } catch (e) { return res; }
+    };
+  }
+
+  // Subscriptions
+  if (typeof client.listSubscriptions === 'function') {
+    wrapped.listSubscriptions = async (...args: any[]) => {
+      const res = await client.listSubscriptions(...args);
+      try { return normalizeSubscriptions(res); } catch (e) { return res; }
+    };
+  }
+  if (typeof client.getSubscription === 'function') {
+    wrapped.getSubscription = async (...args: any[]) => {
+      const res = await client.getSubscription(...args);
+      try { return normalizeSubscription(res); } catch (e) { return res; }
+    };
+  }
+  if (typeof client.subscribe === 'function') {
+    wrapped.subscribe = async (...args: any[]) => {
+      const res = await client.subscribe(...args);
+      try { return normalizeSubscription(res); } catch (e) { return res; }
+    };
+  }
+
+  (wrapped as any).__normalized = true;
+  return wrapped;
+}
+
+/**
+ * Returns a commerce client. This exported function now returns a thin
+ * compatibility wrapper around provider clients so common methods return
+ * normalized domain shapes when possible. Under the hood it still prefers
+ * layer-local providers and falls back to package-level APIs and the SDK.
+ */
+export function getCommerceClient(provider?: string, config?: any): any {
+  const raw = getRawCommerceClient(provider, config);
+  return createNormalizedClient(raw);
+}
+
+export default getCommerceClient;

package/app/utils/index.ts

@@ -0,0 +1,53 @@
+import { NormalizerRegistry, CommerceNormalizer } from '../utils/normalizer';
+
+// Keep imports loose because host `@mframework/commerce` implementations may vary
+import * as CommercePkg from '~/types';
+const CommerceAny: any = CommercePkg as any;
+
+export type Provider = string;
+
+export interface CommerceLayerConfig {
+  provider: Provider;
+  providerConfig?: Record<string, any>;
+  normalizer?: CommerceNormalizer;
+  registry?: NormalizerRegistry;
+}
+
+export function createCommerceLayer(config: CommerceLayerConfig) {
+  const registry = config.registry ?? new NormalizerRegistry();
+  const normalizer = config.normalizer ?? registry.get(config.provider);
+
+  if (!normalizer) {
+    throw new Error('No normalizer found for provider: ' + config.provider);
+  }
+
+  // Create or obtain a client from `@mframework/commerce` in a resilient way
+  const client = ((): any => {
+    try {
+      if (typeof CommerceAny.createClient === 'function') {
+        return CommerceAny.createClient(config.provider, config.providerConfig);
+      }
+      if (typeof CommerceAny.init === 'function') {
+        return CommerceAny.init(config.providerConfig);
+      }
+      return CommerceAny;
+    } catch (e) {
+      // In production, surface useful message while avoiding leaking secrets
+      throw new Error('Failed to initialize commerce client for provider: ' + config.provider);
+    }
+  })();
+
+  async function getProduct(id: string) {
+    const raw = await (client.getProduct?.(id) ?? client.fetchProduct?.(id) ?? client.product?.(id));
+    return normalizer!.normalizeProduct(raw);
+  }
+
+  return {
+    client,
+    getProduct,
+    registry,
+    normalizer,
+  } as const;
+}
+
+export default createCommerceLayer;

package/app/utils/normalizer.ts

@@ -0,0 +1,23 @@
+export interface CommerceNormalizer {
+  normalizeProduct(data: any): any;
+  normalizeCategory?(data: any): any;
+  normalizeCart?(data: any): any;
+}
+
+export class NormalizerRegistry {
+  private registry = new Map<string, CommerceNormalizer>();
+
+  register(name: string, normalizer: CommerceNormalizer) {
+    this.registry.set(name, normalizer);
+  }
+
+  get(name: string): CommerceNormalizer | undefined {
+    return this.registry.get(name);
+  }
+
+  list(): string[] {
+    return Array.from(this.registry.keys());
+  }
+}
+
+export default NormalizerRegistry;

package/app/utils/normalizers/magento.ts

@@ -0,0 +1,29 @@
+import { CommerceNormalizer } from "../normalizer";
+
+export const magentoNormalizer: CommerceNormalizer = {
+  normalizeProduct(data: any) {
+    return {
+      id: data?.id ?? data?.sku ?? data?.item_id,
+      title: data?.name ?? data?.title,
+      price:
+        data?.price ?? data?.price_range?.minimum_price?.final_price?.value,
+      description: data?.description ?? data?.short_description,
+      images: (data?.media_gallery_entries ?? []).map((m: any) => m.file || m.url),
+      raw: data,
+    };
+  },
+
+  normalizeCategory(data: any) {
+    return {
+      id: data?.id,
+      name: data?.name,
+      raw: data,
+    };
+  },
+
+  normalizeCart(data: any) {
+    return { raw: data };
+  },
+};
+
+export default magentoNormalizer;

package/app/utils/normalizers/shopify.ts

@@ -0,0 +1,29 @@
+import { CommerceNormalizer } from "../normalizer";
+
+export const shopifyNormalizer: CommerceNormalizer = {
+  normalizeProduct(data: any) {
+    // Shopify payloads vary depending on SDK; this maps common fields
+    return {
+      id: data?.id ?? data?.variants?.[0]?.id,
+      title: data?.title ?? data?.name,
+      price: data?.variants?.[0]?.price ?? data?.price,
+      description: data?.body_html ?? data?.description,
+      images: (data?.images ?? []).map((i: any) => i?.src || i?.url),
+      raw: data,
+    };
+  },
+
+  normalizeCategory(data: any) {
+    return {
+      id: data?.id,
+      name: data?.title ?? data?.name,
+      raw: data,
+    };
+  },
+
+  normalizeCart(data: any) {
+    return { raw: data };
+  },
+};
+
+export default shopifyNormalizer;

package/nuxt.config.ts

@@ -0,0 +1,11 @@
+import {
+  defineNuxtConfig
+} from 'nuxt/config'
+
+export default defineNuxtConfig({
+  $meta: {
+    name: 'commerce',
+  },
+
+  runtimeConfig: {}
+})

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "@mframework/layer-commerce",
+  "version": "0.0.3",
+  "description": "Commerce Layer for the M Framework",
+  "keywords": [
+    "commerce",
+    "mframework-framework",
+    "nuxt",
+    "layer"
+  ],
+  "license": "MIT",
+  "author": "M Framework",
+  "type": "module",
+  "main": "./nuxt.config.ts",
+  "scripts": {
+    "test": "vitest",
+    "build": "tsc -p tsconfig.json",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "lint": "eslint 'src/**/*.{ts,tsx}' || true",
+    "prepare": "npm run build",
+    "prepublishOnly": "npm run typecheck && npm run build",
+    "codegen": "npx graphql-codegen --config ./node_modules/@mframework/adapter-magento/codegen.ts"
+  },
+  "dependencies": {
+    "@better-auth/stripe": "^1.4.15",
+    "@mframework/core": "^0.0.1",
+    "@mframework/sdk": "^0.0.2",
+    "@polar-sh/sdk": "^0.42.2",
+    "@storefront-ui/nuxt": "^3.1.1",
+    "@tilework/opus": "^0.0.12",
+    "history": "^5.3.0",
+    "jwt-decode": "^4.0.0",
+    "lodash-es": "^4.17.23"
+  },
+  "devDependencies": {
+    "@biomejs/biome": "^2.3.11",
+    "@vitest/coverage-v8": "^4.0.17",
+    "eslint": "^8.0.0",
+    "jest-cucumber": "^4.5.0",
+    "nuxt": "^4.3.0",
+    "typescript": "^5.8.2"
+  }
+}

package/tsconfig.json

@@ -0,0 +1,45 @@
+{
+  "compilerOptions": {
+    "types": ["node", "vitest", "vue", "pinia"],
+    "baseUrl": ".",
+    "paths": {
+      "~/*": ["app/*", "./*"],
+      "@/*": ["app/*", "./*"],
+      "Util/*": ["app/utils/*"],
+      "Query/*": ["app/normalizers/*"],
+      "Component/*": ["app/components/*"],
+      "Store/*": ["app/stores/*"],
+      "Type/*": ["app/types/*"],
+      "../../routes/*": ["app/routes/*"],
+      "#imports": ["app/imports"],
+      "~/app/*": ["app/*"]
+    },
+    "declaration": true,
+    "emitDeclarationOnly": false,
+    "outDir": "dist",
+    "moduleResolution": "bundler",
+    "module": "ESNext",
+    "target": "ESNext",
+    "strict": false,
+    "jsx": "preserve",
+    "skipLibCheck": true,
+    "noEmitOnError": false
+  },
+  "include": [
+    "src",
+    "index.ts",
+    "app",
+    "app/**/*.vue",
+    "app/types",
+    "global.d.ts",
+    "app/utils/client.ts",
+    "app/utils/normalizers"
+  ]
+  ,
+  "exclude": [
+    "**/__tests__/**",
+    "**/*.spec.ts",
+    "**/*.spec.tsx",
+    "node_modules"
+  ]
+}