storyblok 3.13.1 → 3.15.0

package/README.md

@@ -28,6 +28,18 @@ Usage to kickstart a boilerplate, fieldtype or theme
 $ storyblok select
 ```
 
+### pull-languages
+
+Download your space's languages schema as json. This command will download 1 file.
+
+```sh
+$ storyblok pull-languages --space <SPACE_ID>
+```
+
+#### Options
+
+* `space`: your space id
+
 ### pull-components
 
 Download your space's components schema as json. This command will download 2 files: 1 for the components and 1 for the presets.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "storyblok",
-  "version": "3.13.1",
+  "version": "3.15.0",
   "description": "A simple CLI to start Storyblok from your command line.",
   "keywords": [
     "storyblok",
@@ -37,6 +37,7 @@
     "open": "^6.0.0",
     "p-series": "^2.1.0",
     "path": "^0.12.7",
+    "simple-uuid": "^0.0.1",
     "storyblok-js-client": "^4.5.6",
     "update-notifier": "^5.1.0",
     "xml-js": "^1.6.11"

package/src/cli.js

@@ -69,6 +69,31 @@ program
     }
   })
 
+// pull-languages
+program
+  .command('pull-languages')
+  .description("Download your space's languages schema as json")
+  .action(async () => {
+    console.log(`${chalk.blue('-')} Executing pull-languages task`)
+    const space = program.space
+    if (!space) {
+      console.log(chalk.red('X') + ' Please provide the space as argument --space YOUR_SPACE_ID.')
+      process.exit(0)
+    }
+
+    try {
+      if (!api.isAuthorized()) {
+        await api.processLogin()
+      }
+
+      api.setSpaceId(space)
+      await tasks.pullLanguages(api, { space })
+    } catch (e) {
+      console.log(chalk.red('X') + ' An error occurred when executing the pull-languages task: ' + e.message)
+      process.exit(1)
+    }
+  })
+
 // pull-components
 program
   .command(COMMANDS.PULL_COMPONENTS)

package/src/tasks/index.js

@@ -3,6 +3,7 @@ module.exports = {
   scaffold: require('./scaffold'),
   quickstart: require('./quickstart'),
   pullComponents: require('./pull-components'),
+  pullLanguages: require('./pull-languages'),
   pushComponents: require('./push-components'),
   generateMigration: require('./migrations/generate'),
   runMigration: require('./migrations/run'),

package/src/tasks/pull-languages.js

@@ -0,0 +1,39 @@
+const fs = require('fs')
+const chalk = require('chalk')
+
+/**
+ * @method pullLanguages
+ * @param  {Object} api
+ * @param  {Object} options { space: Number }
+ * @return {Promise<Object>}
+ */
+const pullLanguages = async (api, options) => {
+  const { space } = options
+
+  try {
+    const options = await api.getSpaceOptions()
+    const languages = {
+      default_lang_name: options.default_lang_name,
+      languages: options.languages
+    }
+
+    const file = `languages.${space}.json`
+    const data = JSON.stringify(languages, null, 2)
+
+    console.log(`${chalk.green('✓')} We've saved your languages in the file: ${file}`)
+
+    fs.writeFile(`./${file}`, data, (err) => {
+      if (err) {
+        Promise.reject(err)
+        return
+      }
+
+      Promise.resolve(file)
+    })
+  } catch (e) {
+    console.error(`${chalk.red('X')} An error ocurred in pull-languages task when load components data`)
+    return Promise.reject(new Error(e))
+  }
+}
+
+module.exports = pullLanguages

package/src/tasks/sync-commands/datasources.js

@@ -1,5 +1,6 @@
 const chalk = require('chalk')
