appwrite-utils-cli 1.5.2 → 1.6.1

package/CHANGELOG.md

@@ -0,0 +1,199 @@
+# Changelog
+
+All notable changes to the appwrite-utils-cli package will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [1.6.1] - 2025-10-02
+
+### Changed
+- **Code Organization**: Major refactoring to improve maintainability
+  - Extracted wipe operations into dedicated module (501 lines)
+  - Extracted transfer operations into dedicated module (516 lines)
+  - Extracted config discovery logic into separate file (502 lines)
+  - Split interactive CLI into 5 focused command modules (1,595 lines total)
+  - Reduced large file sizes by 30-60% while maintaining all functionality
+- **Logging Standardization**: Unified logging across entire codebase
+  - Replaced ~500 console.* calls with MessageFormatter
+  - Consistent prefixes and formatting for better debugging
+  - Integrated with Winston structured logging
+- **New Utilities**: Added shared utility modules for better code reuse
+  - errorUtils.ts for centralized error handling
+  - directoryUtils.ts for file system operations
+  - typeGuards.ts for TypeScript type safety
+  - pathResolvers.ts for consistent path resolution
+
+## [1.6.0] - 2025-01-27
+
+### Added
+- **Session Authentication Integration**: Complete integration with Appwrite CLI session authentication
+  - New CLI flags: `--use-session`, `--session`, `--sessionCookie` for flexible authentication
+  - Automatic detection and usage of sessions from `~/.appwrite/prefs.json`
+  - Priority authentication system: explicit session → session from prefs → API key → error
+  - Enhanced error messages with available session listing and login guidance
+  - Seamless integration maintaining backward compatibility with API key workflows
+
+- **Native Project Configuration Support**: Full support for appwrite.json/appwrite.config.json files
+  - Automatic project configuration detection and loading from current directory tree
+  - Support for both Collections and TablesDB project formats from official Appwrite CLI
+  - Enhanced project context awareness for better tooling integration
+  - Conversion between project config and internal AppwriteConfig formats
+  - Priority system: CLI args → project config → YAML config → interactive prompt
+
+- **Intelligent Version-Aware Setup**: Enhanced setup command with smart detection
+  - **Project-First Detection**: Automatically detects project type from existing appwrite.json
+  - **Session-Powered Version Detection**: Uses session auth for server version checking when available
+  - **Context-Aware Templates**: Generates tables/columns templates for TablesDB (1.8.0+)
+  - **Legacy Support**: Generates collections/attributes templates for older versions
+  - **Smart Schema Generation**: Creates appropriate JSON schemas (table.schema.json vs collection.schema.json)
+  - **Enhanced Examples**: TablesDB templates include unique constraints and row-level security features
+
+- **Enhanced Client Creation**: Completely overhauled authentication flow
+  - New `getClientWithAuth()` function with intelligent fallback system
+  - Session validation and endpoint matching for security
+  - Enhanced `UtilsController` with session authentication support
+  - Automatic session discovery when no API key provided
+  - Clear authentication method logging and error reporting
+
+- **Hono-TypeScript Function Template**: New web framework template for modern API development
+  - Complete Hono.dev integration with Appwrite functions
+  - Request/response adapters for seamless Appwrite-Hono bridge
+  - Built-in middleware for logging, error handling, and context injection
+  - Example API endpoints with database operations and authentication
+  - Comprehensive documentation and usage examples
+
+- **Enhanced Function Templates**: Improved TypeScript and Python templates
+  - Complete Pydantic models for Python functions with proper type hints
+  - Enhanced Zod schemas for TypeScript functions with full validation
+  - Better error handling and context validation in templates
+  - Updated dependencies (Hono, Zod, Pydantic) in template configurations
+
+- **Dual Collections/Tables Support**: Full support for both legacy and TablesDB APIs
+  - Enhanced YAML loading from both `collections/` and `tables/` directories simultaneously
+  - Automatic conflict detection and resolution between folder structures
+  - Version-aware folder selection based on Appwrite API detection
+  - Backward compatibility with existing projects
+
+- **Interactive CLI Enhancements**: Improved user experience and database association
+  - Better collection/table selection with type indicators (🟢 Collection, 🔵 Table)
+  - Enhanced database filtering using optional `databaseId` for tables
+  - Improved prompts and contextual information display
+  - Better organization of mixed collection/table scenarios
+
+- **Configuration Validation & Migration**: Comprehensive validation and migration tools
+  - New CLI flags: `--validate`, `--validate-strict`, `--migrate-collections-to-tables`
+  - Configuration validation with detailed error reporting and suggestions
+  - Multiple migration strategies for different project needs
+  - Integration with config loading for automatic validation
+
+- **Enhanced Sync Operations**: Fixed and improved sync-from-Appwrite functionality
+  - **Fixed Database Syncing**: Remote databases now properly sync into `config.yaml`
+  - **Version-Aware YAML Generation**: Correct schema references and folder selection
+  - **Improved Error Handling**: Better user feedback and error recovery
+  - **Enhanced Logging**: Comprehensive operation tracking and debugging
+
+### Changed
+- **Authentication Priority**: Complete overhaul of authentication handling throughout CLI
+  - Session authentication now preferred over API key when available
+  - Enhanced error messages guide users to proper authentication setup
+  - Better integration with existing Appwrite CLI workflows
+  - Maintained full backward compatibility with existing projects
+
+- **Setup Command Experience**: Major improvements to project initialization
+  - Intelligent detection provides better user feedback about project type
+  - Version-aware terminology throughout setup process
+  - Enhanced console output with detection source information
+  - Better guidance for TablesDB features and capabilities
+
+- **Configuration Loading**: Enhanced to work with multiple configuration sources
+  - Project configuration loading from appwrite.json files
+  - Better conflict resolution between different config sources
+  - Enhanced validation and error handling for mixed scenarios
+
+- **Enhanced Logging Infrastructure**: Comprehensive logging throughout the CLI
+  - Structured JSON logging with operation context and timing
+  - Version detection and adapter selection logging
+  - Attribute min/max value processing logs with before/after values
+  - Performance timing for bottleneck identification
+
+- **Improved Template System**: Better function template organization and options
+  - Added "TypeScript with Hono Web Framework" option to CLI
+  - Enhanced template variable replacement system
+  - Better template defaults and configuration
+  - Improved template documentation and examples
+
+### Fixed
+- **Authentication Error Handling**: Resolved issues with missing authentication
+  - Better fallback logic when session authentication unavailable
+  - Clear error messages with actionable guidance
+  - Proper handling of invalid or expired session cookies
+  - Enhanced validation of authentication methods
+
+- **Type Safety**: Resolved TypeScript compilation issues
+  - Fixed session authentication type definitions
+  - Proper null/undefined handling in project configuration
+  - Enhanced type inference throughout authentication flow
+  - Better error message types and interfaces
+
+- **Version Detection**: Improved reliability of server version detection
+  - Better error handling when version detection fails
+  - Enhanced fallback mechanisms for offline scenarios
+  - Improved session-based version detection accuracy
+
+- **Integer/Float Min/Max Handling**: Resolved issues with extreme values in attribute creation
+  - Implemented 10 billion threshold logic for min/max values
+  - Proper undefined value handling for Appwrite API compatibility
+  - Consistent normalization between create and update operations
+  - Better comparison logic for determining when updates are needed
+
+- **Collection Re-pushing Prevention**: Eliminated unnecessary collection processing
+  - Intelligent state management prevents duplicate operations
+  - Surgical queue processing for relationship attributes only
+  - Better cache management and state tracking
+  - Performance improvements for large collection push operations
+
+- **Version-Aware Attribute Creation**: Proper API mode detection and routing
+  - All attribute operations now route through adapter pattern
+  - TablesDB vs Legacy API terminology used correctly
+  - Fixed direct SDK calls that bypassed version detection
+  - Maintained backward compatibility with pre-1.8.0 Appwrite
+
+- **Sync-from-Appwrite Issues**: Comprehensive fixes for YAML generation
+  - Database definitions now properly added to configuration
+  - Version-aware folder structure (tables/ vs collections/)
+  - Correct schema references in generated YAML files
+  - Enhanced error handling and user feedback
+
+### Technical Improvements
+- **New Utilities**: Added comprehensive session and project management utilities
+  - `sessionAuth.ts` - Complete session management and validation
+  - `projectConfig.ts` - Appwrite project configuration handling
+  - Enhanced `getClientFromConfig.ts` with session authentication support
+  - Improved `setupFiles.ts` with intelligent version detection
+
+- **Enhanced Type Definitions**: Better TypeScript support throughout
+  - Comprehensive session authentication types
+  - Project configuration interfaces and validation
+  - Enhanced error handling and message formatting
+  - Better integration between authentication methods
+
+- **Improved Error Handling**: More helpful and actionable error messages
+  - Authentication method reporting and guidance
+  - Session availability checking and listing
+  - Project configuration validation feedback
+  - Version detection status and fallback information
+
+- **Full TypeScript Type Safety**: Enhanced type definitions throughout
+- **Comprehensive Test Coverage**: Extensive testing for all new features
+- **Performance Optimizations**: Reduced redundant operations and improved efficiency
+- **Enhanced Debugging**: Better visibility into CLI operations and state changes
+
+## [1.5.2] - 2024-XX-XX
+
+### Previous
+- Earlier version features and improvements
+
+## Earlier Versions
+
+Please refer to git history for changes prior to v1.6.0.

