griddo-sdk 1.0.0

package/api/index.js

@@ -0,0 +1,25 @@
+const axios = require('axios');
+
+const api = (env, method, endpoint, body = null, headers = {}) => {
+    const {
+        api,
+        token,
+    } = env;
+    if (!api) throw new Error('Class SDK should be initialized with connect method.');
+    const noBodyMethods = [
+        'get',
+        'delete',
+    ];
+    if (token) headers.authorization = token;
+    const params = [
+        `${api}${endpoint.startsWith('/') ? '' : '/'}${endpoint}`,
+        ...(noBodyMethods.includes(method.toLowerCase()) ? [] : [body]),
+        { headers },
+    ];
+    return axios[method](...params)
+        .then(response => response.data);
+};
+
+module.exports={
+    api,
+};

package/index.js

@@ -0,0 +1,137 @@
+const { api } = require('./api')
+const { getToken } = require('./models/auth');
+const { getPages, getPage, savePage, deletePage, restorePage } = require('./models/pages');
+const { getStructuredData, saveStructuredData } = require('./models/structuredData');
+const { getLanguages } = require('./models/languages');
+const { getStatus } = require('./models/liveStatus');
+
+class SDK {
+    constructor() {
+        this._env = {};
+        this.api = this.api.bind(this);
+        this.getPage = this.getPage.bind(this);
+        this.savePage = this.savePage.bind(this);
+        this.deletePage = this.deletePage.bind(this);
+        this.restorePage = this.restorePage.bind(this);
+        this.mapPages = this.mapPages.bind(this);
+        this.mapModulesFromPage = this.mapModulesFromPage.bind(this);
+        this.mapModules = this.mapModules.bind(this);
+        this.getStructuredData = this.getStructuredData.bind(this);
+        this.saveStructuredData = this.saveStructuredData.bind(this);
+        this.getLanguage = this.getLanguage.bind(this);
+        this.getDefaultLanguage = this.getDefaultLanguage.bind(this);
+        this.languages = [];
+        this.liveStatus = {};
+    }
+
+    async connect(environment) {
+        const {
+            api,
+            user,
+            password
+        } = environment;
+        if (!api || !user || !password) throw new Error('Environment JSON file should contain the keys api, user and password.');
+        this._env = {
+            api: api.endsWith('/') ? api.slice(0, -1) : api,
+            token: await getToken(environment),
+        };
+        this.languages = await getLanguages(this._env);
+
+        const liveStatus = await getStatus(this._env);
+        for (const item of liveStatus) this.liveStatus[item.status] = item.id;
+    };
+
+    getLanguage(key, value) {
+        return this.languages.find(item => item[key] === value);
+    };
+
+    getDefaultLanguage() {
+        return this.languages.find(item => item.isDefault);
+    };
+
+    async mapPages(callback, templateName) {
+        console.log(`\nMapping ${templateName || 'all'} pages with callback function ${callback.name}...`);
+        if (!callback || typeof (callback) !== 'function') throw new Error('Cannot map pages without a callback function.');
+        const pages = await getPages(this._env, templateName);
+        if (!pages?.length) {
+            console.log('- No pages found.');
+            return;
+        }
+        for (const pageId of pages) {
+            console.log('- Mapping page', pageId);
+            const page = await getPage(this._env, pageId)
+            const pageProtected = JSON.parse(JSON.stringify(page));
+            const result = await callback(pageProtected);
+            if (result && JSON.stringify(page) !== JSON.stringify(result)) {
+                await savePage(this._env, result)
+            }
+        }
+    };
+
+    async mapModulesFromPage(page, moduleName, callback) {
+        console.log(`\tMapping modules ${moduleName} with callback function ${callback.name}...`);
+        if (!callback || typeof (callback) !== 'function') throw new Error('Cannot map modules without a callback function.');
+        if (!moduleName) throw new Error('Cannot map modules in page without selecting the module to map.');
+        if (!page || typeof (page) !== 'object') throw new Error('Page to map modules not found.');
+        const protectedPage = JSON.parse(JSON.stringify(page));
+        let found = false;
+        const search = async (modulePiece) => {
+            for (const key of Object.keys(modulePiece)) {
+                const module = modulePiece[key];
+                if (!module || typeof (module) !== 'object') continue;
+                if (module.component === moduleName) {
+                    if (!found) console.log(`\tModule ${moduleName} found.`);
+                    const newModule = await callback(JSON.parse(JSON.stringify(module)));
+                    if (newModule) modulePiece[key] = newModule;
+                    found = true;
+                }
+                await search(module);
+            }
+        };
+        await search(protectedPage);
+        if (!found) console.log(`\tModule ${moduleName} not found.`);
+        return protectedPage;
+    };
+
+    async mapModules(callback, moduleName, template) {
+        console.log(`\nMapping modules ${moduleName} from ${template || 'all'} pages with callback function ${callback.name}...`);
+        if (!callback || typeof (callback) !== 'function') throw new Error('Cannot map modules without a callback function.');
+        if (!moduleName) throw new Error('Cannot map modules in page without selecting the module to map.');
+        const fixPage = (page) => this.mapModulesFromPage(page, moduleName, callback);
+        await this.mapPages(fixPage, template);
+    };
+
+    async savePage(page) {
+        return await savePage(this._env, page);
+    };
+
+    async getPage(id) {
+        return await getPage(this._env, id);
+    };
+
+    async deletePage(id) {
+        return await deletePage(this._env, id);
+    };
+
+    async restorePage(id) {
+        return await restorePage(this._env, id);
+    };
+
+    async getStructuredData(id, site = null, language = null) {
+        return await getStructuredData(this._env, id, site, language);
+    };
+
+    async saveStructuredData(structuredData) {
+        return await saveStructuredData(this._env, structuredData);
+    };
+
+    async api(...params) {
+        return await api(this._env, ...params);
+    };
+
+    showLog(...text) {
+        console.log(`\t${text.join(' ')} `);
+    };
+};
+
+module.exports = SDK;

