lua-cli 2.1.0-alpha.6 → 2.2.0

package/README.md

@@ -195,7 +195,7 @@ This command will:
   - Available at `http://localhost:3000` (opens automatically)
 - **Live Log Panel**:
   - Real-time log feed showing execution details
-  - WebSocket connection to `wss://api.lua.dev/feed`
+  - WebSocket connection to `wss://api.heylua.ai/feed`
   - Console-style interface with color-coded log levels
   - Shows tool calls, errors, metrics, and execution metadata
   - Displays detailed information in expandable sections
@@ -498,7 +498,7 @@ For more details, see [USER_DATA_API.md](./USER_DATA_API.md).
 
 For support and questions:
 - Create an issue on [GitHub](https://github.com/lua-ai-global/lua-cli/issues)
-- Contact: stefan@lua.dev
+- Contact: stefan@heylua.ai
 
 ## Changelog
 

package/dist/commands/compile.js

@@ -227,7 +227,7 @@ async function bundleTool(tool, distDir) {
             platform: 'node',
             target: 'node16',
             outfile: outputPath,
-            external: ['lua-cli/skill', 'lua-cli/user-data-api', 'zod'], // Exclude lua-cli modules and zod - injected into VM
+            external: ['lua-cli/skill', 'lua-cli/user-data-api', 'lua-cli/product-api', 'lua-cli/custom-data-api', 'zod', 'keytar', 'esbuild', 'commander', 'inquirer', 'node-fetch', 'ws', 'socket.io-client', 'ts-morph'], // Exclude lua-cli modules, zod, and native modules
             minify: true, // Minify for smaller file sizes
             sourcemap: false,
             resolveExtensions: ['.ts', '.js', '.json'],
@@ -272,6 +272,56 @@ async function wrapToolForVM(outputPath, tool) {
       }
     }
   };