package/README.md

@@ -2,7 +2,9 @@
 
 ## Overview
 
-`appwrite-utils-cli` is a powerful, YAML-first command-line interface tool designed for Appwrite developers who need to manage database migrations, schema generation, data import, and comprehensive project management. Built on a modular architecture with enhanced performance, this CLI tool facilitates complex tasks like setting up databases, running migrations, generating schemas, and managing backups efficiently. With version 1.0.0, the CLI introduces a completely refactored import system with 50%+ complexity reduction, YAML-first configuration, and sophisticated data handling capabilities.
+`appwrite-utils-cli` is a powerful, YAML-first command-line interface tool designed for Appwrite developers who need to manage database migrations, schema generation, data import, and comprehensive project management. Built on a modular architecture with enhanced performance, this CLI tool facilitates complex tasks like setting up databases, running migrations, generating schemas, and managing backups efficiently.
+
+**Version 1.6.1**: Major refactoring for improved code organization - extracted operations into focused modules, standardized logging across the codebase, and added utility libraries for better maintainability.
 
 ## Features
 
@@ -13,6 +15,13 @@
 - **Enhanced Performance**: Configurable rate limiting and batch processing for optimal performance
 - **Safety First**: Smart confirmation dialogs for destructive operations with explicit confirmations
 
