@mframework/core 0.0.1

package/src/normalizers/factories/useUserBillingFactory.d.ts

@@ -0,0 +1,27 @@
+import { UseUserBilling, Context, FactoryParams, CustomQuery, PlatformApi } from '../types';
+export interface UseUserBillingFactoryParams<USER_BILLING, USER_BILLING_ITEM, API extends PlatformApi = any> extends FactoryParams<API> {
+    addAddress: (context: Context, params: {
+        address: Readonly<USER_BILLING_ITEM>;
+        billing: Readonly<USER_BILLING>;
+        customQuery?: CustomQuery;
+    }) => Promise<USER_BILLING>;
+    deleteAddress: (context: Context, params: {
+        address: Readonly<USER_BILLING_ITEM>;
+        billing: Readonly<USER_BILLING>;
+        customQuery?: CustomQuery;
+    }) => Promise<USER_BILLING>;
+    updateAddress: (context: Context, params: {
+        address: Readonly<USER_BILLING_ITEM>;
+        billing: Readonly<USER_BILLING>;
+        customQuery?: CustomQuery;
+    }) => Promise<USER_BILLING>;
+    load: (context: Context, params: {
+        billing: Readonly<USER_BILLING>;
+    }) => Promise<USER_BILLING>;
+    setDefaultAddress: (context: Context, params: {
+        address: Readonly<USER_BILLING_ITEM>;
+        billing: Readonly<USER_BILLING>;
+        customQuery?: CustomQuery;
+    }) => Promise<USER_BILLING>;
+}
+export declare const useUserBillingFactory: <USER_BILLING, USER_BILLING_ITEM, API extends PlatformApi = any>(factoryParams: UseUserBillingFactoryParams<USER_BILLING, USER_BILLING_ITEM, API>) => () => UseUserBilling<USER_BILLING, USER_BILLING_ITEM, API>;

package/src/normalizers/factories/useUserFactory.d.ts

@@ -0,0 +1,32 @@
+import { UseUser, Context, FactoryParams, CustomQuery, PlatformApi } from '../types';
+export interface UseUserFactoryParams<USER, UPDATE_USER_PARAMS, REGISTER_USER_PARAMS, API extends PlatformApi = any> extends FactoryParams<API> {
+    load: (context: Context, params?: {
+        customQuery: CustomQuery;
+    }) => Promise<USER>;
+    logOut: (context: Context, params?: {
+        currentUser: USER;
+    }) => Promise<void>;
+    updateUser: (context: Context, params: {
+        currentUser: USER;
+        updatedUserData: UPDATE_USER_PARAMS;
+        customQuery?: CustomQuery;
+    }) => Promise<USER>;
+    register: (context: Context, params: REGISTER_USER_PARAMS & {
+        customQuery?: CustomQuery;
+    }) => Promise<USER>;
+    logIn: (context: Context, params: {
+        username: string;
+        password: string;
+        customQuery?: CustomQuery;
+    }) => Promise<USER>;
+    changePassword: (context: Context, params: {
+        currentUser: USER;
+        currentPassword: string;
+        newPassword: string;
+        customQuery?: CustomQuery;
+    }) => Promise<USER>;
+}
+export declare const useUserFactory: <USER, UPDATE_USER_PARAMS, REGISTER_USER_PARAMS extends {
+    email: string;
+    password: string;
+}, API extends PlatformApi = any>(factoryParams: UseUserFactoryParams<USER, UPDATE_USER_PARAMS, REGISTER_USER_PARAMS, API>) => () => UseUser<USER, UPDATE_USER_PARAMS, API>;

package/src/normalizers/factories/useUserOrderFactory.d.ts

@@ -0,0 +1,7 @@
+import { CustomQuery, UseUserOrder, Context, FactoryParams, PlatformApi } from '../../../../normalizer-core/types';
+export interface UseUserOrderFactoryParams<ORDERS, ORDER_SEARCH_PARAMS, API extends PlatformApi = any> extends FactoryParams<API> {
+    searchOrders: (context: Context, params: ORDER_SEARCH_PARAMS & {
+        customQuery?: CustomQuery;
+    }) => Promise<ORDERS>;
+}
+export declare function useUserOrderFactory<ORDERS, ORDER_SEARCH_PARAMS, API extends PlatformApi = any>(factoryParams: UseUserOrderFactoryParams<ORDERS, ORDER_SEARCH_PARAMS, API>): () => UseUserOrder<ORDERS, ORDER_SEARCH_PARAMS, API>;

