appwrite-utils-cli 1.7.9 → 1.8.2

package/dist/adapters/TablesDBAdapter.js

@@ -5,9 +5,10 @@
  * without any translation layer. It uses object notation parameters
  * and returns Models.Row instead of Models.Document.
  */
-import { Query } from "node-appwrite";
+import { IndexType, Query, RelationMutate, RelationshipType } from "node-appwrite";
 import { chunk } from "es-toolkit";
 import { BaseAdapter, AdapterError } from './DatabaseAdapter.js';
+import { TablesDB, Client } from "node-appwrite";
 /**
  * TablesDBAdapter implementation for native TablesDB API
  */
@@ -16,12 +17,16 @@ export class TablesDBAdapter extends BaseAdapter {
     constructor(client) {
         super(client, 'tablesdb');
         // Assuming TablesDB service is available on the client
-        this.tablesDB = client.tablesDB || client;
+        this.tablesDB = new TablesDB(client);
     }
     // Row (Document) Operations
     async listRows(params) {
         try {
-            const result = await this.tablesDB.listRows(params);
+            const result = await this.tablesDB.listRows({
+                tableId: params.tableId,
+                databaseId: params.databaseId,
+                queries: params.queries || [],
+            });
             return {
                 data: result.rows,
                 rows: result.rows,
@@ -100,8 +105,9 @@ export class TablesDBAdapter extends BaseAdapter {
     }
     async createTable(params) {
         try {
+            const rowSecurity = params.rowSecurity ?? params.documentSecurity ?? false;
             const result = await this.tablesDB.createTable(params.databaseId, params.id, // tableId
-            params.name, params.permissions || [], params.documentSecurity ?? false, params.enabled ?? true);
+            params.name, params.permissions || [], rowSecurity, params.enabled ?? true);
             return {
                 data: result,
                 tables: [result]
@@ -113,8 +119,9 @@ export class TablesDBAdapter extends BaseAdapter {
     }
     async updateTable(params) {
         try {
+            const rowSecurity = params.rowSecurity ?? params.documentSecurity;
             const result = await this.tablesDB.updateTable(params.databaseId, params.id, // tableId
-            params.name, params.permissions, params.documentSecurity, params.enabled);
+            params.name, params.permissions, rowSecurity, params.enabled);
             return {
                 data: result,
                 tables: [result]
@@ -179,39 +186,133 @@ export class TablesDBAdapter extends BaseAdapter {
     // Attribute Operations
     async createAttribute(params) {
         try {
-            // TablesDB uses type-specific attribute methods like the legacy SDK
+            // TablesDB exposes type-specific column methods
+            // TablesDB uses type-specific column methods
             let result;
-            switch (params.type.toLowerCase()) {
+            const type = (params.type || "").toLowerCase();
+            const required = params.required ?? false;
+            const array = params.array ?? false;
+            const encrypt = params.encrypt ?? params.encrypted ?? false;
+            const normalizedDefault = params.default === null || params.default === undefined
+                ? undefined
+                : params.default;
+            const numberDefault = typeof normalizedDefault === "number" ? normalizedDefault : undefined;
+            const stringDefault = typeof normalizedDefault === "string" ? normalizedDefault : undefined;
+            const booleanDefault = typeof normalizedDefault === "boolean" ? normalizedDefault : undefined;
+            switch (type) {
                 case 'string':
-                    result = await this.tablesDB.createStringAttribute(params.databaseId, params.tableId, params.key, params.size || 255, params.required ?? false, params.default, params.array ?? false, params.encrypt ?? false);
+                    result = await this.tablesDB.createStringColumn({
+                        databaseId: params.databaseId,
+                        tableId: params.tableId,
+                        key: params.key,
+                        size: params.size || 255,
+                        required: params.required ?? false,
+                        xdefault: params.default,
+                        array: params.array ?? false,
+                        encrypt: params.encrypt ?? false
+                    });
                     break;
                 case 'integer':
-                    result = await this.tablesDB.createIntegerAttribute(params.databaseId, params.tableId, params.key, params.required ?? false, params.min, params.max, params.default, params.array ?? false);
+                    result = await this.tablesDB.createIntegerColumn({
+                        databaseId: params.databaseId,
+                        tableId: params.tableId,
+                        key: params.key,
+                        required: params.required ?? false,
+                        min: params.min,
+                        max: params.max,
+                        xdefault: params.default,
+                        array: params.array ?? false
+                    });
                     break;
                 case 'float':
                 case 'double':
-                    result = await this.tablesDB.createFloatAttribute(params.databaseId, params.tableId, params.key, params.required ?? false, params.min, params.max, params.default, params.array ?? false);
+                    result = await this.tablesDB.createFloatColumn({
+                        databaseId: params.databaseId,
+                        tableId: params.tableId,
+                        key: params.key,
+                        required: params.required ?? false,
+                        min: params.min,
+                        max: params.max,
+                        xdefault: params.default,
+                        array: params.array ?? false
+                    });
                     break;
                 case 'boolean':
-                    result = await this.tablesDB.createBooleanAttribute(params.databaseId, params.tableId, params.key, params.required ?? false, params.default, params.array ?? false);
+                    result = await this.tablesDB.createBooleanColumn({
+                        databaseId: params.databaseId,
+                        tableId: params.tableId,
+                        key: params.key,
+                        required: params.required ?? false,
+                        xdefault: params.default,
+                        array: params.array ?? false
+                    });
                     break;
                 case 'datetime':
-                    result = await this.tablesDB.createDatetimeAttribute(params.databaseId, params.tableId, params.key, params.required ?? false, params.default, params.array ?? false);
+                    result = await this.tablesDB.createDatetimeColumn({
+                        databaseId: params.databaseId,
+                        tableId: params.tableId,
+                        key: params.key,
+                        required: params.required ?? false,
+                        xdefault: params.default,
+                        array: params.array ?? false
+                    });
                     break;
                 case 'email':
-                    result = await this.tablesDB.createEmailAttribute(params.databaseId, params.tableId, params.key, params.required ?? false, params.default, params.array ?? false);
+                    result = await this.tablesDB.createEmailColumn({
+                        databaseId: params.databaseId,
+                        tableId: params.tableId,
+                        key: params.key,
+                        required: params.required ?? false,
+                        xdefault: params.default,
+                        array: params.array ?? false
+                    });
                     break;
                 case 'enum':
-                    result = await this.tablesDB.createEnumAttribute(params.databaseId, params.tableId, params.key, params.elements || [], params.required ?? false, params.default, params.array ?? false);
+                    // Defensive: require non-empty elements
+                    if (!Array.isArray(params.elements) || params.elements.length === 0) {
+                        throw new AdapterError(`Enum '${params.key}' requires a non-empty 'elements' array`, 'CREATE_ENUM_ELEMENTS_REQUIRED');
+                    }
+                    result = await this.tablesDB.createEnumColumn({
+                        databaseId: params.databaseId,
+                        tableId: params.tableId,
+                        key: params.key,
+                        elements: params.elements,
+                        required: params.required ?? false,
+                        xdefault: params.default,
+                        array: params.array ?? false
+                    });
                     break;
                 case 'ip':
-                    result = await this.tablesDB.createIpAttribute(params.databaseId, params.tableId, params.key, params.required ?? false, params.default, params.array ?? false);
+                    result = await this.tablesDB.createIpColumn({
+                        databaseId: params.databaseId,
+                        tableId: params.tableId,
+                        key: params.key,
+                        required: params.required ?? false,
+                        xdefault: params.default,
+                        array: params.array ?? false
+                    });
                     break;
                 case 'url':
-                    result = await this.tablesDB.createUrlAttribute(params.databaseId, params.tableId, params.key, params.required ?? false, params.default, params.array ?? false);
+                    result = await this.tablesDB.createUrlColumn({
+                        databaseId: params.databaseId,
+                        tableId: params.tableId,
+                        key: params.key,
+                        required: params.required ?? false,
+                        xdefault: params.default,
+                        array: params.array ?? false
+                    });
                     break;
                 case 'relationship':
-                    result = await this.tablesDB.createRelationshipAttribute(params.databaseId, params.tableId, params.key, params.relatedCollection || '', params.type || 'oneToOne', params.twoWay ?? false, params.onDelete || 'restrict');
+                    result = await this.tablesDB.createRelationshipColumn({
+                        databaseId: params.databaseId,
+                        tableId: params.tableId,
+                        key: params.key,
+                        relatedTableId: params.relatedCollection || '',
+                        type: (params.type || 'oneToOne'),
+                        twoWay: params.twoWay ?? false,
+                        twoWayKey: params.twoWayKey,
+                        onDelete: params.onDelete || 'restrict'
+                    });
                     break;
                 default:
                     throw new AdapterError(`Unsupported attribute type: ${params.type}`, 'UNSUPPORTED_ATTRIBUTE_TYPE');
@@ -224,9 +325,135 @@ export class TablesDBAdapter extends BaseAdapter {
     }
     async updateAttribute(params) {
         try {
-            // TablesDB uses type-specific update methods or generic updateAttribute with positional params
-            // Try type-specific first, fallback to generic
-            const result = await this.tablesDB.updateStringAttribute(params.databaseId, params.tableId, params.key, params.required ?? false, params.default);
+            // TablesDB uses type-specific update methods with object notation
+            // We need to detect the existing column type to use the correct update method
+            // For now, we'll need to get the column info first, then use the appropriate update method
+            // Get the current table schema to determine the column type
+            const tableInfo = await this.tablesDB.getTable(params.databaseId, params.tableId);
+            // Find the column to determine its type
+            const column = tableInfo.columns?.find(col => col.key === params.key);
+            if (!column) {
+                throw new AdapterError(`Column '${params.key}' not found in table`, 'COLUMN_NOT_FOUND');
+            }
+            let result;
+            // Use the appropriate updateXColumn method based on the column type
+            // Cast column to proper Models type to access its specific properties
+            const columnType = column.type;
+            switch (columnType) {
+                case 'string':
+                    const stringColumn = column;
+                    result = await this.tablesDB.updateStringColumn({
+                        databaseId: params.databaseId,
+                        tableId: params.tableId,
+                        key: params.key,
+                        required: params.required !== undefined ? params.required : stringColumn.required,
+                        xdefault: params.default !== undefined ? params.default : stringColumn.default,
+                        size: params.size !== undefined ? params.size : stringColumn.size,
+                    });
+                    break;
+                case 'integer':
+                    const integerColumn = column;
+                    result = await this.tablesDB.updateIntegerColumn({
+                        databaseId: params.databaseId,
+                        tableId: params.tableId,
+                        key: params.key,
+                        required: params.required !== undefined ? params.required : integerColumn.required,
+                        xdefault: params.default !== undefined ? params.default : integerColumn.default,
+                        // Only send min/max when explicitly provided to avoid resubmitting extreme values
+                        ...(params.min !== undefined ? { min: params.min } : {}),
+                        ...(params.max !== undefined ? { max: params.max } : {}),
+                    });
+                    break;
+                case 'float':
+                case 'double':
+                    const floatColumn = column;
+                    result = await this.tablesDB.updateFloatColumn({
+                        databaseId: params.databaseId,
+                        tableId: params.tableId,
+                        key: params.key,
+                        required: params.required !== undefined ? params.required : floatColumn.required,
+                        xdefault: params.default !== undefined ? params.default : floatColumn.default,
+                        ...(params.min !== undefined ? { min: params.min } : {}),
+                        ...(params.max !== undefined ? { max: params.max } : {}),
+                    });
+                    break;
+                case 'boolean':
+                    const booleanColumn = column;
+                    result = await this.tablesDB.updateBooleanColumn({
+                        databaseId: params.databaseId,
+                        tableId: params.tableId,
+                        key: params.key,
+                        required: params.required !== undefined ? params.required : booleanColumn.required,
+                        xdefault: params.default !== undefined ? params.default : booleanColumn.default
+                    });
+                    break;
+                case 'datetime':
+                    const datetimeColumn = column;
+                    result = await this.tablesDB.updateDatetimeColumn({
+                        databaseId: params.databaseId,
+                        tableId: params.tableId,
+                        key: params.key,
+                        required: params.required !== undefined ? params.required : datetimeColumn.required,
+                        xdefault: params.default !== undefined ? params.default : datetimeColumn.default
+                    });
+                    break;
+                case 'email':
+                    const emailColumn = column;
+                    result = await this.tablesDB.updateEmailColumn({
+                        databaseId: params.databaseId,
+                        tableId: params.tableId,
+                        key: params.key,
+                        required: params.required !== undefined ? params.required : emailColumn.required,
+                        xdefault: params.default !== undefined ? params.default : emailColumn.default
+                    });
+                    break;
+                case 'enum':
+                    const enumColumn = column;
+                    // Choose elements to send only when provided, otherwise preserve existing
+                    const provided = params.elements;
+                    const existing = enumColumn?.elements;
+                    const nextElements = (Array.isArray(provided) && provided.length > 0) ? provided : existing;
+                    result = await this.tablesDB.updateEnumColumn({
+                        databaseId: params.databaseId,
+                        tableId: params.tableId,
+                        key: params.key,
+                        required: params.required !== undefined ? params.required : enumColumn.required,
+                        xdefault: params.default !== undefined ? params.default : enumColumn.default,
+                        elements: nextElements
+                    });
+                    break;
+                case 'ip':
+                    const ipColumn = column;
+                    result = await this.tablesDB.updateIpColumn({
+                        databaseId: params.databaseId,
+                        tableId: params.tableId,
+                        key: params.key,
+                        required: params.required !== undefined ? params.required : ipColumn.required,
+                        xdefault: params.default !== undefined ? params.default : ipColumn.default
+                    });
+                    break;
+                case 'url':
+                    const urlColumn = column;
+                    result = await this.tablesDB.updateUrlColumn({
+                        databaseId: params.databaseId,
+                        tableId: params.tableId,
+                        key: params.key,
+                        required: params.required !== undefined ? params.required : urlColumn.required,
+                        xdefault: params.default !== undefined ? params.default : urlColumn.default
+                    });
+                    break;
+                case 'relationship':
+                    const relationshipColumn = column;
+                    result = await this.tablesDB.updateRelationshipColumn({
+                        databaseId: params.databaseId,
+                        tableId: params.tableId,
+                        key: params.key,
+                        onDelete: (params.onDelete !== undefined ? params.onDelete : relationshipColumn.onDelete),
+                    });
+                    break;
+                default:
+                    throw new AdapterError(`Unsupported column type for update: ${columnType}`, 'UNSUPPORTED_COLUMN_TYPE');
+            }
             return { data: result };
         }
         catch (error) {
@@ -235,7 +462,11 @@ export class TablesDBAdapter extends BaseAdapter {
     }
     async deleteAttribute(params) {
         try {
-            const result = await this.tablesDB.deleteAttribute(params.databaseId, params.tableId, params.key);
+            const result = await this.tablesDB.deleteColumn({
+                databaseId: params.databaseId,
+                tableId: params.tableId,
+                key: params.key
+            });
             return { data: result };
         }
         catch (error) {
@@ -245,7 +476,7 @@ export class TablesDBAdapter extends BaseAdapter {
     // Bulk Operations (Native TablesDB Support)
     async bulkCreateRows(params) {
         try {
-            const result = await this.tablesDB.bulkCreateRows(params);
+            const result = await this.tablesDB.createRows(params);
             return {
                 data: result.rows,
                 rows: result.rows,
@@ -258,7 +489,7 @@ export class TablesDBAdapter extends BaseAdapter {
     }
     async bulkUpsertRows(params) {
         try {
-            const result = await this.tablesDB.bulkUpsertRows(params);
+            const result = await this.tablesDB.upsertRows(params);
             return {
                 data: result.rows,
                 rows: result.rows,
@@ -323,45 +554,18 @@ export class TablesDBAdapter extends BaseAdapter {
      * Execute a transaction (if supported by TablesDB)
      */
     async executeTransaction(operations) {
-        if (!this.tablesDB.transaction) {
-            throw new AdapterError('Transactions are not supported in this TablesDB version', 'TRANSACTIONS_NOT_SUPPORTED');
-        }
         try {
-            const result = await this.tablesDB.transaction(operations);
+            // Create a new transaction first
+            const transaction = await this.tablesDB.createTransaction();
+            // Add operations to the transaction
+            const result = await this.tablesDB.createOperations({
+                transactionId: transaction.$id,
+                operations: operations.map(op => ({ operation: 'execute', fn: op }))
+            });
             return { data: result };
         }
         catch (error) {
             throw new AdapterError(`Transaction failed: ${error instanceof Error ? error.message : 'Unknown error'}`, 'TRANSACTION_FAILED', error instanceof Error ? error : undefined);
         }
     }
-    /**
-     * Subscribe to real-time updates (if supported)
-     */
-    subscribeToTable(params, callback) {
-        if (!this.tablesDB.subscribe) {
-            throw new AdapterError('Real-time subscriptions are not supported', 'REALTIME_NOT_SUPPORTED');
-        }
-        try {
-            return this.tablesDB.subscribe(`databases.${params.databaseId}.tables.${params.tableId}.rows`, callback);
-        }
-        catch (error) {
-            throw new AdapterError(`Failed to subscribe to table: ${error instanceof Error ? error.message : 'Unknown error'}`, 'SUBSCRIPTION_FAILED', error instanceof Error ? error : undefined);
-        }
-    }
-    /**
-     * Get table statistics (if available in TablesDB)
-     */
-    async getTableStats(params) {
-        try {
-            if (!this.tablesDB.getTableStats) {
-                // Fallback to basic table info
-                return this.getTable(params);
-            }
-            const result = await this.tablesDB.getTableStats(params);
-            return { data: result };
-        }
-        catch (error) {
-            throw new AdapterError(`Failed to get table stats: ${error instanceof Error ? error.message : 'Unknown error'}`, 'GET_TABLE_STATS_FAILED', error instanceof Error ? error : undefined);
-        }
-    }
 }

package/dist/cli/commands/databaseCommands.js

@@ -21,7 +21,7 @@ export const databaseCommands = {
             const localCollections = cli.getLocalCollections();
             // Push operations always use local configuration as source of truth
             // Select databases
-            const selectedDatabaseIds = await SelectionDialogs.selectDatabases(availableDatabases, configuredDatabases, { showSelectAll: true, allowNewOnly: false });
+            const selectedDatabaseIds = await SelectionDialogs.selectDatabases(availableDatabases, configuredDatabases, { showSelectAll: false, allowNewOnly: false, defaultSelected: [] });
             if (selectedDatabaseIds.length === 0) {
                 MessageFormatter.warning("No databases selected. Skipping database sync.", { prefix: "Database" });
                 return;
@@ -33,7 +33,8 @@ export const databaseCommands = {
                 const database = availableDatabases.find(db => db.$id === databaseId);
                 // Use the existing selectCollectionsAndTables method
                 const selectedCollections = await cli.selectCollectionsAndTables(database, cli.controller.database, chalk.blue(`Select collections/tables to push to "${database.name}":`), true, // multiSelect
-                true // prefer local
+                true, // prefer local
+                true // shouldFilterByDatabase
                 );
                 // Map selected collections to table IDs
                 const selectedTableIds = selectedCollections.map((c) => c.$id || c.id);
@@ -66,7 +67,7 @@ export const databaseCommands = {
                     }
                     else {
                         // Select buckets using SelectionDialogs
-                        const selectedBucketIds = await SelectionDialogs.selectBucketsForDatabases(selectedDatabaseIds, availableBuckets, configuredBuckets, { showSelectAll: true, groupByDatabase: true });
+                        const selectedBucketIds = await SelectionDialogs.selectBucketsForDatabases(selectedDatabaseIds, availableBuckets, configuredBuckets, { showSelectAll: false, groupByDatabase: true, defaultSelected: [] });
                         if (selectedBucketIds.length > 0) {
                             // Create BucketSelection objects
                             bucketSelections = SelectionDialogs.createBucketSelection(selectedBucketIds, availableBuckets, configuredBuckets, availableDatabases);

package/dist/cli/commands/functionCommands.js

@@ -8,6 +8,7 @@ import { Query } from "node-appwrite";
 import { MessageFormatter } from "../../shared/messageFormatter.js";
 import { createFunctionTemplate, deleteFunction, downloadLatestFunctionDeployment, listFunctions, listSpecifications, } from "../../functions/methods.js";
 import { deployLocalFunction } from "../../functions/deployments.js";
+import { discoverFnConfigs, mergeDiscoveredFunctions } from "../../functions/fnConfigDiscovery.js";
 import { addFunctionToYamlConfig, findYamlConfig } from "../../config/yamlConfig.js";
 import { RuntimeSchema } from "appwrite-utils";
 export const functionCommands = {
@@ -110,6 +111,13 @@ export const functionCommands = {
             MessageFormatter.error("Failed to initialize controller or load config", undefined, { prefix: "Functions" });
             return;
         }
+        // Discover local .fnconfig.yaml functions and merge into controller config
+        try {
+            const discovered = discoverFnConfigs(cli.currentDir);
+            const merged = mergeDiscoveredFunctions(cli.controller.config.functions || [], discovered);
+            cli.controller.config.functions = merged;
+        }
+        catch { }
         const functions = await cli.selectFunctions("Select function(s) to deploy:", true, true);
         if (!functions?.length) {
             MessageFormatter.error("No function selected", undefined, { prefix: "Functions" });
@@ -140,17 +148,18 @@ export const functionCommands = {
             }
             MessageFormatter.info(`  Appwrite folder: ${cli.controller.getAppwriteFolderPath()}`, { prefix: "Functions" });
             MessageFormatter.info(`  Current working dir: ${process.cwd()}`, { prefix: "Functions" });
-            // Helper function to expand tilde in paths
-            const expandTildePath = (path) => {
-                if (path.startsWith('~/')) {
-                    return path.replace('~', os.homedir());
-                }
-                return path;
-            };
+            // Resolve config dirPath relative to central YAML if it's relative
+            const yamlConfigPath = findYamlConfig(cli.currentDir);
+            const yamlBaseDir = yamlConfigPath ? require('node:path').dirname(yamlConfigPath) : process.cwd();
+            const expandTildePath = (p) => (p?.startsWith('~/') ? p.replace('~', os.homedir()) : p);
             // Check locations in priority order:
             const priorityLocations = [
                 // 1. Config dirPath if specified (with tilde expansion)
-                functionConfig.dirPath ? expandTildePath(functionConfig.dirPath) : undefined,
+                functionConfig.dirPath
+                    ? (require('node:path').isAbsolute(expandTildePath(functionConfig.dirPath))
+                        ? expandTildePath(functionConfig.dirPath)
+                        : require('node:path').resolve(yamlBaseDir, expandTildePath(functionConfig.dirPath)))
+                    : undefined,
                 // 2. Appwrite config folder/functions/name
                 join(cli.controller.getAppwriteFolderPath(), "functions", functionNameLower),
                 // 3. Current working directory/functions/name