+### Dual API Support (Collections & TablesDB)
+- **Collections API**: Traditional Appwrite database operations with document-based terminology
+- **TablesDB API**: New high-performance table API with column-based terminology
+- **Automatic Detection**: Smart API mode detection based on configuration and available packages
+- **Seamless Migration**: Zero-downtime migration between Collections and TablesDB APIs
+- **Terminology Flexibility**: Support for both `collections/documents/attributes` and `tables/rows/columns`
+
 ### Data Management
 - **Advanced Data Import**: YAML-configured imports with sophisticated file handling, URL support, and user deduplication
 - **Relationship Resolution**: Intelligent cross-collection relationship mapping and ID resolution
@@ -44,6 +53,87 @@ npx --package=appwrite-utils-cli@latest appwrite-migrate [options]
 
 **Note: Do not install this locally into your project. It is meant to be used as a command-line tool only.**
 
+## TablesDB Support
+
+`appwrite-utils-cli` provides comprehensive support for both traditional Appwrite Collections API and the new TablesDB API, enabling high-performance database operations with modern terminology.
+
+### API Mode Detection
+
+The CLI automatically detects which API to use based on:
+
+1. **Package Detection**: Checks for `node-appwrite-tablesdb` package installation
+2. **Configuration**: Detects `collections` vs `tables` in YAML configuration
+3. **Environment**: Falls back to Collections API if TablesDB is not available
+
+### Installing TablesDB Support
+
+To enable TablesDB functionality, install the TablesDB package alongside the CLI:
+
+```bash
+# For global CLI usage
+npm install -g node-appwrite-tablesdb
+
+# For project-specific usage
+npm install node-appwrite-tablesdb
+npx --package=appwrite-utils-cli@latest --package=node-appwrite-tablesdb@latest appwrite-migrate --it
+```
+
+### Configuration Comparison
+
+#### Collections API (Traditional)
+```yaml
+# .appwrite/config.yaml
+databases:
+  - name: "main"
+    id: "main"
+    collections:  # Collections terminology
+      - name: "Users"
+        id: "users"
+        attributes:
+          - key: "email"
+            type: "string"
+            required: true
+```
+
+#### TablesDB API (New)
+```yaml
+# .appwrite/config.yaml
+databases:
+  - name: "main"
+    id: "main"
+    tables:  # TablesDB terminology
+      - name: "Users"
+        id: "users"
+        attributes:  # Internally consistent
+          - key: "email"
+            type: "string"
+            required: true
+```
+
+### Performance Benefits
+
+TablesDB provides significant performance improvements:
+
+- **Bulk Operations**: Native support for bulk inserts, updates, and deletes
+- **Advanced Queries**: Enhanced query capabilities with better optimization
+- **Reduced Latency**: Direct table operations without document overhead
+- **Scalability**: Better performance with large datasets
+
+### Migration Commands
+
+The CLI provides seamless migration between APIs:
+
+```bash
+# Migrate Collections config to TablesDB format
+npx appwrite-utils-cli appwrite-migrate --migrate-to-tablesdb
+
+# Convert existing Collections to Tables (when TablesDB is available)
+npx appwrite-utils-cli appwrite-migrate --sync --use-tablesdb
+
+# Generate schemas for TablesDB
+npx appwrite-utils-cli appwrite-migrate --generate --api-mode=tablesdb
+```
+
 ## YAML-First Configuration
 
 Version 1.0.0 introduces a YAML-first approach for better cross-platform compatibility and enhanced developer experience.