+
+  // Mock lua-cli/product-api module
+  const luaCliProductApi = {
+    product: typeof product !== 'undefined' ? product : {
+      data: {
+        get: async (page = 1, limit = 10) => ({ success: true, data: [], pagination: { currentPage: page, totalPages: 1, totalCount: 0, limit, hasNextPage: false, hasPrevPage: false, nextPage: null, prevPage: null } }),
+        update: async (data, productId) => ({ updated: true, isNew: false, product: data }),
+        create: async (data) => ({ updated: false, isNew: true, product: data }),
+        delete: async (productId) => ({ deleted: true }),
+        search: async (searchQuery) => ({ success: true, message: \`Found 0 products for "\${searchQuery}"\`, data: [] })
+      }
+    }
+  };
+
+  // Mock lua-cli/custom-data-api module
+  const luaCliCustomDataApi = {
+    customData: typeof customData !== 'undefined' ? customData : {
+      create: async (collectionName, data) => ({
+        id: 'mock-id-' + Date.now(),
+        data: data.data,
+        createdAt: Date.now(),
+        updatedAt: Date.now(),
+        searchText: data.searchText
+      }),
+      get: async (collectionName, filter, page = 1, limit = 10) => ({
+        data: [],
+        pagination: {
+          currentPage: page,
+          totalPages: 1,
+          totalCount: 0,
+          limit,
+          hasNextPage: false,
+          hasPrevPage: false
+        }
+      }),
+      getEntry: async (collectionName, entryId) => null,
+      update: async (collectionName, entryId, data) => ({
+        status: 'success',
+        message: 'Custom data entry updated'
+      }),
+      search: async (collectionName, searchText, limit = 10, scoreThreshold = 0.6) => ({
+        data: [],
+        count: 0
+      }),
+      delete: async (collectionName, entryId) => ({
+        status: 'success',
+        message: 'Custom data entry deleted'
+      })
+    }
+  };
   
   // Mock zod module  
   const zodModule = (() => {
@@ -313,6 +363,12 @@ async function wrapToolForVM(outputPath, tool) {
     if (id === 'lua-cli/user-data-api') {
       return luaCliUserDataApi;
     }
+    if (id === 'lua-cli/product-api') {
+      return luaCliProductApi;
+    }
+    if (id === 'lua-cli/custom-data-api') {
+      return luaCliCustomDataApi;
+    }
     if (id === 'zod') {
       return zodModule;
     }
@@ -344,7 +400,7 @@ async function bundleMainIndex(indexPath, distDir) {
             platform: 'node',
             target: 'node16',
             outfile: path.join(distDir, 'index.js'),
-            external: ['lua-cli/skill', 'lua-cli/user-data-api', 'zod'], // Exclude lua-cli modules and zod
+            external: ['lua-cli/skill', 'lua-cli/user-data-api', 'lua-cli/product-api', 'lua-cli/custom-data-api', 'zod', 'keytar', 'esbuild', 'commander', 'inquirer', 'node-fetch', 'ws', 'socket.io-client', 'ts-morph'], // Exclude lua-cli modules, zod, and native modules
             minify: true, // Minify for smaller file sizes
             sourcemap: false,
             resolveExtensions: ['.ts', '.js', '.json'],

package/dist/custom-data-api.d.ts

@@ -0,0 +1,72 @@
+export interface CustomDataEntry {
+    id: string;
+    data: any;
+    createdAt: number;
+    updatedAt: number;
+    searchText?: string;
+}
+export interface CreateCustomDataRequest {
+    data: any;
+    searchText?: string;
+}
+export interface CreateCustomDataResponse {
+    id: string;
+    data: any;
+    createdAt: number;
+    updatedAt: number;
+    searchText?: string;
+}
+export interface GetCustomDataResponse {
+    data: CustomDataEntry[];
+    pagination: {
+        currentPage: number;
+        totalPages: number;
+        totalCount: number;
+        limit: number;
+        hasNextPage: boolean;
+        hasPrevPage: boolean;
+    };
+}
+export interface UpdateCustomDataRequest {
+    data: any;
+    searchText?: string;
+}
+export interface UpdateCustomDataResponse {
+    status: string;
+    message: string;
+}
+export interface SearchCustomDataResponse {
+    data: Array<CustomDataEntry & {
+        score: number;
+    }>;
+    count: number;
+}
+export interface DeleteCustomDataResponse {
+    status: string;
+    message: string;
+}
+export declare class CustomDataAPI {
+    private collections;
+    constructor();
+    private generateId;
+    private getCollection;
+    create(collectionName: string, data: CreateCustomDataRequest): Promise<CreateCustomDataResponse>;
+    get(collectionName: string, filter?: any, page?: number, limit?: number): Promise<GetCustomDataResponse>;
+    getEntry(collectionName: string, entryId: string): Promise<CustomDataEntry | null>;
+    update(collectionName: string, entryId: string, data: UpdateCustomDataRequest): Promise<UpdateCustomDataResponse>;
+    search(collectionName: string, searchText: string, limit?: number, scoreThreshold?: number): Promise<SearchCustomDataResponse>;
+    delete(collectionName: string, entryId: string): Promise<DeleteCustomDataResponse>;
+    private matchesFilter;
+    private calculateSimilarity;
+    getAllCollections(): Map<string, CustomDataEntry[]>;
+    clearCollection(collectionName: string): void;
+    clearAllCollections(): void;
+}
+export declare const customData: {
+    create: (collectionName: string, data: CreateCustomDataRequest) => Promise<CreateCustomDataResponse>;
+    get: (collectionName: string, filter?: any, page?: number, limit?: number) => Promise<GetCustomDataResponse>;
+    getEntry: (collectionName: string, entryId: string) => Promise<CustomDataEntry | null>;
+    update: (collectionName: string, entryId: string, data: UpdateCustomDataRequest) => Promise<UpdateCustomDataResponse>;
+    search: (collectionName: string, searchText: string, limit?: number, scoreThreshold?: number) => Promise<SearchCustomDataResponse>;
+    delete: (collectionName: string, entryId: string) => Promise<DeleteCustomDataResponse>;
+};

package/dist/custom-data-api.js

@@ -0,0 +1,174 @@
+export class CustomDataAPI {
+    constructor() {
+        // Store data by collection name
+        this.collections = new Map();
+    }
+    generateId() {
+        return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function (c) {
+            const r = Math.random() * 16 | 0;
+            const v = c == 'x' ? r : (r & 0x3 | 0x8);
+            return v.toString(16);
+        });
+    }
+    getCollection(collectionName) {
+        if (!this.collections.has(collectionName)) {
+            this.collections.set(collectionName, []);
+        }
+        return this.collections.get(collectionName);
+    }
+    async create(collectionName, data) {
+        const collection = this.getCollection(collectionName);
+        const now = Date.now();
+        const entry = {
+            id: this.generateId(),
+            data: data.data,
+            createdAt: now,
+            updatedAt: now,
+            searchText: data.searchText
+        };
+        collection.push(entry);
+        return {
+            id: entry.id,
+            data: entry.data,
+            createdAt: entry.createdAt,
+            updatedAt: entry.updatedAt,
+            searchText: entry.searchText
+        };
+    }
+    async get(collectionName, filter, page = 1, limit = 10) {
+        const collection = this.getCollection(collectionName);
+        let filteredData = [...collection];
+        // Apply filter if provided
+        if (filter) {
+            filteredData = collection.filter(entry => {
+                return this.matchesFilter(entry.data, filter);
+            });
+        }
+        // Apply pagination
+        const startIndex = (page - 1) * limit;
+        const endIndex = startIndex + limit;
+        const paginatedData = filteredData.slice(startIndex, endIndex);
+        const totalCount = filteredData.length;
+        const totalPages = Math.ceil(totalCount / limit);
+        return {
+            data: paginatedData,
+            pagination: {
+                currentPage: page,
+                totalPages: totalPages,
+                totalCount: totalCount,
+                limit: limit,
+                hasNextPage: page < totalPages,
+                hasPrevPage: page > 1
+            }
+        };
+    }
+    async getEntry(collectionName, entryId) {
+        const collection = this.getCollection(collectionName);
+        return collection.find(entry => entry.id === entryId) || null;
+    }
+    async update(collectionName, entryId, data) {
+        const collection = this.getCollection(collectionName);
+        const entryIndex = collection.findIndex(entry => entry.id === entryId);
+        if (entryIndex === -1) {
+            return {
+                status: 'error',
+                message: 'Custom data entry not found'
+            };
+        }
+        const entry = collection[entryIndex];
+        entry.data = { ...entry.data, ...data.data };
+        entry.updatedAt = Date.now();
+        if (data.searchText !== undefined) {
+            entry.searchText = data.searchText;
+        }
+        return {
+            status: 'success',
+            message: 'Custom data entry updated'
+        };
+    }
+    async search(collectionName, searchText, limit = 10, scoreThreshold = 0.6) {
+        const collection = this.getCollection(collectionName);
+        const results = [];
+        for (const entry of collection) {
+            if (entry.searchText) {
+                const score = this.calculateSimilarity(searchText.toLowerCase(), entry.searchText.toLowerCase());
+                if (score >= scoreThreshold) {
+                    results.push({ ...entry, score });
+                }
+            }
+        }
+        // Sort by score descending
+        results.sort((a, b) => b.score - a.score);
+        // Apply limit
+        const limitedResults = results.slice(0, limit);
+        return {
+            data: limitedResults,
+            count: limitedResults.length
+        };
+    }
+    async delete(collectionName, entryId) {
+        const collection = this.getCollection(collectionName);
+        const initialLength = collection.length;
+        const updatedCollection = collection.filter(entry => entry.id !== entryId);
+        this.collections.set(collectionName, updatedCollection);
+        if (updatedCollection.length < initialLength) {
+            return {
+                status: 'success',
+                message: 'Custom data entry deleted'
+            };
+        }
+        else {
+            return {
+                status: 'error',
+                message: 'Custom data entry not found'
+            };
+        }
+    }
+    // Helper method to check if an object matches a filter
+    matchesFilter(obj, filter) {
+        for (const key in filter) {
+            if (filter.hasOwnProperty(key)) {
+                if (typeof filter[key] === 'object' && filter[key] !== null) {
+                    if (typeof obj[key] !== 'object' || !this.matchesFilter(obj[key], filter[key])) {
+                        return false;
+                    }
+                }
+                else {
+                    if (obj[key] !== filter[key]) {
+                        return false;
+                    }
+                }
+            }
+        }
+        return true;
+    }
+    // Simple similarity calculation (Jaccard similarity for words)
+    calculateSimilarity(str1, str2) {
+        const words1 = new Set(str1.split(/\s+/));
+        const words2 = new Set(str2.split(/\s+/));
+        const intersection = new Set([...words1].filter(x => words2.has(x)));
+        const union = new Set([...words1, ...words2]);
+        return intersection.size / union.size;
+    }
+    // Method to get all collections (for debugging/testing)
+    getAllCollections() {
+        return this.collections;
+    }
+    // Method to clear a collection (for testing)
+    clearCollection(collectionName) {
+        this.collections.set(collectionName, []);
+    }
+    // Method to clear all collections (for testing)
+    clearAllCollections() {
+        this.collections.clear();
+    }
+}
+const customDataAPI = new CustomDataAPI();
+export const customData = {
+    create: (collectionName, data) => customDataAPI.create(collectionName, data),
+    get: (collectionName, filter, page, limit) => customDataAPI.get(collectionName, filter, page, limit),
+    getEntry: (collectionName, entryId) => customDataAPI.getEntry(collectionName, entryId),
+    update: (collectionName, entryId, data) => customDataAPI.update(collectionName, entryId, data),
+    search: (collectionName, searchText, limit, scoreThreshold) => customDataAPI.search(collectionName, searchText, limit, scoreThreshold),
+    delete: (collectionName, entryId) => customDataAPI.delete(collectionName, entryId),
+};

package/dist/index.d.ts

@@ -1,3 +1,4 @@
 #!/usr/bin/env node
 export { user, UserDataAPI } from './user-data-api.js';
 export { product, ProductAPI } from './product-api.js';
+export { customData, CustomDataAPI } from './custom-data-api.js';

package/dist/index.js

@@ -46,3 +46,4 @@ program.parse(process.argv);
 // Export user data API for use in projects
 export { user, UserDataAPI } from './user-data-api.js';
 export { product, ProductAPI } from './product-api.js';
+export { customData, CustomDataAPI } from './custom-data-api.js';

package/dist/product-api.d.ts

@@ -34,15 +34,156 @@ export interface SearchProductsResponse {
     message: string;
     data: Product[];
 }
+export interface BasketItem {
+    id: string;
+    price: number;
+    quantity: number;
+    SKU?: string;
+    addedAt?: string;
+    [key: string]: any;
+}
+export interface Basket {
+    id: string;
+    userId: string;
+    agentId: string;
+    data: {
+        currency: string;
+        items: BasketItem[];
+        createdAt: string;
+    };
+    common: {
+        status: 'active' | 'checked_out' | 'abandoned' | 'expired';
+        totalAmount: string | number;
+        itemCount: number;
+    };
+    createdAt: string;
+    updatedAt: string;
+    __v: number;
+}
+export interface CreateBasketRequest {
+    currency: string;
+}
+export interface CreateBasketResponse {
+    success: boolean;
+    message: string;
+    data: Basket;
+}
+export interface GetBasketsResponse {
+    success: boolean;
+    message: string;
+    data: Basket[];
+}
+export interface AddItemToBasketRequest {
+    id: string;
+    price: number;
+    quantity: number;
+    [key: string]: any;
+}
+export interface AddItemToBasketResponse {
+    success: boolean;
+    message: string;
+    data: Basket;
+}
+export interface RemoveItemFromBasketResponse {
+    success: boolean;
+    message: string;
+    data: Basket;
+}
+export interface ClearBasketResponse {
+    success: boolean;
+    message: string;
+    data: Basket;
+}
+export interface UpdateBasketStatusResponse {
+    success: boolean;
+    message: string;
+    data: Basket;
+}
+export interface Order {
+    id: string;
+    userId: string;
+    agentId: string;
+    orderId: string;
+    data: {
+        currency: string;
+        items: BasketItem[];
+        createdAt: string;
+        basketId: string;
+        orderDate: string;
+        orderId: string;
+        [key: string]: any;
+    };
+    common: {
+        status: 'pending' | 'confirmed' | 'fulfilled' | 'cancelled';
+        totalAmount: string | number;
+        currency: string;
+        itemCount: number;
+    };
+    createdAt: string;
+    updatedAt: string;
+    __v: number;
+}
+export interface CreateOrderRequest {
+    basketId: string;
+    data: {
+        [key: string]: any;
+    };
+}
+export interface CreateOrderResponse {
+    success: boolean;
+    message: string;
+    data: Order;
+}
+export interface UpdateOrderStatusResponse {
+    success: boolean;
+    message: string;
+    data: Order;
+}
+export interface GetUserOrdersResponse {
+    success: boolean;
+    message: string;
+    data: Order[];
+}
+export type BasketStatus = 'active' | 'checked_out' | 'abandoned' | 'expired';
+export type OrderStatus = 'pending' | 'confirmed' | 'fulfilled' | 'cancelled';
 export declare class ProductAPI {
-    products: any;
+    products: Product[];
+    baskets: Basket[];
+    orders: Order[];
     constructor();
     get(page?: number, limit?: number): Promise<ProductsResponse>;
     create(data: Record<string, any>): Promise<CreateProductResponse>;
     update(data: Record<string, any>, productId: string): Promise<UpdateProductResponse>;
     delete(productId: string): Promise<DeleteProductResponse>;
     search(searchQuery: string): Promise<SearchProductsResponse>;
+    createBasket(data: CreateBasketRequest): Promise<CreateBasketResponse>;
+    getBaskets(status?: BasketStatus): Promise<GetBasketsResponse>;
+    addItemToBasket(basketId: string, data: AddItemToBasketRequest): Promise<AddItemToBasketResponse>;
+    removeItemFromBasket(basketId: string, itemId: string): Promise<RemoveItemFromBasketResponse>;
+    clearBasket(basketId: string): Promise<ClearBasketResponse>;
+    updateBasketStatus(basketId: string, status: BasketStatus): Promise<UpdateBasketStatusResponse>;
+    createOrder(data: CreateOrderRequest): Promise<CreateOrderResponse>;
+    updateOrderStatus(orderId: string, status: OrderStatus): Promise<UpdateOrderStatusResponse>;
+    getUserOrders(userId: string): Promise<GetUserOrdersResponse>;
 }
 export declare const product: {
+    create: (data: Record<string, any>) => Promise<CreateProductResponse>;
+    get: (page?: number, limit?: number) => Promise<ProductsResponse>;
+    update: (data: Record<string, any>, productId: string) => Promise<UpdateProductResponse>;
+    delete: (productId: string) => Promise<DeleteProductResponse>;
+    search: (searchQuery: string) => Promise<SearchProductsResponse>;
     data: ProductAPI;
+    basket: {
+        create: (data: CreateBasketRequest) => Promise<CreateBasketResponse>;
+        get: (status?: BasketStatus) => Promise<GetBasketsResponse>;
+        addItem: (basketId: string, data: AddItemToBasketRequest) => Promise<AddItemToBasketResponse>;
+        removeItem: (basketId: string, itemId: string) => Promise<RemoveItemFromBasketResponse>;
+        clear: (basketId: string) => Promise<ClearBasketResponse>;
+        updateStatus: (basketId: string, status: BasketStatus) => Promise<UpdateBasketStatusResponse>;
+    };
+    order: {
+        create: (data: CreateOrderRequest) => Promise<CreateOrderResponse>;
+        updateStatus: (orderId: string, status: OrderStatus) => Promise<UpdateOrderStatusResponse>;
+        get: (userId: string) => Promise<GetUserOrdersResponse>;
+    };
 };

package/dist/product-api.js

@@ -1,27 +1,141 @@
 export class ProductAPI {
     constructor() {
-        this.products = {};
+        this.products = [];
+        this.baskets = [];
+        this.orders = [];
     }
     async get(page = 1, limit = 10) {
-        return { success: true, data: this.products, pagination: { currentPage: page, totalPages: 1, totalCount: this.products.length, limit: limit, hasNextPage: false, hasPrevPage: false, nextPage: null, prevPage: null } };
+        return {
+            success: true,
+            data: this.products,
+            pagination: {
+                currentPage: page,
+                totalPages: 1,
+                totalCount: this.products.length,
+                limit: limit,
+                hasNextPage: false,
+                hasPrevPage: false,
+                nextPage: null,
+                prevPage: null
+            }
+        };
     }
     async create(data) {
-        this.products = data;
-        return { updated: true, isNew: true, product: this.products };
+        const product = data;
+        const existingIndex = this.products.findIndex(p => p.id === product.id);
+        if (existingIndex >= 0) {
+            this.products[existingIndex] = product;
+            return { updated: true, isNew: false, product };
+        }
+        else {
+            this.products.push(product);
+            return { updated: false, isNew: true, product };
+        }
     }
     async update(data, productId) {
-        // Update is the same as create for this API
-        this.products = { ...this.products, ...data };
-        return { updated: true, isNew: false, product: this.products };
+        const product = data;
+        const existingIndex = this.products.findIndex(p => p.id === productId);
+        if (existingIndex >= 0) {
+            this.products[existingIndex] = { ...this.products[existingIndex], ...product };
+            return { updated: true, isNew: false, product: this.products[existingIndex] };
+        }
+        else {
+            this.products.push(product);
+            return { updated: false, isNew: true, product };
+        }
     }
     async delete(productId) {
+        const initialLength = this.products.length;
         this.products = this.products.filter((product) => product.id !== productId);
-        return { deleted: true };
+        return { deleted: this.products.length < initialLength };
     }
     async search(searchQuery) {
-        return { success: true, message: 'Products searched successfully', data: this.products };
+        const results = this.products.filter(product => Object.values(product).some(value => String(value).toLowerCase().includes(searchQuery.toLowerCase())));
+        return {
+            success: true,
+            message: `Successfully found ${results.length} products for "${searchQuery}"`,
+            data: results
+        };
+    }
+    async createBasket(data) {
+        const basket = { ...data, createdAt: new Date().toISOString(), updatedAt: new Date().toISOString(), __v: 0 };
+        this.baskets.push(basket);
+        return { success: true, message: 'Basket created successfully', data: basket };
+    }
+    async getBaskets(status) {
+        if (status) {
+            return { success: true, message: 'Baskets fetched successfully', data: this.baskets.filter((basket) => basket.common.status === status) };
+        }
+        return { success: true, message: 'Baskets fetched successfully', data: this.baskets };
+    }
+    async addItemToBasket(basketId, data) {
+        const basket = this.baskets.find((basket) => basket.id === basketId);
+        if (basket) {
+            basket.data.items.push(data);
+            return { success: true, message: 'Item added to basket successfully', data: basket };
+        }
+        return { success: false, message: 'Basket not found', data: null };
+    }
+    async removeItemFromBasket(basketId, itemId) {
+        const basket = this.baskets.find((basket) => basket.id === basketId);
+        if (basket) {
+            basket.data.items = basket.data.items.filter((item) => item.id !== itemId);
+            return { success: true, message: 'Item removed from basket successfully', data: basket };
+        }
+        return { success: false, message: 'Basket not found', data: null };
+    }
+    async clearBasket(basketId) {
+        const basket = this.baskets.find((basket) => basket.id === basketId);
+        if (basket) {
+            basket.data.items = [];
+            return { success: true, message: 'Basket cleared successfully', data: basket };
+        }
+        return { success: false, message: 'Basket not found', data: null };
+    }
+    async updateBasketStatus(basketId, status) {
+        const basket = this.baskets.find((basket) => basket.id === basketId);
+        if (basket) {
+            basket.common.status = status;
+            return { success: true, message: 'Basket status updated successfully', data: basket };
+        }
+        return { success: false, message: 'Basket not found', data: null };
+    }
+    async createOrder(data) {
+        const order = { ...data, createdAt: new Date().toISOString(), updatedAt: new Date().toISOString(), __v: 0 };
+        this.orders.push(order);
+        return { success: true, message: 'Order created successfully', data: order };
+    }
+    async updateOrderStatus(orderId, status) {
+        const order = this.orders.find((order) => order.id === orderId);
+        if (order) {
+            order.common.status = status;
+            return { success: true, message: 'Order status updated successfully', data: order };
+        }
+        return { success: false, message: 'Order not found', data: null };
+    }
+    async getUserOrders(userId) {
+        return { success: true, message: 'User orders fetched successfully', data: this.orders.filter((order) => order.userId === userId) };
     }
 }
+const productAPI = new ProductAPI();
 export const product = {
-    data: new ProductAPI()
+    create: productAPI.create,
+    get: productAPI.get,
+    update: productAPI.update,
+    delete: productAPI.delete,
+    search: productAPI.search,
+    data: productAPI,
+    basket: {
+        create: productAPI.createBasket,
+        get: productAPI.getBaskets,
+        addItem: productAPI.addItemToBasket,
+        removeItem: productAPI.removeItemFromBasket,
+        clear: productAPI.clearBasket,
+        updateStatus: productAPI.updateBasketStatus
+    },
+    order: {
+        create: productAPI.createOrder,
+        updateStatus: productAPI.updateOrderStatus,
+        get: productAPI.getUserOrders
+    }
 };