package/src/normalizers/factories/useUserShippingFactory.d.ts

@@ -0,0 +1,27 @@
+import { UseUserShipping, Context, FactoryParams, CustomQuery, PlatformApi } from '../types';
+export interface UseUserShippingFactoryParams<USER_SHIPPING, USER_SHIPPING_ITEM, API extends PlatformApi = any> extends FactoryParams<API> {
+    addAddress: (context: Context, params: {
+        address: Readonly<USER_SHIPPING_ITEM>;
+        shipping: Readonly<USER_SHIPPING>;
+        customQuery?: CustomQuery;
+    }) => Promise<USER_SHIPPING>;
+    deleteAddress: (context: Context, params: {
+        address: Readonly<USER_SHIPPING_ITEM>;
+        shipping: Readonly<USER_SHIPPING>;
+        customQuery?: CustomQuery;
+    }) => Promise<USER_SHIPPING>;
+    updateAddress: (context: Context, params: {
+        address: Readonly<USER_SHIPPING_ITEM>;
+        shipping: Readonly<USER_SHIPPING>;
+        customQuery?: CustomQuery;
+    }) => Promise<USER_SHIPPING>;
+    load: (context: Context, params: {
+        shipping: Readonly<USER_SHIPPING>;
+    }) => Promise<USER_SHIPPING>;
+    setDefaultAddress: (context: Context, params: {
+        address: Readonly<USER_SHIPPING_ITEM>;
+        shipping: Readonly<USER_SHIPPING>;
+        customQuery?: CustomQuery;
+    }) => Promise<USER_SHIPPING>;
+}
+export declare const useUserShippingFactory: <USER_SHIPPING, USER_SHIPPING_ITEM, API extends PlatformApi = any>(factoryParams: UseUserShippingFactoryParams<USER_SHIPPING, USER_SHIPPING_ITEM, API>) => () => UseUserShipping<USER_SHIPPING, USER_SHIPPING_ITEM, API>;

package/src/normalizers/factories/useWishlistFactory.d.ts

@@ -0,0 +1,24 @@
+import { UseWishlist, CustomQuery, Context, FactoryParams, PlatformApi } from '../types';
+export interface UseWishlistFactoryParams<WISHLIST, WISHLIST_ITEM, PRODUCT, API extends PlatformApi = any> extends FactoryParams<API> {
+    load: (context: Context, params: {
+        customQuery?: CustomQuery;
+    }) => Promise<WISHLIST>;
+    addItem: (context: Context, params: {
+        currentWishlist: WISHLIST;
+        product: PRODUCT;
+        customQuery?: CustomQuery;
+    }) => Promise<WISHLIST>;
+    removeItem: (context: Context, params: {
+        currentWishlist: WISHLIST;
+        product: WISHLIST_ITEM;
+        customQuery?: CustomQuery;
+    }) => Promise<WISHLIST>;
+    clear: (context: Context, params: {
+        currentWishlist: WISHLIST;
+    }) => Promise<WISHLIST>;
+    isInWishlist: (context: Context, params: {
+        currentWishlist: WISHLIST;
+        product: PRODUCT;
+    }) => boolean;
+}
+export declare const useWishlistFactory: <WISHLIST, WISHLIST_ITEM, PRODUCT, API extends PlatformApi = any>(factoryParams: UseWishlistFactoryParams<WISHLIST, WISHLIST_ITEM, PRODUCT, API>) => () => UseWishlist<WISHLIST, WISHLIST_ITEM, PRODUCT, API>;

package/src/normalizers/utils/context/index.d.ts

@@ -0,0 +1,8 @@
+import { Context } from '../../../../../normalizer-core/types';
+interface ContextConfiguration {
+    useVSFContext: () => Context;
+}
+declare let useVSFContext: () => Context<any, any, any>;
+declare const configureContext: (config: ContextConfiguration) => void;
+declare const generateContext: (factoryParams: any) => any;
+export { generateContext, useVSFContext, configureContext };

package/src/normalizers/utils/factoryParams/commonMethods.d.ts

@@ -0,0 +1,2 @@
+declare const createCommonMethods: (factoryParams: any, context: any) => any;
+export { createCommonMethods };

package/src/normalizers/utils/factoryParams/index.d.ts

@@ -0,0 +1,2 @@
+declare const configureFactoryParams: (factoryParams: any, refs?: any) => any;
+export { configureFactoryParams };

