appwrite-utils-cli 1.5.1 → 1.6.0

package/tests/integration/syncOperations.test.ts

@@ -0,0 +1,463 @@
+import fs from 'fs';
+import path from 'path';
+import { jest } from '@jest/globals';
+import { TestUtils } from '../testUtils';
+import { AdapterFactory } from '../../src/adapters/AdapterFactory';
+import { MessageFormatter } from '../../src/shared/messageFormatter';
+
+// Mock dependencies
+jest.mock('../../src/shared/messageFormatter');
+jest.mock('../../src/adapters/AdapterFactory');
+jest.mock('../../src/utils/versionDetection');
+
+// Import the actual modules we're testing
+import { loadConfig } from '../../src/utils/loadConfigs';
+
+describe('Sync Operations Integration Tests', () => {
+  let testDir: string;
+  let mockAdapter: any;
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+
+    // Create mock adapter with all required methods
+    mockAdapter = {
+      syncFromAppwrite: jest.fn(),
+      syncToAppwrite: jest.fn(),
+      validateConfiguration: jest.fn(),
+      generateYamlConfig: jest.fn(),
+      getDatabases: jest.fn(),
+      getCollections: jest.fn(),
+      createCollection: jest.fn(),
+      updateCollection: jest.fn(),
+      deleteCollection: jest.fn(),
+      client: TestUtils.createMockAppwriteResponses(),
+    };
+
+    (AdapterFactory.createAdapter as jest.Mock).mockResolvedValue(mockAdapter);
+  });
+
+  afterEach(() => {
+    TestUtils.cleanup();
+  });
+
+  describe('Sync from Appwrite to Local Configuration', () => {
+    it('should sync collections to collections/ directory for database API', async () => {
+      testDir = TestUtils.createTestProject({ hasCollections: true });
+
+      // Mock Appwrite response for collections
+      mockAdapter.getDatabases.mockResolvedValue([
+        {
+          $id: 'test-db-id',
+          name: 'test-database',
+          enabled: true,
+        }
+      ]);
+
+      mockAdapter.getCollections.mockResolvedValue([
+        {
+          $id: 'synced-collection',
+          name: 'SyncedCollection',
+          documentSecurity: false,
+          enabled: true,
+          $permissions: [],
+          attributes: [
+            {
+              key: 'title',
+              type: 'string',
+              size: 255,
+              required: true,
+              array: false,
+            }
+          ],
+          indexes: [],
+          $createdAt: new Date().toISOString(),
+          $updatedAt: new Date().toISOString(),
+        }
+      ]);
+
+      mockAdapter.generateYamlConfig.mockImplementation((collections, outputDir) => {
+        const collectionsDir = path.join(outputDir, 'collections');
+        fs.mkdirSync(collectionsDir, { recursive: true });
+
+        collections.forEach((collection: any) => {
+          const yamlContent = `
+name: ${collection.name}
+id: ${collection.$id}
+documentSecurity: ${collection.documentSecurity}
+enabled: ${collection.enabled}
+permissions: []
+attributes:
+  - key: ${collection.attributes[0].key}
+    type: ${collection.attributes[0].type}
+    size: ${collection.attributes[0].size}
+    required: ${collection.attributes[0].required}
+indexes: []
+`;
+          fs.writeFileSync(
+            path.join(collectionsDir, `${collection.name}.yaml`),
+            yamlContent
+          );
+        });
+      });
+
+      await mockAdapter.syncFromAppwrite(testDir);
+
+      // Verify collections were written to collections/ directory
+      const collectionsDir = path.join(testDir, 'collections');
+      expect(fs.existsSync(collectionsDir)).toBe(true);
+
+      const collectionFiles = fs.readdirSync(collectionsDir);
+      expect(collectionFiles).toContain('SyncedCollection.yaml');
+
+      const collectionContent = fs.readFileSync(
+        path.join(collectionsDir, 'SyncedCollection.yaml'),
+        'utf8'
+      );
+      expect(collectionContent).toContain('name: SyncedCollection');
+    });
+
+    it('should sync tables to tables/ directory for tablesdb API', async () => {
+      testDir = TestUtils.createTestProject({ hasTables: true });
+
+      // Mock TablesDB adapter
+      mockAdapter.getDatabases.mockResolvedValue([
+        {
+          $id: 'test-db-id',
+          name: 'test-database',
+          enabled: true,
+        }
+      ]);
+
+      mockAdapter.getCollections.mockResolvedValue([
+        {
+          tableId: 'synced-table',
+          name: 'SyncedTable',
+          databaseId: 'test-db-id',
+          documentSecurity: false,
+          enabled: true,
+          $permissions: [],
+          attributes: [
+            {
+              key: 'content',
+              type: 'string',
+              size: 1000,
+              required: true,
+              array: false,
+            }
+          ],
+          indexes: [],
+          $createdAt: new Date().toISOString(),
+          $updatedAt: new Date().toISOString(),
+        }
+      ]);
+
+      mockAdapter.generateYamlConfig.mockImplementation((tables, outputDir) => {
+        const tablesDir = path.join(outputDir, 'tables');
+        fs.mkdirSync(tablesDir, { recursive: true });
+
+        tables.forEach((table: any) => {
+          const yamlContent = `
+name: ${table.name}
+tableId: ${table.tableId}
+databaseId: ${table.databaseId}
+documentSecurity: ${table.documentSecurity}
+enabled: ${table.enabled}
+permissions: []
+attributes:
+  - key: ${table.attributes[0].key}
+    type: ${table.attributes[0].type}
+    size: ${table.attributes[0].size}
+    required: ${table.attributes[0].required}
+indexes: []
+`;
+          fs.writeFileSync(
+            path.join(tablesDir, `${table.name}.yaml`),
+            yamlContent
+          );
+        });
+      });
+
+      await mockAdapter.syncFromAppwrite(testDir);
+
+      // Verify tables were written to tables/ directory
+      const tablesDir = path.join(testDir, 'tables');
+      expect(fs.existsSync(tablesDir)).toBe(true);
+
+      const tableFiles = fs.readdirSync(tablesDir);
+      expect(tableFiles).toContain('SyncedTable.yaml');
+
+      const tableContent = fs.readFileSync(
+        path.join(tablesDir, 'SyncedTable.yaml'),
+        'utf8'
+      );
+      expect(tableContent).toContain('name: SyncedTable');
+      expect(tableContent).toContain('tableId: synced-table');
+      expect(tableContent).toContain('databaseId: test-db-id');
+    });
+
+    it('should preserve existing configurations during sync', async () => {
+      testDir = TestUtils.createTestProject({
+        hasCollections: true,
+        hasTables: true,
+      });
+
+      // Add existing configurations
+      const existingCollectionContent = fs.readFileSync(
+        path.join(testDir, 'collections', 'TestCollection.ts'),
+        'utf8'
+      );
+
+      mockAdapter.getDatabases.mockResolvedValue([]);
+      mockAdapter.getCollections.mockResolvedValue([]);
+      mockAdapter.generateYamlConfig.mockImplementation(() => {
+        // Don't overwrite existing files
+      });
+
+      await mockAdapter.syncFromAppwrite(testDir);
+
+      // Verify existing files weren't overwritten
+      const currentContent = fs.readFileSync(
+        path.join(testDir, 'collections', 'TestCollection.ts'),
+        'utf8'
+      );
+      expect(currentContent).toBe(existingCollectionContent);
+    });
+  });
+
+  describe('Database Configuration Sync', () => {
+    it('should update main config.yaml with database information', async () => {
+      testDir = TestUtils.createTestProject({ useYaml: true });
+
+      mockAdapter.getDatabases.mockResolvedValue([
+        {
+          $id: 'db1',
+          name: 'Database One',
+          enabled: true,
+        },
+        {
+          $id: 'db2',
+          name: 'Database Two',
+          enabled: false,
+        }
+      ]);
+
+      mockAdapter.generateYamlConfig.mockImplementation((collections, outputDir) => {
+        // Update the main config file
+        const configPath = path.join(outputDir, '.appwrite', 'config.yaml');
+        const currentConfig = fs.readFileSync(configPath, 'utf8');
+        const updatedConfig = currentConfig + `
+# Synced databases
+syncedDatabases:
+  - $id: db1
+    name: Database One
+    enabled: true
+  - $id: db2
+    name: Database Two
+    enabled: false
+`;
+        fs.writeFileSync(configPath, updatedConfig);
+      });
+
+      await mockAdapter.syncFromAppwrite(testDir);
+
+      const configContent = fs.readFileSync(
+        path.join(testDir, '.appwrite', 'config.yaml'),
+        'utf8'
+      );
+      expect(configContent).toContain('syncedDatabases:');
+      expect(configContent).toContain('Database One');
+      expect(configContent).toContain('Database Two');
+    });
+  });
+
+  describe('Version-Aware Sync Operations', () => {
+    it('should use appropriate directory based on detected API version', async () => {
+      testDir = TestUtils.createTestProject();
+
+      // Mock version detection for old version (should use collections/)
+      const oldVersionAdapter = { ...mockAdapter };
+      oldVersionAdapter.getCollections.mockResolvedValue([
+        TestUtils.createTestCollection({ name: 'OldVersionCollection' })
+      ]);
+
+      await oldVersionAdapter.syncFromAppwrite(testDir);
+
+      // For newer versions, should use tables/
+      const newVersionAdapter = { ...mockAdapter };
+      newVersionAdapter.getCollections.mockResolvedValue([
+        TestUtils.createTestTable({ name: 'NewVersionTable' })
+      ]);
+
+      await newVersionAdapter.syncFromAppwrite(testDir);
+
+      // Verify appropriate handling based on version
+      expect(mockAdapter.syncFromAppwrite).toHaveBeenCalledTimes(2);
+    });
+
+    it('should handle mixed API environments gracefully', async () => {
+      testDir = TestUtils.createTestProject({
+        hasCollections: true,
+        hasTables: true,
+      });
+
+      // Mock mixed response
+      mockAdapter.getCollections.mockResolvedValue([
+        TestUtils.createTestCollection({ name: 'MixedCollection' }),
+        TestUtils.createTestTable({ name: 'MixedTable' }),
+      ]);
+
+      mockAdapter.generateYamlConfig.mockImplementation((items, outputDir) => {
+        items.forEach((item: any) => {
+          const isTable = item._isFromTablesDir || item.tableId;
+          const dir = isTable ? 'tables' : 'collections';
+          const dirPath = path.join(outputDir, dir);
+          fs.mkdirSync(dirPath, { recursive: true });
+
+          const yamlContent = `name: ${item.name}\n`;
+          fs.writeFileSync(
+            path.join(dirPath, `${item.name}.yaml`),
+            yamlContent
+          );
+        });
+      });
+
+      await mockAdapter.syncFromAppwrite(testDir);
+
+      // Should handle both types appropriately
+      expect(mockAdapter.generateYamlConfig).toHaveBeenCalled();
+    });
+  });
+
+  describe('Error Handling and Recovery', () => {
+    it('should handle network errors during sync gracefully', async () => {
+      testDir = TestUtils.createTestProject();
+
+      mockAdapter.getDatabases.mockRejectedValue(new Error('Network timeout'));
+
+      await expect(mockAdapter.syncFromAppwrite(testDir)).rejects.toThrow('Network timeout');
+
+      // Verify that partial configurations are not left in inconsistent state
+      const collectionsDir = path.join(testDir, 'collections');
+      const tablesDir = path.join(testDir, 'tables');
+
+      // Should not create partial directories on failure
+      if (fs.existsSync(collectionsDir)) {
+        const files = fs.readdirSync(collectionsDir);
+        expect(files.length).toBe(0); // No partial files
+      }
+    });
+
+    it('should validate synced configurations before writing', async () => {
+      testDir = TestUtils.createTestProject();
+
+      // Mock invalid configuration from Appwrite
+      mockAdapter.getCollections.mockResolvedValue([
+        {
+          // Missing required fields
+          name: '',
+          $id: '',
+          attributes: [],
+        }
+      ]);
+
+      mockAdapter.validateConfiguration.mockReturnValue({
+        isValid: false,
+        errors: ['Collection name is required', 'Collection ID is required'],
+        warnings: [],
+      });
+
+      await expect(mockAdapter.syncFromAppwrite(testDir)).rejects.toThrow();
+
+      expect(mockAdapter.validateConfiguration).toHaveBeenCalled();
+    });
+
+    it('should provide rollback capability on sync failure', async () => {
+      testDir = TestUtils.createTestProject({ hasCollections: true });
+
+      // Backup existing state
+      const originalFiles = fs.readdirSync(path.join(testDir, 'collections'));
+
+      mockAdapter.getCollections.mockResolvedValue([
+        TestUtils.createTestCollection({ name: 'NewCollection' })
+      ]);
+
+      // Simulate failure during write
+      mockAdapter.generateYamlConfig.mockImplementation(() => {
+        throw new Error('Write permission denied');
+      });
+
+      await expect(mockAdapter.syncFromAppwrite(testDir)).rejects.toThrow();
+
+      // Verify original files are preserved
+      const currentFiles = fs.readdirSync(path.join(testDir, 'collections'));
+      expect(currentFiles).toEqual(originalFiles);
+    });
+  });
+
+  describe('Performance Optimization', () => {
+    it('should handle large numbers of collections efficiently', async () => {
+      testDir = TestUtils.createTestProject();
+
+      // Create large number of collections
+      const largeCollectionSet = Array.from({ length: 1000 }, (_, i) =>
+        TestUtils.createTestCollection({
+          name: `Collection${i}`,
+          $id: `collection-${i}`,
+        })
+      );
+
+      mockAdapter.getCollections.mockResolvedValue(largeCollectionSet);
+      mockAdapter.generateYamlConfig.mockImplementation((collections, outputDir) => {
+        // Simulate efficient batch writing
+        const collectionsDir = path.join(outputDir, 'collections');
+        fs.mkdirSync(collectionsDir, { recursive: true });
+
+        // Write files in batches to avoid memory issues
+        const batchSize = 100;
+        for (let i = 0; i < collections.length; i += batchSize) {
+          const batch = collections.slice(i, i + batchSize);
+          batch.forEach((collection: any) => {
+            fs.writeFileSync(
+              path.join(collectionsDir, `${collection.name}.yaml`),
+              `name: ${collection.name}\n`
+            );
+          });
+        }
+      });
+
+      const startTime = Date.now();
+      await mockAdapter.syncFromAppwrite(testDir);
+      const syncTime = Date.now() - startTime;
+
+      expect(syncTime).toBeLessThan(10000); // Should complete within 10 seconds
+
+      const collectionFiles = fs.readdirSync(path.join(testDir, 'collections'));
+      expect(collectionFiles.length).toBe(1000);
+    });
+
+    it('should use incremental sync when possible', async () => {
+      testDir = TestUtils.createTestProject({ hasCollections: true });
+
+      // Mock last sync timestamp
+      const lastSyncFile = path.join(testDir, '.appwrite', '.last-sync');
+      fs.writeFileSync(lastSyncFile, new Date().toISOString());
+
+      mockAdapter.getCollections.mockResolvedValue([
+        TestUtils.createTestCollection({
+          name: 'UpdatedCollection',
+          $updatedAt: new Date().toISOString(),
+        })
+      ]);
+
+      await mockAdapter.syncFromAppwrite(testDir);
+
+      // Should only sync updated items
+      expect(mockAdapter.getCollections).toHaveBeenCalledWith(
+        expect.objectContaining({
+          modifiedSince: expect.any(String),
+        })
+      );
+    });
+  });
+});

package/tests/jest.config.js

@@ -0,0 +1,25 @@
+/** @type {import('jest').Config} */
+module.exports = {
+  preset: 'ts-jest',
+  testEnvironment: 'node',
+  roots: ['<rootDir>/src', '<rootDir>/tests'],
+  testMatch: ['**/__tests__/**/*.ts', '**/?(*.)+(spec|test).ts'],
+  transform: {
+    '^.+\\.ts$': 'ts-jest',
+  },
+  collectCoverageFrom: [
+    'src/**/*.ts',
+    '!src/**/*.d.ts',
+    '!src/main.ts', // Exclude entry point
+    '!src/functions/templates/**', // Exclude template files
+  ],
+  coverageDirectory: 'coverage',
+  coverageReporters: ['text', 'lcov', 'html'],
+  setupFilesAfterEnv: ['<rootDir>/tests/setup.ts'],
+  testTimeout: 30000,
+  moduleFileExtensions: ['ts', 'js', 'json'],
+  testPathIgnorePatterns: ['/node_modules/', '/dist/'],
+  clearMocks: true,
+  restoreMocks: true,
+  verbose: true,
+};