@@ -55,8 +145,9 @@ The CLI automatically detects configuration files in this order:
 2. `appwrite.yaml`
 3. `appwriteConfig.ts` (legacy, still supported)
 
-### YAML Configuration Example
+### YAML Configuration Examples
 
+#### Collections API Configuration
 ```yaml
 # .appwrite/config.yaml with JSON Schema support
 # yaml-language-server: $schema=./.yaml_schemas/appwrite-config.schema.json
@@ -68,7 +159,7 @@ appwriteKey: "your-api-key"
 databases:
   - name: "main"
     id: "main"
-    collections:
+    collections:  # Collections terminology
       - name: "Users"
         id: "users"
         attributes:
@@ -76,6 +167,46 @@ databases:
             type: "string"
             required: true
             format: "email"
+          - key: "name"
+            type: "string"
+            required: true
+
+buckets:
+  - name: "documents"
+    id: "documents"
+    permissions:
+      - target: "any"
+        permission: "read"
+
+logging:
+  enabled: false  # Disabled by default
+  level: "info"
+  console: true
+```
+
+#### TablesDB API Configuration
+```yaml
+# .appwrite/config.yaml for TablesDB
+# yaml-language-server: $schema=./.yaml_schemas/appwrite-config.schema.json
+
+appwriteEndpoint: "https://cloud.appwrite.io/v1"
+appwriteProject: "your-project-id"
+appwriteKey: "your-api-key"
+
+databases:
+  - name: "main"
+    id: "main"
+    tables:  # TablesDB terminology
+      - name: "Users"
+        id: "users"
+        attributes:  # Internal compatibility
+          - key: "email"
+            type: "string"
+            required: true
+            format: "email"
+          - key: "name"
+            type: "string"
+            required: true
 
 buckets:
   - name: "documents"
@@ -120,8 +251,9 @@ npx --package=appwrite-utils-cli@latest appwrite-migrate [options]
 
 Version 1.0.0 introduces a powerful YAML-based import system with sophisticated data handling capabilities.
 
-### Import Configuration Example
+### Import Configuration Examples
 
+#### Collections API Import
 ```yaml
 # .appwrite/import/users-import.yaml
 # yaml-language-server: $schema=../.yaml_schemas/import-config.schema.json
@@ -132,7 +264,7 @@ source:
   type: "json"
 
 target:
-  collection: "Users"
+  collection: "Users"  # Collections terminology
   type: "create"
   primaryKey: "user_id"
   createUsers: true
