lua-cli 2.5.1 → 2.5.3

package/dist/common/order.instance.js

@@ -1,12 +1,14 @@
 /**
  * Order instance class providing a fluent API for managing orders
  * Provides methods for updating order status and order data
+ * Supports direct property access (e.g., order.shippingAddress) for accessing data and common properties
  */
 export default class OrderInstance {
     /**
-     * Creates a new OrderInstance
+     * Creates a new OrderInstance with proxy support for direct property access
      * @param api - The OrderApi instance for making API calls
      * @param order - The order response data from the API
+     * @returns Proxied instance that allows direct access to data and common properties
      */
     constructor(api, order) {
         this.data = order.data;
@@ -22,6 +24,79 @@ export default class OrderInstance {
             enumerable: false,
             configurable: true
         });
+        // Return a proxy that allows direct property access
+        return new Proxy(this, {
+            get(target, prop, receiver) {
+                // If the property exists on the instance itself, return it
+                if (prop in target) {
+                    return Reflect.get(target, prop, receiver);
+                }
+                // Check data object
+                if (typeof prop === 'string' && prop in target.data) {
+                    return target.data[prop];
+                }
+                // Check common object
+                if (typeof prop === 'string' && prop in target.common) {
+                    return target.common[prop];
+                }
+                return undefined;
+            },
+            set(target, prop, value, receiver) {
+                // Reserved properties that should be set on the instance itself
+                const reservedProps = ['data', 'common', 'id', 'userId', 'agentId', 'orderId', 'orderAPI', 'updateStatus', 'update', 'toJSON'];
+                if (typeof prop === 'string' && reservedProps.includes(prop)) {
+                    return Reflect.set(target, prop, value, receiver);
+                }
+                // Check if property exists in data or common, otherwise default to data
+                if (typeof prop === 'string') {
+                    if (prop in target.common) {
+                        target.common[prop] = value;
+                    }
+                    else {
+                        target.data[prop] = value;
+                    }
+                    return true;
+                }
+                return false;
+            },
+            has(target, prop) {
+                // Check if property exists on instance, in data, or in common
+                return prop in target || (typeof prop === 'string' && (prop in target.data || prop in target.common));
+            },
+            ownKeys(target) {
+                // Return instance keys, data keys, and common keys
+                const instanceKeys = Reflect.ownKeys(target);
+                const dataKeys = Object.keys(target.data);
+                const commonKeys = Object.keys(target.common);
+                return [...new Set([...instanceKeys, ...dataKeys, ...commonKeys])];
+            },
+            getOwnPropertyDescriptor(target, prop) {
+                // First check if it's an instance property
+                const instanceDesc = Reflect.getOwnPropertyDescriptor(target, prop);
+                if (instanceDesc) {
+                    return instanceDesc;
+                }
+                // Then check data properties
+                if (typeof prop === 'string' && prop in target.data) {
+                    return {
+                        configurable: true,
+                        enumerable: true,
+                        writable: true,
+                        value: target.data[prop]
+                    };
+                }
+                // Then check common properties
+                if (typeof prop === 'string' && prop in target.common) {
+                    return {
+                        configurable: true,
+                        enumerable: true,
+                        writable: true,
+                        value: target.common[prop]
+                    };
+                }
+                return undefined;
+            }
+        });
     }
     /**
      * Custom toJSON method to control what gets serialized when logging

package/dist/common/product.instance.d.ts

@@ -2,14 +2,17 @@ import { Product } from "../interfaces/product.js";
 /**
  * Product instance class providing a fluent API for managing individual products
  * Provides methods for updating and deleting products
+ * Supports direct property access (e.g., product.name) instead of product.data.name
  */
 export default class ProductInstance {
     data: Product;
     private productAPI;
+    [key: string]: any;
     /**
-     * Creates a new ProductInstance
+     * Creates a new ProductInstance with proxy support for direct property access
      * @param api - The ProductAPI instance for making API calls
      * @param product - The product data from the API
+     * @returns Proxied instance that allows direct access to product properties
      */
     constructor(api: any, product: Product);
     /**

package/dist/common/product.instance.js

@@ -1,12 +1,14 @@
 /**
  * Product instance class providing a fluent API for managing individual products
  * Provides methods for updating and deleting products
+ * Supports direct property access (e.g., product.name) instead of product.data.name
  */
 export default class ProductInstance {
     /**
-     * Creates a new ProductInstance
+     * Creates a new ProductInstance with proxy support for direct property access
      * @param api - The ProductAPI instance for making API calls
      * @param product - The product data from the API
+     * @returns Proxied instance that allows direct access to product properties
      */
     constructor(api, product) {
         this.data = product;
@@ -17,6 +19,60 @@ export default class ProductInstance {
             enumerable: false,
             configurable: true
         });
+        // Return a proxy that allows direct property access
+        return new Proxy(this, {
+            get(target, prop, receiver) {
+                // If the property exists on the instance itself, return it
+                if (prop in target) {
+                    return Reflect.get(target, prop, receiver);
+                }
+                // Otherwise, try to get it from the data object
+                if (typeof prop === 'string' && prop in target.data) {
+                    return target.data[prop];
+                }
+                return undefined;
+            },
+            set(target, prop, value, receiver) {
+                // Reserved properties that should be set on the instance itself
+                const reservedProps = ['data', 'productAPI', 'update', 'delete', 'toJSON'];
+                if (typeof prop === 'string' && reservedProps.includes(prop)) {
+                    return Reflect.set(target, prop, value, receiver);
+                }
+                // All other properties get set on the data object
+                if (typeof prop === 'string') {
+                    target.data[prop] = value;
+                    return true;
+                }
+                return false;
+            },
+            has(target, prop) {
+                // Check if property exists on instance or in data
+                return prop in target || (typeof prop === 'string' && prop in target.data);
+            },
+            ownKeys(target) {
+                // Return both instance keys and data keys
+                const instanceKeys = Reflect.ownKeys(target);
+                const dataKeys = Object.keys(target.data);
+                return [...new Set([...instanceKeys, ...dataKeys])];
+            },
+            getOwnPropertyDescriptor(target, prop) {
+                // First check if it's an instance property
+                const instanceDesc = Reflect.getOwnPropertyDescriptor(target, prop);
+                if (instanceDesc) {
+                    return instanceDesc;
+                }
+                // Then check if it's a data property
+                if (typeof prop === 'string' && prop in target.data) {
+                    return {
+                        configurable: true,
+                        enumerable: true,
+                        writable: true,
+                        value: target.data[prop]
+                    };
+                }
+                return undefined;
+            }
+        });
     }
     /**
      * Custom toJSON method to control what gets serialized when logging

package/dist/common/product.pagination.instance.d.ts

@@ -3,6 +3,7 @@ import ProductInstance from "./product.instance.js";
 /**
  * Product pagination instance class providing a fluent API for paginated product results
  * Provides methods for navigating through pages of products
+ * Supports array methods like map, filter, forEach for direct iteration
  */
 export default class ProductPaginationInstance {
     products: ProductInstance[];
@@ -23,6 +24,63 @@ export default class ProductPaginationInstance {
      * @param results - The paginated product results from the API
      */
     constructor(api: any, results: ProductsResponse);
+    /**
+     * Returns the number of products in the current page
+     */
+    get length(): number;
+    /**
+     * Maps over the products array
+     * @param callback - Function to execute for each product
+     * @returns Array of mapped results
+     */
+    map<T>(callback: (product: ProductInstance, index: number, array: ProductInstance[]) => T): T[];
+    /**
+     * Filters the products array
+     * @param callback - Function to test each product
+     * @returns Array of products that pass the test
+     */
+    filter(callback: (product: ProductInstance, index: number, array: ProductInstance[]) => boolean): ProductInstance[];
+    /**
+     * Executes a function for each product
+     * @param callback - Function to execute for each product
+     */
+    forEach(callback: (product: ProductInstance, index: number, array: ProductInstance[]) => void): void;
+    /**
+     * Finds the first product that satisfies the test
+     * @param callback - Function to test each product
+     * @returns The first product that passes the test, or undefined
+     */
+    find(callback: (product: ProductInstance, index: number, array: ProductInstance[]) => boolean): ProductInstance | undefined;
+    /**
+     * Finds the index of the first product that satisfies the test
+     * @param callback - Function to test each product
+     * @returns The index of the first product that passes the test, or -1
+     */
+    findIndex(callback: (product: ProductInstance, index: number, array: ProductInstance[]) => boolean): number;
+    /**
+     * Checks if some products satisfy the test
+     * @param callback - Function to test each product
+     * @returns true if at least one product passes the test
+     */
+    some(callback: (product: ProductInstance, index: number, array: ProductInstance[]) => boolean): boolean;
+    /**
+     * Checks if all products satisfy the test
+     * @param callback - Function to test each product
+     * @returns true if all products pass the test
+     */
+    every(callback: (product: ProductInstance, index: number, array: ProductInstance[]) => boolean): boolean;
+    /**
+     * Reduces the products array to a single value
+     * @param callback - Function to execute on each product
+     * @param initialValue - Initial value for the accumulator
+     * @returns The final accumulated value
+     */
+    reduce<T>(callback: (accumulator: T, product: ProductInstance, index: number, array: ProductInstance[]) => T, initialValue: T): T;
+    /**
+     * Makes the instance iterable
+     * @returns Iterator for the products array
+     */
+    [Symbol.iterator](): Iterator<ProductInstance>;
     /**
      * Custom toJSON method to control what gets serialized when logging
      * @returns Serialized products and pagination data

package/dist/common/product.pagination.instance.js

@@ -2,6 +2,7 @@ import ProductInstance from "./product.instance.js";
 /**
  * Product pagination instance class providing a fluent API for paginated product results
  * Provides methods for navigating through pages of products
+ * Supports array methods like map, filter, forEach for direct iteration
  */
 export default class ProductPaginationInstance {
     /**
@@ -29,6 +30,83 @@ export default class ProductPaginationInstance {
             configurable: true
         });
     }
+    /**
+     * Returns the number of products in the current page
+     */
+    get length() {
+        return this.products.length;
+    }
+    /**
+     * Maps over the products array
+     * @param callback - Function to execute for each product
+     * @returns Array of mapped results
+     */
+    map(callback) {
+        return this.products.map(callback);
+    }
+    /**
+     * Filters the products array
+     * @param callback - Function to test each product
+     * @returns Array of products that pass the test
+     */
+    filter(callback) {
+        return this.products.filter(callback);
+    }
+    /**
+     * Executes a function for each product
+     * @param callback - Function to execute for each product
+     */
+    forEach(callback) {
+        this.products.forEach(callback);
+    }
+    /**
+     * Finds the first product that satisfies the test
+     * @param callback - Function to test each product
+     * @returns The first product that passes the test, or undefined
+     */
+    find(callback) {
+        return this.products.find(callback);
+    }
+    /**
+     * Finds the index of the first product that satisfies the test
+     * @param callback - Function to test each product
+     * @returns The index of the first product that passes the test, or -1
+     */
+    findIndex(callback) {
+        return this.products.findIndex(callback);
+    }
+    /**
+     * Checks if some products satisfy the test
+     * @param callback - Function to test each product
+     * @returns true if at least one product passes the test
+     */
+    some(callback) {
+        return this.products.some(callback);
+    }
+    /**
+     * Checks if all products satisfy the test
+     * @param callback - Function to test each product
+     * @returns true if all products pass the test
+     */
+    every(callback) {
+        return this.products.every(callback);
+    }
+    /**
+     * Reduces the products array to a single value
+     * @param callback - Function to execute on each product
+     * @param initialValue - Initial value for the accumulator
+     * @returns The final accumulated value
+     */
+    reduce(callback, initialValue) {
+        return this.products.reduce(callback, initialValue);
+    }
+    /**
+     * Makes the instance iterable
+     * @returns Iterator for the products array
+     */
+    [Symbol.iterator]() {
+        return this.products[Symbol.iterator]();
+    }
     /**
      * Custom toJSON method to control what gets serialized when logging
      * @returns Serialized products and pagination data

package/dist/common/product.search.instance.d.ts

@@ -4,6 +4,7 @@ import ProductInstance from "./product.instance.js";
 /**
  * Product search instance class providing a fluent API for product search results
  * Contains an array of ProductInstance objects matching the search query
+ * Supports array methods like map, filter, forEach for direct iteration
  */
 export default class ProductSearchInstance {
     products: ProductInstance[];
@@ -14,6 +15,63 @@ export default class ProductSearchInstance {
      * @param results - The product search results from the API
      */
     constructor(api: ProductAPI, results: SearchProductsResponse);
+    /**
+     * Returns the number of products in the search results
+     */
+    get length(): number;
+    /**
+     * Maps over the products array
+     * @param callback - Function to execute for each product
+     * @returns Array of mapped results
+     */
+    map<T>(callback: (product: ProductInstance, index: number, array: ProductInstance[]) => T): T[];
+    /**
+     * Filters the products array
+     * @param callback - Function to test each product
+     * @returns Array of products that pass the test
+     */
+    filter(callback: (product: ProductInstance, index: number, array: ProductInstance[]) => boolean): ProductInstance[];
+    /**
+     * Executes a function for each product
+     * @param callback - Function to execute for each product
+     */
+    forEach(callback: (product: ProductInstance, index: number, array: ProductInstance[]) => void): void;
+    /**
+     * Finds the first product that satisfies the test
+     * @param callback - Function to test each product
+     * @returns The first product that passes the test, or undefined
+     */
+    find(callback: (product: ProductInstance, index: number, array: ProductInstance[]) => boolean): ProductInstance | undefined;
+    /**
+     * Finds the index of the first product that satisfies the test
+     * @param callback - Function to test each product
+     * @returns The index of the first product that passes the test, or -1
+     */
+    findIndex(callback: (product: ProductInstance, index: number, array: ProductInstance[]) => boolean): number;
+    /**
+     * Checks if some products satisfy the test
+     * @param callback - Function to test each product
+     * @returns true if at least one product passes the test
+     */
+    some(callback: (product: ProductInstance, index: number, array: ProductInstance[]) => boolean): boolean;
+    /**
+     * Checks if all products satisfy the test
+     * @param callback - Function to test each product
+     * @returns true if all products pass the test
+     */
+    every(callback: (product: ProductInstance, index: number, array: ProductInstance[]) => boolean): boolean;
+    /**
+     * Reduces the products array to a single value
+     * @param callback - Function to execute on each product
+     * @param initialValue - Initial value for the accumulator
+     * @returns The final accumulated value
+     */
+    reduce<T>(callback: (accumulator: T, product: ProductInstance, index: number, array: ProductInstance[]) => T, initialValue: T): T;
+    /**
+     * Makes the instance iterable
+     * @returns Iterator for the products array
+     */
+    [Symbol.iterator](): Iterator<ProductInstance>;
     /**
      * Custom toJSON method to control what gets serialized when logging
      * @returns Serialized search results with product data

package/dist/common/product.search.instance.js

@@ -2,6 +2,7 @@ import ProductInstance from "./product.instance.js";
 /**
  * Product search instance class providing a fluent API for product search results
  * Contains an array of ProductInstance objects matching the search query
+ * Supports array methods like map, filter, forEach for direct iteration
  */
 export default class ProductSearchInstance {
     /**
@@ -19,6 +20,83 @@ export default class ProductSearchInstance {
             configurable: true
         });
     }
+    /**
+     * Returns the number of products in the search results
+     */
+    get length() {
+        return this.products.length;
+    }
+    /**
+     * Maps over the products array
+     * @param callback - Function to execute for each product
+     * @returns Array of mapped results
+     */
+    map(callback) {
+        return this.products.map(callback);
+    }
+    /**
+     * Filters the products array
+     * @param callback - Function to test each product
+     * @returns Array of products that pass the test
+     */
+    filter(callback) {
+        return this.products.filter(callback);
+    }
+    /**
+     * Executes a function for each product
+     * @param callback - Function to execute for each product
+     */
+    forEach(callback) {
+        this.products.forEach(callback);
+    }
+    /**
+     * Finds the first product that satisfies the test
+     * @param callback - Function to test each product
+     * @returns The first product that passes the test, or undefined
+     */
+    find(callback) {
+        return this.products.find(callback);
+    }
+    /**
+     * Finds the index of the first product that satisfies the test
+     * @param callback - Function to test each product
+     * @returns The index of the first product that passes the test, or -1
+     */
+    findIndex(callback) {
+        return this.products.findIndex(callback);
+    }
+    /**
+     * Checks if some products satisfy the test
+     * @param callback - Function to test each product
+     * @returns true if at least one product passes the test
+     */
+    some(callback) {
+        return this.products.some(callback);
+    }
+    /**
+     * Checks if all products satisfy the test
+     * @param callback - Function to test each product
+     * @returns true if all products pass the test
+     */
+    every(callback) {
+        return this.products.every(callback);
+    }
+    /**
+     * Reduces the products array to a single value
+     * @param callback - Function to execute on each product
+     * @param initialValue - Initial value for the accumulator
+     * @returns The final accumulated value
+     */
+    reduce(callback, initialValue) {
+        return this.products.reduce(callback, initialValue);
+    }
+    /**
+     * Makes the instance iterable
+     * @returns Iterator for the products array
+     */
+    [Symbol.iterator]() {
+        return this.products[Symbol.iterator]();
+    }
     /**
      * Custom toJSON method to control what gets serialized when logging
      * @returns Serialized search results with product data

package/dist/common/user.instance.d.ts

@@ -1,8 +1,7 @@
-import { UserData } from "../interfaces/admin.js";
 import { UserDataAPI } from "../types/index.js";
 /**
  * User data instance class providing a fluent API for managing user data
- * Automatically sanitizes sensitive fields and provides methods for updating and clearing data
+ * Provides methods for updating and clearing data
  * Supports direct property access (e.g., user.name) instead of user.data.name
  */
 export default class UserDataInstance {
@@ -12,17 +11,10 @@ export default class UserDataInstance {
     /**
      * Creates a new UserDataInstance with proxy support for direct property access
      * @param api - The UserDataAPI instance for making API calls
-     * @param data - The user data from the API (will be sanitized automatically)
+     * @param data - The user data from the API
      * @returns Proxied instance that allows direct access to data properties
      */
-    constructor(api: UserDataAPI, data: UserData);
-    /**
-     * Removes sensitive fields from the data before storing
-     * @param data - The raw user data to sanitize
-     * @returns Sanitized data with sensitive fields removed
-     * @private
-     */
-    private sanitizeData;
+    constructor(api: UserDataAPI, data: any);
     /**
      * Custom toJSON method to control what gets serialized when logging
      * @returns Serialized user data
@@ -31,7 +23,7 @@ export default class UserDataInstance {
     /**
      * Updates the user's data
      * @param data - The data fields to update or add to user data
-     * @returns Promise resolving to the updated sanitized user data
+     * @returns Promise resolving to the updated user data
      * @throws Error if the update fails
      */
     update(data: Record<string, any>): Promise<any>;

package/dist/common/user.instance.js

@@ -1,17 +1,17 @@
 /**
  * User data instance class providing a fluent API for managing user data
- * Automatically sanitizes sensitive fields and provides methods for updating and clearing data
+ * Provides methods for updating and clearing data
  * Supports direct property access (e.g., user.name) instead of user.data.name
  */
 export default class UserDataInstance {
     /**
      * Creates a new UserDataInstance with proxy support for direct property access
      * @param api - The UserDataAPI instance for making API calls
-     * @param data - The user data from the API (will be sanitized automatically)
+     * @param data - The user data from the API
      * @returns Proxied instance that allows direct access to data properties
      */
     constructor(api, data) {
-        this.data = this.sanitizeData(data);
+        this.data = data;
         // Make userAPI non-enumerable so it doesn't show up in console.log
         Object.defineProperty(this, 'userAPI', {
             value: api,
@@ -74,25 +74,6 @@ export default class UserDataInstance {
             }
         });
     }
-    /**
-     * Removes sensitive fields from the data before storing
-     * @param data - The raw user data to sanitize
-     * @returns Sanitized data with sensitive fields removed
-     * @private
-     */
-    sanitizeData(data) {
-        if (!data || typeof data !== 'object') {
-            return data;
-        }
-        // Create a copy of the data to avoid mutating the original
-        const sanitized = { ...data };
-        // Remove sensitive fields
-        const sensitiveFields = ['agentId', 'userId'];
-        sensitiveFields.forEach(field => {
-            delete sanitized[field];
-        });
-        return sanitized;
-    }
     /**
      * Custom toJSON method to control what gets serialized when logging
      * @returns Serialized user data
@@ -110,13 +91,13 @@ export default class UserDataInstance {
     /**
      * Updates the user's data
      * @param data - The data fields to update or add to user data
-     * @returns Promise resolving to the updated sanitized user data
+     * @returns Promise resolving to the updated user data
      * @throws Error if the update fails
      */
     async update(data) {
         try {
             const response = await this.userAPI.update(data);
-            this.data = this.sanitizeData(response.data);
+            this.data = response.data;
             return this.data;
         }
         catch (error) {

package/dist/index.js

@@ -30,6 +30,7 @@ Categories:
   ☁️  Deployment       Push and deploy to production
   💬 Testing          Chat and test your agent
   ⚙️  Configuration    Manage environment and persona
+  📖 Utilities        Quick access to admin and docs
 
 Examples:
   $ lua auth configure      🔑 Set up your API key
@@ -41,6 +42,8 @@ Examples:
   $ lua chat               💬 Start interactive chat
   $ lua env                ⚙️  Manage environment variables
   $ lua persona            🤖 Manage agent persona
+  $ lua admin              🔧 Open admin dashboard
+  $ lua docs               📖 Open documentation
 
 🌙 Documentation: https://docs.heylua.ai
 🌙 Support: https://heylua.ai/support