-const StoryblokClient = require('storyblok-js-client')
+const UUID = require('simple-uuid')
+const api = require('../../utils/api')
 
 class SyncDatasources {
   /**
@@ -11,9 +12,7 @@ class SyncDatasources {
     this.sourceSpaceId = options.sourceSpaceId
     this.targetSpaceId = options.targetSpaceId
     this.oauthToken = options.oauthToken
-    this.client = new StoryblokClient({
-      oauthToken: options.oauthToken
-    })
+    this.client = api.getClient()
   }
 
   async sync () {
@@ -41,9 +40,10 @@ class SyncDatasources {
     await this.updateDatasources()
   }
 
-  async getDatasourceEntries (spaceId, datasourceId) {
+  async getDatasourceEntries (spaceId, datasourceId, dimensionId = null) {
+    const dimensionQuery = dimensionId ? `&dimension=${dimensionId}` : ''
     try {
-      const entriesFirstPage = await this.client.get(`spaces/${spaceId}/datasource_entries/?datasource_id=${datasourceId}`)
+      const entriesFirstPage = await this.client.get(`spaces/${spaceId}/datasource_entries/?datasource_id=${datasourceId}${dimensionQuery}`)
       const entriesRequets = []
       for (let i = 2; i <= Math.ceil(entriesFirstPage.total / 25); i++) {
         entriesRequets.push(this.client.get(`spaces/${spaceId}/datasource_entries/?datasource_id=${datasourceId}`, { page: i }))
@@ -88,9 +88,9 @@ class SyncDatasources {
     }
   }
 
-  async syncDatasourceEntries (sourceId, targetId) {
+  async syncDatasourceEntries (datasourceId, targetId) {
     try {
-      const sourceEntries = await this.getDatasourceEntries(this.sourceSpaceId, sourceId)
+      const sourceEntries = await this.getDatasourceEntries(this.sourceSpaceId, datasourceId)
       const targetEntries = await this.getDatasourceEntries(this.targetSpaceId, targetId)
       const updateEntries = targetEntries.filter(e => sourceEntries.map(se => se.name).includes(e.name))
       const addEntries = sourceEntries.filter(e => !targetEntries.map(te => te.name).includes(e.name))
@@ -126,17 +126,31 @@ class SyncDatasources {
 
     for (let i = 0; i < datasourcesToAdd.length; i++) {
       try {
+        console.log(`  ${chalk.green('-')} Creating datasource ${datasourcesToAdd[i].name} (${datasourcesToAdd[i].slug})`)
         /* Create the datasource */
         const newDatasource = await this.client.post(`spaces/${this.targetSpaceId}/datasources`, {
           name: datasourcesToAdd[i].name,
           slug: datasourcesToAdd[i].slug
         })
 
-        await this.syncDatasourceEntries(datasourcesToAdd[i].id, newDatasource.data.datasource.id)
-        console.log(chalk.green('✓') + ' Created datasource ' + datasourcesToAdd[i].name)
+        if (datasourcesToAdd[i].dimensions.length) {
+          console.log(
+            `    ${chalk.blue('-')} Creating dimensions...`
+          )
+          const { data } = await this.createDatasourcesDimensions(datasourcesToAdd[i].dimensions, newDatasource.data.datasource)
+          await this.syncDatasourceEntries(datasourcesToAdd[i].id, newDatasource.data.datasource.id)
+          console.log(
+            `    ${chalk.blue('-')} Sync dimensions values...`
+          )
+          await this.syncDatasourceDimensionsValues(datasourcesToAdd[i], data.datasource)
+          console.log(`  ${chalk.green('✓')} Created datasource ${datasourcesToAdd[i].name}`)
+        } else {
+          await this.syncDatasourceEntries(datasourcesToAdd[i].id, newDatasource.data.datasource.id)
+          console.log(`  ${chalk.green('✓')} Created datasource ${datasourcesToAdd[i].name}`)
+        }
       } catch (err) {
         console.error(
-          `${chalk.red('X')} Datasource ${datasourcesToAdd[i].name} creation failed: ${err.message}`
+          `${chalk.red('X')} Datasource ${datasourcesToAdd[i].name} creation failed: ${err.response.data.error || err.message}`
         )
       }
     }
