@njdamstra/appwrite-utils-cli 1.8.9 → 1.10.1

package/dist/migrations/transfer.js

@@ -1,17 +1,16 @@
 import { converterFunctions, tryAwaitWithRetry } from "@njdamstra/appwrite-utils";
 import { Client, Databases, IndexType, Query, Storage, Users, } from "node-appwrite";
 import { InputFile } from "node-appwrite/file";
-import { getAppwriteClient } from "../utils/helperFunctions.js";
+import { getAppwriteClient } from "@njdamstra/appwrite-utils-helpers";
 // Legacy attribute helpers retained only for local-to-local flows if needed
 import { parseAttribute } from "@njdamstra/appwrite-utils";
 import chalk from "chalk";
 import { fetchAllCollections } from "../collections/methods.js";
-import { MessageFormatter } from "../shared/messageFormatter.js";
-import { LegacyAdapter } from "../adapters/LegacyAdapter.js";
+import { MessageFormatter, mapToCreateAttributeParams } from "@njdamstra/appwrite-utils-helpers";
 import { ProgressManager } from "../shared/progressManager.js";
-import { getClient, getAdapter } from "../utils/getClientFromConfig.js";
+import { getClient, getAdapter } from "@njdamstra/appwrite-utils-helpers";
 import { diffTableColumns } from "../collections/tableOperations.js";
