mango-cms 0.0.13

package/frontend-starter/src/helpers/localDB.js

@@ -0,0 +1,315 @@
+import axios from "axios"
+import Mango from "./mango"
+import Swal from "sweetalert2"
+
+// Function for setting cookies
+let setCookie = function (cname, cvalue) {
+    var d = new Date();
+    d.setTime(d.getTime() + (365 * 24 * 60 * 60 * 1000));
+    var expires = "expires=" + d.toUTCString();
+    document.cookie = cname + "=" + cvalue + ";" + expires + ";path=/";
+}
+
+function timeout(ms) {
+    return new Promise((resolve, reject) => {
+        setTimeout(() => {
+            reject(new Error(`Timeout after ${ms} ms`));
+        }, ms);
+    });
+}
+
+async function runWithTimeout(callback, ms) {
+    try {
+        let response = await Promise.race([
+            callback(),
+            timeout(ms)
+        ]);
+        console.log('timeout', response)
+        return response;
+    } catch (error) {
+        console.error(error.message);
+    }
+}
+
+export default class LocalDB {
+
+    constructor(collection, api) {
+
+        this.collection = collection
+
+        this.getDb()
+
+        this.ready = false
+        this.db = null
+        this.loading = false
+        this.saving = false
+        this.deleting = false
+        this.entry = null
+        this.entries = null
+
+        this.api = api
+
+    }
+
+    async getDb() {
+
+        let request = window.indexedDB.open(this.collection, 1);
+
+        request.onerror = e => {
+            this.ready = false
+            console.error('Error opening db', e);
+        };
+
+        request.onsuccess = e => {
+            this.db = e.target.result
+            this.ready = true
+        };
+
+        request.onupgradeneeded = e => {
+            console.log('onupgradeneeded');
+            this.db = e.target.result;
+            let objectStore = this.db.createObjectStore(this.collection, { autoIncrement: true, keyPath: 'id' });
+        };
+
+    }
+
+    async save(entry, syncing) {
+
+        if (!this.ready) return
+
+        this.saving = true;
+
+        let entryExists = !!entry.id
+        let onlyLocal = !isNaN(entry?.id) || !entryExists
+
+        let existingEntry
+
+        if (onlyLocal && entryExists) {
+            entry.id = Number(entry.id)
+            existingEntry = await this.get(entry.id)
+        } else if (entryExists) {
+            try {
+                existingEntry = await this.get(entry.id)
+            } catch {
+                // console.log('must just be in cloud')
+            }
+        }
+
+        return await new Promise(async (resolve, reject) => {
+
+            let trans = this.db.transaction([this.collection], 'readwrite');
+            let store = trans.objectStore(this.collection);
+
+            if (existingEntry) entry = { ...existingEntry, ...entry }
+
+            // Remove Vue Proxy stuff so indexedDB is happy
+            let savedImage = entry.image
+            delete entry.image
+            entry = JSON.parse(JSON.stringify(entry))
+            if (!syncing) entry.updatedLocally = new Date()
+
+            // Format Address for offline
+            // if (!entry.address?.id && entry.address?.formatted) entry.address = entry.address.formatted
+
+            // Handle images
+            if (savedImage?.type?.includes?.('image')) entry.image = savedImage
+            if (savedImage?.includes?.('http')) entry.image = savedImage
+
+
+            let method = entryExists ? 'put' : 'add'
+            let request = store[method](entry)
+
+            request.onsuccess = async () => {
+                this.saving = false
+                let localId = request.result
+
+                if (window?.offlineMode) return resolve({ ...entry, id: localId })
+
+                // If it only exists in the localDB, remove the ID for Mango
+                if (onlyLocal) delete entry.id
+
+                try {
+
+                    // Try to upload the image
+                    if (entry?.image?.type?.includes?.('image')) {
+                        await runWithTimeout(async () => {
+                            console.log('upload')
+                            const formData = new FormData()
+                            formData.append('file', entry.image)
+                            const response = await axios.post(`${this.api}/upload`, formData)
+                            console.log('upload response:', response)
+                            const path = response?.data?.paths?.[0]
+                            const url = `${this.api}${path}`
+                            entry.image = url
+                        }, 10 * 1000)
+                    }
+
+                    // Save to the cloud - this will throw if offline)
+
+                    // If the entry is over a day old...
+                    let olderThanOneDay = new Date(entry?.updatedLocally || '1/1/2024') < new Date(new Date().getTime() - 24 * 60 * 60 * 1000)
+                    if (onlyLocal && olderThanOneDay) await this.delete(localId)
+
+                    delete entry.updatedLocally
+
+                    // Save to Mango (timeout if already created, else no timeout)
+                    let response
+                    if (onlyLocal) {
+                        // Check the internet speed, if too slow, throw and queue for later
+                        let speedTest = await axios.get(`/images/logo.jpg?v=${Date.now()}`, { timeout: 1000 })
+                        let { response: mangoResponse, warnings } = await Mango[this.collection].save(entry, null, true)
+                        if (warnings?.length) Swal.fire('WARNING:', warnings?.join(', '), 'warning')
+                        console.log('mangoResponse', mangoResponse)
+                        response = mangoResponse
+                    }
+                    else response = await runWithTimeout(async () => await Mango[this.collection].save(entry), 5000)
+
+                    // If successfull, delete from local queue
+                    if (response?.id) {
+                        await this.delete(localId)
+                        resolve(response);
+                    } else {
+                        console.log('response', response)
+                        // Mango will throw if offline so delete this entry and save it to the failed queue
+                        // await Mango.failedleads.save({ data: { raw: entry }, error: response, user: window.localStorage.getItem('user') })
+                        // await this.delete(localId)
+
+                        // Unauthorized
+                        if (typeof response == 'string' && response?.includes?.('not have permission')) {
+                            // Logout if credentials are bad
+                            window.localStorage.removeItem('user')
+                            window.localStorage.removeItem('token')
+                            window.localStorage.removeItem('email')
+                            window.localStorage.removeItem('auth')
+                            setCookie(`Authorization`, ``)
+                            window.location.reload()
+                        }
+
+                        // Existing Address
+                        if (typeof response == 'string' && response?.includes?.('already visited this address')) {
+                            await this.delete(localId)
+                            Swal.fire('Existing Address', response, 'warning')
+                            if (window.location.href.includes(`leads/${localId}`)) window.location.href = '/'
+                            resolve({ stop: true });
+                        }
+
+                        // Address Lockout
+                        if (typeof response == 'string' && response?.includes?.('asked not to be disturbed')) {
+                            await this.delete(localId)
+                            Swal.fire('Address Lockout', response, 'warning')
+                            if (window.location.href.includes(`leads/${localId}`)) window.location.href = '/'
+                            resolve({ stop: true });
+                        }
+
+                        console.log(response, onlyLocal);
+                        resolve({ ...entry, id: localId });
+                    }
+
+                } catch (e) {
+                    console.log(e.message)
+                    resolve({ ...entry, id: localId });
+                }
+            };
+
+            request.onerror = (e) => {
+                this.saving = false
+                reject(e);
+            };
+
+        });
+
+    }
+
+    async get(id) {
+
+        if (!this.ready) return
+
+        this.loading = true;
+
+        return await new Promise((resolve, reject) => {
+            let trans = this.db.transaction([this.collection], 'readonly');
+            let store = trans.objectStore(this.collection);
+            let request = store.get(id);
+
+            request.onsuccess = () => {
+                this.loading = false;
+                resolve(request.result);
+            };
+
+            request.onerror = (e) => {
+                this.loading = false;
+                reject(e);
+            };
+        });
+
+    }
+
+    async getEntries({ pageIndex = 0, pageSize = 1000 } = {}) {
+
+        if (!this.ready) return []
+
+        this.loading = true;
+
+        let response = await new Promise((resolve, reject) => {
+            let trans = this.db.transaction([this.collection], 'readonly');
+            let store = trans.objectStore(this.collection);
+            let cursorRequest = store.openCursor();
+
+            let entries = [];
+            let skippedEntries = pageIndex * pageSize;
+
+            cursorRequest.onsuccess = (e) => {
+                let cursor = e.target.result;
+                if (cursor) {
+                    if (skippedEntries > 0) {
+                        // Skip the entries before the current page
+                        cursor.advance(skippedEntries);
+                        skippedEntries = 0;
+                    } else {
+                        entries.push(cursor.value);
+                        if (entries.length < pageSize) {
+                            cursor.continue();
+                        } else {
+                            resolve(entries);
+                        }
+                    }
+                } else {
+                    // No more entries to read; resolve with what we have
+                    resolve(entries);
+                }
+            };
+
+            cursorRequest.onerror = (e) => {
+                reject(e);
+            };
+        });
+
+        // console.log('response', response);
+        this.loading = false;
+        return response;
+    }
+
+    async delete(id) {
+
+        this.deleting = true;
+
+        return new Promise((resolve, reject) => {
+
+            let trans = this.db.transaction([this.collection], 'readwrite');
+            let store = trans.objectStore(this.collection);
+            let request = store.delete(id);
+
+            request.onsuccess = () => {
+                this.deleting = false
+                resolve(request.result);
+            };
+
+            request.onerror = (e) => {
+                this.deleting = false
+                reject(e);
+            };
+
+        });
+    }
+
+}