@@ -154,13 +168,35 @@ class SyncDatasources {
       try {
         /* Update the datasource */
         const sourceDatasource = this.sourceDatasources.find(d => d.slug === datasourcesToUpdate[i].slug)
+
         await this.client.put(`spaces/${this.targetSpaceId}/datasources/${datasourcesToUpdate[i].id}`, {
           name: sourceDatasource.name,
           slug: sourceDatasource.slug
         })
 
-        await this.syncDatasourceEntries(sourceDatasource.id, datasourcesToUpdate[i].id)
-        console.log(chalk.green('✓') + ' Updated datasource ' + datasourcesToUpdate[i].name)
+        if (datasourcesToUpdate[i].dimensions.length) {
+          console.log(`  ${chalk.blue('-')} Updating datasources dimensions ${datasourcesToUpdate[i].name}...`)
+          const sourceDimensionsNames = sourceDatasource.dimensions.map((dimension) => dimension.name)
+          const targetDimensionsNames = datasourcesToUpdate[i].dimensions.map((dimension) => dimension.name)
+          const intersection = sourceDimensionsNames.filter(item => !targetDimensionsNames.includes(item))
+          let datasourceToSyncDimensionsValues = datasourcesToUpdate[i]
+
+          if (intersection) {
+            const dimensionsToCreate = sourceDatasource.dimensions.filter((dimension) => {
+              if (intersection.includes(dimension.name)) return dimension
+            })
+            const { data } = await this.createDatasourcesDimensions(dimensionsToCreate, datasourcesToUpdate[i], true)
+            datasourceToSyncDimensionsValues = data.datasource
+          }
+
+          await this.syncDatasourceEntries(sourceDatasource.id, datasourcesToUpdate[i].id)
+
+          await this.syncDatasourceDimensionsValues(sourceDatasource, datasourceToSyncDimensionsValues)
+          console.log(`${chalk.green('✓')} Updated datasource ${datasourcesToUpdate[i].name}`)
+        } else {
+          await this.syncDatasourceEntries(sourceDatasource.id, datasourcesToUpdate[i].id)
+          console.log(`${chalk.green('✓')} Updated datasource ${datasourcesToUpdate[i].name}`)
+        }
       } catch (err) {
         console.error(
           `${chalk.red('X')} Datasource ${datasourcesToUpdate[i].name} update failed: ${err.message}`
@@ -168,6 +204,102 @@ class SyncDatasources {
       }
     }
   }
+
+  async createDatasourcesDimensions (dimensions, datasource, isToUpdate = false) {
+    const newDimensions = dimensions.map((dimension) => {
+      return {
+        name: dimension.name,
+        entry_value: dimension.entry_value,
+        datasource_id: datasource.id,
+        _uid: UUID()
+      }
+    })
+
+    let payload = null
+
+    if (isToUpdate) {
+      payload = {
+        dimensions: [...datasource.dimensions, ...newDimensions],
+        dimensions_attributes: [...datasource.dimensions, ...newDimensions]
+      }
+    } else {
+      payload = {
+        dimensions: newDimensions,
+        dimensions_attributes: newDimensions
+      }
+    }
+
+    try {
+      return await this.client.put(`spaces/${this.targetSpaceId}/datasources/${datasource.id}`, {
+        ...datasource,
+        ...payload
+      })
+    } catch (error) {
+      console.error(error)
+    }
+  }
+
+  async syncDatasourceDimensionsValues (sourceDatasource, targetDatasource) {
+    const sourceEntriesPromisses = []
+    const targetEmptyEntriesPromisses = []
+    try {
+      for (let index = 0; index < sourceDatasource.dimensions.length; index++) {
+        const targetDimensionId = targetDatasource.dimensions[index].id
+        sourceEntriesPromisses.push(...await this.getDatasourceEntries(this.sourceSpaceId, sourceDatasource.id, sourceDatasource.dimensions[index].id))
+        targetEmptyEntriesPromisses.push(
+          ...await this.getDatasourceEntries(this.targetSpaceId, targetDatasource.id, targetDimensionId).then((res) => {
+            return res.map((entry) => {
+              return {
+                ...entry,
+                target_dimension_id: targetDimensionId
+              }
+            })
+          })
+        )
+      }
+
+      await Promise.all(sourceEntriesPromisses)
+      await Promise.all(targetEmptyEntriesPromisses)
+
+      const targetEntriesPromisses = []
+
+      while (sourceEntriesPromisses.length !== 0) {
+        const currentSourceEntry = sourceEntriesPromisses[0]
+        const targetEntryIndex = targetEmptyEntriesPromisses.findIndex((tEntry) => tEntry.name === currentSourceEntry.name)
+        const currentTargetEntry = targetEmptyEntriesPromisses[targetEntryIndex]
+        const valuesAreEqual = currentTargetEntry.dimension_value === currentSourceEntry.dimension_value
+
+        if (valuesAreEqual) {
+          sourceEntriesPromisses.shift()
+          targetEmptyEntriesPromisses.splice(targetEntryIndex, 1)
+        } else {
+          const payload = {
+            ...currentTargetEntry,
+            dimension_value: currentSourceEntry.dimension_value
+          }
+
+          targetEntriesPromisses.push(await this.syncDimensionEntryValues(currentTargetEntry.target_dimension_id, currentTargetEntry.id, payload))
+          sourceEntriesPromisses.shift()
+          targetEmptyEntriesPromisses.splice(targetEntryIndex, 1)
+        }
+      }
+
+      await Promise.all(targetEntriesPromisses)
+    } catch (error) {
+      console.error(`    ${chalk.red('X')} Sync dimensions values failed: ${error.response.data.error || error.message || error}`)
+    }
+  }
+
+  async syncDimensionEntryValues (dimensionId = null, datasourceEntryId = null, payload = null) {
+    try {
+      await this.client.put(`spaces/${this.targetSpaceId}/datasource_entries/${datasourceEntryId}`, {
+        datasource_entry: payload,
+        dimension_id: dimensionId
+      })
+    } catch (error) {
+      console.error(`    ${chalk.red('X')} Sync entry error ${payload.name} sync failed: ${error.response.data.error || error.message}`)
+    }
+  }
 }
 
 module.exports = SyncDatasources

