@njdamstra/appwrite-utils-cli 1.8.9 → 1.10.0

package/src/migrations/dataLoader.ts

@@ -14,18 +14,15 @@ import {
 } from "@njdamstra/appwrite-utils";
 import path from "path";
 import fs from "fs";
-import { convertObjectByAttributeMappings } from "../utils/dataConverters.js";
+import { convertObjectByAttributeMappings } from "@njdamstra/appwrite-utils-helpers";
 import { z } from "zod";
 import { checkForCollection } from "../collections/methods.js";
 import { ID, Users, type Databases } from "node-appwrite";
-import { logger } from "../shared/logging.js";
+import { logger, LegacyAdapter, MessageFormatter } from "@njdamstra/appwrite-utils-helpers";
 import { findOrCreateOperation, updateOperation } from "../shared/migrationHelpers.js";
 import { AuthUserCreateSchema } from "../schemas/authUser.js";
-import { LegacyAdapter } from "../adapters/LegacyAdapter.js";
 import { UsersController } from "../users/methods.js";
-import { finalizeByAttributeMap } from "../utils/helperFunctions.js";
 import { isEmpty } from "es-toolkit/compat";
-import { MessageFormatter } from "../shared/messageFormatter.js";
 
 // Define a schema for the structure of collection import data using Zod for validation
 export const CollectionImportDataSchema = z.object({

package/src/migrations/importController.ts

@@ -13,13 +13,12 @@ import type {
   AttributeMappings,
 } from "@njdamstra/appwrite-utils";
 import type { ImportDataActions } from "./importDataActions.js";
-import { areCollectionNamesSame, tryAwaitWithRetry } from "../utils/index.js";
+import { areCollectionNamesSame, tryAwaitWithRetry } from "@njdamstra/appwrite-utils-helpers";
 import type { SetupOptions } from "../utilsController.js";
 import { resolveAndUpdateRelationships } from "./relationships.js";
 import { UsersController } from "../users/methods.js";
-import { logger } from "../shared/logging.js";
+import { logger, LegacyAdapter } from "@njdamstra/appwrite-utils-helpers";
 import { updateOperation } from "../shared/migrationHelpers.js";
-import { LegacyAdapter } from "../adapters/LegacyAdapter.js";
 import {
   BatchSchema,
   OperationCreateSchema,
@@ -30,7 +29,7 @@ import {
   transferDatabaseLocalToLocal,
   transferStorageLocalToLocal,
 } from "./transfer.js";
-import { MessageFormatter } from "../shared/messageFormatter.js";
+import { MessageFormatter } from "@njdamstra/appwrite-utils-helpers";
 import { ProgressManager } from "../shared/progressManager.js";
 
 export class ImportController {

package/src/migrations/importDataActions.ts

@@ -6,11 +6,11 @@ import {
   type AttributeMappings,
 } from "@njdamstra/appwrite-utils";
 import { converterFunctions, type ConverterFunctions } from "@njdamstra/appwrite-utils";
-import { convertObjectBySchema } from "../utils/dataConverters.js";
+import { convertObjectBySchema } from "@njdamstra/appwrite-utils-helpers";
 import { type AfterImportActions } from "@njdamstra/appwrite-utils";
 import { afterImportActions } from "./afterImportActions.js";
-import { logger } from "../shared/logging.js";
-import { tryAwaitWithRetry } from "../utils/helperFunctions.js";
+import { logger } from "@njdamstra/appwrite-utils-helpers";
+import { tryAwaitWithRetry } from "@njdamstra/appwrite-utils-helpers";
 
 export class ImportDataActions {
   private db: Databases;

package/src/migrations/relationships.ts

@@ -5,8 +5,7 @@ import type {
   Attribute,
   RelationshipAttribute,
 } from "@njdamstra/appwrite-utils";
-import { logger } from "../shared/logging.js";
-import { MessageFormatter } from "../shared/messageFormatter.js";
+import { logger, MessageFormatter } from "@njdamstra/appwrite-utils-helpers";
 
 /**
  * Finds collections that have defined relationship attributes.

package/src/migrations/services/DataTransformationService.ts

@@ -5,8 +5,8 @@ import type {
   CollectionCreate,
 } from "@njdamstra/appwrite-utils";
 import type { ImportDataActions } from "../importDataActions.js";
-import { convertObjectByAttributeMappings } from "../../utils/dataConverters.js";
-import { logger } from "../../shared/logging.js";
+import { convertObjectByAttributeMappings } from "@njdamstra/appwrite-utils-helpers";
+import { logger } from '@njdamstra/appwrite-utils-helpers';
 
 /**
  * Service responsible for data transformation during import.

package/src/migrations/services/FileHandlerService.ts

@@ -2,7 +2,7 @@ import path from "path";
 import fs from "fs";
 import type { AttributeMappings, AppwriteConfig } from "@njdamstra/appwrite-utils";
 import type { ImportDataActions } from "../importDataActions.js";
-import { logger } from "../../shared/logging.js";
+import { logger } from '@njdamstra/appwrite-utils-helpers';
 import { RateLimitManager } from "./RateLimitManager.js";
 
 /**

package/src/migrations/services/ImportOrchestrator.ts

@@ -23,12 +23,12 @@ import { RelationshipResolver, type CollectionImportData } from "./RelationshipR
 import type { ImportDataActions } from "../importDataActions.js";
 import type { SetupOptions } from "../../utilsController.js";
 import { UsersController } from "../../users/methods.js";
-import { logger } from "../../shared/logging.js";
-import { MessageFormatter } from "../../shared/messageFormatter.js";
+import { logger } from '@njdamstra/appwrite-utils-helpers';
+import { MessageFormatter } from '@njdamstra/appwrite-utils-helpers';
 import { ProgressManager } from "../../shared/progressManager.js";
-import { tryAwaitWithRetry } from "../../utils/index.js";
+import { tryAwaitWithRetry } from "@njdamstra/appwrite-utils-helpers";
 import { updateOperation, findOrCreateOperation } from "../../shared/migrationHelpers.js";
-import { LegacyAdapter } from "../../adapters/LegacyAdapter.js";
+import { LegacyAdapter } from '@njdamstra/appwrite-utils-helpers';
 import { resolveAndUpdateRelationships } from "../relationships.js";
 
 // Enhanced rate limiting configuration - now managed by RateLimitManager

package/src/migrations/services/RateLimitManager.ts

@@ -1,5 +1,5 @@
 import pLimit from "p-limit";
-import { logger } from "../../shared/logging.js";
+import { logger } from '@njdamstra/appwrite-utils-helpers';
 
 export interface RateLimitConfig {
   // Data operations

package/src/migrations/services/RelationshipResolver.ts

@@ -4,7 +4,7 @@ import type {
   AppwriteConfig,
   CollectionCreate,
 } from "@njdamstra/appwrite-utils";
-import { logger } from "../../shared/logging.js";
+import { logger } from '@njdamstra/appwrite-utils-helpers';
 import { isEmpty } from "es-toolkit/compat";
 import type { UserMappingService } from "./UserMappingService.js";
 

package/src/migrations/services/UserMappingService.ts

@@ -5,7 +5,7 @@ import type {
   AppwriteConfig,
 } from "@njdamstra/appwrite-utils";
 import { AuthUserCreateSchema } from "../../schemas/authUser.js";
-import { logger } from "../../shared/logging.js";
+import { logger } from '@njdamstra/appwrite-utils-helpers';
 import type { DataTransformationService } from "./DataTransformationService.js";
 
 /**

package/src/migrations/services/ValidationService.ts

@@ -4,7 +4,7 @@ import type {
   CollectionCreate,
 } from "@njdamstra/appwrite-utils";
 import type { ImportDataActions } from "../importDataActions.js";
-import { logger } from "../../shared/logging.js";
+import { logger } from '@njdamstra/appwrite-utils-helpers';
 import fs from "fs";
 import path from "path";
 

package/src/migrations/transfer.ts

@@ -9,18 +9,16 @@ import {
   type Models,
 } 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 type { DatabaseAdapter } from "../adapters/DatabaseAdapter.js";
+import { LegacyAdapter, type DatabaseAdapter } from "@njdamstra/appwrite-utils-helpers";
 
 export interface TransferOptions {
   fromDb: Models.Database | undefined;
@@ -241,99 +239,137 @@ export const transferStorageLocalToRemote = async (
 // 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: Databases,
   fromDbId: string,
-  targetDbId: string
+  targetDbId: string,
+  collectionIds?: string[],
+  adapter?: DatabaseAdapter
 ) => {
+  // If no adapter provided, fall back to creating a LegacyAdapter from the Databases client
+  const dbAdapter: DatabaseAdapter = adapter || new LegacyAdapter((localDb as any).client);
+
   MessageFormatter.info(
-    `Starting database transfer from ${fromDbId} to ${targetDbId}`,
+    `Starting database transfer from ${fromDbId} to ${targetDbId} (mode: ${dbAdapter.getApiMode()})`,
     { prefix: "Transfer" }
   );
-  // Get all collections from source database
-  const sourceCollections = await fetchAllCollections(fromDbId, localDb);
+
+  // Get all tables/collections from source database via adapter
+  const sourceListRes = await dbAdapter.listTables({ databaseId: fromDbId, queries: [Query.limit(500)] });
+  let sourceTables: any[] = 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: any) => idSet.has(c.$id) || idSet.has(c.name));
+  }
+
   MessageFormatter.info(
-    `Found ${sourceCollections.length} collections in source database`,
+    `Found ${sourceTables.length} tables/collections in source database`,
     { prefix: "Transfer" }
   );
 
-  // Process each collection
-  for (const collection of sourceCollections) {
+  // Process each table/collection
+  for (const table of sourceTables) {
     MessageFormatter.processing(
-      `Processing collection: ${collection.name} (${collection.$id})`,
+      `Processing table: ${table.name} (${table.$id})`,
       { prefix: "Transfer" }
     );
 
     try {
-      // Create or update collection in target
-      let targetCollection: Models.Collection;
-      const existingCollection = await tryAwaitWithRetry(async () =>
-        localDb.listCollections(targetDbId, [
-          Query.equal("$id", collection.$id),
-        ])
-      );
+      // Check if table exists in target via adapter
+      let targetTableId = table.$id;
+      let targetTableData: any;
 
-      if (existingCollection.collections.length > 0) {
-        targetCollection = existingCollection.collections[0];
-        MessageFormatter.info(
-          `Collection ${collection.name} exists in target database`,
-          { prefix: "Transfer" }
-        );
+      try {
+        const existingRes = await dbAdapter.getTable({ databaseId: targetDbId, tableId: table.$id });
+        targetTableData = existingRes.data || (existingRes.tables && existingRes.tables[0]);
 
-        // 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`,
+        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 {
+      } catch {
+        // Table does not exist in target, create it
+        targetTableData = null;
+      }
+
+      if (!targetTableData) {
         MessageFormatter.progress(
-          `Creating collection ${collection.name} in target database...`,
+          `Creating table ${table.name} in target database...`,
           { prefix: "Transfer" }
         );
-        targetCollection = await tryAwaitWithRetry(async () =>
-          localDb.createCollection(
-            targetDbId,
-            collection.$id,
-            collection.name,
-            collection.$permissions,
-            collection.documentSecurity,
-            collection.enabled
-          )
+        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 local adapter (wrap the existing client)
-      const localAdapter: DatabaseAdapter = new LegacyAdapter((localDb as any).client);
-      MessageFormatter.info(`Creating attributes for ${collection.name} via adapter...`, { prefix: 'Transfer' });
-      const uniformAttrs = collection.attributes.map((attr) => parseAttribute(attr as any));
+      // 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: any) => a.key || a.$id));
+
+      const uniformAttrs = (table.attributes || []).map((attr: any) => parseAttribute(attr as any));
       const nonRel = uniformAttrs.filter((a: any) => a.type !== 'relationship');
       for (const attr of nonRel) {
-        const params = mapToCreateAttributeParams(attr as any, { databaseId: targetDbId, tableId: targetCollection.$id });
-        await localAdapter.createAttribute(params);
+        if (existingKeys.has(attr.key)) continue;
+        const params = mapToCreateAttributeParams(attr as any, { databaseId: targetDbId, tableId: targetTableId });
+        await dbAdapter.createAttribute(params);
         await new Promise((r) => setTimeout(r, 150));
       }
 
@@ -343,8 +379,9 @@ export const transferDatabaseLocalToLocal = async (
         let lastStatus = '';
         while (Date.now() - start < maxWait) {
           try {
-            const tableRes = await localAdapter.getTable({ databaseId: targetDbId, tableId: targetCollection.$id });
-            const attrs = (tableRes as any).attributes || (tableRes as any).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: any) => a.key === attr.key);
             if (found) {
               if (found.status === 'available') break;
@@ -366,17 +403,18 @@ export const transferDatabaseLocalToLocal = async (
       // Relationship attributes
       const rels = uniformAttrs.filter((a: any) => a.type === 'relationship');
       for (const attr of rels) {
-        const params = mapToCreateAttributeParams(attr as any, { databaseId: targetDbId, tableId: targetCollection.$id });
-        await localAdapter.createAttribute(params);
+        if (existingKeys.has(attr.key)) continue;
+        const params = mapToCreateAttributeParams(attr as any, { 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 as any).key,
             type: (idx as any).type,
             attributes: (idx as any).attributes,
@@ -387,10 +425,10 @@ export const transferDatabaseLocalToLocal = async (
         } catch (e) {
           // Try update path by deleting and recreating if necessary
           try {
-            await localAdapter.deleteIndex({ databaseId: targetDbId, tableId: targetCollection.$id, key: (idx as any).key });
-            await localAdapter.createIndex({
+            await dbAdapter.deleteIndex({ databaseId: targetDbId, tableId: targetTableId, key: (idx as any).key });
+            await dbAdapter.createIndex({
               databaseId: targetDbId,
-              tableId: targetCollection.$id,
+              tableId: targetTableId,
               key: (idx as any).key,
               type: (idx as any).type,
               attributes: (idx as any).attributes,
@@ -404,20 +442,20 @@ export const transferDatabaseLocalToLocal = async (
         }
       }
 
-      // Transfer documents
+      // Transfer documents/rows via adapter
       const { transferDocumentsBetweenDbsLocalToLocal } = await import(
-        "../collections/methods.js"
+        "../collections/transferOperations.js"
       );
       await transferDocumentsBetweenDbsLocalToLocal(
-        localDb,
+        dbAdapter,
         fromDbId,
         targetDbId,
-        collection.$id,
-        targetCollection.$id
+        table.$id,
+        targetTableId
       );
     } catch (error) {
       MessageFormatter.error(
-        `Error processing collection ${collection.name}`,
+        `Error processing table ${table.name}`,
         error instanceof Error ? error : new Error(String(error)),
         { prefix: "Transfer" }
       );
@@ -431,13 +469,18 @@ export const transferDatabaseLocalToRemote = async (
   projectId: string,
   apiKey: string,
   fromDbId: string,
-  toDbId: string
+  toDbId: string,
+  collectionIds?: string[]
 ) => {
   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" }

package/src/migrations/yaml/YamlImportConfigLoader.ts

@@ -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';
 import type { ImportDef, AttributeMappings } from "@njdamstra/appwrite-utils";
 
 // YAML Import Configuration Schema

package/src/migrations/yaml/YamlImportIntegration.ts

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

package/src/migrations/yaml/generateImportSchemas.ts

@@ -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.

package/src/setupCommands.ts

@@ -1,21 +1,20 @@
 import { mkdirSync, writeFileSync, existsSync } from "node:fs";
 import path from "node:path";
 import { ulid } from "ulidx";
-import { MessageFormatter } from "./shared/messageFormatter.js";
+import { MessageFormatter } from "@njdamstra/appwrite-utils-helpers";
 import {
   detectAppwriteVersionCached,
   fetchServerVersion,
   isVersionAtLeast,
   type ApiMode
-} from "./utils/versionDetection.js";
+} from "@njdamstra/appwrite-utils-helpers";
 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";
+} from "@njdamstra/appwrite-utils-helpers";
+import { findYamlConfig, generateYamlConfigTemplate, loadYamlConfig } from "@njdamstra/appwrite-utils-helpers";
+import { hasSessionAuth } from "@njdamstra/appwrite-utils-helpers";
 
 /**
  * Terminology configuration for API mode-specific naming

package/src/setupController.ts

@@ -3,7 +3,7 @@ import { loadConfig } from "./utils/loadConfigs.js";
 import path from "path";
 import fs from "fs";
 import type { AppwriteConfig } from "@njdamstra/appwrite-utils";
-import { MessageFormatter } from "./shared/messageFormatter.js";
+import { MessageFormatter } from "@njdamstra/appwrite-utils-helpers";
 
 export class SetupController {
   private currentDir: string;

package/src/shared/backupTracking.ts

@@ -1,6 +1,6 @@
-import type { DatabaseAdapter } from "../adapters/DatabaseAdapter.js";
-import { logger } from "./logging.js";
-import { tryAwaitWithRetry } from "../utils/helperFunctions.js";
+import type { DatabaseAdapter } from "@njdamstra/appwrite-utils-helpers";
+import { logger } from '@njdamstra/appwrite-utils-helpers';
+import { tryAwaitWithRetry } from "@njdamstra/appwrite-utils-helpers";
 import { Query, ID } from "node-appwrite";
 import {
   BACKUP_TABLE_ID,

package/src/shared/confirmationDialogs.ts

@@ -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 interface DestructiveOperationOptions {
   operation: string;

package/src/shared/migrationHelpers.ts

@@ -2,15 +2,15 @@ import { ID, Query, type Databases } from "node-appwrite";
 import { BatchSchema, OperationSchema, type Operation } 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 type { DatabaseAdapter } from "../adapters/DatabaseAdapter.js";
-import { MessageFormatter } from "./messageFormatter.js";
+import type { DatabaseAdapter } from "@njdamstra/appwrite-utils-helpers";
+import { MessageFormatter } from '@njdamstra/appwrite-utils-helpers';
 
 /**
  * Object that contains the context for an action that needs to be executed after import

package/src/shared/operationQueue.ts

@@ -2,10 +2,9 @@ import { Query, type Databases, type Models } from "node-appwrite";
 import type { Attribute } from "@njdamstra/appwrite-utils";
 import { createOrUpdateAttributeWithStatusCheck } from "../collections/attributes.js";
 import { fetchAndCacheCollectionByName } from "../collections/methods.js";
-import { tryAwaitWithRetry } from "../utils/helperFunctions.js";
-import type { DatabaseAdapter } from "../adapters/DatabaseAdapter.js";
-import { logger } from "../shared/logging.js";
-import { MessageFormatter } from "../shared/messageFormatter.js";
+import { tryAwaitWithRetry } from "@njdamstra/appwrite-utils-helpers";
+import type { DatabaseAdapter } from "@njdamstra/appwrite-utils-helpers";
+import { logger, MessageFormatter } from "@njdamstra/appwrite-utils-helpers";
 
 export interface QueuedOperation {
   type: "attribute";

package/src/shared/operationsTable.ts

@@ -1,6 +1,6 @@
-import type { DatabaseAdapter } from "../adapters/DatabaseAdapter.js";
-import { logger } from "./logging.js";
-import { tryAwaitWithRetry } from "../utils/helperFunctions.js";
+import type { DatabaseAdapter } from "@njdamstra/appwrite-utils-helpers";
+import { logger } from '@njdamstra/appwrite-utils-helpers';
+import { tryAwaitWithRetry } from "@njdamstra/appwrite-utils-helpers";
 import { Query, ID } from "node-appwrite";
 import {
 	OPERATIONS_TABLE_ID,

package/src/shared/progressManager.ts

@@ -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 interface ProgressOptions {
   title?: string;