lua-cli 2.2.8-alpha.2 → 2.3.0-alpha.1

package/dist/product-api.d.ts

@@ -1,189 +0,0 @@
-export interface Product {
-    id: string;
-    [key: string]: any;
-}
-export interface ProductsResponse {
-    success: boolean;
-    data: Product[];
-    pagination: {
-        currentPage: number;
-        totalPages: number;
-        totalCount: number;
-        limit: number;
-        hasNextPage: boolean;
-        hasPrevPage: boolean;
-        nextPage: number | null;
-        prevPage: number | null;
-    };
-}
-export interface CreateProductResponse {
-    updated: boolean;
-    isNew: boolean;
-    product: Product;
-}
-export interface UpdateProductResponse {
-    updated: boolean;
-    isNew: boolean;
-    product: Product;
-}
-export interface DeleteProductResponse {
-    deleted: boolean;
-}
-export interface SearchProductsResponse {
-    success: boolean;
-    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: 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,141 +0,0 @@
-export class ProductAPI {
-    constructor() {
-        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
-            }
-        };
-    }
-    async create(data) {
-        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) {
-        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: this.products.length < initialLength };
-    }
-    async search(searchQuery) {
-        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 = {
-    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
-    }
-};