@@ -165,6 +297,51 @@ options:
   continueOnError: true
 ```
 
+#### TablesDB API Import
+```yaml
+# .appwrite/import/users-tablesdb-import.yaml
+# yaml-language-server: $schema=../.yaml_schemas/import-config.schema.json
+
+source:
+  file: "importData/users.json"
+  basePath: "RECORDS"
+  type: "json"
+
+target:
+  table: "Users"  # TablesDB terminology (alternatively: collection: "Users" works too)
+  type: "create"
+  primaryKey: "user_id"
+  createUsers: true
+
+mapping:
+  attributes:  # Note: Still uses 'attributes' for compatibility
+    - oldKey: "user_id"
+      targetKey: "userId"
+      converters: ["anyToString"]
+      validation:
+        - rule: "required"
+          params: ["{userId}"]
+
+    - oldKey: "profile_image_url"
+      targetKey: "avatar"
+      fileData:
+        path: "{profile_image_url}"
+        name: "{user_id}_avatar"
+      afterImport:
+        - action: "createFileAndUpdateRowField"  # TablesDB-specific action
+          params: ["{dbId}", "{tableId}", "{rowId}", "avatar", "{bucketId}", "{filePath}", "{fileName}"]
+
+  relationships:
+    - sourceField: "department_id"
+      targetField: "departmentId"
+      targetTable: "Departments"  # TablesDB terminology
+
+options:
+  batchSize: 100  # TablesDB supports larger batches
+  continueOnError: true
+  useBulkOperations: true  # Enable TablesDB bulk operations
+```
+
 ### Import System Features
 
 - **File Handling**: Complete support for URL downloads and local file search
@@ -188,12 +365,19 @@ Available options:
 
 ### Data Management
 - `--dbIds`: Comma-separated list of database IDs to operate on
-- `--collectionIds`: Comma-separated list of collection IDs to operate on
+- `--collectionIds`: Comma-separated list of collection IDs to operate on (also accepts `--tableIds`)
 - `--bucketIds`: Comma-separated list of bucket IDs to operate on
 - `--wipe`: Wipe data with smart confirmation (all: everything, docs: only documents, users: only user data)
-- `--wipeCollections`: Non-destructively wipe specified collections
+- `--wipeCollections`: Non-destructively wipe specified collections (also `--wipeTables`)
 - `--writeData`: Write converted imported data to file for validation
 
+### TablesDB-Specific Options
+- `--api-mode`: Force API mode (`collections` or `tablesdb`)
+- `--use-tablesdb`: Force TablesDB API usage when available
+- `--migrate-to-tablesdb`: Convert Collections configuration to TablesDB format
+- `--bulk-operations`: Enable bulk operations for TablesDB (default: true when available)
+- `--tableIds`: Comma-separated list of table IDs (alias for `--collectionIds`)
+
 ### Configuration & Synchronization
 - `--push`: Push local YAML/TypeScript config to Appwrite project
 - `--sync`: Synchronize by pulling config from Appwrite project
@@ -282,6 +466,44 @@ Transfer specific collections from one place to another, with all of their data:
 npx appwrite-utils-cli appwrite-migrate --transfer --fromDbId sourceDbId --toDbId targetDbId --fromCollectionId sourceCollectionId --toCollectionId targetCollectionId --remoteEndpoint https://appwrite.otherserver.com --remoteProjectId yourProjectId --remoteApiKey yourApiKey
 ```
 
+### TablesDB Examples
+
+#### Enable TablesDB Mode
+```bash
+# Force TablesDB API usage
+npx appwrite-utils-cli appwrite-migrate --sync --use-tablesdb
+
+# Generate schemas with TablesDB terminology
+npx appwrite-utils-cli appwrite-migrate --generate --api-mode=tablesdb
+```
+
+#### Migration from Collections to TablesDB
+```bash
+# Convert Collections configuration to TablesDB format
+npx appwrite-utils-cli appwrite-migrate --migrate-to-tablesdb
+
+# Sync with TablesDB API (requires node-appwrite-tablesdb)
+npx --package=node-appwrite-tablesdb appwrite-utils-cli appwrite-migrate --sync --use-tablesdb
+```
+
+#### Bulk Operations with TablesDB
+```bash
+# Import with bulk operations enabled
+npx appwrite-utils-cli appwrite-migrate --import --bulk-operations
+
+# Transfer tables with high-performance bulk operations
+npx appwrite-utils-cli appwrite-migrate --transfer --fromDbId sourceDb --toDbId targetDb --tableIds table1,table2 --use-tablesdb
+```
+
+#### Working with Tables (TablesDB terminology)
+```bash
+# Wipe specific tables
+npx appwrite-utils-cli appwrite-migrate --wipeTables --tableIds users,posts
+
+# Generate constants with table terminology
+npx appwrite-utils-cli appwrite-migrate --generateConstants --api-mode=tablesdb
+```
+
 ### Transfer Buckets
 
 Transfer files between buckets:
@@ -325,28 +547,28 @@ Available specifications:
 
 This updated CLI ensures that developers have robust tools at their fingertips to manage complex Appwrite projects effectively from the command line, with both interactive and non-interactive modes available for flexibility.
 