package/src/normalizers/utils/factoryParams/platformMethods.d.ts

@@ -0,0 +1,2 @@
+declare const createPlatformMethods: (apiSection: any, context: any, refs: any) => any;
+export { createPlatformMethods };

package/src/normalizers/utils/helpers/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Adds prefix with base path configured in router.base to provided url
+ * @param {string} path - url to which base path will be added
+ * @returns Relative path prefixed with router.base or not modified absolute path (it needs start from http or https)
+ */
+declare function addBasePath(path: string): string;
+export { addBasePath };

package/src/normalizers/utils/i18n-redirects/index.d.ts

@@ -0,0 +1,12 @@
+declare const i18nRedirectsUtil: ({ path, defaultLocale, availableLocales, cookieLocale, acceptedLanguages, autoRedirectByLocale }: {
+    path: string;
+    defaultLocale: string;
+    cookieLocale: string;
+    availableLocales: string[];
+    acceptedLanguages: string[];
+    autoRedirectByLocale: boolean;
+}) => {
+    getRedirectPath: () => string;
+    getTargetLocale: () => string;
+};
+export default i18nRedirectsUtil;

package/src/normalizers/utils/logger/defaultLogger.d.ts

@@ -0,0 +1,7 @@
+declare const defaultLogger: {
+    debug: any;
+    info: any;
+    warn: any;
+    error: any;
+};
+export default defaultLogger;

package/src/normalizers/utils/logger/index.d.ts

@@ -0,0 +1,5 @@
+import { VSFLogger } from '../../types';
+declare let Logger: VSFLogger;
+declare type LoggerImplementation = VSFLogger | ((verbosity: string) => VSFLogger);
+declare const registerLogger: (loggerImplementation: LoggerImplementation, verbosity: string) => void;
+export { Logger, registerLogger };

package/src/normalizers/utils/logger/makeMessageStyle.d.ts

@@ -0,0 +1,2 @@
+import { LogName } from './types';
+export declare function makeMessageStyle(logEnum: LogName): string[];

package/src/normalizers/utils/logger/makeMethod.d.ts

@@ -0,0 +1,2 @@
+import { LogName } from './types';
+export declare function makeMethod(logEnum: LogName, fn: Function): () => any;

package/src/normalizers/utils/logger/mask.d.ts

@@ -0,0 +1,2 @@
+declare const mask: (el: any) => any;
+export default mask;

package/src/normalizers/utils/logger/types.d.ts

@@ -0,0 +1,13 @@
+export declare enum LogName {
+    Error = "error",
+    Info = "info",
+    Debug = "debug",
+    None = "none",
+    Warn = "warn"
+}
+export declare const LogLevelStyle: {
+    Log: string;
+    Info: string;
+    Warn: string;
+    Error: string;
+};

package/src/normalizers/utils/logger/utils.d.ts

@@ -0,0 +1,4 @@
+export declare type LogMessage = string[] | Error | Record<string, any> | string | boolean;
+export declare const getMessage: (message: LogMessage) => string | undefined;
+export declare const detectNode: boolean;
+export declare const mountLog: (name: string, style: string) => string[];

package/src/normalizers/utils/shared/index.d.ts

@@ -0,0 +1,4 @@
+import { Ref } from 'vue';
+declare function sharedRef<T>(value: T, key: string): Ref;
+declare function sharedRef(key: string, _?: any): Ref;
+export { sharedRef };

package/src/normalizers/utils/ssr/index.d.ts

@@ -0,0 +1,11 @@
+import { Ref } from 'vue';
+
+declare type VsfRef = <T>(data?: T, key?: string) => Ref<T>;
+interface SSRConfiguration {
+    onSSR: (fn: () => void) => any;
+    vsfRef: VsfRef;
+}
+declare let onSSR: (callback: Function, target?: import("vue").ComponentInternalInstance) => Function;
+declare let vsfRef: VsfRef;
+declare const configureSSR: (config: SSRConfiguration) => void;
+export { onSSR, vsfRef, configureSSR };

package/src/normalizers/utils/wrap/index.d.ts

@@ -0,0 +1,3 @@
+import { Ref, UnwrapRef } from 'vue';
+
+export default function wrap<T>(element: Ref<UnwrapRef<T>> | T): Ref<UnwrapRef<T>>;

package/src/plugins/defineAdapter.ts

@@ -0,0 +1,5 @@
+import type { BaseAdapter } from '../adapters/common'
+
+export function defineM FrameworkAdapter<T extends BaseAdapter<any>>(adapter: T): T {
+  return adapter
+}