package/frontend-starter/src/helpers/mango.js

@@ -0,0 +1,338 @@
+// import collections from '../../../mango/config/.collections.json'
+// import { algoliaAppId, algoliaSearchKey, algoliaIndex, port, domain } from '../../../mango/config/settings'
+import collections from '../../../config/config/.collections.json'
+import { algoliaAppId, algoliaSearchKey, algoliaIndex, port, domain } from '../../../config/config/settings'
+import axios from "axios";
+import { ref } from 'vue'
+import algoliasearch from 'algoliasearch/lite'
+
+let endpoints = {
+    authors: ['get'],
+    // scripture: { validate: ['post'] }
+}
+
+// console.log('collections', collections)
+
+const client = algoliasearch(algoliaAppId, algoliaSearchKey);
+const algolia = client.initIndex(algoliaIndex);
+
+let api = `https://${domain}`
+let ws = `wss://${domain}/graphql`
+
+if (process.env.NODE_ENV != 'production') {
+    api = `http://localhost:${port}`
+    ws = `ws://localhost:${port}/graphql`
+}
+
+const Mango = collections.reduce((a, c) => {
+
+    let runQuery = ({ limit, page, search, fields, id, sort, depthLimit } = {}) => {
+
+        let fullQuery
+
+
+        const params = { limit, page, search, fields, sort, depthLimit }
+
+        if (params.search != undefined) params.search = JSON.stringify(params.search)
+        if (params.fields != undefined) params.fields = JSON.stringify(params.fields)
+        if (params.sort != undefined) params.sort = JSON.stringify(params.sort)
+
+        const query = Object.keys(params)
+            .filter(key => params[key] != undefined)
+            ?.map(key => `${encodeURIComponent(key)}=${encodeURIComponent(params[key])}`)
+            ?.join('&') || ''
+        // console.log(query)
+
+        fullQuery = `${api}/${c.name}/${id || ''}?${query}`
+
+        let Authorization = window.localStorage.getItem('token')
+
+        return new Promise((resolve, reject) => {
+            axios.get(fullQuery, { headers: { Authorization } })
+                .then(response => resolve(response?.data?.response))
+                .catch(e => reject(e))
+        })
+
+    }
+
+    let runGraphql = (query) => {
+
+        let Authorization = window.localStorage.getItem('token')
+        query = { query }
+        return new Promise((resolve, reject) => {
+            axios.post(`${api}/graphql`, query, { headers: { Authorization } })
+                .then(response => resolve(response?.data?.data))
+                .catch(e => reject(e))
+        })
+
+    }
+
+    let runAlgolia = (search, query, algoliaFilters) => {
+
+        search = search || ''
+
+        let filters = `collection:${c.name}`
+        if (algoliaFilters) filters += ` AND ${algoliaFilters}`
+
+        let algoliaQuery = {
+            page: query?.page || 0,
+            filters,
+            hitsPerPage: query?.limit || 10
+        }
+
+        if (query?.fields) algoliaQuery.attributesToRetrieve = query.fields
+
+        return new Promise((resolve, reject) => {
+            algolia.search(search, algoliaQuery)
+                .then(({ hits, nbHits }) => {
+                    hits.forEach(h => h.id = h.objectID)
+                    resolve({ hits, nbHits })
+                })
+        })
+
+    }
+
+    let save = (data) => {
+        let { id } = data
+        let method = id ? 'put' : 'post'
+
+        // // Remove _id and computed fields
+        delete data.collection
+        delete data._id
+        delete data.id
+
+        for (let field of c.fields) {
+            if (field.computed) delete data[field.name]
+            if (field.relationship) data[field.name] = Array.isArray(data[field.name]) ? data[field.name].map(r => r.id) : data[field.name]?.id ? data[field.name].id : data[field.name]
+        }
+        for (let name in data) {
+            if (name.includes('__')) delete data[name]
+        }
+
+        let payload = { ...data }
+
+        let Authorization = window.localStorage.getItem('token')
+
+        return new Promise((resolve, reject) => {
+            axios[method](`${api}/${c.name}/${id || ''}`, payload, { headers: { Authorization } })
+                .then(response => resolve(response?.data?.response))
+                .catch(e => reject(e))
+        })
+    }
+
+    let deleteEntry = (data) => {
+        let id = data.id || data
+
+        let Authorization = window.localStorage.getItem('token')
+
+        return new Promise((resolve, reject) => {
+            axios.delete(`${api}/${c.name}/${id || ''}`, { headers: { Authorization } })
+                .then(response => resolve(response?.data))
+                .catch(e => reject(e))
+        })
+    }
+
+    a[c.name] = runQuery
+    a[c.name]['save'] = save
+    a[c.name]['delete'] = deleteEntry
+    a[c.singular] = (id, query) => runQuery({ id, ...query })
+
+    a[c.name]['search'] = runAlgolia
+    a[c.name]['search']['init'] = (search, query, algoliaFilters) => {
+        let loading = ref(true)
+        let data = ref(null)
+        let error = ref(null)
+        let totalResults = ref(null)
+
+        let response = runAlgolia(search, query, algoliaFilters)
+            .then(response => {
+                data.value = response.hits
+                totalResults.value = response.nbHits
+                loading.value = false
+            })
+            .catch(e => {
+                loading.value = false
+                error.value = e
+            })
+
+        return { data, loading, error }
+    }
+
+    a[c.name]['init'] = ({ limit, page, search, fields, id, sort } = {}) => {
+
+        let loading = ref(true)
+        let data = ref(null)
+        let error = ref(null)
+
+        let response = runQuery({ limit, page, search, fields, id, sort })
+            .then(response => {
+                data.value = response
+                loading.value = false
+            })
+            .catch(e => {
+                loading.value = false
+                error.value = e
+            })
+
+        return { data, loading, error }
+
+    }
+
+    a[c.singular]['init'] = (id) => a[c.name]['init']({ id })
+
+    a.relationRequest = ({ limit, page, search, fields, id, sort, depthLimit, path } = {}) => {
+
+        let fullQuery
+
+
+        const params = { limit, page, search, fields, sort, depthLimit }
+
+        if (params.search != undefined) params.search = JSON.stringify(params.search)
+        if (params.fields != undefined) params.fields = JSON.stringify(params.fields)
+        if (params.sort != undefined) params.sort = JSON.stringify(params.sort)
+
+        const query = Object.keys(params)
+            .filter(key => params[key] != undefined)
+            ?.map(key => `${encodeURIComponent(key)}=${encodeURIComponent(params[key])}`)
+            ?.join('&') || ''
+        // console.log(query)
+
+        fullQuery = `${api}/${path}?${query}`
+
+        let Authorization = window.localStorage.getItem('token')
+
+        return new Promise((resolve, reject) => {
+            axios.get(fullQuery, { headers: { Authorization } })
+                .then(response => resolve(response?.data?.response))
+                .catch(e => reject(e))
+        })
+
+    }
+    a.relationRequest.init = (query) => {
+
+        let loading = ref(true)
+        let data = ref(null)
+        let error = ref(null)
+
+        let response = a.relationRequest(query)
+            .then(response => {
+                data.value = response
+                loading.value = false
+            })
+            .catch(e => {
+                loading.value = false
+                error.value = e
+            })
+
+        return { data, loading, error }
+
+    }
+
+
+    a.graphql = runGraphql
+    a.graphql.init = (query) => {
+
+        let loading = ref(true)
+        let data = ref(null)
+        let error = ref(null)
+
+        let response = runGraphql(query)
+            .then(response => {
+                data.value = response
+                loading.value = false
+            })
+            .catch(e => {
+                loading.value = false
+                error.value = e
+            })
+
+        return { data, loading, error }
+
+    }
+
+    return a
+
+}, {})
+
+Mango.search = (search, query, algoliaFilters) => {
+
+    search = search || ''
+
+    let filters = ``
+    if (algoliaFilters) filters += `${algoliaFilters}`
+
+    let algoliaQuery = {
+        page: query?.page || 0,
+        filters,
+        hitsPerPage: query?.limit || 10
+    }
+
+    if (query?.fields) algoliaQuery.attributesToRetrieve = query.fields
+
+    return new Promise((resolve, reject) => {
+        algolia.search(search, algoliaQuery)
+            .then(({ hits }) => {
+                hits.forEach(h => h.id = h.objectID)
+                resolve(hits)
+            })
+    })
+
+}
+
+Mango.login = ({ email, password }) => {
+    return new Promise((resolve, reject) => {
+        axios.post(`${api}/endpoints/account/login`, { email, password })
+            .then(response => {
+                window.localStorage.setItem('token', response.data.token)
+                window.localStorage.setItem('user', response.data.memberId)
+                window.localStorage.setItem('email', email)
+                resolve(response.data)
+            })
+            .catch(e => reject(e))
+    })
+}
+
+Mango.endpoints = Object.keys(endpoints).reduce((a, c) => {
+
+    a[c] = {}
+
+    for (let method of endpoints[c]) {
+        a[c][method] = () => {
+
+            return new Promise((resolve, reject) => {
+                console.log('method', method)
+                console.log('`${api}/endpoints/${c}`', `${api}/endpoints/${c}`)
+                axios[method](`${api}/endpoints/${c}`)
+                    .then(response => resolve(response?.data))
+                    .catch(e => reject(e))
+            })
+
+        }
+    }
+
+    for (let method of endpoints[c]) {
+        a[c][method]['init'] = () => {
+
+            let loading = ref(true)
+            let data = ref(null)
+            let error = ref(null)
+
+            let response = a[c][method]().then(r => {
+                data.value = r
+                loading.value = false
+            })
+
+            return { data, loading, error }
+        }
+    }
+
+    return a
+
+}, {})
+
+Mango.collections = collections
+Mango.ws = ws
+
+Mango.online = async () => { try { return (await axios.get(`${api}/endpoints/test`))?.data?.includes('🥭') } catch (e) { return false } }
+
+export default Mango

package/frontend-starter/src/helpers/model.js

@@ -0,0 +1,9 @@
+
+import { computed } from 'vue'
+
+export function useModel(props, emit, name = 'modelValue') {
+    return computed({
+        get: () => props[name],
+        set: (value) => emit(`update:${name}`, value)
+    })
+}