@agility/content-sync 1.2.0-beta.7 → 1.2.0-beta.8.1

package/README.md

@@ -35,6 +35,24 @@ Install `@agility/content-sync`:
 npm install @agility/content-sync
 ```
 
+## Import Patterns
+
+```javascript
+// Default import
+import getSyncClient from '@agility/content-sync';
+const syncClient = getSyncClient({...});
+
+// Named import  
+import { getSyncClient } from '@agility/content-sync';
+const syncClient = getSyncClient({...});
+
+// CommonJS
+const getSyncClient = require('@agility/content-sync');
+const syncClient = getSyncClient({...});
+```
+
+> **Note:** If upgrading and encountering `Cannot read properties of undefined (reading 'getSyncClient')`, use `require('@agility/content-sync').default.getSyncClient` for compatibility with transpiled code.
+
 ## Sync to Filesystem (using Defaults)
 1. Create a sync client:
     ```javascript
@@ -62,7 +80,7 @@ npm install @agility/content-sync
 ## Accessing Content
 Once content is in your sync store, you can easily access it as you need it:
 ```javascript
-import agilitySync from '@agility/constent-sync'
+import agilitySync from '@agility/content-sync'
 const syncClient = agilitySync.getSyncClient({
     //your 'guid' from Agility CMS
     guid: 'some-guid',
@@ -175,7 +193,7 @@ module.exports = {
 ```
 2. Register the `syncClient` to use your **Sync Store**
 ```javascript
-import agilitySync from '@agility/constent-sync'
+import agilitySync from '@agility/content-sync'
 import sampleSyncConsoleInterface from './store-interface-console'
 const syncClient = agilitySync.getSyncClient({
     //your 'guid' from Agility CMS

package/dist/agility-sync-sdk.node.js

@@ -14749,7 +14749,15 @@ function createSyncClient(userConfig) {
   };
 }
 
+// Export for ES modules
 
 
+// Export for CommonJS - support both direct function call and .default.getSyncClient pattern
+var syncClientExport = getSyncClient;
+syncClientExport.getSyncClient = getSyncClient;
+syncClientExport["default"] = { getSyncClient: getSyncClient };
+
+/* harmony default export */ var sync_client = __webpack_exports__["default"] = (syncClientExport);
+
 /***/ })
-/******/ ]);
+/******/ ])["default"];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agility/content-sync",
-  "version": "1.2.0-beta.7",
+  "version": "1.2.0-beta.8.1",
   "description": "JavaScript SDK for synchronizing content from Agility CMS",
   "main": "dist/agility-sync-sdk.node.js",
   "scripts": {

package/src/sync-client.js

@@ -82,4 +82,12 @@ function createSyncClient(userConfig) {
     }
 }
 
-export { getSyncClient }
+// Export for ES modules
+export { getSyncClient }
+
+// Export for CommonJS - support both direct function call and .default.getSyncClient pattern
+const syncClientExport = getSyncClient;
+syncClientExport.getSyncClient = getSyncClient;
+syncClientExport.default = { getSyncClient };
+
+export default syncClientExport

package/test/00-built-module-exports.tests.js

@@ -0,0 +1,99 @@
+import chai from 'chai'
+const assert = chai.assert;
+
+// Test the built dist module (what gets published to npm)
+const path = require('path');
+const fs = require('fs');
+
+//This tests the actual built module that gets published
+describe('Built Module Export Compatibility:', function() {
+
+    this.timeout('30s');
+    
+    let builtModulePath;
+
+    before(function() {
+        builtModulePath = path.resolve(__dirname, '../dist/agility-sync-sdk.node.js');
+        
+        // Check if the built file exists
+        if (!fs.existsSync(builtModulePath)) {
+            throw new Error('Built module not found. Run "npm run build" first.');
+        }
+    });
+    
+    it('should support CommonJS require() import', function(done) {
+        // Clear require cache to ensure fresh import
+        delete require.cache[builtModulePath];
+        
+        const contentSync = require(builtModulePath);
+        assert.strictEqual(typeof contentSync, 'function', 'CommonJS import should return a function');
+        done();
+    });
+
+    it('should support customer pattern: require().default.getSyncClient', function(done) {
+        // This is the exact pattern that was failing: content_sync_1.default.getSyncClient
+        delete require.cache[builtModulePath];
+        
+        const contentSync = require(builtModulePath);
+        
+        assert.strictEqual(typeof contentSync.default, 'object', 'default should be an object');
+        assert.strictEqual(typeof contentSync.default.getSyncClient, 'function', 'default.getSyncClient should be a function');
+        
+        // Test that it actually works
+        const syncClient = contentSync.default.getSyncClient({
+            guid: 'test-guid',
+            apiKey: 'test-key'
+        });
+        
+        assert.strictEqual(typeof syncClient, 'object', 'Should return sync client object');
+        assert.strictEqual(typeof syncClient.syncContent, 'function', 'Should have syncContent method');
+        assert.strictEqual(typeof syncClient.syncPages, 'function', 'Should have syncPages method');
+        assert.strictEqual(typeof syncClient.runSync, 'function', 'Should have runSync method');
+        assert.strictEqual(typeof syncClient.clearSync, 'function', 'Should have clearSync method');
+        
+        done();
+    });
+
+    it('should support alternative patterns for flexibility', function(done) {
+        delete require.cache[builtModulePath];
+        
+        const contentSync = require(builtModulePath);
+        const testConfig = { guid: 'test-guid', apiKey: 'test-key' };
+        
+        // Test direct function call
+        const client1 = contentSync(testConfig);
+        assert.strictEqual(typeof client1, 'object', 'Direct function call should work');
+        
+        // Test .getSyncClient property
+        const client2 = contentSync.getSyncClient(testConfig);
+        assert.strictEqual(typeof client2, 'object', 'getSyncClient property should work');
+        
+        done();
+    });
+
+    it('should maintain consistency across all import patterns', function(done) {
+        delete require.cache[builtModulePath];
+        
+        const contentSync = require(builtModulePath);
+        const testConfig = { guid: 'test-guid', apiKey: 'test-key' };
+        
+        const client1 = contentSync(testConfig);
+        const client2 = contentSync.getSyncClient(testConfig);
+        const client3 = contentSync.default.getSyncClient(testConfig);
+        
+        // All should have the same structure
+        const expectedProperties = ['config', 'agilityClient', 'syncContent', 'syncPages', 'clearSync', 'runSync', 'store'];
+        
+        expectedProperties.forEach(prop => {
+            assert.property(client1, prop, `client1 should have ${prop}`);
+            assert.property(client2, prop, `client2 should have ${prop}`);
+            assert.property(client3, prop, `client3 should have ${prop}`);
+            
+            // Types should match
+            assert.strictEqual(typeof client1[prop], typeof client2[prop], `${prop} types should match between client1 and client2`);
+            assert.strictEqual(typeof client2[prop], typeof client3[prop], `${prop} types should match between client2 and client3`);
+        });
+        
+        done();
+    });
+});

package/test/01-getSyncClient.tests.js

@@ -1,7 +1,8 @@
 import chai from 'chai'
 const assert = chai.assert;
 
-import agilitySync from '../src/sync-client'
+import * as agilitySync from '../src/sync-client'
+import syncClientDefault from '../src/sync-client'
 import { createSyncClientUsingConsoleStore } from './_syncClients.config'
 
 
@@ -34,5 +35,81 @@ describe('getSyncClient:', function() {
         const syncClient = createSyncClientUsingConsoleStore()    
         done();
     })
+
+    // Export compatibility tests to ensure multiple import patterns work
+    describe('Export Compatibility:', function() {
+        
+        it('should support named import (getSyncClient)', function(done) {
+            assert.strictEqual(typeof agilitySync.getSyncClient, 'function', 'Named import should be a function');
+            
+            const syncClient = agilitySync.getSyncClient({
+                guid: 'test-guid',
+                apiKey: 'test-key'
+            });
+            assert.strictEqual(typeof syncClient, 'object', 'Should return sync client object');
+            done();
+        })
+
+        it('should support default import as function', function(done) {
+            assert.strictEqual(typeof syncClientDefault, 'function', 'Default import should be a function');
+            
+            const syncClient = syncClientDefault({
+                guid: 'test-guid',
+                apiKey: 'test-key'
+            });
+            assert.strictEqual(typeof syncClient, 'object', 'Should return sync client object');
+            done();
+        })
+
+        it('should support default import with getSyncClient property', function(done) {
+            assert.strictEqual(typeof syncClientDefault.getSyncClient, 'function', 'Default.getSyncClient should be a function');
+            
+            const syncClient = syncClientDefault.getSyncClient({
+                guid: 'test-guid',
+                apiKey: 'test-key'
+            });
+            assert.strictEqual(typeof syncClient, 'object', 'Should return sync client object');
+            done();
+        })
+
+        it('should support CommonJS-style default.getSyncClient pattern', function(done) {
+            // This tests the pattern that was failing for the customer: content_sync_1.default.getSyncClient
+            assert.strictEqual(typeof syncClientDefault.default, 'object', 'Default.default should be an object');
+            assert.strictEqual(typeof syncClientDefault.default.getSyncClient, 'function', 'Default.default.getSyncClient should be a function');
+            
+            const syncClient = syncClientDefault.default.getSyncClient({
+                guid: 'test-guid',
+                apiKey: 'test-key'
+            });
+            assert.strictEqual(typeof syncClient, 'object', 'Should return sync client object');
+            done();
+        })
+
+        it('should ensure all import patterns return equivalent sync clients', function(done) {
+            const config = { guid: 'test-guid', apiKey: 'test-key' };
+            
+            const client1 = agilitySync.getSyncClient(config);
+            const client2 = syncClientDefault(config);
+            const client3 = syncClientDefault.getSyncClient(config);
+            const client4 = syncClientDefault.default.getSyncClient(config);
+            
+            // All should have the same structure
+            assert.strictEqual(typeof client1, 'object');
+            assert.strictEqual(typeof client2, 'object');
+            assert.strictEqual(typeof client3, 'object');
+            assert.strictEqual(typeof client4, 'object');
+            
+            // All should have the same methods
+            const expectedMethods = ['syncContent', 'syncPages', 'clearSync', 'runSync'];
+            expectedMethods.forEach(method => {
+                assert.strictEqual(typeof client1[method], 'function', `client1.${method} should be a function`);
+                assert.strictEqual(typeof client2[method], 'function', `client2.${method} should be a function`);
+                assert.strictEqual(typeof client3[method], 'function', `client3.${method} should be a function`);
+                assert.strictEqual(typeof client4[method], 'function', `client4.${method} should be a function`);
+            });
+            
+            done();
+        })
+    })
  
 });

package/webpack.config.js

@@ -7,7 +7,8 @@ const nodeConfig = {
     output: {
         filename: 'agility-sync-sdk.node.js',
         path: path.resolve(__dirname, 'dist'),
-        libraryTarget: 'commonjs2'
+        libraryTarget: 'commonjs2',
+        libraryExport: 'default'
     },
     optimization: {
         minimize: false