package/src/plugins/defineModule.ts

@@ -0,0 +1,5 @@
+import { M FrameworkModule } from '../types/module'
+
+export function defineM FrameworkModule<T extends M FrameworkModule>(module: T): T {
+  return module
+}

package/src/plugins/index.ts

@@ -0,0 +1,3 @@
+export function defineMeeoviPlugin(plugin: () => void) {
+  plugin()
+}

package/src/plugins/registry.ts

@@ -0,0 +1,58 @@
+import { M FrameworkModule } from '../types/module'
+import { M FrameworkContext } from '../runtime/context'
+import {
+  M FrameworkAdapterKey,
+  M FrameworkAdapterMap,
+  M FrameworkAdapterOf
+} from '../types/adapters'
+import { M FrameworkEventBus } from '../types/events'
+
+export class ModuleRegistry {
+  private modules = new Map<string, M FrameworkModule>()
+  private adapters = new Map<M FrameworkAdapterKey, M FrameworkAdapterMap[M FrameworkAdapterKey]>()
+  private bus: M FrameworkEventBus | null = null
+
+  constructor(bus?: M FrameworkEventBus) {
+    if (bus) this.bus = bus
+  }
+
+  registerModule(module: M FrameworkModule, ctx: M FrameworkContext) {
+    if (this.modules.has(module.id)) return
+
+    this.modules.set(module.id, module)
+    if (module.adapters) {
+      for (const [key, adapter] of Object.entries(module.adapters)) {
+        const typedKey = key as M FrameworkAdapterKey
+        this.registerAdapter(typedKey, adapter as M FrameworkAdapterMap[typeof typedKey])
+      }
+    }
+    module.setup?.(ctx)
+  }
+
+  getAdapter<K extends M FrameworkAdapterKey>(key: K): M FrameworkAdapterOf<K> | undefined {
+    return this.adapters.get(key) as M FrameworkAdapterOf<K> | undefined
+  }
+
+  // Register an adapter at runtime. Emits `adapter:registered` so modules
+  // depending on adapters can react when new adapters become available.
+  registerAdapter<K extends M FrameworkAdapterKey>(key: K, adapter: M FrameworkAdapterMap[K]) {
+    this.adapters.set(key, adapter)
+    if (this.bus) {
+      try {
+        // notify listeners asynchronously
+        this.bus.emit('adapter:registered', { key } as any).catch(() => {})
+      } catch (e) {
+        // ignore emit errors
+      }
+    }
+  }
+
+  async runLifecycle(hook: keyof M FrameworkModule, ctx: M FrameworkContext) {
+    for (const module of this.modules.values()) {
+      const fn = module[hook]
+      if (typeof fn === 'function') {
+        await fn.call(module, ctx)
+      }
+    }
+  }
+}

package/src/runtime/app.ts

@@ -0,0 +1,31 @@
+import { M FrameworkConfig } from '../types/config'
+import { M FrameworkContext } from './context'
+import { ModuleRegistry } from '../plugins/registry'
+import { createEventBus } from '../types/events'
+import type { M FrameworkEventBus } from '../types/events'
+import { setRuntimeContext } from './hooks'
+import { runAppLifecycle } from './lifecycle'
+import type { M FrameworkApp, M FrameworkAppOptions } from '../types/app'
+
+export function createM FrameworkApp(options: M FrameworkAppOptions): M FrameworkApp {
+  const eventBus: M FrameworkEventBus = createEventBus()
+  const registry = new ModuleRegistry(eventBus)
+  const context = new M FrameworkContext(options.config, registry)
+
+  setRuntimeContext(context, eventBus)
+
+  options.modules?.forEach((mod) => registry.registerModule(mod, context))
+
+  return {
+    context,
+    events: eventBus,
+    async start() {
+      await runAppLifecycle(registry, context, eventBus)
+      return context
+    }
+  }
+}
+
+export type { M FrameworkAppOptions }
+export type { M FrameworkApp }
+export type { M FrameworkConfig }

package/src/runtime/config.ts

@@ -0,0 +1,24 @@
+export function defineMeeoviConfig() {
+  return {
+    productProvider: 'directus',
+    cartProvider: 'directus',
+    contentProvider: 'directus',
+    authUrl: '/api/auth',
+    searchUrl: '/api/search',
+    adapters: {
+      commerce: '',
+      social: '',
+      search: '',
+      auth: '',
+      chat: '',
+      lists: ''
+    }
+  }
+}
+
+export function defineMeeoviTheme(theme: any) {
+  return theme
+}
+
+export type MeeoviConfig = ReturnType<typeof defineMeeoviConfig>
+export type MeeoviTheme = ReturnType<typeof defineMeeoviTheme>

