mango-cms 0.1.15 → 0.1.17

package/default/front/src/helpers/localDB.js

@@ -1,315 +0,0 @@
-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/default/front/src/helpers/mango.js

@@ -1,341 +0,0 @@
-// 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, options = {}) => {
-        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 || r) : 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')
-        let headers = {
-            Authorization,
-            ...options.headers
-        }
-
-        return new Promise((resolve, reject) => {
-            axios[method](`${api}/${c.name}/${id || ''}`, payload, { headers })
-                .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/default/front/src/helpers/model.js

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