appwrite-utils-cli 1.7.7 → 1.7.8

package/dist/migrations/appwriteToX.js

@@ -5,15 +5,51 @@ import { fetchAllCollections } from "../collections/methods.js";
 import { fetchAllDatabases } from "../databases/methods.js";
 import { CollectionSchema, attributeSchema, AppwriteConfigSchema, permissionsSchema, attributesSchema, indexesSchema, parseAttribute, } 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";
+/**
+ * Convert between collection and table terminology based on data structure
+ */
+function normalizeCollectionOrTable(collection) {
+    // 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;
     storage;
     updatedConfig;
     collToAttributeMap = new Map();
     appwriteFolderPath;
+    adapter;
+    apiMode;
+    databaseApiModes = new Map();
     constructor(config, appwriteFolderPath, storage) {
         this.config = config;
         this.updatedConfig = config;
@@ -21,6 +57,24 @@ export class AppwriteToX {
         this.appwriteFolderPath = appwriteFolderPath;
         this.ensureClientInitialized();
     }
+    /**
+     * Initialize adapter for database operations with API mode detection
+     */
+    async initializeAdapter() {
+        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();
+            }
+        }
+    }
     ensureClientInitialized() {
         if (!this.config.appwriteClient) {
             const client = new Client();
@@ -52,15 +106,103 @@ export class AppwriteToX {
         return parsedPermissions ?? [];
     };
     updateCollectionConfigAttributes = (collection) => {
-        for (const attribute of collection.attributes) {
-            const attributeMap = this.collToAttributeMap.get(collection.name);
+        // 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)
+                .get(normalizedCollection.name)
                 ?.push(attributeParsed);
         }
     };
-    async appwriteSync(config, databases) {
+    /**
+     * Fetch collections/tables using the appropriate adapter or legacy client
+     */
+    async fetchCollectionsOrTables(databaseId, db) {
+        // Try to use adapter first
+        if (this.adapter) {
+            try {
+                const result = await this.adapter.listTables({ databaseId });
+                const items = result.tables || result.collections || [];
+                MessageFormatter.info(`Fetched ${items.length} items using ${this.apiMode} adapter`, { prefix: "Migration" });
+                return items;
+            }
+            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
+     */
+    async getCollectionOrTable(databaseId, collectionId) {
+        // Try to use adapter first
+        if (this.adapter) {
+            try {
+                const result = await this.adapter.getTable({ databaseId, tableId: collectionId });
+                return result;
+            }
+            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
+     */
+    async detectDatabaseApiMode(databaseId) {
+        // 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
+     */
+    getSchemaGeneratorApiContext() {
+        const databaseModes = {};
+        // 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, databases, databaseSelections, bucketSelections) {
+        // Initialize adapter for proper API mode detection and usage
+        await this.initializeAdapter();
         const db = getDatabaseFromConfig(config);
         if (!databases) {
             try {
@@ -73,16 +215,22 @@ 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 = { ...config };
         // Initialize databases array if it doesn't exist
         if (!updatedConfig.databases) {
             updatedConfig.databases = [];
         }
         // 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);
             if (existingDbIndex === -1) {
@@ -106,10 +254,19 @@ export class AppwriteToX {
         MessageFormatter.success(`Database sync summary: ${addedCount} added, ${updatedCount} updated, ${updatedConfig.databases.length} total`, { prefix: "Migration" });
         // 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) => bucket.$id.toLowerCase().includes(database.$id.toLowerCase()));
+        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()));
             if (matchedBucket) {
                 const dbConfig = updatedConfig.databases.find((db) => db.$id === database.$id);
                 if (dbConfig) {
@@ -125,73 +282,131 @@ 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) => {
-                    return parseAttribute(attr);
-                })
-                    .filter((attribute) => attribute.type === "relationship"
-                    ? attribute.side !== "child"
-                    : true);
-                for (const attribute of collAttributes) {
-                    if (attribute.type === "relationship" &&
-                        attribute.relatedCollection) {
-                        MessageFormatter.info(`Fetching related collection for ID: ${attribute.relatedCollection}`, { 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;
-                            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" });
+            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);
+                    // Process attributes with proper error handling
+                    let collAttributes = [];
+                    try {
+                        collAttributes = normalizedCollection.attributes
+                            .map((attr) => {
+                            if (!attr) {
+                                MessageFormatter.warning("Skipping null/undefined attribute", { prefix: "Migration" });
+                                return null;
+                            }
+                            return parseAttribute(attr);
+                        })
+                            .filter((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" });
+                        // Continue with empty attributes array
+                        collAttributes = [];
+                    }
+                    for (const attribute of collAttributes) {
+                        if (attribute.type === "relationship" &&
+                            attribute.relatedCollection) {
+                            MessageFormatter.info(`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(normalizedCollection.name, collAttributes);
+                    // Process indexes with proper error handling using normalized collection
+                    let collIndexes = [];
+                    try {
+                        const finalIndexes = (normalizedCollection.indexes || collection.indexes || []).map((index) => {
+                            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) => {
+                                    return order !== null && order;
+                                }),
+                            };
+                        }).filter((index) => 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;
+                        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++;
                 }
-                this.collToAttributeMap.set(collection.name, collAttributes);
-                const finalIndexes = collection.indexes.map((index) => {
-                    return {
-                        ...index,
-                        orders: index.orders?.filter((order) => {
-                            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,
-                });
-                if (existingCollectionIndex !== -1) {
-                    // Update existing collection
-                    updatedConfig.collections[existingCollectionIndex] = collToPush;
-                }
-                else {
-                    // Add new collection
-                    updatedConfig.collections.push(collToPush);
+                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}`, { prefix: "Migration" });
+            MessageFormatter.success(`Database '${database.name}' processing complete: ${processedCount} collections processed, ${errorCount} errors`, { prefix: "Migration" });
         }
         // Add unmatched buckets as global buckets
-        const globalBuckets = allBuckets.buckets.filter((bucket) => !updatedConfig.databases.some((db) => db.bucket && db.bucket.$id === bucket.$id));
+        // 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));
         updatedConfig.buckets = globalBuckets.map((bucket) => ({
             $id: bucket.$id,
             name: bucket.name,
@@ -225,23 +440,32 @@ export class AppwriteToX {
         this.updatedConfig = updatedConfig;
         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) {
+    async toSchemas(databases, databaseSelections, bucketSelections) {
         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;
             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" });
             generator.generateSchemas();

package/dist/migrations/yaml/YamlImportConfigLoader.d.ts

@@ -6,8 +6,8 @@ export declare const YamlImportConfigSchema: z.ZodObject<{
         basePath: z.ZodOptional<z.ZodString>;
         type: z.ZodDefault<z.ZodEnum<{
             json: "json";
-            yaml: "yaml";
             csv: "csv";
+            yaml: "yaml";
         }>>;
     }, z.core.$strip>;
     target: z.ZodObject<{

package/dist/migrations/yaml/generateImportSchemas.js

@@ -518,6 +518,13 @@ export function generateTableSchema() {
     tableSchema.$id = "https://appwrite-utils.dev/schemas/table.schema.json";
     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 = {
@@ -528,26 +535,34 @@ export function generateTableSchema() {
         },
         "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" },
         "description": "Column names to include in the index",
         "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;
 }
 /**

package/dist/shared/schemaGenerator.js

@@ -111,13 +111,16 @@ export class SchemaGenerator {
         collections?.forEach((collection) => {
             const { databaseId, ...collectionWithoutDbId } = collection; // Destructure to exclude databaseId
             const collectionFilePath = path.join(collectionsFolderPath, `${collection.name}.ts`);
+            // Determine if we're in tables mode for terminology
+            const isTablesMode = outputDir === "tables";
+            const securityField = isTablesMode ? "rowSecurity" : "documentSecurity";
             const collectionContent = `import { type CollectionCreate } from "appwrite-utils";
-  
+
   const ${collection.name}Config: Partial<CollectionCreate> = {
     name: "${collection.name}",
     $id: "${collection.$id}",
     enabled: ${collection.enabled},
-    documentSecurity: ${collection.documentSecurity},
+    ${securityField}: ${collection.documentSecurity},
     $permissions: [
       ${collection.$permissions
                 .map((permission) => `{ permission: "${permission.permission}", target: "${permission.target}" }`)
@@ -128,25 +131,34 @@ export class SchemaGenerator {
                 .map((attr) => {
                 return `{ ${Object.entries(attr)
                     .map(([key, value]) => {
+                    // Handle table vs collection terminology for related fields
+                    let outputKey = key;
+                    let outputValue = value;
+                    if (isTablesMode) {
+                        // Convert collection terminology to table terminology
+                        if (key === "relatedCollection") {
+                            outputKey = "relatedTable";
+                        }
+                    }
                     // Check the type of the value and format it accordingly
-                    if (typeof value === "string") {
+                    if (typeof outputValue === "string") {
                         // If the value is a string, wrap it in quotes
-                        return `${key}: "${value.replace(/"/g, '\\"')}"`; // Escape existing quotes in the string
+                        return `${outputKey}: "${outputValue.replace(/"/g, '\\"')}"`; // Escape existing quotes in the string
                     }
-                    else if (Array.isArray(value)) {
+                    else if (Array.isArray(outputValue)) {
                         // If the value is an array, join it with commas
-                        if (value.length > 0) {
-                            return `${key}: [${value
+                        if (outputValue.length > 0) {
+                            return `${outputKey}: [${outputValue
                                 .map((item) => `"${item}"`)
                                 .join(", ")}]`;
                         }
                         else {
-                            return `${key}: []`;
+                            return `${outputKey}: []`;
                         }
                     }
                     else {
                         // If the value is not a string (e.g., boolean or number), output it directly
-                        return `${key}: ${value}`;
+                        return `${outputKey}: ${outputValue}`;
                     }
                 })
                     .join(", ")} }`;
@@ -155,16 +167,17 @@ export class SchemaGenerator {
     ],
     indexes: [
       ${(collection.indexes?.map((index) => {
-                // Map each attribute to ensure it is properly quoted
+                // Use appropriate terminology for index attributes/columns
+                const indexField = isTablesMode ? "columns" : "attributes";
                 const formattedAttributes = index.attributes.map((attr) => `"${attr}"`).join(", ") ?? "";
-                return `{ key: "${index.key}", type: "${index.type}", attributes: [${formattedAttributes}], orders: [${index.orders
+                return `{ key: "${index.key}", type: "${index.type}", ${indexField}: [${formattedAttributes}], orders: [${index.orders
                     ?.filter((order) => order !== null)
                     .map((order) => `"${order}"`)
                     .join(", ") ?? ""}] }`;
             }) ?? []).join(",\n    ")}
     ]
   };
-  
+
   export default ${collection.name}Config;
   `;
             fs.writeFileSync(collectionFilePath, collectionContent, {