appwrite-utils-cli 1.5.1 → 1.6.0

package/src/shared/indexManager.ts

@@ -3,6 +3,7 @@ import { Databases, IndexType, Query, type Models } 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
@@ -48,7 +49,7 @@ export const createOrUpdateIndex = async (
       
       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
@@ -60,14 +61,14 @@ export const createOrUpdateIndex = async (
         shouldCreate = true;
       } 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;
       }
     } 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" });
       }
     }
 
@@ -84,7 +85,7 @@ export const createOrUpdateIndex = async (
       });
 
       if (verbose) {
-        console.log(chalk.green(`✓ Created index ${index.key}`));
+        MessageFormatter.success(`Created index ${index.key}`, { prefix: "Index Manager" });
       }
 
       return newIndex;
@@ -111,7 +112,7 @@ export const createOrUpdateIndexes = async (
   }
 
   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
@@ -122,13 +123,13 @@ export const createOrUpdateIndexes = async (
       // Add delay between index operations to prevent rate limiting
       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 as 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" });
   }
 };
 
@@ -184,7 +185,7 @@ export const deleteObsoleteIndexes = async (
   }
 
   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
@@ -196,7 +197,7 @@ export const deleteObsoleteIndexes = async (
     });
 
     if (verbose) {
-      console.log(chalk.gray(`🗑️ Deleted obsolete index ${index.key}`));
+      MessageFormatter.info(`Deleted obsolete index ${index.key}`, { prefix: "Index Manager" });
     }
 
     await delay(250);
@@ -245,8 +246,8 @@ export const validateIndexConfiguration = (
   }
 
   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/src/shared/jsonSchemaGenerator.ts

@@ -3,6 +3,12 @@ import path from "path";
 import type { AppwriteConfig, Attribute, CollectionCreate } from "appwrite-utils";
 import { toCamelCase, toPascalCase } from "../utils/index.js";
 import chalk from "chalk";
+import {
+  extractSimpleRelationships,
+  resolveCollectionName,
+  type SimpleRelationship
+} from "./relationshipExtractor.js";
+import { MessageFormatter } from "./messageFormatter.js";
 
 export interface JsonSchemaProperty {
   type: string | string[];
@@ -33,43 +39,23 @@ export interface JsonSchema {
   definitions?: Record<string, JsonSchemaProperty>;
 }
 
-export class JsonSchemaGenerator {
-  private config: AppwriteConfig;
-  private appwriteFolderPath: string;
-  private relationshipMap = new Map<string, any[]>();
-
-  constructor(config: AppwriteConfig, appwriteFolderPath: string) {
-    this.config = config;
-    this.appwriteFolderPath = appwriteFolderPath;
-    this.extractRelationships();
-  }
-
-  private resolveCollectionName = (idOrName: string): string => {
-    const col = this.config.collections?.find(
-      (c) => c.$id === (idOrName as any) || c.name === idOrName
-    );
-    return col?.name ?? idOrName;
-  };
+export class JsonSchemaGenerator {
+  private config: AppwriteConfig;
+  private appwriteFolderPath: string;
+  private relationshipMap = new Map<string, SimpleRelationship[]>();
 
-  private extractRelationships(): void {
-    if (!this.config.collections) return;
+  constructor(config: AppwriteConfig, appwriteFolderPath: string) {
+    this.config = config;
+    this.appwriteFolderPath = appwriteFolderPath;
+    this.extractRelationships();
+  }
 
-    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);
-        }
-      });
-    });
+  private resolveCollectionName = (idOrName: string): string => {
+    return resolveCollectionName(this.config, idOrName);
+  };
+
+  private extractRelationships(): void {
+    this.relationshipMap = extractSimpleRelationships(this.config);
   }
 
   private attributeToJsonSchemaProperty(attribute: Attribute): JsonSchemaProperty {
@@ -160,14 +146,14 @@ export class JsonSchemaGenerator {
         }
         break;
 
-      case "relationship":
-        if (attribute.relatedCollection) {
-          // For relationships, reference the related collection schema
-          schema.$ref = `#/definitions/${toPascalCase(this.resolveCollectionName(attribute.relatedCollection))}`;
-        } else {
-          schema.type = "string";
-        }
-        break;
+      case "relationship":
+        if (attribute.relatedCollection) {
+          // For relationships, reference the related collection schema
+          schema.$ref = `#/definitions/${toPascalCase(this.resolveCollectionName(attribute.relatedCollection))}`;
+        } else {
+          schema.type = "string";
+        }
+        break;
 
       default:
         schema.type = "string";
@@ -254,7 +240,7 @@ export class JsonSchemaGenerator {
 
     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;
     }
@@ -266,7 +252,7 @@ export class JsonSchemaGenerator {
     }
 
     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) => {
@@ -277,9 +263,9 @@ export class JsonSchemaGenerator {
       if (outputFormat === "json" || outputFormat === "both") {
         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" });
         }
       }
 
@@ -288,9 +274,9 @@ export class JsonSchemaGenerator {
         const tsContent = this.generateTypeScriptSchema(schema, collection.name);
         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" });
         }
       }
     });
