commandkit 1.2.0-rc.13 → 1.2.0-rc.15

package/dist/kv/kv.d.ts

@@ -45,342 +45,342 @@ declare class KV implements Disposable, AsyncDisposable {
   private db;
   private statements;
   /**
-       * Creates a new KV store instance
-       *
-       * @param path - Database file path, buffer, URL, or existing DatabaseSync instance
-       * @param options - Configuration options for the KV store
-       */
+   * Creates a new KV store instance
+   *
+   * @param path - Database file path, buffer, URL, or existing DatabaseSync instance
+   * @param options - Configuration options for the KV store
+   */
   constructor(path: string | Buffer | URL | DatabaseSync, options?: KvOptions);
   /**
-       * Gets the current timestamp in milliseconds
-       */
+   * Gets the current timestamp in milliseconds
+   */
   private getCurrentTime;
   /**
-       * Checks if the database connection is open
-       *
-       * @returns `true` if the database is open, `false` otherwise
-       */
+   * Checks if the database connection is open
+   *
+   * @returns `true` if the database is open, `false` otherwise
+   */
   isOpen(): boolean;
   /**
-       * Gets the underlying SQLite database instance
-       *
-       * @returns The DatabaseSync instance
-       */
+   * Gets the underlying SQLite database instance
+   *
+   * @returns The DatabaseSync instance
+   */
   getDatabase(): DatabaseSync;
   /**
-       * Closes the database connection
-       */
+   * Closes the database connection
+   */
   close(): void;
   /**
-       * Disposable implementation - closes the database when disposed
-       */
+   * Disposable implementation - closes the database when disposed
+   */
   [Symbol.dispose](): void;
   /**
-       * AsyncDisposable implementation - closes the database when disposed
-       */
+   * AsyncDisposable implementation - closes the database when disposed
+   */
   [Symbol.asyncDispose](): Promise<void>;
   /**
-       * Retrieves a value by key
-       *
-       * @param key - The key to retrieve (supports dot notation for nested properties)
-       * @returns The value associated with the key, or `undefined` if not found or expired
-       *
-       * @example
-       * ```typescript
-       * // Store an object
-       * kv.set('user:123', { name: 'John', age: 30, settings: { theme: 'dark' } });
-       *
-       * // Get the entire object
-       * const user = kv.get('user:123');
-       * // { name: 'John', age: 30, settings: { theme: 'dark' } }
-       *
-       * // Get nested properties using dot notation
-       * const name = kv.get('user:123.name'); // 'John'
-       * const theme = kv.get('user:123.settings.theme'); // 'dark'
-       * ```
-       */
+   * Retrieves a value by key
+   *
+   * @param key - The key to retrieve (supports dot notation for nested properties)
+   * @returns The value associated with the key, or `undefined` if not found or expired
+   *
+   * @example
+   * ```typescript
+   * // Store an object
+   * kv.set('user:123', { name: 'John', age: 30, settings: { theme: 'dark' } });
+   *
+   * // Get the entire object
+   * const user = kv.get('user:123');
+   * // { name: 'John', age: 30, settings: { theme: 'dark' } }
+   *
+   * // Get nested properties using dot notation
+   * const name = kv.get('user:123.name'); // 'John'
+   * const theme = kv.get('user:123.settings.theme'); // 'dark'
+   * ```
+   */
   get<T = any>(key: string): T | undefined;
   /**
-       * Sets a key-value pair
-       *
-       * @param key - The key to set (supports dot notation for nested properties)
-       * @param value - The value to associate with the key (any JSON-serializable type)
-       *
-       * @example
-       * ```typescript
-       * // Store primitive values
-       * kv.set('counter', 42);
-       * kv.set('active', true);
-       * kv.set('name', 'John');
-       *
-       * // Store objects
-       * kv.set('user:123', { name: 'John', age: 30 });
-       *
-       * // Store arrays
-       * kv.set('tags', ['javascript', 'typescript', 'sqlite']);
-       *
-       * // Store dates
-       * kv.set('created', new Date());
-       *
-       * // Store maps and sets
-       * kv.set('permissions', new Map([['admin', true], ['user', false]]));
-       * kv.set('unique_ids', new Set([1, 2, 3, 4, 5]));
-       *
-       * // Use dot notation for nested properties
-       * kv.set('user:123.settings.theme', 'dark');
-       * kv.set('user:123.settings.notifications', true);
-       * ```
-       */
+   * Sets a key-value pair
+   *
+   * @param key - The key to set (supports dot notation for nested properties)
+   * @param value - The value to associate with the key (any JSON-serializable type)
+   *
+   * @example
+   * ```typescript
+   * // Store primitive values
+   * kv.set('counter', 42);
+   * kv.set('active', true);
+   * kv.set('name', 'John');
+   *
+   * // Store objects
+   * kv.set('user:123', { name: 'John', age: 30 });
+   *
+   * // Store arrays
+   * kv.set('tags', ['javascript', 'typescript', 'sqlite']);
+   *
+   * // Store dates
+   * kv.set('created', new Date());
+   *
+   * // Store maps and sets
+   * kv.set('permissions', new Map([['admin', true], ['user', false]]));
+   * kv.set('unique_ids', new Set([1, 2, 3, 4, 5]));
+   *
+   * // Use dot notation for nested properties
+   * kv.set('user:123.settings.theme', 'dark');
+   * kv.set('user:123.settings.notifications', true);
+   * ```
+   */
   set(key: string, value: any): void;
   /**
-       * Sets a key-value pair with expiration
-       *
-       * @param key - The key to set (supports dot notation for nested properties)
-       * @param value - The value to associate with the key (any JSON-serializable type)
-       * @param ttl - Time to live in milliseconds
-       *
-       * @example
-       * ```typescript
-       * // Set with 1 hour expiration
-       * kv.setex('session:123', { userId: 123, token: 'abc123' }, 60 * 60 * 1000);
-       *
-       * // Set with 5 minutes expiration
-       * kv.setex('temp:data', { cached: true, timestamp: Date.now() }, 5 * 60 * 1000);
-       *
-       * // Use dot notation with expiration
-       * kv.setex('user:123.temp_settings', { theme: 'light' }, 30 * 60 * 1000);
-       * ```
-       */
+   * Sets a key-value pair with expiration
+   *
+   * @param key - The key to set (supports dot notation for nested properties)
+   * @param value - The value to associate with the key (any JSON-serializable type)
+   * @param ttl - Time to live in milliseconds
+   *
+   * @example
+   * ```typescript
+   * // Set with 1 hour expiration
+   * kv.setex('session:123', { userId: 123, token: 'abc123' }, 60 * 60 * 1000);
+   *
+   * // Set with 5 minutes expiration
+   * kv.setex('temp:data', { cached: true, timestamp: Date.now() }, 5 * 60 * 1000);
+   *
+   * // Use dot notation with expiration
+   * kv.setex('user:123.temp_settings', { theme: 'light' }, 30 * 60 * 1000);
+   * ```
+   */
   setex(key: string, value: any, ttl: number): void;
   /**
-       * Performs mathematical operations on numeric values in the KV store
-       *
-       * @param key - The key to perform math operation on (supports dot notation for nested properties)
-       * @param operator - The mathematical operator to apply
-       * @param value - The value to use in the operation
-       * @returns The updated value after the mathematical operation
-       * @throws Error if the existing value is not numeric or if the operation is invalid
-       *
-       * @example
-       * ```typescript
-       * // Initialize a counter
-       * kv.set('counter', 10);
-       *
-       * // Increment by 5
-       * const result1 = kv.math('counter', '+', 5); // 15
-       *
-       * // Multiply by 2
-       * const result2 = kv.math('counter', '*', 2); // 30
-       *
-       * // Use with bigint
-       * kv.set('big_counter', BigInt(1000));
-       * const result3 = kv.math('big_counter', '+', BigInt(500)); // 1500n
-       *
-       * // Use with dot notation
-       * kv.set('user:123', { score: 100, level: 5 });
-       * const result4 = kv.math('user:123.score', '+', 50); // 150
-       * ```
-       */
+   * Performs mathematical operations on numeric values in the KV store
+   *
+   * @param key - The key to perform math operation on (supports dot notation for nested properties)
+   * @param operator - The mathematical operator to apply
+   * @param value - The value to use in the operation
+   * @returns The updated value after the mathematical operation
+   * @throws Error if the existing value is not numeric or if the operation is invalid
+   *
+   * @example
+   * ```typescript
+   * // Initialize a counter
+   * kv.set('counter', 10);
+   *
+   * // Increment by 5
+   * const result1 = kv.math('counter', '+', 5); // 15
+   *
+   * // Multiply by 2
+   * const result2 = kv.math('counter', '*', 2); // 30
+   *
+   * // Use with bigint
+   * kv.set('big_counter', BigInt(1000));
+   * const result3 = kv.math('big_counter', '+', BigInt(500)); // 1500n
+   *
+   * // Use with dot notation
+   * kv.set('user:123', { score: 100, level: 5 });
+   * const result4 = kv.math('user:123.score', '+', 50); // 150
+   * ```
+   */
   math(key: string, operator: KvMathOperator, value: number | bigint): number | bigint;
   /**
-       * Sets expiration for an existing key
-       *
-       * @param key - The key to set expiration for
-       * @param ttl - Time to live in milliseconds
-       * @returns `true` if the key exists and expiration was set, `false` otherwise
-       *
-       * @example
-       * ```typescript
-       * kv.set('user:123', { name: 'John', age: 30 });
-       *
-       * // Set 30 minute expiration
-       * if (kv.expire('user:123', 30 * 60 * 1000)) {
-       *   console.log('Expiration set successfully');
-       * }
-       * ```
-       */
+   * Sets expiration for an existing key
+   *
+   * @param key - The key to set expiration for
+   * @param ttl - Time to live in milliseconds
+   * @returns `true` if the key exists and expiration was set, `false` otherwise
+   *
+   * @example
+   * ```typescript
+   * kv.set('user:123', { name: 'John', age: 30 });
+   *
+   * // Set 30 minute expiration
+   * if (kv.expire('user:123', 30 * 60 * 1000)) {
+   *   console.log('Expiration set successfully');
+   * }
+   * ```
+   */
   expire(key: string, ttl: number): boolean;
   /**
-       * Gets the time to live for a key
-       *
-       * @param key - The key to check
-       * @returns Time to live in milliseconds, or `-1` if the key doesn't exist, or `-2` if the key has no expiration
-       *
-       * @example
-       * ```typescript
-       * const ttl = kv.ttl('user:123');
-       * if (ttl > 0) {
-       *   console.log(`Key expires in ${ttl}ms`);
-       * } else if (ttl === -2) {
-       *   console.log('Key has no expiration');
-       * } else {
-       *   console.log('Key does not exist');
-       * }
-       * ```
-       */
+   * Gets the time to live for a key
+   *
+   * @param key - The key to check
+   * @returns Time to live in milliseconds, or `-1` if the key doesn't exist, or `-2` if the key has no expiration
+   *
+   * @example
+   * ```typescript
+   * const ttl = kv.ttl('user:123');
+   * if (ttl > 0) {
+   *   console.log(`Key expires in ${ttl}ms`);
+   * } else if (ttl === -2) {
+   *   console.log('Key has no expiration');
+   * } else {
+   *   console.log('Key does not exist');
+   * }
+   * ```
+   */
   ttl(key: string): number;
   /**
-       * Deletes a key-value pair
-       *
-       * @param key - The key to delete
-       *
-       * @example
-       * ```typescript
-       * kv.delete('user:123');
-       * kv.delete('user:123.settings.theme'); // Delete nested property
-       * ```
-       */
+   * Deletes a key-value pair
+   *
+   * @param key - The key to delete
+   *
+   * @example
+   * ```typescript
+   * kv.delete('user:123');
+   * kv.delete('user:123.settings.theme'); // Delete nested property
+   * ```
+   */
   delete(key: string): void;
   /**
-       * Checks if a key exists and is not expired
-       *
-       * @param key - The key to check
-       * @returns `true` if the key exists and is not expired, `false` otherwise
-       *
-       * @example
-       * ```typescript
-       * if (kv.has('user:123')) {
-       *   console.log('User exists and is not expired');
-       * }
-       *
-       * if (kv.has('user:123.settings.theme')) {
-       *   console.log('Theme setting exists');
-       * }
-       * ```
-       */
+   * Checks if a key exists and is not expired
+   *
+   * @param key - The key to check
+   * @returns `true` if the key exists and is not expired, `false` otherwise
+   *
+   * @example
+   * ```typescript
+   * if (kv.has('user:123')) {
+   *   console.log('User exists and is not expired');
+   * }
+   *
+   * if (kv.has('user:123.settings.theme')) {
+   *   console.log('Theme setting exists');
+   * }
+   * ```
+   */
   has(key: string): boolean;
   /**
-       * Gets all keys in the current namespace (excluding expired keys)
-       *
-       * @returns Array of all non-expired keys
-       *
-       * @example
-       * ```typescript
-       * const keys = kv.keys();
-       * console.log('All keys:', keys);
-       * ```
-       */
+   * Gets all keys in the current namespace (excluding expired keys)
+   *
+   * @returns Array of all non-expired keys
+   *
+   * @example
+   * ```typescript
+   * const keys = kv.keys();
+   * console.log('All keys:', keys);
+   * ```
+   */
   keys(): string[];
   /**
-       * Gets all values in the current namespace (excluding expired keys)
-       *
-       * @returns Array of all non-expired values
-       *
-       * @example
-       * ```typescript
-       * const values = kv.values();
-       * console.log('All values:', values);
-       * ```
-       */
+   * Gets all values in the current namespace (excluding expired keys)
+   *
+   * @returns Array of all non-expired values
+   *
+   * @example
+   * ```typescript
+   * const values = kv.values();
+   * console.log('All values:', values);
+   * ```
+   */
   values(): any[];
   /**
-       * Gets the total number of key-value pairs in the current namespace (excluding expired keys)
-       *
-       * @returns The count of non-expired key-value pairs
-       *
-       * @example
-       * ```typescript
-       * const count = kv.count();
-       * console.log(`Total entries: ${count}`);
-       * ```
-       */
+   * Gets the total number of key-value pairs in the current namespace (excluding expired keys)
+   *
+   * @returns The count of non-expired key-value pairs
+   *
+   * @example
+   * ```typescript
+   * const count = kv.count();
+   * console.log(`Total entries: ${count}`);
+   * ```
+   */
   count(): number;
   /**
-       * Removes all key-value pairs from the current namespace
-       *
-       * @example
-       * ```typescript
-       * kv.clear(); // Removes all entries in current namespace
-       * ```
-       */
+   * Removes all key-value pairs from the current namespace
+   *
+   * @example
+   * ```typescript
+   * kv.clear(); // Removes all entries in current namespace
+   * ```
+   */
   clear(): void;
   /**
-       * Gets all key-value pairs as an object (excluding expired keys)
-       *
-       * @returns Object with all non-expired key-value pairs
-       *
-       * @example
-       * ```typescript
-       * const all = kv.all();
-       * console.log('All entries:', all);
-       * // Output: { 'key1': value1, 'key2': value2 }
-       * ```
-       */
+   * Gets all key-value pairs as an object (excluding expired keys)
+   *
+   * @returns Object with all non-expired key-value pairs
+   *
+   * @example
+   * ```typescript
+   * const all = kv.all();
+   * console.log('All entries:', all);
+   * // Output: { 'key1': value1, 'key2': value2 }
+   * ```
+   */
   all(): Record<string, any>;
   /**
-       * Gets all available namespaces (tables) in the database
-       *
-       * @returns Array of namespace names
-       *
-       * @example
-       * ```typescript
-       * const namespaces = kv.namespaces();
-       * console.log('Available namespaces:', namespaces);
-       * ```
-       */
+   * Gets all available namespaces (tables) in the database
+   *
+   * @returns Array of namespace names
+   *
+   * @example
+   * ```typescript
+   * const namespaces = kv.namespaces();
+   * console.log('Available namespaces:', namespaces);
+   * ```
+   */
   namespaces(): string[];
   /**
-       * Gets the current namespace name
-       *
-       * @returns The current namespace string
-       */
+   * Gets the current namespace name
+   *
+   * @returns The current namespace string
+   */
   getCurrentNamespace(): string;
   /**
-       * Creates a new KV instance with a different namespace
-       *
-       * @param namespace - The namespace to use for the new instance
-       * @returns A new KV instance with the specified namespace
-       *
-       * @example
-       * ```typescript
-       * const userKv = kv.namespace('users');
-       * const configKv = kv.namespace('config');
-       *
-       * userKv.set('123', { name: 'John', age: 30 });
-       * configKv.set('theme', 'dark');
-       * ```
-       */
+   * Creates a new KV instance with a different namespace
+   *
+   * @param namespace - The namespace to use for the new instance
+   * @returns A new KV instance with the specified namespace
+   *
+   * @example
+   * ```typescript
+   * const userKv = kv.namespace('users');
+   * const configKv = kv.namespace('config');
+   *
+   * userKv.set('123', { name: 'John', age: 30 });
+   * configKv.set('theme', 'dark');
+   * ```
+   */
   namespace(namespace: string): KV;
   /**
-       * Iterator implementation for iterating over all non-expired key-value pairs
-       *
-       * @returns Iterator yielding [key, value] tuples
-       *
-       * @example
-       * ```typescript
-       * for (const [key, value] of kv) {
-       *   console.log(`${key}:`, value);
-       * }
-       *
-       * // Or using spread operator
-       * const entries = [...kv];
-       * ```
-       */
+   * Iterator implementation for iterating over all non-expired key-value pairs
+   *
+   * @returns Iterator yielding [key, value] tuples
+   *
+   * @example
+   * ```typescript
+   * for (const [key, value] of kv) {
+   *   console.log(`${key}:`, value);
+   * }
+   *
+   * // Or using spread operator
+   * const entries = [...kv];
+   * ```
+   */
   [Symbol.iterator](): Iterator<[string, any]>;
   /**
-       * Executes a function within a transaction
-       *
-       * @param fn - Function to execute within the transaction (can be async)
-       * @returns The result of the function
-       *
-       * @example
-       * ```typescript
-       * // Synchronous transaction
-       * kv.transaction(() => {
-       *   kv.set('user:123', { name: 'John', age: 30 });
-       *   kv.set('user:456', { name: 'Jane', age: 25 });
-       *   // If any operation fails, all changes are rolled back
-       * });
-       *
-       * // Async transaction
-       * await kv.transaction(async () => {
-       *   kv.set('user:123', { name: 'John', age: 30 });
-       *   await someAsyncOperation();
-       *   kv.set('user:456', { name: 'Jane', age: 25 });
-       *   // If any operation fails, all changes are rolled back
-       * });
-       * ```
-       */
+   * Executes a function within a transaction
+   *
+   * @param fn - Function to execute within the transaction (can be async)
+   * @returns The result of the function
+   *
+   * @example
+   * ```typescript
+   * // Synchronous transaction
+   * kv.transaction(() => {
+   *   kv.set('user:123', { name: 'John', age: 30 });
+   *   kv.set('user:456', { name: 'Jane', age: 25 });
+   *   // If any operation fails, all changes are rolled back
+   * });
+   *
+   * // Async transaction
+   * await kv.transaction(async () => {
+   *   kv.set('user:123', { name: 'John', age: 30 });
+   *   await someAsyncOperation();
+   *   kv.set('user:456', { name: 'Jane', age: 25 });
+   *   // If any operation fails, all changes are rolled back
+   * });
+   * ```
+   */
   transaction<T>(fn: () => T | Promise<T>): Promise<T>;
 }
 /**

package/dist/kv/kv.js

@@ -1,4 +1,5 @@
-const require_chunk = require('../chunk-kSYXY2_d.js');
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_chunk = require('../chunk-BE-pF4vm.js');
 const require_kv_dotprops = require('./dotprops.js');
 const require_kv_serde = require('./serde.js');
 let node_sqlite = require("node:sqlite");