appwrite-utils-cli 1.7.7 → 1.7.8

package/src/migrations/appwriteToX.ts

@@ -26,9 +26,52 @@ import {
   type Specification,
 } from "appwrite-utils";
 import { getDatabaseFromConfig } from "./afterImportActions.js";
+import { getAdapterFromConfig } from "../utils/getClientFromConfig.js";
 import { listBuckets } from "../storage/methods.js";
 import { listFunctions, listFunctionDeployments } from "../functions/methods.js";
 import { MessageFormatter } from "../shared/messageFormatter.js";
+import { isLegacyDatabases } from "../utils/typeGuards.js";
+import type { DatabaseAdapter } from "../adapters/DatabaseAdapter.js";
+import type { DatabaseSelection, BucketSelection } from "../shared/selectionDialogs.js";
+
+/**
+ * Convert between collection and table terminology based on data structure
+ */
+function normalizeCollectionOrTable(collection: any): {
+  attributes: any[];
+  permissions: any[];
+  name: string;
+  $id: string;
+  enabled: boolean;
+  indexes?: any[];
+} {
+  // Check if this is a table (has columns) or collection (has attributes)
+  const isTable = collection.columns && Array.isArray(collection.columns);
+
+  if (isTable) {
+    // Table structure - convert columns to attributes
+    MessageFormatter.debug(`Detected table structure: ${collection.name || collection.tableName}`, { prefix: "Migration" });
+    return {
+      ...collection,
+      attributes: collection.columns || [],
+      permissions: collection.$permissions || collection.permissions || [],
+      name: collection.name || collection.tableName,
+      $id: collection.$id || collection.tableId,
+      enabled: collection.enabled ?? true
+    };
+  } else {
+    // Collection structure - use as-is with fallbacks
+    MessageFormatter.debug(`Detected collection structure: ${collection.name}`, { prefix: "Migration" });
+    return {
+      ...collection,
+      attributes: collection.attributes || [],
+      permissions: collection.$permissions || collection.permissions || [],
+      name: collection.name,
+      $id: collection.$id,
+      enabled: collection.enabled ?? true
+    };
+  }
+}
 
 export class AppwriteToX {
   config: AppwriteConfig;
@@ -36,6 +79,9 @@ export class AppwriteToX {
   updatedConfig: AppwriteConfig;
   collToAttributeMap = new Map<string, Attribute[]>();
   appwriteFolderPath: string;
+  adapter?: DatabaseAdapter;
+  apiMode?: 'legacy' | 'tablesdb';
+  databaseApiModes = new Map<string, 'legacy' | 'tablesdb'>();
 
   constructor(
     config: AppwriteConfig,
@@ -49,6 +95,27 @@ export class AppwriteToX {
     this.ensureClientInitialized();
   }
 
+  /**
+   * Initialize adapter for database operations with API mode detection
+   */
+  private async initializeAdapter(): Promise<void> {
+    if (!this.adapter) {
+      try {
+        const { adapter, apiMode } = await getAdapterFromConfig(this.config);
+        this.adapter = adapter;
+        this.apiMode = apiMode;
+        MessageFormatter.info(`Initialized database adapter with API mode: ${apiMode}`, { prefix: "Migration" });
+      } catch (error) {
+        MessageFormatter.warning(
+          `Failed to initialize adapter, falling back to legacy client: ${error instanceof Error ? error.message : 'Unknown error'}`,
+          { prefix: "Migration" }
+        );
+        // Fallback to legacy client initialization
+        this.ensureClientInitialized();
+      }
+    }
+  }
+
   private ensureClientInitialized() {
     if (!this.config.appwriteClient) {
       const client = new Client();
@@ -83,18 +150,128 @@ export class AppwriteToX {
   };
 
   updateCollectionConfigAttributes = (collection: Models.Collection) => {
-    for (const attribute of collection.attributes) {
-      const attributeMap = this.collToAttributeMap.get(
-        collection.name as string
-      );
+    // Normalize collection/table structure to handle both TablesDB and Legacy formats
+    const normalizedCollection = normalizeCollectionOrTable(collection);
+
+    for (const attribute of normalizedCollection.attributes) {
+      if (!attribute) {
+        MessageFormatter.warning("Skipping null/undefined attribute in updateCollectionConfigAttributes", { prefix: "Migration" });
+        continue;
+      }
       const attributeParsed = attributeSchema.parse(attribute);
       this.collToAttributeMap
-        .get(collection.name as string)
+        .get(normalizedCollection.name)
         ?.push(attributeParsed);
     }
   };
 
-  async appwriteSync(config: AppwriteConfig, databases?: Models.Database[]) {
+  /**
+   * Fetch collections/tables using the appropriate adapter or legacy client
+   */
+  private async fetchCollectionsOrTables(databaseId: string, db: any): Promise<Models.Collection[]> {
+    // Try to use adapter first
+    if (this.adapter) {
+      try {
+        const result = await this.adapter.listTables({ databaseId });
+        const items = (result as any).tables || result.collections || [];
+        MessageFormatter.info(`Fetched ${items.length} items using ${this.apiMode} adapter`, { prefix: "Migration" });
+        return items as Models.Collection[];
+      } catch (error) {
+        MessageFormatter.warning(
+          `Adapter fetch failed, falling back to legacy: ${error instanceof Error ? error.message : 'Unknown error'}`,
+          { prefix: "Migration" }
+        );
+      }
+    }
+
+    // Fallback to legacy method
+    try {
+      const collections = await fetchAllCollections(databaseId, db);
+      MessageFormatter.info(`Fetched ${collections.length} collections using legacy client`, { prefix: "Migration" });
+      return collections;
+    } catch (error) {
+      MessageFormatter.error(
+        "Failed to fetch collections with both adapter and legacy methods",
+        error instanceof Error ? error : new Error(String(error)),
+        { prefix: "Migration" }
+      );
+      throw error;
+    }
+  }
+
+  /**
+   * Get collection/table using the appropriate adapter or legacy client
+   */
+  private async getCollectionOrTable(databaseId: string, collectionId: string): Promise<Models.Collection> {
+    // Try to use adapter first
+    if (this.adapter) {
+      try {
+        const result = await this.adapter.getTable({ databaseId, tableId: collectionId });
+        return result as Models.Collection;
+      } catch (error) {
+        MessageFormatter.warning(
+          `Adapter get failed, falling back to legacy: ${error instanceof Error ? error.message : 'Unknown error'}`,
+          { prefix: "Migration" }
+        );
+      }
+    }
+
+    // Fallback to legacy method
+    const db = getDatabaseFromConfig(this.config);
+    return await db.getCollection(databaseId, collectionId);
+  }
+
+  /**
+   * Detect API mode for a specific database by testing adapter capabilities
+   */
+  private async detectDatabaseApiMode(databaseId: string): Promise<'legacy' | 'tablesdb'> {
+    // If we already detected this database, return cached result
+    if (this.databaseApiModes.has(databaseId)) {
+      return this.databaseApiModes.get(databaseId)!;
+    }
+
+    // If we have a global adapter, use its API mode as default
+    if (this.apiMode) {
+      this.databaseApiModes.set(databaseId, this.apiMode);
+      MessageFormatter.debug(`Using global API mode for database ${databaseId}: ${this.apiMode}`, { prefix: "Migration" });
+      return this.apiMode;
+    }
+
+    // Default to legacy if no adapter available
+    const defaultMode = 'legacy';
+    this.databaseApiModes.set(databaseId, defaultMode);
+    MessageFormatter.debug(`Defaulting to legacy mode for database ${databaseId}`, { prefix: "Migration" });
+    return defaultMode;
+  }
+
+  /**
+   * Get API mode context for schema generation
+   */
+  private getSchemaGeneratorApiContext(): any {
+    const databaseModes: Record<string, 'legacy' | 'tablesdb'> = {};
+
+    // Get API mode for each database
+    for (const db of this.updatedConfig.databases || []) {
+      const apiMode = this.databaseApiModes.get(db.$id) || this.apiMode || 'legacy';
+      databaseModes[db.$id] = apiMode;
+    }
+
+    return {
+      apiMode: this.apiMode || 'legacy',
+      databaseApiModes: databaseModes,
+      adapterMetadata: this.adapter?.getMetadata()
+    };
+  }
+
+  async appwriteSync(
+    config: AppwriteConfig,
+    databases?: Models.Database[],
+    databaseSelections?: DatabaseSelection[],
+    bucketSelections?: BucketSelection[]
+  ) {
+    // Initialize adapter for proper API mode detection and usage
+    await this.initializeAdapter();
+
     const db = getDatabaseFromConfig(config);
     if (!databases) {
       try {
@@ -110,6 +287,16 @@ export class AppwriteToX {
         throw new Error(`Database fetch failed: ${error instanceof Error ? error.message : 'Unknown error'}`);
       }
     }
+
+    // Filter databases based on selection if provided
+    let databasesToProcess = databases;
+    if (databaseSelections && databaseSelections.length > 0) {
+      databasesToProcess = databases?.filter(db =>
+        databaseSelections.some(selection => selection.databaseId === db.$id)
+      ) || [];
+      MessageFormatter.info(`Filtered to ${databasesToProcess.length} selected databases`, { prefix: "Migration" });
+    }
+
     let updatedConfig: AppwriteConfig = { ...config };
 
     // Initialize databases array if it doesn't exist
@@ -118,11 +305,11 @@ export class AppwriteToX {
     }
 
     // Sync remote databases to local config - add missing ones
-    MessageFormatter.info(`Syncing ${databases.length} remote databases with local config...`, { prefix: "Migration" });
+    MessageFormatter.info(`Syncing ${databasesToProcess.length} remote databases with local config...`, { prefix: "Migration" });
     let addedCount = 0;
     let updatedCount = 0;
 
-    for (const remoteDb of databases) {
+    for (const remoteDb of databasesToProcess) {
       // Check if this database already exists in the config
       const existingDbIndex = updatedConfig.databases.findIndex(
         (localDb) => localDb.$id === remoteDb.$id
@@ -151,10 +338,23 @@ export class AppwriteToX {
     // Fetch all buckets
     const allBuckets = await listBuckets(this.storage);
 
+    // Filter buckets based on selection if provided
+    let matchedBuckets = allBuckets.buckets;
+    if (bucketSelections && bucketSelections.length > 0) {
+      matchedBuckets = allBuckets.buckets.filter(bucket =>
+        bucketSelections.some(selection => selection.bucketId === bucket.$id)
+      );
+      MessageFormatter.info(`Filtered to ${matchedBuckets.length} selected buckets`, { prefix: "Migration" });
+    }
+
     // Loop through each database
-    for (const database of databases) {
-      // Match bucket to database
-      const matchedBucket = allBuckets.buckets.find((bucket) =>
+    for (const database of databasesToProcess) {
+      // Detect API mode for this specific database
+      const dbApiMode = await this.detectDatabaseApiMode(database.$id);
+      MessageFormatter.info(`Processing database '${database.name}' with API mode: ${dbApiMode}`, { prefix: "Migration" });
+
+      // Match bucket to database (from filtered buckets if selections provided)
+      const matchedBucket = matchedBuckets.find((bucket) =>
         bucket.$id.toLowerCase().includes(database.$id.toLowerCase())
       );
 
@@ -176,103 +376,183 @@ export class AppwriteToX {
         }
       }
 
-      const collections = await fetchAllCollections(database.$id, db);
+      // Use adapter-aware collection/table fetching with proper API mode detection
+      const collections = await this.fetchCollectionsOrTables(database.$id, db);
+
+      // Filter collections based on table selection if provided
+      let collectionsToProcess = collections;
+      if (databaseSelections && databaseSelections.length > 0) {
+        const dbSelection = databaseSelections.find(selection => selection.databaseId === database.$id);
+        if (dbSelection && dbSelection.tableIds.length > 0) {
+          collectionsToProcess = collections.filter(collection =>
+            dbSelection.tableIds.includes(collection.$id)
+          );
+          MessageFormatter.info(`Filtered to ${collectionsToProcess.length} selected tables for database '${database.name}'`, { prefix: "Migration" });
+        }
+      }
 
       // Loop through each collection in the current database
       if (!updatedConfig.collections) {
         updatedConfig.collections = [];
       }
-      for (const collection of collections) {
-        MessageFormatter.processing(`Processing collection: ${collection.name}`, { prefix: "Migration" });
-        const existingCollectionIndex = updatedConfig.collections.findIndex(
-          (c) => c.name === collection.name
-        );
-        // Parse the collection permissions and attributes
-        const collPermissions = this.parsePermissionsArray(
-          collection.$permissions
-        );
-        const collAttributes = collection.attributes
-          .map((attr: any) => {
-            return parseAttribute(attr);
-          })
-          .filter((attribute: Attribute) =>
-            attribute.type === "relationship"
-              ? attribute.side !== "child"
-              : true
+
+      MessageFormatter.info(`Processing ${collectionsToProcess.length} collections/tables in database '${database.name}'`, { prefix: "Migration" });
+      let processedCount = 0;
+      let errorCount = 0;
+
+      for (const collection of collectionsToProcess) {
+        try {
+          if (!collection) {
+            MessageFormatter.warning("Skipping null/undefined collection", { prefix: "Migration" });
+            errorCount++;
+            continue;
+          }
+
+          // Normalize collection/table structure to handle both TablesDB and Legacy formats
+          const normalizedCollection = normalizeCollectionOrTable(collection);
+
+          MessageFormatter.processing(`Processing ${normalizedCollection.name} (${normalizedCollection.$id})`, { prefix: "Migration" });
+          const existingCollectionIndex = updatedConfig.collections.findIndex(
+            (c) => c.name === normalizedCollection.name
+          );
+
+          // Parse the collection permissions and attributes using normalized structure
+          const collPermissions = this.parsePermissionsArray(
+            normalizedCollection.permissions
           );
-        for (const attribute of collAttributes) {
-          if (
-            attribute.type === "relationship" &&
-            attribute.relatedCollection
-          ) {
-            MessageFormatter.info(
-              `Fetching related collection for ID: ${attribute.relatedCollection}`,
+
+          // Process attributes with proper error handling
+          let collAttributes: Attribute[] = [];
+          try {
+            collAttributes = normalizedCollection.attributes
+              .map((attr: any) => {
+                if (!attr) {
+                  MessageFormatter.warning("Skipping null/undefined attribute", { prefix: "Migration" });
+                  return null;
+                }
+                return parseAttribute(attr);
+              })
+              .filter((attribute: Attribute | null): attribute is Attribute =>
+                attribute !== null &&
+                (attribute.type !== "relationship" ? true : attribute.side !== "child")
+              );
+          } catch (error) {
+            MessageFormatter.error(
+              `Error processing attributes for ${normalizedCollection.name}`,
+              error instanceof Error ? error : new Error(String(error)),
               { prefix: "Migration" }
             );
-            try {
-              const relatedCollectionPulled = await db.getCollection(
-                database.$id,
-                attribute.relatedCollection
-              );
-              MessageFormatter.info(
-                `Fetched Collection Name: ${relatedCollectionPulled.name}`,
-                { prefix: "Migration" }
-              );
-              attribute.relatedCollection = relatedCollectionPulled.name;
+            // Continue with empty attributes array
+            collAttributes = [];
+          }
+
+          for (const attribute of collAttributes) {
+            if (
+              attribute.type === "relationship" &&
+              attribute.relatedCollection
+            ) {
               MessageFormatter.info(
-                `Updated attribute.relatedCollection to: ${attribute.relatedCollection}`,
-                { prefix: "Migration" }
-              );
-            } catch (error) {
-              MessageFormatter.error(
-                "Error fetching related collection",
-                error instanceof Error ? error : new Error(String(error)),
+                `Fetching related collection for ID: ${attribute.relatedCollection}`,
                 { prefix: "Migration" }
               );
+              try {
+                const relatedCollectionPulled = await this.getCollectionOrTable(
+                  database.$id,
+                  attribute.relatedCollection
+                );
+                MessageFormatter.info(
+                  `Fetched Collection Name: ${relatedCollectionPulled.name}`,
+                  { prefix: "Migration" }
+                );
+                attribute.relatedCollection = relatedCollectionPulled.name;
+                MessageFormatter.info(
+                  `Updated attribute.relatedCollection to: ${attribute.relatedCollection}`,
+                  { prefix: "Migration" }
+                );
+              } catch (error) {
+                MessageFormatter.error(
+                  "Error fetching related collection",
+                  error instanceof Error ? error : new Error(String(error)),
+                  { prefix: "Migration" }
+                );
+              }
             }
           }
-        }
-        this.collToAttributeMap.set(collection.name, collAttributes);
-        const finalIndexes = collection.indexes.map((index: Models.Index) => {
-          return {
-            ...index,
-            orders: index.orders?.filter((order: string) => {
-              return order !== null && order;
-            }),
-          };
-        });
-        const collIndexes = indexesSchema.parse(finalIndexes) ?? [];
-
-        // Prepare the collection object to be added or updated
-        const collToPush = CollectionSchema.parse({
-          $id: collection.$id,
-          name: collection.name,
-          enabled: collection.enabled,
-          documentSecurity: collection.documentSecurity,
-          $createdAt: collection.$createdAt,
-          $updatedAt: collection.$updatedAt,
-          $permissions:
-            collPermissions.length > 0 ? collPermissions : undefined,
-          indexes: collIndexes.length > 0 ? collIndexes : undefined,
-          attributes: collAttributes.length > 0 ? collAttributes : undefined,
-        });
+          this.collToAttributeMap.set(normalizedCollection.name, collAttributes);
+
+          // Process indexes with proper error handling using normalized collection
+          let collIndexes: any[] = [];
+          try {
+            const finalIndexes = (normalizedCollection.indexes || collection.indexes || []).map((index: any) => {
+              if (!index) {
+                MessageFormatter.warning("Skipping null/undefined index", { prefix: "Migration" });
+                return null;
+              }
+              return {
+                ...index,
+                // Convert TablesDB 'columns' to expected 'attributes' for schema validation
+                attributes: index.attributes || index.columns || [],
+                orders: index.orders?.filter((order: string) => {
+                  return order !== null && order;
+                }),
+              };
+            }).filter((index: any): index is any => index !== null);
+
+            collIndexes = indexesSchema.parse(finalIndexes) ?? [];
+          } catch (error) {
+            MessageFormatter.error(
+              `Error processing indexes for ${normalizedCollection.name}`,
+              error instanceof Error ? error : new Error(String(error)),
+              { prefix: "Migration" }
+            );
+            // Continue with empty indexes array
+            collIndexes = [];
+          }
+
+          // Prepare the collection object to be added or updated using normalized data
+          const collToPush = CollectionSchema.parse({
+            $id: normalizedCollection.$id,
+            name: normalizedCollection.name,
+            enabled: normalizedCollection.enabled,
+            documentSecurity: collection.documentSecurity, // Use original collection for this field
+            $createdAt: collection.$createdAt, // Use original collection for timestamps
+            $updatedAt: collection.$updatedAt,
+            $permissions:
+              collPermissions.length > 0 ? collPermissions : undefined,
+            indexes: collIndexes.length > 0 ? collIndexes : undefined,
+            attributes: collAttributes.length > 0 ? collAttributes : undefined,
+          });
 
-        if (existingCollectionIndex !== -1) {
-          // Update existing collection
-          updatedConfig.collections[existingCollectionIndex] = collToPush;
-        } else {
-          // Add new collection
-          updatedConfig.collections.push(collToPush);
+          if (existingCollectionIndex !== -1) {
+            // Update existing collection
+            updatedConfig.collections[existingCollectionIndex] = collToPush;
+            MessageFormatter.debug(`Updated existing collection: ${normalizedCollection.name}`, { prefix: "Migration" });
+          } else {
+            // Add new collection
+            updatedConfig.collections.push(collToPush);
+            MessageFormatter.debug(`Added new collection: ${normalizedCollection.name}`, { prefix: "Migration" });
+          }
+
+          processedCount++;
+        } catch (error) {
+          MessageFormatter.error(
+            `Error processing collection: ${collection?.name || 'unknown'}`,
+            error instanceof Error ? error : new Error(String(error)),
+            { prefix: "Migration" }
+          );
+          errorCount++;
         }
       }
 
       MessageFormatter.success(
-        `Processed ${collections.length} collections in ${database.name}`,
+        `Database '${database.name}' processing complete: ${processedCount} collections processed, ${errorCount} errors`,
         { prefix: "Migration" }
       );
     }
     // Add unmatched buckets as global buckets
-    const globalBuckets = allBuckets.buckets.filter(
+    // Use filtered buckets if selections provided, otherwise use all buckets
+    const sourceBuckets = bucketSelections && bucketSelections.length > 0 ? matchedBuckets : allBuckets.buckets;
+    const globalBuckets = sourceBuckets.filter(
       (bucket) =>
         !updatedConfig.databases.some(
           (db) => db.bucket && db.bucket.$id === bucket.$id
@@ -318,16 +598,31 @@ export class AppwriteToX {
     MessageFormatter.success(`Sync completed - ${updatedConfig.databases.length} databases, ${updatedConfig.collections?.length || 0} collections, ${updatedConfig.buckets?.length || 0} buckets, ${updatedConfig.functions?.length || 0} functions`, { prefix: "Migration" });
   }
 
-  async toSchemas(databases?: Models.Database[]) {
+  async toSchemas(
+    databases?: Models.Database[],
+    databaseSelections?: DatabaseSelection[],
+    bucketSelections?: BucketSelection[]
+  ) {
     try {
       MessageFormatter.info("Starting sync-from-Appwrite process...", { prefix: "Migration" });
-      await this.appwriteSync(this.config, databases);
+      await this.appwriteSync(this.config, databases, databaseSelections, bucketSelections);
 
       const generator = new SchemaGenerator(
         this.updatedConfig,
         this.appwriteFolderPath
       );
 
+      // Pass API mode context to the schema generator
+      const apiContext = this.getSchemaGeneratorApiContext();
+
+      // Extend the config with API mode information for schema generation
+      const configWithApiContext = {
+        ...this.updatedConfig,
+        apiMode: apiContext.apiMode,
+        databaseApiModes: apiContext.databaseApiModes,
+        adapterMetadata: apiContext.adapterMetadata
+      };
+
       // Check if this is a YAML-based project
       const yamlConfigPath = findYamlConfig(this.appwriteFolderPath);
       const isYamlProject = !!yamlConfigPath;
@@ -335,11 +630,11 @@ export class AppwriteToX {
       if (isYamlProject) {
         MessageFormatter.info("Detected YAML configuration - generating YAML collection definitions", { prefix: "Migration" });
         generator.updateYamlCollections();
-        await generator.updateConfig(this.updatedConfig, true);
+        await generator.updateConfig(configWithApiContext, true);
       } else {
         MessageFormatter.info("Generating TypeScript collection definitions", { prefix: "Migration" });
         generator.updateTsSchemas();
-        await generator.updateConfig(this.updatedConfig, false);
+        await generator.updateConfig(configWithApiContext, false);
       }
 
       MessageFormatter.info("Generating Zod schemas from synced collections...", { prefix: "Migration" });

package/src/migrations/yaml/generateImportSchemas.ts

@@ -524,6 +524,14 @@ export function generateTableSchema(): any {
   tableSchema.title = "Appwrite Table Definition";
   tableSchema.description = "YAML configuration for Appwrite table definitions (new TablesDB API)";
 
+  // Replace 'documentSecurity' with 'rowSecurity'
+  delete tableSchema.properties.documentSecurity;
+  tableSchema.properties.rowSecurity = {
+    "type": "boolean",
+    "description": "Enable row-level security",
+    "default": false
+  };
+
   // Replace 'attributes' with 'columns'
   delete tableSchema.properties.attributes;
   tableSchema.properties.columns = {
@@ -535,7 +543,8 @@ export function generateTableSchema(): any {
     "default": []
   };
 
-  // Update index definition to support both attributes and columns
+  // Update index definition to use columns instead of attributes
+  delete tableSchema.$defs.index.properties.attributes;
   tableSchema.$defs.index.properties.columns = {
     "type": "array",
     "items": { "type": "string" },
@@ -543,20 +552,29 @@ export function generateTableSchema(): any {
     "minItems": 1
   };
 
-  // Make index support either attributes or columns
-  tableSchema.$defs.index.oneOf = [
-    { "required": ["key", "type", "attributes"] },
-    { "required": ["key", "type", "columns"] }
-  ];
-  delete tableSchema.$defs.index.required;
+  // Update index required fields to use columns
+  const requiredIndex = tableSchema.$defs.index.required;
+  if (requiredIndex && requiredIndex.includes("attributes")) {
+    const attributesIndex = requiredIndex.indexOf("attributes");
+    requiredIndex[attributesIndex] = "columns";
+  }
 
   // Add column definition (similar to attribute but with table terminology)
   tableSchema.$defs.column = JSON.parse(JSON.stringify(tableSchema.$defs.attribute));
+
+  // Add encrypted property (table-specific feature)
+  tableSchema.$defs.column.properties.encrypted = {
+    "type": "boolean",
+    "description": "Whether the column should be encrypted",
+    "default": false
+  };
+
+  // Replace relatedCollection with relatedTable for table terminology
+  delete tableSchema.$defs.column.properties.relatedCollection;
   tableSchema.$defs.column.properties.relatedTable = {
     "type": "string",
     "description": "Related table for relationship columns"
   };
-  delete tableSchema.$defs.column.properties.relatedCollection;
 
   return tableSchema;
 }