@@ -301,7 +287,7 @@ export class JsonSchemaGenerator {
     }
 
     if (verbose) {
-      console.log(chalk.green("✓ JSON schema generation completed"));
+      MessageFormatter.success("JSON schema generation completed", { prefix: "Schema" });
     }
   }
 
@@ -358,7 +344,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" });
     }
   }
 
@@ -392,4 +378,4 @@ export default jsonSchemas;
 
     return { valid: errors.length === 0, errors };
   }
-}
+}

package/src/shared/logging.ts

@@ -9,6 +9,36 @@ export interface LoggingConfig {
   console: boolean;
 }
 
+/**
+ * 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
+  }
+} as const;
+
 const DEFAULT_LOGGING_CONFIG: LoggingConfig = {
   enabled: false,
   level: "info",
@@ -21,6 +51,18 @@ export const configureLogging = (config: Partial<LoggingConfig> = {}) => {
   loggingConfig = { ...DEFAULT_LOGGING_CONFIG, ...config };
 };
 
+/**
+ * Configure logging using a preset
+ */
+export const configureLoggingPreset = (preset: keyof typeof LOGGING_PRESETS, logDirectory?: string) => {
+  const presetConfig = LOGGING_PRESETS[preset];
+  configureLogging({
+    ...presetConfig,
+    ...(logDirectory && { logDirectory })
+  });
+  updateLogger();
+};
+
 const createLogger = () => {
   const transports: winston.transport[] = [];
 
@@ -72,3 +114,36 @@ 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?: string) => {
+  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/src/shared/messageFormatter.ts

@@ -74,12 +74,25 @@ export class MessageFormatter {
         console.log(chalk.gray(JSON.stringify(data, null, 2)));
       }
     }
-    
+
     if (!options.skipLogging) {
       logger.debug(`DEBUG: ${options.prefix ? `${options.prefix}: ` : ""}${message}`, data);
     }
   }
 
