appwrite-utils-cli 1.5.1 → 1.6.0

package/dist/shared/functionManager.js

@@ -5,6 +5,7 @@ import fs from "node:fs";
 import chalk from "chalk";
 import pLimit from "p-limit";
 import { tryAwaitWithRetry } from "../utils/helperFunctions.js";
+import { MessageFormatter } from "./messageFormatter.js";
 /**
  * Validates and filters events array for Appwrite functions
  * - Filters out empty/invalid strings
@@ -34,7 +35,7 @@ export class FunctionManager {
     async findFunctionDirectory(functionName, options = {}) {
         const { searchPaths = [process.cwd()], caseSensitive = false, allowFuzzyMatch = true, verbose = false } = options;
         if (verbose) {
-            console.log(chalk.blue(`🔍 Searching for function: ${functionName}`));
+            MessageFormatter.info(`Searching for function: ${functionName}`, { prefix: "Functions" });
         }
         // Normalize function name for comparison
         const normalizedName = caseSensitive ? functionName : functionName.toLowerCase();
@@ -44,7 +45,7 @@ export class FunctionManager {
         for (const path of standardPaths) {
             if (await this.isValidFunctionDirectory(path)) {
                 if (verbose) {
-                    console.log(chalk.green(`✓ Found function at standard location: ${path}`));
+                    MessageFormatter.success(`Found function at standard location: ${path}`, { prefix: "Functions" });
                 }
                 return path;
             }
@@ -55,14 +56,14 @@ export class FunctionManager {
                 const foundPath = await this.recursiveDirectorySearch(searchPath, nameVariations, { caseSensitive, verbose });
                 if (foundPath) {
                     if (verbose) {
-                        console.log(chalk.green(`✓ Found function via fuzzy search: ${foundPath}`));
+                        MessageFormatter.success(`Found function via fuzzy search: ${foundPath}`, { prefix: "Functions" });
                     }
                     return foundPath;
                 }
             }
         }
         if (verbose) {
-            console.log(chalk.yellow(`⚠ Function directory not found: ${functionName}`));
+            MessageFormatter.warning(`Function directory not found: ${functionName}`, { prefix: "Functions" });
         }
         return null;
     }
@@ -116,7 +117,7 @@ export class FunctionManager {
         }
         catch (error) {
             if (verbose) {
-                console.log(chalk.gray(`Skipping inaccessible directory: ${searchPath}`));
+                MessageFormatter.debug(`Skipping inaccessible directory: ${searchPath}`, undefined, { prefix: "Functions" });
             }
         }
         return null;
@@ -169,9 +170,9 @@ export class FunctionManager {
         const { activate = true, entrypoint = functionConfig.entrypoint || "index.js", commands = functionConfig.commands || "npm install", ignored = ["node_modules", ".git", ".vscode", ".DS_Store", "__pycache__", ".venv"], verbose = false, forceRedeploy = false } = options;
         return await functionLimit(async () => {
             if (verbose) {
-                console.log(chalk.blue(`🚀 Deploying function: ${functionConfig.name}`));
-                console.log(chalk.gray(`   Path: ${functionPath}`));
-                console.log(chalk.gray(`   Entrypoint: ${entrypoint}`));
+                MessageFormatter.processing(`Deploying function: ${functionConfig.name}`, { prefix: "Functions" });
+                MessageFormatter.debug(`Path: ${functionPath}`, undefined, { prefix: "Functions" });
+                MessageFormatter.debug(`Entrypoint: ${entrypoint}`, undefined, { prefix: "Functions" });
             }
             // Validate function directory
             if (!await this.isValidFunctionDirectory(functionPath)) {
@@ -185,7 +186,7 @@ export class FunctionManager {
             }
             catch (error) {
                 if (verbose) {
-                    console.log(chalk.yellow(`Function ${functionConfig.$id} does not exist, creating...`));
+                    MessageFormatter.info(`Function ${functionConfig.$id} does not exist, creating...`, { prefix: "Functions" });
                 }
             }
             // Create function if it doesn't exist
@@ -202,7 +203,7 @@ export class FunctionManager {
             // Deploy the function
             const deployment = await this.createDeployment(functionConfig.$id, functionPath, { activate, entrypoint, commands, ignored, verbose });
             if (verbose) {
-                console.log(chalk.green(`✅ Function ${functionConfig.name} deployed successfully`));
+                MessageFormatter.success(`Function ${functionConfig.name} deployed successfully`, { prefix: "Functions" });
             }
             return deployment;
         });
@@ -210,7 +211,7 @@ export class FunctionManager {
     async createFunction(functionConfig, options = {}) {
         const { verbose = false } = options;
         if (verbose) {
-            console.log(chalk.blue(`Creating function: ${functionConfig.name}`));
+            MessageFormatter.processing(`Creating function: ${functionConfig.name}`, { prefix: "Functions" });
         }
         return await tryAwaitWithRetry(async () => {
             return await this.functions.create(functionConfig.$id, functionConfig.name, functionConfig.runtime, functionConfig.execute || [], functionConfig.events || [], functionConfig.schedule || "", functionConfig.timeout || 15, functionConfig.enabled !== false, functionConfig.logging !== false, functionConfig.entrypoint, functionConfig.commands, functionConfig.scopes || [], functionConfig.installationId, functionConfig.providerRepositoryId, functionConfig.providerBranch, functionConfig.providerSilentMode, functionConfig.providerRootDirectory);
@@ -219,7 +220,7 @@ export class FunctionManager {
     async updateFunction(functionConfig, options = {}) {
         const { verbose = false } = options;
         if (verbose) {
-            console.log(chalk.blue(`Updating function: ${functionConfig.name}`));
+            MessageFormatter.processing(`Updating function: ${functionConfig.name}`, { prefix: "Functions" });
         }
         return await tryAwaitWithRetry(async () => {
             return await this.functions.update(functionConfig.$id, functionConfig.name, functionConfig.runtime, functionConfig.execute || [], functionConfig.events || [], functionConfig.schedule || "", functionConfig.timeout || 15, functionConfig.enabled !== false, functionConfig.logging !== false, functionConfig.entrypoint, functionConfig.commands, functionConfig.scopes || [], functionConfig.installationId, functionConfig.providerRepositoryId, functionConfig.providerBranch, functionConfig.providerSilentMode, functionConfig.providerRootDirectory, functionConfig.specification);
@@ -230,12 +231,12 @@ export class FunctionManager {
         const { execSync } = await import("child_process");
         const { platform } = await import("node:os");
         if (verbose) {
-            console.log(chalk.blue("Executing pre-deploy commands..."));
+            MessageFormatter.processing("Executing pre-deploy commands...", { prefix: "Functions" });
         }
         const isWindows = platform() === "win32";
         for (const command of commands) {
             if (verbose) {
-                console.log(chalk.gray(`  $ ${command}`));
+                MessageFormatter.debug(`$ ${command}`, undefined, { prefix: "Functions" });
             }
             try {
                 execSync(command, {
@@ -246,12 +247,12 @@ export class FunctionManager {
                 });
             }
             catch (error) {
-                console.error(chalk.red(`Failed to execute command: ${command}`));
+                MessageFormatter.error(`Failed to execute command: ${command}`, error, { prefix: "Functions" });
                 throw error;
             }
         }
         if (verbose) {
-            console.log(chalk.green("✓ Pre-deploy commands completed"));
+            MessageFormatter.success("Pre-deploy commands completed", { prefix: "Functions" });
         }
     }
     async createDeployment(functionId, codePath, options = {}) {
@@ -261,7 +262,7 @@ export class FunctionManager {
         const tarPath = join(process.cwd(), `function-${functionId}-${Date.now()}.tar.gz`);
         try {
             if (verbose) {
-                console.log(chalk.blue("Creating deployment archive..."));
+                MessageFormatter.processing("Creating deployment archive...", { prefix: "Functions" });
             }
             // Create tarball
             await createTarball({
@@ -274,7 +275,7 @@ export class FunctionManager {
                         relativePath.includes(`/${pattern.toLowerCase()}`) ||
                         relativePath.includes(`\\${pattern.toLowerCase()}`));
                     if (shouldIgnore && verbose) {
-                        console.log(chalk.gray(`  Ignoring: ${path}`));
+                        MessageFormatter.debug(`Ignoring: ${path}`, undefined, { prefix: "Functions" });
                     }
                     return !shouldIgnore;
                 },
@@ -283,7 +284,7 @@ export class FunctionManager {
             const fileBuffer = await fs.promises.readFile(tarPath);
             const fileObject = InputFile.fromBuffer(new Uint8Array(fileBuffer), `function-${functionId}.tar.gz`);
             if (verbose) {
-                console.log(chalk.blue("Uploading deployment..."));
+                MessageFormatter.processing("Uploading deployment...", { prefix: "Functions" });
             }
             const deployment = await tryAwaitWithRetry(async () => {
                 return await this.functions.createDeployment(functionId, fileObject, activate, entrypoint, commands);

package/dist/shared/indexManager.js

@@ -3,6 +3,7 @@ import { Databases, IndexType, Query } from "node-appwrite";
 import { delay, tryAwaitWithRetry } from "../utils/helperFunctions.js";
 import chalk from "chalk";
 import pLimit from "p-limit";
+import { MessageFormatter } from "./messageFormatter.js";
 // Concurrency limits for different operations
 const indexLimit = pLimit(3); // Low limit for index operations
 const queryLimit = pLimit(25); // Higher limit for read operations
@@ -23,7 +24,7 @@ export const createOrUpdateIndex = async (dbId, db, collectionId, index, options
             existingIndex = existingIndexes.indexes[0];
             if (forceRecreate || !indexesSame(existingIndex, index)) {
                 if (verbose) {
-                    console.log(chalk.yellow(`⚠ Updating index ${index.key} in collection ${collectionId}`));
+                    MessageFormatter.warning(`Updating index ${index.key} in collection ${collectionId}`, { prefix: "Index Manager" });
                 }
                 // Delete existing index
                 await tryAwaitWithRetry(async () => {
@@ -34,7 +35,7 @@ export const createOrUpdateIndex = async (dbId, db, collectionId, index, options
             }
             else {
                 if (verbose) {
-                    console.log(chalk.green(`✓ Index ${index.key} is up to date`));
+                    MessageFormatter.success(`Index ${index.key} is up to date`, { prefix: "Index Manager" });
                 }
                 return existingIndex;
             }
@@ -42,7 +43,7 @@ export const createOrUpdateIndex = async (dbId, db, collectionId, index, options
         else {
             shouldCreate = true;
             if (verbose) {
-                console.log(chalk.blue(`+ Creating index ${index.key} in collection ${collectionId}`));
+                MessageFormatter.info(`Creating index ${index.key} in collection ${collectionId}`, { prefix: "Index Manager" });
             }
         }
         if (shouldCreate) {
@@ -50,7 +51,7 @@ export const createOrUpdateIndex = async (dbId, db, collectionId, index, options
                 return await db.createIndex(dbId, collectionId, index.key, index.type, index.attributes, index.orders);
             });
             if (verbose) {
-                console.log(chalk.green(`✓ Created index ${index.key}`));
+                MessageFormatter.success(`Created index ${index.key}`, { prefix: "Index Manager" });
             }
             return newIndex;
         }
@@ -63,7 +64,7 @@ export const createOrUpdateIndexes = async (dbId, db, collectionId, indexes, opt
         return;
     }
     if (verbose) {
-        console.log(chalk.blue(`Processing ${indexes.length} indexes for collection ${collectionId}`));
+        MessageFormatter.info(`Processing ${indexes.length} indexes for collection ${collectionId}`, { prefix: "Index Manager" });
     }
     // Process indexes sequentially to avoid conflicts
     for (const index of indexes) {
@@ -73,12 +74,12 @@ export const createOrUpdateIndexes = async (dbId, db, collectionId, indexes, opt
             await delay(250);
         }
         catch (error) {
-            console.error(chalk.red(`❌ Failed to process index ${index.key}:`), error);
+            MessageFormatter.error(`Failed to process index ${index.key}`, error, { prefix: "Index Manager" });
             throw error;
         }
     }
     if (verbose) {
-        console.log(chalk.green(`✓ Completed processing indexes for collection ${collectionId}`));
+        MessageFormatter.success(`Completed processing indexes for collection ${collectionId}`, { prefix: "Index Manager" });
     }
 };
 export const createUpdateCollectionIndexes = async (db, dbId, collection, collectionConfig, options = {}) => {
@@ -98,7 +99,7 @@ export const deleteObsoleteIndexes = async (db, dbId, collection, collectionConf
         return;
     }
     if (verbose) {
-        console.log(chalk.yellow(`🗑️ Removing ${obsoleteIndexes.length} obsolete indexes from collection ${collection.name}`));
+        MessageFormatter.warning(`Removing ${obsoleteIndexes.length} obsolete indexes from collection ${collection.name}`, { prefix: "Index Manager" });
     }
     // Process deletions with rate limiting
     for (const index of obsoleteIndexes) {
@@ -108,7 +109,7 @@ export const deleteObsoleteIndexes = async (db, dbId, collection, collectionConf
             });
         });
         if (verbose) {
-            console.log(chalk.gray(`🗑️ Deleted obsolete index ${index.key}`));
+            MessageFormatter.info(`Deleted obsolete index ${index.key}`, { prefix: "Index Manager" });
         }
         await delay(250);
     }
@@ -143,8 +144,8 @@ export const validateIndexConfiguration = (indexes, options = {}) => {
         }
     }
     if (verbose && errors.length > 0) {
-        console.log(chalk.red(`❌ Index validation errors:`));
-        errors.forEach(error => console.log(chalk.red(`  - ${error}`)));
+        MessageFormatter.error("Index validation errors", undefined, { prefix: "Index Manager" });
+        errors.forEach(error => MessageFormatter.error(`  - ${error}`, undefined, { prefix: "Index Manager" }));
     }
     return { valid: errors.length === 0, errors };
 };

package/dist/shared/jsonSchemaGenerator.js

@@ -2,6 +2,8 @@ import fs from "fs";
 import path from "path";
 import { toCamelCase, toPascalCase } from "../utils/index.js";
 import chalk from "chalk";
+import { extractSimpleRelationships, resolveCollectionName } from "./relationshipExtractor.js";
+import { MessageFormatter } from "./messageFormatter.js";
 export class JsonSchemaGenerator {
     config;
     appwriteFolderPath;
@@ -12,28 +14,10 @@ export class JsonSchemaGenerator {
         this.extractRelationships();
     }
     resolveCollectionName = (idOrName) => {
-        const col = this.config.collections?.find((c) => c.$id === idOrName || c.name === idOrName);
-        return col?.name ?? idOrName;
+        return resolveCollectionName(this.config, idOrName);
     };
     extractRelationships() {
-        if (!this.config.collections)
-            return;
-        this.config.collections.forEach((collection) => {
-            if (!collection.attributes)
-                return;
-            collection.attributes.forEach((attr) => {
-                if (attr.type === "relationship" && attr.relatedCollection) {
-                    const relationships = this.relationshipMap.get(collection.name) || [];
-                    relationships.push({
-                        attributeKey: attr.key,
-                        relatedCollection: this.resolveCollectionName(attr.relatedCollection),
-                        relationType: attr.relationType,
-                        isArray: attr.relationType === "oneToMany" || attr.relationType === "manyToMany"
-                    });
-                    this.relationshipMap.set(collection.name, relationships);
-                }
-            });
-        });
+        this.relationshipMap = extractSimpleRelationships(this.config);
     }
     attributeToJsonSchemaProperty(attribute) {
         const property = {
@@ -188,7 +172,7 @@ export class JsonSchemaGenerator {
         const { outputFormat = "both", outputDirectory = "schemas", verbose = false } = options;
         if (!this.config.collections) {
             if (verbose) {
-                console.log(chalk.yellow("No collections found in config"));
+                MessageFormatter.warning("No collections found in config", { prefix: "Schema" });
             }
             return;
         }
@@ -198,7 +182,7 @@ export class JsonSchemaGenerator {
             fs.mkdirSync(jsonSchemasPath, { recursive: true });
         }
         if (verbose) {
-            console.log(chalk.blue(`Generating JSON schemas for ${this.config.collections.length} collections...`));
+            MessageFormatter.processing(`Generating JSON schemas for ${this.config.collections.length} collections...`, { prefix: "Schema" });
         }
         this.config.collections.forEach((collection) => {
             const schema = this.createJsonSchema(collection);
@@ -208,7 +192,7 @@ export class JsonSchemaGenerator {
                 const jsonPath = path.join(jsonSchemasPath, `${camelCaseName}.json`);
                 fs.writeFileSync(jsonPath, JSON.stringify(schema, null, 2), { encoding: "utf-8" });
                 if (verbose) {
-                    console.log(chalk.green(`✓ JSON schema written to ${jsonPath}`));
+                    MessageFormatter.success(`JSON schema written to ${jsonPath}`, { prefix: "Schema" });
                 }
             }
             // Generate TypeScript file
@@ -217,7 +201,7 @@ export class JsonSchemaGenerator {
                 const tsPath = path.join(jsonSchemasPath, `${camelCaseName}.schema.ts`);
                 fs.writeFileSync(tsPath, tsContent, { encoding: "utf-8" });
                 if (verbose) {
-                    console.log(chalk.green(`✓ TypeScript schema written to ${tsPath}`));
+                    MessageFormatter.success(`TypeScript schema written to ${tsPath}`, { prefix: "Schema" });
                 }
             }
         });
@@ -226,7 +210,7 @@ export class JsonSchemaGenerator {
             this.generateIndexFile(outputFormat, jsonSchemasPath, verbose);
         }
         if (verbose) {
-            console.log(chalk.green("✓ JSON schema generation completed"));
+            MessageFormatter.success("JSON schema generation completed", { prefix: "Schema" });
         }
     }
     generateTypeScriptSchema(schema, collectionName) {
@@ -274,7 +258,7 @@ export default jsonSchemas;
 `;
         fs.writeFileSync(indexPath, indexContent, { encoding: "utf-8" });
         if (verbose) {
-            console.log(chalk.green(`✓ Index file written to ${indexPath}`));
+            MessageFormatter.success(`Index file written to ${indexPath}`, { prefix: "Schema" });
         }
     }
     validateSchema(schema) {

package/dist/shared/logging.d.ts

@@ -5,6 +5,57 @@ export interface LoggingConfig {
     logDirectory?: string;
     console: boolean;
 }
+/**
+ * Predefined logging configurations for common debugging scenarios
+ */
+export declare const LOGGING_PRESETS: {
+    /** Minimal logging - errors only to console */
+    readonly minimal: {
+        readonly enabled: false;
+        readonly level: "error";
+        readonly console: true;
+    };
+    /** Standard logging - info level to file and console */
+    readonly standard: {
+        readonly enabled: true;
+        readonly level: "info";
+        readonly console: true;
+    };
+    /** Debug logging - verbose debug output for troubleshooting */
+    readonly debug: {
+        readonly enabled: true;
+        readonly level: "debug";
+        readonly console: true;
+    };
+    /** Silent - no logging output */
+    readonly silent: {
+        readonly enabled: false;
+        readonly level: "error";
+        readonly console: false;
+    };
+};
 export declare const configureLogging: (config?: Partial<LoggingConfig>) => void;