package/src/runtime/context.ts

@@ -0,0 +1,18 @@
+import { M FrameworkConfig } from '../types/config'
+import { ModuleRegistry } from '../plugins/registry'
+import { M FrameworkAdapterKey, M FrameworkAdapterOf } from '../types/adapters'
+
+export class M FrameworkContext {
+  readonly config: M FrameworkConfig
+  readonly modules: ModuleRegistry
+
+  constructor(config: M FrameworkConfig, modules: ModuleRegistry) {
+    this.config = config
+    this.modules = modules
+  }
+
+  getAdapter<K extends M FrameworkAdapterKey>(key: K): M FrameworkAdapterOf<K> | undefined {
+    return this.modules.getAdapter<K>(key)
+  }
+}
+

package/src/runtime/hooks.ts

@@ -0,0 +1,28 @@
+import { M FrameworkContext } from './context'
+import { M FrameworkEventBus } from '../types/events'
+
+let currentContext: M FrameworkContext | null = null
+let currentEventBus: M FrameworkEventBus | null = null
+
+export function setRuntimeContext(ctx: M FrameworkContext, bus: M FrameworkEventBus) {
+  currentContext = ctx
+  currentEventBus = bus
+}
+
+export function useM FrameworkContext(): M FrameworkContext {
+  if (!currentContext) {
+    throw new Error('[@mframework/core] useM FrameworkContext() called before app initialization')
+  }
+  return currentContext
+}
+
+export function useM FrameworkEventBus(): M FrameworkEventBus {
+  if (!currentEventBus) {
+    throw new Error('[@mframework/core] useM FrameworkEventBus() called before app initialization')
+  }
+  return currentEventBus
+}
+
+export function useRuntimeConfig() {
+  return useM FrameworkContext().config
+}

package/src/runtime/lifecycle.ts

@@ -0,0 +1,16 @@
+import { M FrameworkContext } from './context'
+import { ModuleRegistry } from '../plugins/registry'
+import { M FrameworkEventBus } from '../types/events'
+
+export async function runAppLifecycle(
+  registry: ModuleRegistry,
+  ctx: M FrameworkContext,
+  bus: M FrameworkEventBus
+) {
+  // Example lifecycle sequence
+  await registry.runLifecycle('onAppInit', ctx)
+
+  bus.emit('app:ready', { context: ctx })
+}
+
+

package/src/types/adapters.ts

@@ -0,0 +1,17 @@
+import type { SearchAdapter } from '../adapters/search'
+import type { ListsAdapter } from '../adapters/lists'
+import type { CatalogAdapter } from '../adapters/catalog'
+import type { CartAdapter } from '../adapters/cart'
+import type { AuthAdapter } from '../adapters/auth' // when you add it
+
+export interface M FrameworkAdapterMap {
+  search: SearchAdapter
+  lists: ListsAdapter
+  catalog: CatalogAdapter
+  cart: CartAdapter
+  auth: AuthAdapter
+  // modules can extend this via declaration merging
+}
+
+export type M FrameworkAdapterKey = keyof M FrameworkAdapterMap
+export type M FrameworkAdapterOf<K extends M FrameworkAdapterKey> = M FrameworkAdapterMap[K]

package/src/types/app.ts

@@ -0,0 +1,15 @@
+import { M FrameworkConfig } from './config'
+import { M FrameworkContext } from '../runtime/context'
+import { M FrameworkEventBus } from './events'
+import { M FrameworkModule } from './module'
+
+export interface M FrameworkApp {
+  context: M FrameworkContext
+  events: M FrameworkEventBus
+  start(): Promise<M FrameworkContext>
+}
+
+export interface M FrameworkAppOptions {
+  config: M FrameworkConfig
+  modules?: M FrameworkModule[]
+}

package/src/types/auth/adapter.ts

@@ -0,0 +1,7 @@
+import { AuthSession } from "./session"
+
+export interface AuthAdapter {
+  getSession(): Promise<AuthSession | null>
+  signIn(email: string, password: string): Promise<AuthSession>
+  signOut(): Promise<void>
+}

package/src/types/auth/inputs.ts