+  static processing(message: string, options: MessageOptions = {}) {
+    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: string, subtitle?: string) {
     const divider = chalk.cyan("═".repeat(60));
     console.log(`\n${divider}`);

package/src/shared/migrationHelpers.ts

@@ -4,6 +4,13 @@ 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 type { DatabaseAdapter } from "../adapters/DatabaseAdapter.js";
+import { MessageFormatter } from "./messageFormatter.js";
 
 /**
  * Object that contains the context for an action that needs to be executed after import
@@ -29,15 +36,9 @@ export type ContextObject = z.infer<typeof ContextObject>;
 export const createOrFindAfterImportOperation = async (
   database: Databases,
   collectionId: string,
-  context: ContextObject,
-  useMigrations: boolean = true
+  context: ContextObject
 ) => {
-  if (!useMigrations) {
-    logger.info("Migrations disabled, skipping after import operation tracking");
-    return;
-  }
-
-  let operation = await findOrCreateOperation(
+  let operation = await findOrCreateOperationLegacy(
     database,
     collectionId,
     "afterImportAction"
@@ -75,14 +76,8 @@ export const addBatch = async (database: Databases, data: string) => {
 
 export const getAfterImportOperations = async (
   database: Databases,
-  collectionId: string,
-  useMigrations: boolean = true
+  collectionId: string
 ) => {
-  if (!useMigrations) {
-    logger.info("Migrations disabled, returning empty operations list");
-    return [];
-  }
-
   let lastDocumentId: string | undefined;
   const allOperations = [];
   let total = 0;
@@ -116,7 +111,8 @@ export const getAfterImportOperations = async (
   return allOps;
 };
 
-export const findOrCreateOperation = async (
+// Legacy function for backward compatibility with old migrations database
+const findOrCreateOperationLegacy = async (
   database: Databases,
   collectionId: string,
   operationType: string,
@@ -133,9 +129,8 @@ export const findOrCreateOperation = async (
   );
 
   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(
@@ -158,26 +153,37 @@ export const findOrCreateOperation = async (
   }
 };
 
+export const findOrCreateOperation = async (
+  db: DatabaseAdapter,
+  databaseId: string,
+  operationType: string,
+  collectionId?: string,
+  data?: any
+): Promise<any> => {
+  // Use new operations table system
+  return await findOrCreateOp(db, databaseId, operationType, {
+    targetCollection: collectionId,
+    data: data
+  });
+};
+
 export const updateOperation = async (
-  database: Databases,
+  db: DatabaseAdapter,
+  databaseId: string,
   operationId: string,
-  updateFields: any,
-  useMigrations: boolean = true
-) => {
-  if (!useMigrations) {
-    logger.info("Migrations disabled, skipping operation update");
-    return;
-  }
+  updates: any
+): Promise<any> => {
+  // Use new operations table system
+  return await updateOp(db, databaseId, operationId, updates);
+};
 
-  await tryAwaitWithRetry(
-    async () =>
-      await database.updateDocument(
-        "migrations",
-        "currentOperations",
-        operationId,
-        updateFields
-      )
-  );
+export const getOperation = async (
+  db: DatabaseAdapter,
+  databaseId: string,
+  operationId: string
+): Promise<any> => {
+  // Use new operations table system
+  return await getOp(db, databaseId, operationId);
 };
 
 // Actual max 1073741824
@@ -193,10 +199,11 @@ export const splitIntoBatches = (data: any[]): any[][] => {
   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 (

package/src/shared/operationLogger.ts

@@ -1,45 +1,20 @@
 import type { Databases, Models } from "node-appwrite";
 import type { OperationCreate } from "../storage/schemas.js";
-import { tryAwaitWithRetry } from "appwrite-utils";
-import { ulid } from "ulidx";
 
+/**
+ * Legacy operation logger - deprecated
+ * This function is maintained for backward compatibility but no longer performs any logging.
+ * The operations table system has been refactored to use the dynamic adapter pattern.
+ *
+ * @deprecated This function will be removed in a future version
+ */
 export const logOperation = async (
   db: Databases,
   dbId: string,
   operationDetails: OperationCreate,
-  operationId?: string,
-  useMigrations: boolean = true
+  operationId?: string
 ): Promise<Models.Document | null> => {
-  if (!useMigrations) {
-    console.log("Migrations disabled, skipping operation logging");
-    return null;
-  }
-  try {
-    let operation;
-    if (operationId) {
-      // Update existing operation log
-      operation = await tryAwaitWithRetry(
-        async () =>
-          await db.updateDocument(
-            "migrations",
-            "currentOperations",
-            operationId,
-            operationDetails
-          )
-      );
-    } else {
-      // Create new operation log
-      operation = await db.createDocument(
-        "migrations",
-        "currentOperations",
-        ulid(),
-        operationDetails
-      );
-    }
-    console.log(`Operation logged: ${operation.$id}`);
-    return operation;
-  } catch (error) {
-    console.error(`Error logging operation: ${error}`);
-    throw error;
-  }
+  // No-op: Operations logging has been moved to the new operations table system
+  // Callers should migrate to using operationsTable.ts functions directly
+  return null;
 };