package/src/tasks/sync.js

@@ -43,29 +43,29 @@ const SyncSpaces = {
 
   async syncStories () {
     console.log(chalk.green('✓') + ' Syncing stories...')
-    var targetFolders = await this.client.getAll(`spaces/${this.targetSpaceId}/stories`, {
+    const targetFolders = await this.client.getAll(`spaces/${this.targetSpaceId}/stories`, {
       folder_only: 1,
       sort_by: 'slug:asc'
     })
 
-    var folderMapping = {}
+    const folderMapping = {}
 
     for (let i = 0; i < targetFolders.length; i++) {
       var folder = targetFolders[i]
       folderMapping[folder.full_slug] = folder.id
     }
 
-    var all = await this.client.getAll(`spaces/${this.sourceSpaceId}/stories`, {
+    const all = await this.client.getAll(`spaces/${this.sourceSpaceId}/stories`, {
       story_only: 1
     })
 
     for (let i = 0; i < all.length; i++) {
       console.log(chalk.green('✓') + ' Starting update ' + all[i].full_slug)
 
-      var storyResult = await this.client.get('spaces/' + this.sourceSpaceId + '/stories/' + all[i].id)
-      var sourceStory = storyResult.data.story
-      var slugs = sourceStory.full_slug.split('/')
-      var folderId = 0
+      const { data } = await this.client.get('spaces/' + this.sourceSpaceId + '/stories/' + all[i].id)
+      const sourceStory = data.story
+      const slugs = sourceStory.full_slug.split('/')
+      let folderId = 0
 
       if (slugs.length > 1) {
         slugs.pop()
@@ -87,7 +87,7 @@ const SyncSpaces = {
         const payload = {
           story: storyData,
           force_update: '1',
-          ...(sourceStory.published ? { published: 1 } : {})
+          ...(sourceStory.published ? { publish: 1 } : {})
         }
 
         let createdStory = null

package/src/utils/api.js

@@ -156,6 +156,15 @@ module.exports = {
       .catch(err => Promise.reject(err))
   },
 
+  getSpaceOptions () {
+    const client = this.getClient()
+
+    return client
+      .get(this.getPath(''))
+      .then((data) => data.data.space.options || {})
+      .catch((err) => Promise.reject(err))
+  },
+
   getComponents () {
     const client = this.getClient()
 

package/tests/constants.js

@@ -229,11 +229,31 @@ const FAKE_SPACES = () => [
   }
 ]
 
+const FAKE_SPACE_OPTIONS = () => ({
+  languages: [
+    {
+      code: 'pt',
+      name: 'Português'
+    },
+    {
+      code: 'nl-be',
+      name: 'Dutch (Belgian)'
+    }
+  ],
+  hosted_backup: false,
+  onboarding_step: '3',
+  default_lang_name: 'English',
+  rev_share_enabled: true,
+  required_assest_fields: [],
+  use_translated_stories: false
+})
+
 module.exports = {
   EMAIL_TEST,
   TOKEN_TEST,
   FAKE_STORIES,
   PASSWORD_TEST,
   FAKE_COMPONENTS,
-  FAKE_SPACES
+  FAKE_SPACES,
+  FAKE_SPACE_OPTIONS
 }

package/tests/units/pull-languages.spec.js

@@ -0,0 +1,62 @@
+const fs = require('fs')
+const pullLanguages = require('../../src/tasks/pull-languages')
+const { FAKE_SPACE_OPTIONS } = require('../constants')
+
+jest.mock('fs')
+
+describe('testing pullLanguages', () => {
+  afterEach(() => {
+    jest.clearAllMocks()
+  })
+
+  it('api.getSpaceOptions() should be called once time', () => {
+    const api = {
+      getSpaceOptions: jest.fn(() => Promise.resolve(FAKE_SPACE_OPTIONS()))
+    }
+
+    return pullLanguages(api, {})
+      .then(() => {
+        expect(api.getSpaceOptions.mock.calls.length).toBe(1)
+      })
+  })
+
+  it('api.getSpaceOptions() should be call fs.writeFile correctly', async () => {
+    const SPACE = 12345
+    const BODY = FAKE_SPACE_OPTIONS()
+
+    const api = {
+      getSpaceOptions () {
+        return Promise.resolve(BODY)
+      }
+    }
+
+    const options = {
+      space: SPACE
+    }
+
+    const expectFileName = `languages.${SPACE}.json`
+    const expectData = {
+      default_lang_name: BODY.default_lang_name,
+      languages: BODY.languages
+    }
+
+    return pullLanguages(api, options)
+      .then(_ => {
+        const [path, data] = fs.writeFile.mock.calls[0]
+
+        expect(fs.writeFile.mock.calls.length).toBe(1)
+        expect(path).toBe(`./${expectFileName}`)
+        expect(JSON.parse(data)).toEqual(expectData)
+      })
+  })
+
+  it('api.getSpaceOptions() when a error ocurred, catch the body response', async () => {
+    const _api = {
+      getSpaceOptions (_, fn) {
+        return Promise.reject(new Error('Failed'))
+      }
+    }
+
+    await expect(pullLanguages(_api, {})).rejects.toThrow('Error: Failed')
+  })
+})