-## Changelog
-
-### 1.5.0 - Recursive Zod v4 Schemas + One‑Way Relationship Support
-
-Highlights
-- Recursive getters: Generated schemas now use Zod v4 recursive getters (no `z.lazy`, no `BaseSchema` layering). Cleaner types and fully inferred mutual recursion.
-- One‑way relationships: Relationship attributes are now included even when `twoWay: false`. Related imports resolve collection IDs to names.
-- Required semantics: Relationship getters respect `required` and `array`:
-  - required scalar → `RelatedSchema`
-  - optional scalar → `RelatedSchema.nullish()`
-  - required array → `RelatedSchema.array()`
-  - optional array → `RelatedSchema.array().nullish()`
-- JSON Schemas: `$ref` definitions use resolved collection names when YAML provides IDs.
-
-Validation changes
-- Relationship schema: `twoWayKey` and `side` are now required only when `twoWay` is `true`.
-- Helpful errors: Keeps strong validation but removes false negatives for one‑way relationships.
-
-Developer notes
-- Imports: Schema generators import only `...Schema` from related collections (no type imports needed).
-- Example YAML: `Posts.yaml` demonstrates a required `manyToMany` (`categories`) and a one‑way `manyToOne` (`author`).
-
+## Changelog
+
+### 1.5.0 - Recursive Zod v4 Schemas + One‑Way Relationship Support
+
+Highlights
+- Recursive getters: Generated schemas now use Zod v4 recursive getters (no `z.lazy`, no `BaseSchema` layering). Cleaner types and fully inferred mutual recursion.
+- One‑way relationships: Relationship attributes are now included even when `twoWay: false`. Related imports resolve collection IDs to names.
+- Required semantics: Relationship getters respect `required` and `array`:
+  - required scalar → `RelatedSchema`
+  - optional scalar → `RelatedSchema.nullish()`
+  - required array → `RelatedSchema.array()`
+  - optional array → `RelatedSchema.array().nullish()`
+- JSON Schemas: `$ref` definitions use resolved collection names when YAML provides IDs.
+
+Validation changes
+- Relationship schema: `twoWayKey` and `side` are now required only when `twoWay` is `true`.
+- Helpful errors: Keeps strong validation but removes false negatives for one‑way relationships.
+
+Developer notes
+- Imports: Schema generators import only `...Schema` from related collections (no type imports needed).
+- Example YAML: `Posts.yaml` demonstrates a required `manyToMany` (`categories`) and a one‑way `manyToOne` (`author`).
+
 
 ### 1.3.0 - Zod v4 Upgrade & Collection Management Fixes
 

package/dist/adapters/AdapterFactory.d.ts

@@ -11,9 +11,12 @@ import type { DatabaseAdapter } from './DatabaseAdapter.js';
 export interface AdapterFactoryConfig {
     appwriteEndpoint: string;
     appwriteProject: string;
-    appwriteKey: string;
+    appwriteKey?: string;
     apiMode?: 'auto' | 'legacy' | 'tablesdb';
     forceRefresh?: boolean;
+    sessionCookie?: string;
+    authMethod?: 'session' | 'apikey' | 'auto';
+    preConfiguredClient?: any;
 }
 export interface AdapterFactoryResult {
     adapter: DatabaseAdapter;
@@ -59,6 +62,10 @@ export declare class AdapterFactory {
      * Clear adapter cache (useful for testing)
      */
     static clearCache(): void;
+    /**
+     * Validate authentication configuration
+     */
+    private static validateAuthConfig;
     /**
      * Test connection and API capabilities
      */
@@ -72,11 +79,11 @@ export declare class AdapterFactory {
 /**
  * Convenience function for quick adapter creation
  */
-export declare function createDatabaseAdapter(endpoint: string, project: string, apiKey: string, mode?: 'auto' | 'legacy' | 'tablesdb'): Promise<DatabaseAdapter>;
+export declare function createDatabaseAdapter(endpoint: string, project: string, apiKey?: string, mode?: 'auto' | 'legacy' | 'tablesdb', sessionCookie?: string): Promise<DatabaseAdapter>;
 /**
  * Helper function to get adapter metadata without creating full adapter
  */
-export declare function getApiCapabilities(endpoint: string, project: string, apiKey: string): Promise<{
+export declare function getApiCapabilities(endpoint: string, project: string, apiKey?: string, sessionCookie?: string): Promise<{
     apiMode: ApiMode;
     terminology: {
         container: string;