@@ -0,0 +1,33 @@
+import { z } from 'zod'
+
+export const LoginInputSchema = z.object({
+  email: z.string().email(),
+  password: z.string().min(8)
+})
+
+export type LoginInput = z.infer<typeof LoginInputSchema>
+
+export const RegisterInputSchema = z.object({
+  email: z.string().email(),
+  password: z.string().min(8),
+  confirmPassword: z.string().min(8)
+}).refine((data) => data.password === data.confirmPassword, {
+  message: 'Passwords do not match',
+  path: ['confirmPassword']
+})
+
+export type RegisterInput = z.infer<typeof RegisterInputSchema>
+
+export const ForgotPasswordInputSchema = z.object({
+  email: z.string().email()
+})
+
+export type ForgotPasswordInput = z.infer<typeof ForgotPasswordInputSchema>
+
+export const ResetPasswordInputSchema = z.object({
+  token: z.string(),
+  password: z.string().min(8),
+  confirmPassword: z.string().min(8)
+})
+
+export type ResetPasswordInput = z.infer<typeof ResetPasswordInputSchema>

package/src/types/auth/providers.ts

@@ -0,0 +1,6 @@
+export interface OAuthProvider {
+  id: string
+  label: string
+  icon?: string
+  authUrl: string
+}

package/src/types/auth/session.ts

@@ -0,0 +1,8 @@
+import { AuthUser } from "./user"
+
+export interface AuthSession {
+  user: AuthUser | null
+  accessToken: string | null
+  refreshToken?: string | null
+  expiresAt?: number
+}

package/src/types/auth/user.ts

@@ -0,0 +1,9 @@
+export interface AuthUser {
+  id: string
+  email: string
+  name?: string
+  avatarUrl?: string
+  emailVerified: boolean
+  createdAt: string
+  updatedAt: string
+}

package/src/types/commerce/adapter.ts

@@ -0,0 +1,21 @@
+import { CommerceCart } from "./cart"
+import { CommerceCategory } from "./category"
+import { CommerceProduct } from "./product"
+
+export interface CommerceAdapter {
+  getProductBySlug(slug: string): Promise<CommerceProduct | null>
+  getProducts(params: {
+    search?: string
+    categoryId?: string
+    limit?: number
+    offset?: number
+  }): Promise<CommerceProduct[]>
+
+  getCategoryTree(): Promise<CommerceCategory[]>
+
+  getCart(cartId: string): Promise<CommerceCart | null>
+  addToCart(
+    cartId: string | null,
+    input: { productId: string; quantity: number }
+  ): Promise<CommerceCart>
+}

package/src/types/commerce/cart.ts

@@ -0,0 +1,16 @@
+import { CommercePrice } from "./product"
+
+export interface CommerceCartItem {
+  id: string
+  productId: string
+  quantity: number
+  price: CommercePrice
+  [key: string]: unknown
+}
+
+export interface CommerceCart {
+  id: string
+  items: CommerceCartItem[]
+  total: CommercePrice
+  [key: string]: unknown
+}

package/src/types/commerce/category.ts

@@ -0,0 +1,7 @@
+export interface CommerceCategory {
+  id: string
+  slug: string
+  name: string
+  parentId?: string
+  children?: CommerceCategory[]
+}

package/src/types/commerce/order.ts

@@ -0,0 +1,13 @@
+import { CommerceCartItem } from "./cart"
+import { CommercePrice } from "./product"
+
+export interface Order {
+  id: string
+  items: CommerceCartItem[]
+  subtotal: CommercePrice
+  total: CommercePrice
+  currency: string
+  status: 'pending' | 'paid' | 'shipped' | 'completed' | 'cancelled'
+  createdAt: string
+  updatedAt: string
+}

package/src/types/commerce/product.ts

@@ -0,0 +1,31 @@
+export interface CommercePrice {
+  amount: number
+  currency: string
+}
+
+export interface CommerceImage {
+  url: string
+  alt?: string
+}
+
+export interface CommerceProduct {
+  id: string
+  slug: string
+  sku?: string
+  name: string
+  description?: string
+  shortDescription?: string
+  price: CommercePrice
+  images: CommerceImage[]
+  categories?: string[]
+  variants?: CommerceVariant[]
+  attributes?: Record<string, string | number | boolean>
+}
+
+export interface CommerceVariant {
+  id: string
+  sku?: string
+  name?: string
+  price?: CommercePrice
+  attributes?: Record<string, string | number | boolean>
+}