-import { mapToCreateAttributeParams } from "../shared/attributeMapper.js";
+import { LegacyAdapter } from "@njdamstra/appwrite-utils-helpers";
 export const transferStorageLocalToLocal = async (storage, fromBucketId, toBucketId) => {
     MessageFormatter.info(`Transferring files from ${fromBucketId} to ${toBucketId}`, { prefix: "Transfer" });
     let lastFileId;
@@ -130,51 +129,96 @@ export const transferStorageLocalToRemote = async (localStorage, endpoint, proje
 // Document transfer functions moved to collections/methods.ts with enhanced UX
 // Remote document transfer functions moved to collections/methods.ts with enhanced UX
 /**
- * Transfers all collections and documents from one local database to another local database.
+ * Transfers all tables/collections and documents from one local database to another local database.
+ * Uses the DatabaseAdapter for unified TablesDB / legacy support.
  *
- * @param {Databases} localDb - The local database instance.
+ * @param {Databases} localDb - The local database instance (kept for signature compat).
  * @param {string} fromDbId - The ID of the source database.
  * @param {string} targetDbId - The ID of the target database.
+ * @param {string[]} collectionIds - Optional filter: specific table/collection IDs to transfer. undefined = all, empty array = none.
+ * @param {DatabaseAdapter} adapter - The database adapter (TablesDB or Legacy).
  * @return {Promise<void>} A promise that resolves when the transfer is complete.
  */
-export const transferDatabaseLocalToLocal = async (localDb, fromDbId, targetDbId) => {
-    MessageFormatter.info(`Starting database transfer from ${fromDbId} to ${targetDbId}`, { prefix: "Transfer" });
-    // Get all collections from source database
-    const sourceCollections = await fetchAllCollections(fromDbId, localDb);
-    MessageFormatter.info(`Found ${sourceCollections.length} collections in source database`, { prefix: "Transfer" });
-    // Process each collection
-    for (const collection of sourceCollections) {
-        MessageFormatter.processing(`Processing collection: ${collection.name} (${collection.$id})`, { prefix: "Transfer" });
+export const transferDatabaseLocalToLocal = async (localDb, fromDbId, targetDbId, collectionIds, adapter) => {
+    // If no adapter provided, fall back to creating a LegacyAdapter from the Databases client
+    const dbAdapter = adapter || new LegacyAdapter(localDb.client);
+    MessageFormatter.info(`Starting database transfer from ${fromDbId} to ${targetDbId} (mode: ${dbAdapter.getApiMode()})`, { prefix: "Transfer" });
+    // Get all tables/collections from source database via adapter
+    const sourceListRes = await dbAdapter.listTables({ databaseId: fromDbId, queries: [Query.limit(500)] });
+    let sourceTables = sourceListRes.tables || sourceListRes.collections || sourceListRes.data || [];
+    // Filter by collectionIds if provided (match by $id or by name)
+    if (collectionIds !== undefined) {
+        if (collectionIds.length === 0) {
+            MessageFormatter.info("No tables/collections selected for transfer, skipping.", { prefix: "Transfer" });
+            return;
+        }
+        const idSet = new Set(collectionIds);
+        sourceTables = sourceTables.filter((c) => idSet.has(c.$id) || idSet.has(c.name));
+    }
+    MessageFormatter.info(`Found ${sourceTables.length} tables/collections in source database`, { prefix: "Transfer" });
+    // Process each table/collection
+    for (const table of sourceTables) {
+        MessageFormatter.processing(`Processing table: ${table.name} (${table.$id})`, { prefix: "Transfer" });
         try {
-            // Create or update collection in target
-            let targetCollection;
-            const existingCollection = await tryAwaitWithRetry(async () => localDb.listCollections(targetDbId, [
-                Query.equal("$id", collection.$id),
-            ]));
-            if (existingCollection.collections.length > 0) {
-                targetCollection = existingCollection.collections[0];
-                MessageFormatter.info(`Collection ${collection.name} exists in target database`, { prefix: "Transfer" });
-                // Update collection if needed
-                if (targetCollection.name !== collection.name ||
-                    targetCollection.$permissions !== collection.$permissions ||
-                    targetCollection.documentSecurity !== collection.documentSecurity ||
-                    targetCollection.enabled !== collection.enabled) {
-                    targetCollection = await tryAwaitWithRetry(async () => localDb.updateCollection(targetDbId, collection.$id, collection.name, collection.$permissions, collection.documentSecurity, collection.enabled));
-                    MessageFormatter.success(`Collection ${collection.name} updated`, { prefix: "Transfer" });
+            // Check if table exists in target via adapter
+            let targetTableId = table.$id;
+            let targetTableData;
+            try {
+                const existingRes = await dbAdapter.getTable({ databaseId: targetDbId, tableId: table.$id });
+                targetTableData = existingRes.data || (existingRes.tables && existingRes.tables[0]);
+                if (targetTableData) {
+                    MessageFormatter.info(`Table ${table.name} exists in target database`, { prefix: "Transfer" });
+                    // Update table if needed
+                    const securityField = table.rowSecurity ?? table.documentSecurity ?? false;
+                    const targetSecurity = targetTableData.rowSecurity ?? targetTableData.documentSecurity ?? false;
+                    if (targetTableData.name !== table.name ||
+                        JSON.stringify(targetTableData.$permissions) !== JSON.stringify(table.$permissions) ||
+                        targetSecurity !== securityField ||
+                        targetTableData.enabled !== table.enabled) {
+                        await tryAwaitWithRetry(async () => dbAdapter.updateTable({
+                            databaseId: targetDbId,
+                            id: table.$id,
+                            name: table.name,
+                            permissions: table.$permissions,
+                            documentSecurity: table.documentSecurity,
+                            rowSecurity: table.rowSecurity,
+                            enabled: table.enabled,
+                        }));
+                        MessageFormatter.success(`Table ${table.name} updated`, { prefix: "Transfer" });
+                    }
                 }
             }
-            else {
-                MessageFormatter.progress(`Creating collection ${collection.name} in target database...`, { prefix: "Transfer" });
-                targetCollection = await tryAwaitWithRetry(async () => localDb.createCollection(targetDbId, collection.$id, collection.name, collection.$permissions, collection.documentSecurity, collection.enabled));
+            catch {
+                // Table does not exist in target, create it
+                targetTableData = null;
             }
-            // Create attributes via local adapter (wrap the existing client)
-            const localAdapter = new LegacyAdapter(localDb.client);
-            MessageFormatter.info(`Creating attributes for ${collection.name} via adapter...`, { prefix: 'Transfer' });
-            const uniformAttrs = collection.attributes.map((attr) => parseAttribute(attr));
+            if (!targetTableData) {
+                MessageFormatter.progress(`Creating table ${table.name} in target database...`, { prefix: "Transfer" });
+                const createRes = await tryAwaitWithRetry(async () => dbAdapter.createTable({
+                    databaseId: targetDbId,
+                    id: table.$id,
+                    name: table.name,
+                    permissions: table.$permissions,
+                    documentSecurity: table.documentSecurity,
+                    rowSecurity: table.rowSecurity,
+                    enabled: table.enabled,
+                }));
+                targetTableData = createRes.data || (createRes.tables && createRes.tables[0]);
+            }
+            // Create attributes via adapter
+            MessageFormatter.info(`Creating attributes for ${table.name} via adapter...`, { prefix: 'Transfer' });
+            // Fetch existing attributes in target to skip already-created ones
+            const targetTableRes = await dbAdapter.getTable({ databaseId: targetDbId, tableId: targetTableId });
+            const targetInfo = targetTableRes.data || (targetTableRes.tables && targetTableRes.tables[0]);
+            const existingAttrs = targetInfo?.attributes || targetInfo?.columns || [];
+            const existingKeys = new Set(existingAttrs.map((a) => a.key || a.$id));
+            const uniformAttrs = (table.attributes || []).map((attr) => parseAttribute(attr));
             const nonRel = uniformAttrs.filter((a) => a.type !== 'relationship');
             for (const attr of nonRel) {
-                const params = mapToCreateAttributeParams(attr, { databaseId: targetDbId, tableId: targetCollection.$id });
-                await localAdapter.createAttribute(params);
+                if (existingKeys.has(attr.key))
+                    continue;
+                const params = mapToCreateAttributeParams(attr, { databaseId: targetDbId, tableId: targetTableId });
+                await dbAdapter.createAttribute(params);
                 await new Promise((r) => setTimeout(r, 150));
             }
             // Wait for attributes to become available
@@ -184,8 +228,9 @@ export const transferDatabaseLocalToLocal = async (localDb, fromDbId, targetDbId
                 let lastStatus = '';
                 while (Date.now() - start < maxWait) {
                     try {
-                        const tableRes = await localAdapter.getTable({ databaseId: targetDbId, tableId: targetCollection.$id });
-                        const attrs = tableRes.attributes || tableRes.columns || [];
+                        const tableRes = await dbAdapter.getTable({ databaseId: targetDbId, tableId: targetTableId });
+                        const tInfo = tableRes.data || (tableRes.tables && tableRes.tables[0]);
+                        const attrs = tInfo?.attributes || tInfo?.columns || [];
                         const found = attrs.find((a) => a.key === attr.key);
                         if (found) {
                             if (found.status === 'available')
@@ -208,16 +253,18 @@ export const transferDatabaseLocalToLocal = async (localDb, fromDbId, targetDbId
             // Relationship attributes
             const rels = uniformAttrs.filter((a) => a.type === 'relationship');
             for (const attr of rels) {
-                const params = mapToCreateAttributeParams(attr, { databaseId: targetDbId, tableId: targetCollection.$id });
-                await localAdapter.createAttribute(params);
+                if (existingKeys.has(attr.key))
+                    continue;
+                const params = mapToCreateAttributeParams(attr, { databaseId: targetDbId, tableId: targetTableId });
+                await dbAdapter.createAttribute(params);
                 await new Promise((r) => setTimeout(r, 150));
             }
             // Handle indexes via adapter (create or update)
-            for (const idx of collection.indexes) {
+            for (const idx of (table.indexes || [])) {
                 try {
-                    await localAdapter.createIndex({
+                    await dbAdapter.createIndex({
                         databaseId: targetDbId,
-                        tableId: targetCollection.$id,
+                        tableId: targetTableId,
                         key: idx.key,
                         type: idx.type,
                         attributes: idx.attributes,
@@ -229,10 +276,10 @@ export const transferDatabaseLocalToLocal = async (localDb, fromDbId, targetDbId
                 catch (e) {
                     // Try update path by deleting and recreating if necessary
                     try {
-                        await localAdapter.deleteIndex({ databaseId: targetDbId, tableId: targetCollection.$id, key: idx.key });
-                        await localAdapter.createIndex({
+                        await dbAdapter.deleteIndex({ databaseId: targetDbId, tableId: targetTableId, key: idx.key });
+                        await dbAdapter.createIndex({
                             databaseId: targetDbId,
-                            tableId: targetCollection.$id,
+                            tableId: targetTableId,
                             key: idx.key,
                             type: idx.type,
                             attributes: idx.attributes,
@@ -246,20 +293,24 @@ export const transferDatabaseLocalToLocal = async (localDb, fromDbId, targetDbId
                     }
                 }
             }
-            // Transfer documents
-            const { transferDocumentsBetweenDbsLocalToLocal } = await import("../collections/methods.js");
-            await transferDocumentsBetweenDbsLocalToLocal(localDb, fromDbId, targetDbId, collection.$id, targetCollection.$id);
+            // Transfer documents/rows via adapter
+            const { transferDocumentsBetweenDbsLocalToLocal } = await import("../collections/transferOperations.js");
+            await transferDocumentsBetweenDbsLocalToLocal(dbAdapter, fromDbId, targetDbId, table.$id, targetTableId);
         }
         catch (error) {
-            MessageFormatter.error(`Error processing collection ${collection.name}`, error instanceof Error ? error : new Error(String(error)), { prefix: "Transfer" });
+            MessageFormatter.error(`Error processing table ${table.name}`, error instanceof Error ? error : new Error(String(error)), { prefix: "Transfer" });
         }
     }
 };
-export const transferDatabaseLocalToRemote = async (localDb, endpoint, projectId, apiKey, fromDbId, toDbId) => {
+export const transferDatabaseLocalToRemote = async (localDb, endpoint, projectId, apiKey, fromDbId, toDbId, collectionIds) => {
     const client = getAppwriteClient(endpoint, projectId, apiKey);
     const remoteDb = new Databases(client);
     // Get all collections from source database
-    const sourceCollections = await fetchAllCollections(fromDbId, localDb);
+    let sourceCollections = await fetchAllCollections(fromDbId, localDb);
+    if (collectionIds && collectionIds.length > 0) {
+        const idSet = new Set(collectionIds);
+        sourceCollections = sourceCollections.filter((c) => idSet.has(c.$id));
+    }
     MessageFormatter.info(`Found ${sourceCollections.length} collections in source database`, { prefix: "Transfer" });
     // Process each collection
     for (const collection of sourceCollections) {

package/dist/migrations/yaml/YamlImportConfigLoader.js

@@ -2,7 +2,7 @@ import { z } from "zod";
 import path from "path";
 import fs from "fs";
 import yaml from "js-yaml";
-import { logger } from "../../shared/logging.js";
+import { logger } from '@njdamstra/appwrite-utils-helpers';
 // YAML Import Configuration Schema
 export const YamlImportConfigSchema = z.object({
     source: z.object({

package/dist/migrations/yaml/YamlImportIntegration.js

@@ -1,7 +1,7 @@
 import { YamlImportConfigLoader } from "./YamlImportConfigLoader.js";
 import { createImportSchemas, createImportExamples } from "./generateImportSchemas.js";
-import { logger } from "../../shared/logging.js";
-import { normalizeYamlData, usesTableTerminology, convertTerminology } from "../../utils/yamlConverter.js";
+import { logger } from '@njdamstra/appwrite-utils-helpers';
+import { normalizeYamlData, usesTableTerminology, convertTerminology } from "@njdamstra/appwrite-utils-helpers";
 import path from "path";
 import fs from "fs";
 import yaml from "js-yaml";

package/dist/migrations/yaml/generateImportSchemas.js

@@ -1,6 +1,6 @@
 import fs from "fs";
 import path from "path";
-import { logger } from "../../shared/logging.js";
+import { logger } from '@njdamstra/appwrite-utils-helpers';
 /**
  * Generates JSON Schema for YAML import configurations.
  * Provides IntelliSense support for YAML files in IDEs.

package/dist/setupCommands.d.ts

@@ -1,4 +1,4 @@
-import { type ApiMode } from "./utils/versionDetection.js";
+import { type ApiMode } from "@njdamstra/appwrite-utils-helpers";
 /**
  * Terminology configuration for API mode-specific naming
  */

package/dist/setupCommands.js

@@ -1,12 +1,11 @@
 import { mkdirSync, writeFileSync, existsSync } from "node:fs";
 import path from "node:path";
 import { ulid } from "ulidx";
-import { MessageFormatter } from "./shared/messageFormatter.js";
-import { detectAppwriteVersionCached, fetchServerVersion, isVersionAtLeast } from "./utils/versionDetection.js";
-import { loadAppwriteProjectConfig, findAppwriteProjectConfig, isTablesDBProject } from "./utils/projectConfig.js";
-import { findYamlConfig, generateYamlConfigTemplate } from "./config/yamlConfig.js";
-import { loadYamlConfig } from "./config/yamlConfig.js";
-import { hasSessionAuth } from "./utils/sessionAuth.js";
+import { MessageFormatter } from "@njdamstra/appwrite-utils-helpers";
+import { detectAppwriteVersionCached, fetchServerVersion, isVersionAtLeast } from "@njdamstra/appwrite-utils-helpers";
+import { loadAppwriteProjectConfig, findAppwriteProjectConfig, isTablesDBProject } from "@njdamstra/appwrite-utils-helpers";
+import { findYamlConfig, generateYamlConfigTemplate, loadYamlConfig } from "@njdamstra/appwrite-utils-helpers";
+import { hasSessionAuth } from "@njdamstra/appwrite-utils-helpers";
 /**
  * Get terminology configuration based on API mode
  */

package/dist/setupController.js

@@ -2,7 +2,7 @@ import { setupDirsFiles } from "./utils/setupFiles.js";
 import { loadConfig } from "./utils/loadConfigs.js";
 import path from "path";
 import fs from "fs";
-import { MessageFormatter } from "./shared/messageFormatter.js";
+import { MessageFormatter } from "@njdamstra/appwrite-utils-helpers";
 export class SetupController {
     currentDir;
     config = null;

package/dist/shared/backupTracking.d.ts

@@ -1,4 +1,4 @@
-import type { DatabaseAdapter } from "../adapters/DatabaseAdapter.js";
+import type { DatabaseAdapter } from "@njdamstra/appwrite-utils-helpers";
 import { type BackupMetadata } from "./backupMetadataSchema.js";
 /**
  * Creates the backup tracking table in the specified database

package/dist/shared/backupTracking.js

@@ -1,5 +1,5 @@
-import { logger } from "./logging.js";
-import { tryAwaitWithRetry } from "../utils/helperFunctions.js";
+import { logger } from '@njdamstra/appwrite-utils-helpers';
+import { tryAwaitWithRetry } from "@njdamstra/appwrite-utils-helpers";
 import { Query, ID } from "node-appwrite";
 import { BACKUP_TABLE_ID, BACKUP_TABLE_NAME, BackupMetadataSchema } from "./backupMetadataSchema.js";
 /**

package/dist/shared/confirmationDialogs.js

@@ -1,6 +1,6 @@
 import inquirer from "inquirer";
 import chalk from "chalk";
-import { MessageFormatter } from "./messageFormatter.js";
+import { MessageFormatter } from '@njdamstra/appwrite-utils-helpers';
 export class ConfirmationDialogs {
     /**
      * Shows a confirmation dialog for destructive operations

package/dist/shared/migrationHelpers.d.ts

@@ -1,6 +1,6 @@
 import { type Databases } from "node-appwrite";
 import { z } from "zod";
-import type { DatabaseAdapter } from "../adapters/DatabaseAdapter.js";
+import type { DatabaseAdapter } from "@njdamstra/appwrite-utils-helpers";
 /**
  * Object that contains the context for an action that needs to be executed after import
  * Used in the afterImportActionsDefinitions

package/dist/shared/migrationHelpers.js

@@ -2,10 +2,10 @@ import { ID, Query } from "node-appwrite";
 import { BatchSchema, OperationSchema } from "../storage/schemas.js";
 import { AttributeMappingsSchema } from "@njdamstra/appwrite-utils";
 import { z } from "zod";
-import { logger } from "./logging.js";
-import { tryAwaitWithRetry } from "../utils/helperFunctions.js";
+import { logger } from '@njdamstra/appwrite-utils-helpers';
+import { tryAwaitWithRetry } from "@njdamstra/appwrite-utils-helpers";
 import { findOrCreateOperation as findOrCreateOp, updateOperation as updateOp, getOperation as getOp } from "./operationsTable.js";
-import { MessageFormatter } from "./messageFormatter.js";
+import { MessageFormatter } from '@njdamstra/appwrite-utils-helpers';
 /**
  * Object that contains the context for an action that needs to be executed after import
  * Used in the afterImportActionsDefinitions

package/dist/shared/operationQueue.d.ts

@@ -1,6 +1,6 @@
 import { type Databases, type Models } from "node-appwrite";
 import type { Attribute } from "@njdamstra/appwrite-utils";
-import type { DatabaseAdapter } from "../adapters/DatabaseAdapter.js";
+import type { DatabaseAdapter } from "@njdamstra/appwrite-utils-helpers";
 export interface QueuedOperation {
     type: "attribute";
     collectionId?: string;

package/dist/shared/operationQueue.js

@@ -1,9 +1,8 @@
 import { Query } from "node-appwrite";
 import { createOrUpdateAttributeWithStatusCheck } from "../collections/attributes.js";
 import { fetchAndCacheCollectionByName } from "../collections/methods.js";
-import { tryAwaitWithRetry } from "../utils/helperFunctions.js";
-import { logger } from "../shared/logging.js";
-import { MessageFormatter } from "../shared/messageFormatter.js";
+import { tryAwaitWithRetry } from "@njdamstra/appwrite-utils-helpers";
+import { logger, MessageFormatter } from "@njdamstra/appwrite-utils-helpers";
 // Global state management
 export const queuedOperations = [];
 export const nameToIdMapping = new Map();

package/dist/shared/operationsTable.d.ts

@@ -1,4 +1,4 @@
-import type { DatabaseAdapter } from "../adapters/DatabaseAdapter.js";
+import type { DatabaseAdapter } from "@njdamstra/appwrite-utils-helpers";
 import { type OperationRecord } from "./operationsTableSchema.js";
 /**
  * Creates the operations tracking table in the specified database

package/dist/shared/operationsTable.js

@@ -1,5 +1,5 @@
-import { logger } from "./logging.js";
-import { tryAwaitWithRetry } from "../utils/helperFunctions.js";
+import { logger } from '@njdamstra/appwrite-utils-helpers';
+import { tryAwaitWithRetry } from "@njdamstra/appwrite-utils-helpers";
 import { Query, ID } from "node-appwrite";
 import { OPERATIONS_TABLE_ID, OPERATIONS_TABLE_NAME, OperationRecordSchema, } from "./operationsTableSchema.js";
 /**

package/dist/shared/progressManager.js

@@ -1,6 +1,6 @@
 import cliProgress from "cli-progress";
 import chalk from "chalk";
-import { MessageFormatter } from "./messageFormatter.js";
+import { MessageFormatter } from '@njdamstra/appwrite-utils-helpers';
 export class ProgressManager {
     static instances = new Map();
     bar;

package/dist/shared/selectionDialogs.js

@@ -1,7 +1,7 @@
 import inquirer from "inquirer";
 import chalk from "chalk";
-import { MessageFormatter } from "./messageFormatter.js";
-import { logger } from "./logging.js";
+import { MessageFormatter } from '@njdamstra/appwrite-utils-helpers';
+import { logger } from '@njdamstra/appwrite-utils-helpers';
 /**
  * Comprehensive selection dialog system for enhanced sync flow
  *
@@ -186,7 +186,7 @@ export class SelectionDialogs {
         if (showDatabaseContext) {
             MessageFormatter.section(`Table Selection for ${databaseName}`);
         }
-        const configuredIds = new Set(configuredTables.map(table => table.$id || table.id));
+        const configuredIds = new Set(configuredTables.map(table => table.$id || table.id || table.tableId || table.name));
         let choices = [];
         if (showSelectAll && availableTables.length > 1) {
             choices.push({
@@ -196,18 +196,19 @@ export class SelectionDialogs {
             });
         }
         availableTables.forEach(table => {
-            const isConfigured = configuredIds.has(table.$id);
+            const tableId = table.$id || table.id || table.tableId || table.name;
+            const isConfigured = configuredIds.has(tableId);
             const status = isConfigured ? chalk.green('✅') : chalk.blue('○');
-            const name = `${status} ${table.name} (${table.$id})`;
+            const name = `${status} ${table.name} (${tableId})`;
             if (allowNewOnly && isConfigured) {
                 return; // Skip configured tables if only allowing new ones
             }
             choices.push({
                 name,
-                value: table.$id,
+                value: tableId,
                 short: table.name,
                 // Do not preselect anything unless explicitly provided
-                checked: defaultSelected.includes(table.$id)
+                checked: defaultSelected.includes(tableId)
             });
         });
         if (choices.length === 0) {
@@ -231,7 +232,7 @@ export class SelectionDialogs {
             }]);
         // Handle select all
         if (selectedTableIds.includes('__SELECT_ALL__')) {
-            const allIds = availableTables.map(table => table.$id);
+            const allIds = availableTables.map(table => table.$id || table.id || table.tableId || table.name);
             if (allowNewOnly) {
                 return allIds.filter(id => !configuredIds.has(id));
             }

package/dist/storage/methods.js

@@ -1,15 +1,15 @@
 import { Compression, Databases, Permission, Query, Role, Storage, } from "node-appwrite";
 import { tryAwaitWithRetry } from "@njdamstra/appwrite-utils";
-import { getClientFromConfig } from "../utils/getClientFromConfig.js";
+import { getClientFromConfig } from "@njdamstra/appwrite-utils-helpers";
 import { ulid } from "ulidx";
 import { logOperation } from "../shared/operationLogger.js";
 import { splitIntoBatches } from "../shared/migrationHelpers.js";
-import { retryFailedPromises } from "../utils/retryFailedPromises.js";
+import { retryFailedPromises } from "@njdamstra/appwrite-utils-helpers";
 import { InputFile } from "node-appwrite/file";
-import { MessageFormatter, Messages } from "../shared/messageFormatter.js";
+import { MessageFormatter, Messages } from "@njdamstra/appwrite-utils-helpers";
 import { ProgressManager } from "../shared/progressManager.js";
 import { recordBackup } from "../shared/backupTracking.js";
-import { AdapterFactory } from "../adapters/AdapterFactory.js";
+import { AdapterFactory } from "@njdamstra/appwrite-utils-helpers";
 import { createBackupZip } from "./backupCompression.js";
 export const getStorage = (config) => {
     const client = getClientFromConfig(config);