appwrite-utils-cli 1.9.7 → 1.12.0

package/tests/integration/syncOperations.test.ts

@@ -1,463 +0,0 @@
-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

@@ -1,25 +0,0 @@
-/** @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,
-};