package/models/auth.js

@@ -0,0 +1,18 @@
+const api = require('../api');
+
+const getToken = async (params) => {
+    const {
+        api: apiKey,
+        user: email,
+        password,
+    } = params;
+    console.log('Logging to api...');
+    const token = await api({ api: apiKey }, 'post', '/login_check', { email, password })
+        .then(data => data.token);
+    console.log('Authenticated.')
+    return token;
+};
+
+module.exports = {
+    getToken,
+};

package/models/languages.js

@@ -0,0 +1,8 @@
+const api = require('../api');
+
+const getLanguages = env => api(env, 'get', '/languages')
+    .then(data => data.items);
+
+module.exports = {
+    getLanguages,
+};

package/models/liveStatus.js

@@ -0,0 +1,7 @@
+const api = require('../api');
+
+const getStatus = env => api(env, 'get', '/live-status');
+
+module.exports={
+    getStatus,
+};

package/models/pages.js

@@ -0,0 +1,50 @@
+const api = require('../api');
+
+const getPages = (env, template = null) => api(env, 'get', `/pages/all/id/${template ? `?template=${template}` : ''}`);
+
+const getPage = async (env, pageId) => {
+    const page = await api(env, 'get', `/page/${pageId}`)
+    console.log('\tLoaded page', page.title);
+    return page;
+};
+
+const savePage = async (env, page) => {
+    const actions = {
+        new: {
+            method: 'post',
+            endpoint: '/page/',
+            actionName: 'created',
+        },
+        update: {
+            method: 'put',
+            endpoint: `/page/${page.id}`,
+            actionName: 'updated',
+        },
+    };
+    const {
+        method,
+        endpoint,
+        actionName,
+    } = actions[page.id ? 'update' : 'new'];
+    const savedPage = await api(env, method, endpoint, page);
+    console.log(`\tPage ${actionName}.`);
+    return savedPage;
+};
+
+const deletePage = (env, id) => {
+    console.log('\tDelete page', id);
+    return api(env, 'delete', `/page/${id}`);
+};
+
+const restorePage = (env, id) => {
+    console.log('\tRestore page', id);
+    return api(env, 'delete', `/page/${id}/undo`);
+};
+
+module.exports = {
+    getPages,
+    getPage,
+    savePage,
+    deletePage,
+    restorePage,
+};

package/models/structuredData.js

@@ -0,0 +1,39 @@
+const api = require('../api');
+
+const getStructuredData = async (env, id, site = null, language = null) => {
+    const headers = {
+        lang: language,
+    };
+    const items = await api(env, 'get', `${site ? `/site/${site}` : ''}/structured_data_contents/${id}?pagination=false&includeDraft=true`, { headers })
+        .then(data => data.items);
+    console.log(`\tStructured data ${id} loaded.`);
+    return items;
+};
+
+const saveStructuredData = async (env, structuredData) => {
+    const actions = {
+        new: {
+            method: 'post',
+            endpoint: '/structured_data_content/',
+            actionName: 'created',
+        },
+        update: {
+            method: 'put',
+            endpoint: `/structured_data_content/${structuredData.id}`,
+            actionName: 'updated',
+        },
+    };
+    const {
+        method,
+        endpoint,
+        actionName,
+    } = actions[structuredData.id ? 'update' : 'new'];
+    const savedItem = await api(env, method, endpoint, structuredData);
+    console.log(`\tStructured data ${structuredData?.content?.title || structuredData?.content?.label || 'untitled'} in ${structuredData.structuredData} ${actionName}.`);
+    return savedItem;
+};
+
+module.exports = {
+    getStructuredData,
+    saveStructuredData,
+};

package/package.json

@@ -0,0 +1,22 @@
+{
+  "name": "griddo-sdk",
+  "version": "1.0.0",
+  "description": "",
+  "main": "index.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/griddo/griddo-sdk.git"
+  },
+  "author": "",
+  "license": "ISC",
+  "bugs": {
+    "url": "https://github.com/griddo/griddo-sdk/issues"
+  },
+  "homepage": "https://github.com/griddo/griddo-sdk#readme",
+  "dependencies": {
+    "axios": "^0.26.0"
+  }
+}