+/**
+ * Configure logging using a preset
+ */
+export declare const configureLoggingPreset: (preset: keyof typeof LOGGING_PRESETS, logDirectory?: string) => void;
 export declare let logger: winston.Logger;
 export declare const updateLogger: () => void;
+/**
+ * Enable debug logging for troubleshooting push process issues
+ * This is a convenience function for quickly enabling comprehensive logging
+ */
+export declare const enableDebugLogging: (logDirectory?: string) => void;
+/**
+ * Disable logging (reset to default)
+ */
+export declare const disableLogging: () => void;
+/**
+ * Get current logging configuration
+ */
+export declare const getLoggingConfig: () => {
+    enabled: boolean;
+    level: string;
+    logDirectory?: string;
+    console: boolean;
+};

package/dist/shared/logging.js

@@ -1,6 +1,35 @@
 import winston from "winston";
 import fs from "fs";
 import path from "path";
+/**
+ * Predefined logging configurations for common debugging scenarios
+ */
+export const LOGGING_PRESETS = {
+    /** Minimal logging - errors only to console */
+    minimal: {
+        enabled: false,
+        level: 'error',
+        console: true
+    },
+    /** Standard logging - info level to file and console */
+    standard: {
+        enabled: true,
+        level: 'info',
+        console: true
+    },
+    /** Debug logging - verbose debug output for troubleshooting */
+    debug: {
+        enabled: true,
+        level: 'debug',
+        console: true
+    },
+    /** Silent - no logging output */
+    silent: {
+        enabled: false,
+        level: 'error',
+        console: false
+    }
+};
 const DEFAULT_LOGGING_CONFIG = {
     enabled: false,
     level: "info",
@@ -10,6 +39,17 @@ let loggingConfig = DEFAULT_LOGGING_CONFIG;
 export const configureLogging = (config = {}) => {
     loggingConfig = { ...DEFAULT_LOGGING_CONFIG, ...config };
 };
+/**
+ * Configure logging using a preset
+ */
+export const configureLoggingPreset = (preset, logDirectory) => {
+    const presetConfig = LOGGING_PRESETS[preset];
+    configureLogging({
+        ...presetConfig,
+        ...(logDirectory && { logDirectory })
+    });
+    updateLogger();
+};
 const createLogger = () => {
     const transports = [];
     // Add console transport if enabled
@@ -44,3 +84,33 @@ export let logger = createLogger();
 export const updateLogger = () => {
     logger = createLogger();
 };
+/**
+ * Enable debug logging for troubleshooting push process issues
+ * This is a convenience function for quickly enabling comprehensive logging
+ */
+export const enableDebugLogging = (logDirectory) => {
+    configureLogging({
+        enabled: true,
+        level: 'debug',
+        console: true,
+        logDirectory
+    });
+    updateLogger();
+    logger.info('Debug logging enabled for push process troubleshooting', {
+        level: 'debug',
+        console: true,
+        logDirectory: logDirectory || 'zlogs',
+        operation: 'enableDebugLogging'
+    });
+};
+/**
+ * Disable logging (reset to default)
+ */
+export const disableLogging = () => {
+    configureLogging(DEFAULT_LOGGING_CONFIG);
+    updateLogger();
+};
+/**
+ * Get current logging configuration
+ */
+export const getLoggingConfig = () => ({ ...loggingConfig });

package/dist/shared/messageFormatter.d.ts

@@ -11,6 +11,8 @@ export declare class MessageFormatter {
     static step(step: number, total: number, message: string, options?: MessageOptions): void;
     static progress(message: string, options?: MessageOptions): void;
     static debug(message: string, data?: any, options?: MessageOptions): void;
+    static processing(message: string, options?: MessageOptions): void;
+    static divider(): void;
     static banner(title: string, subtitle?: string): void;
     static section(title: string): void;
     static list(items: string[], title?: string): void;

package/dist/shared/messageFormatter.js

@@ -59,6 +59,16 @@ export class MessageFormatter {
             logger.debug(`DEBUG: ${options.prefix ? `${options.prefix}: ` : ""}${message}`, data);
         }
     }
+    static processing(message, options = {}) {
+        const formatted = `${chalk.cyan("⚙️")} ${options.prefix ? `${options.prefix}: ` : ""}${message}`;
+        console.log(formatted);
+        if (!options.skipLogging) {
+            logger.info(`PROCESSING: ${options.prefix ? `${options.prefix}: ` : ""}${message}`);
+        }
+    }
+    static divider() {
+        console.log(chalk.gray("─".repeat(60)));
+    }
     static banner(title, subtitle) {
         const divider = chalk.cyan("═".repeat(60));
         console.log(`\n${divider}`);

package/dist/shared/migrationHelpers.d.ts

@@ -1,5 +1,6 @@
 import { type Databases } from "node-appwrite";
 import { z } from "zod";
+import type { DatabaseAdapter } from "../adapters/DatabaseAdapter.js";
 /**
  * Object that contains the context for an action that needs to be executed after import
  * Used in the afterImportActionsDefinitions
@@ -37,9 +38,9 @@ export declare const ContextObject: z.ZodObject<{
     context: z.ZodAny;
 }, z.core.$strip>;
 export type ContextObject = z.infer<typeof ContextObject>;
-export declare const createOrFindAfterImportOperation: (database: Databases, collectionId: string, context: ContextObject, useMigrations?: boolean) => Promise<void>;
+export declare const createOrFindAfterImportOperation: (database: Databases, collectionId: string, context: ContextObject) => Promise<void>;
 export declare const addBatch: (database: Databases, data: string) => Promise<string>;
-export declare const getAfterImportOperations: (database: Databases, collectionId: string, useMigrations?: boolean) => Promise<{
+export declare const getAfterImportOperations: (database: Databases, collectionId: string) => Promise<{
     $id: string;
     $createdAt: string;
     $updatedAt: string;
@@ -52,20 +53,9 @@ export declare const getAfterImportOperations: (database: Databases, collectionI
     status: "error" | "pending" | "ready" | "in_progress" | "completed" | "cancelled";
     batches?: string[] | undefined;
 }[]>;
-export declare const findOrCreateOperation: (database: Databases, collectionId: string, operationType: string, additionalQueries?: string[]) => Promise<{
-    $id: string;
-    $createdAt: string;
-    $updatedAt: string;
-    operationType: string;
-    collectionId: string;
-    data: any;
-    progress: number;
-    total: number;
-    error: string;
-    status: "error" | "pending" | "ready" | "in_progress" | "completed" | "cancelled";
-    batches?: string[] | undefined;
-}>;
-export declare const updateOperation: (database: Databases, operationId: string, updateFields: any, useMigrations?: boolean) => Promise<void>;
+export declare const findOrCreateOperation: (db: DatabaseAdapter, databaseId: string, operationType: string, collectionId?: string, data?: any) => Promise<any>;
+export declare const updateOperation: (db: DatabaseAdapter, databaseId: string, operationId: string, updates: any) => Promise<any>;
+export declare const getOperation: (db: DatabaseAdapter, databaseId: string, operationId: string) => Promise<any>;
 export declare const maxDataLength = 1073741820;
 export declare const maxBatchItems = 25;
 export declare const splitIntoBatches: (data: any[]) => any[][];

package/dist/shared/migrationHelpers.js

@@ -4,6 +4,8 @@ import { AttributeMappingsSchema } from "appwrite-utils";
 import { z } from "zod";
 import { logger } from "./logging.js";
 import { tryAwaitWithRetry } from "../utils/helperFunctions.js";
+import { findOrCreateOperation as findOrCreateOp, updateOperation as updateOp, getOperation as getOp } from "./operationsTable.js";
+import { MessageFormatter } from "./messageFormatter.js";
 /**
  * Object that contains the context for an action that needs to be executed after import
  * Used in the afterImportActionsDefinitions
@@ -22,12 +24,8 @@ export const ContextObject = z.object({
     attributeMappings: AttributeMappingsSchema,
     context: z.any(),
 });
-export const createOrFindAfterImportOperation = async (database, collectionId, context, useMigrations = true) => {
-    if (!useMigrations) {
-        logger.info("Migrations disabled, skipping after import operation tracking");
-        return;
-    }
-    let operation = await findOrCreateOperation(database, collectionId, "afterImportAction");
+export const createOrFindAfterImportOperation = async (database, collectionId, context) => {
+    let operation = await findOrCreateOperationLegacy(database, collectionId, "afterImportAction");
     if (!operation.batches) {
         operation.batches = [];
     }
@@ -46,11 +44,7 @@ export const addBatch = async (database, data) => {
     });
     return batch.$id;
 };
-export const getAfterImportOperations = async (database, collectionId, useMigrations = true) => {
-    if (!useMigrations) {
-        logger.info("Migrations disabled, returning empty operations list");
-        return [];
-    }
+export const getAfterImportOperations = async (database, collectionId) => {
     let lastDocumentId;
     const allOperations = [];
     let total = 0;
@@ -74,7 +68,8 @@ export const getAfterImportOperations = async (database, collectionId, useMigrat
     const allOps = allOperations.map((op) => OperationSchema.parse(op));
     return allOps;
 };
-export const findOrCreateOperation = async (database, collectionId, operationType, additionalQueries) => {
+// Legacy function for backward compatibility with old migrations database
+const findOrCreateOperationLegacy = async (database, collectionId, operationType, additionalQueries) => {
     const operations = await tryAwaitWithRetry(async () => await database.listDocuments("migrations", "currentOperations", [
         Query.equal("collectionId", collectionId),
         Query.equal("operationType", operationType),
@@ -82,10 +77,9 @@ export const findOrCreateOperation = async (database, collectionId, operationTyp
         ...(additionalQueries || []),
     ]));
     if (operations.documents.length > 0) {
-        return OperationSchema.parse(operations.documents[0]); // Assuming the first document is the operation we want
+        return OperationSchema.parse(operations.documents[0]);
     }
     else {
-        // Create a new operation document
         const op = await tryAwaitWithRetry(async () => await database.createDocument("migrations", "currentOperations", ID.unique(), {
             operationType,
             collectionId,
@@ -98,12 +92,20 @@ export const findOrCreateOperation = async (database, collectionId, operationTyp
         return OperationSchema.parse(op);
     }
 };
-export const updateOperation = async (database, operationId, updateFields, useMigrations = true) => {
-    if (!useMigrations) {
-        logger.info("Migrations disabled, skipping operation update");
-        return;
-    }
-    await tryAwaitWithRetry(async () => await database.updateDocument("migrations", "currentOperations", operationId, updateFields));
+export const findOrCreateOperation = async (db, databaseId, operationType, collectionId, data) => {
+    // Use new operations table system
+    return await findOrCreateOp(db, databaseId, operationType, {
+        targetCollection: collectionId,
+        data: data
+    });
+};
+export const updateOperation = async (db, databaseId, operationId, updates) => {
+    // Use new operations table system
+    return await updateOp(db, databaseId, operationId, updates);
+};
+export const getOperation = async (db, databaseId, operationId) => {
+    // Use new operations table system
+    return await getOp(db, databaseId, operationId);
 };
 // Actual max 1073741824
 export const maxDataLength = 1073741820;
@@ -116,7 +118,8 @@ export const splitIntoBatches = (data) => {
     data.forEach((item, index) => {
         const itemLength = JSON.stringify(item).length;
         if (itemLength > maxDataLength) {
-            console.log(item, `Large item found at index ${index} with length ${itemLength}:`);
+            MessageFormatter.warning(`Large item found at index ${index} with length ${itemLength}`, { prefix: "Batch Splitter" });
+            logger.debug("Large item data:", item);
         }
         // Check if adding the current item would exceed the max length or max items per batch
         if (currentBatchLength + itemLength >= maxDataLength ||